RogerBW's Blog

I’ve been doing the Weekly Challenges. The latest involved date calculations and didn't involve array permutations. (Note that this ends today.)

Task 1: Seize The Day

Given a year, a month, a weekday of month, and a day of week (1 (Mon) .. 7
(Sun)), print the day.

Rust's chrono has a built-in for this. Har har. For languages that don't:

• find weekday of first day of month
• find date of first desired weekday in month
• add 7 per subsequent week count
• check whether this is still in the same month

Raku:

sub seizetheday($year, $month, $weekcount, $dayofweek) {

Start at the first day of the month.

    my $dt = Date.new(year => $year,
                      month => $month,
                      day => 1);

Get its weekday.

    my $wd = $dt.day-of-week;

If that's not the weekday we want, move it forward to the first one that is.

    if ($wd != $dayofweek) {
        $dt = $dt.later(days => ($dayofweek - $wd + 7) % 7);
    }

Then if we want a later X-day, step forward by weeks.

    if ($weekcount > 1) {
        $dt = $dt.later(weeks => ($weekcount - 1));
    }

If this modified date isn't in the same month and year as the original, return zero.

    if ($dt.month != $month || $dt.year != $year) {
        return 0;
    }

Return the day of the month.

    return $dt.day;
}

Lua and PostScript don't have date libraries. Well, they do now. All it really needs is a converter from y-m-d to Julian date, a converter the other way—both of which you can readily build from the formulae on the Wikipedia page—and a day-of-week calculator which is essentially Julian date mod 7 with an offset.

Kotlin and Scala, both using the Java time library, end up looking almost identical.

Task 2: Maximise Greatness

You are given an array of integers.

Write a script to permute the give array such that you get the maximum possible greatness.

To determine greatness, nums[i] < perm[i] where 0 <= i < nums.length

The hardest part here is the description of the problem, because it might lead one astray into actually trying permutations.

First, sort the list. Then have a pair of pointers, let's call them lead and lag; start both at zero.

Run lead over each list element. If the value there is greater than the value at lag, increment lag by one. (Because the list is sorted, this is the lowest possible lead value that's greater than the lag value.)

The final value of lag is the greatness.

In practice we aren't using C so lead is implemented as an iterator over the sorted list.

Ruby:

def maximisegreatness(a)
  b = a.sort
  g = 0
  b.each do |c|
    if c > b[g] then
      g += 1
    end
  end
  return g
end

Full code on github.