Decreasing sequences
It occurred to me that I could think of two ways to generate a decreasing sequence. The built-in i. will do this:
i. _7
6 5 4 3 2 1 0
But I could see a way to do it with self-reference $: or with iterate ^::
(<:^:*^:a:) 7
7 6 5 4 3 2 1 0
This essentially says “iterate gathering results” ^:a: “while non-zero” ^:* “decrement” <:. This differs slightly from i. _7 because it includes the number 7, but whatever.
The self-reference $: method is a little longer:
0:`(, $:@<:) @.* 7
7 6 5 4 3 2 1 0
Like any recursive function, we need a base case and an inductive case. Sentences like
f`g@.t
in J give you case analysis, so a sentence like:
0:`f @.*
is a strong clue that your base case maps 0 to 0 and runs all positive numbers through f, and that’s what’s happening here. So the next step is understanding , $:@<:. This is about as simple as self-reference can get: we’re making a hook (it means the same as ] , $:@<: if forks make more sense to you than hooks) basically using , to append the current value with the result of the recursive call. $:@<: says “apply myself after decrementing the argument”.
This suggests an obvious way to get the increasing list, by just flipping around the arguments to , append:
0:`($:@<: , ]) @.* 7
0 1 2 3 4 5 6 7
I’m sure the self-reference version is worse in performance terms, but there isn’t as straightforward a way to flip it around like this, so this counts as an advantage here.
Detecting palindromes
This is one thing where Prolog usually has a significant advantage over other languages, because you can make the relationship between palindromes and reflection explicit:
palindrome(X) :- reverse(X, X).
However, J is still able to beat this:
palindrome =: -: |.
Match the value with its reflection.