RogerBW's Blog

I’ve been doing the Weekly Challenges. The latest involved multi-level counts and word ordering. (Note that this ends today.)

Task 1: Unique Occurrences

You are given an array of integers, @ints.

Write a script to return 1 if the number of occurrences of each value in the given array is unique or 0 otherwise.

For me the most obvious way was to create a hash of counts, then uniquify those counts and see if the list size shrank. Raku:

sub uniqueoccurrences(@a) {
    my %c;

Create a map of integers to counts.

    @a.map({%c{$_}++});

Put those counts in a set, and see if it's the same size as the map.

    if (Set(%c.values).elems == %c.elems) {
        return 1;
    } else {
        return 0;
    }
}

Task 2: Dictionary Rank

You are given a word, $word.

Write a script to compute the dictionary rank of the given word.

Again the algorithm seemed very clear:

• generate all permutations of the letters
• uniquify and sort them
• look for the original word in the ordered list.

In PostScript (relying heavily on my library extensions:

/dictionaryrank {
    0 dict begin
    /a exch def

Copy the length of the input string; we'll be using that repeatedly later.

    /l a length def
    /d 0 dict def

Permute the characters of a, placing the resultant strings as dictionary keys in d to ensure they're unique.

    a s2a { a2s d exch true put } permute

Those strings have become PostScript name objects, so convert them back to strings, before sorting and iterating the list.

    d keys { l string cvs } map quicksort enumerate.array {

The enumerator gives us [ index value ] as a single stack object, so break that out onto the stack.

        aload pop

If the value matches the original string,

        a deepeq {

add 1 to the current index and exit.

            1 add
            exit
        } {

Otherwise pop the index since we won't be using it.

            pop
        } ifelse
    } forall
    end
} bind def

Full code on github.