I love small challenges as a way to learn a language. I spotted this one in the #rstats hashtag on Mastodon

“square each digit of an integer (return integer), eg 9113 becomes 81119”

and I just had to try it in APL.

First, extract each of the digits using format

``````      {⍎¨⍕⍵}9113
9 1 1 3
``````

then square each digit, using the commute operator to make `2*x` into `x*2` (`*` is power)

``````      {2*⍨⍎¨⍕⍵}9113
81 1 1 9
``````

The next bit took me a bit of trying, but I got there (please do let me know if there’s an easier way)… extract each digit as a character

``````      {⍕¨2*⍨⍎¨⍕⍵}9113
┌──┬─┬─┬─┐
│81│1│1│9│
└──┴─┴─┴─┘
``````

then catenate-reduce

``````      {,/⍕¨2*⍨⍎¨⍕⍵}9113
┌─────┐
│81119│
└─────┘
``````

and finally enlist down to a scalar and parse as a number again

``````      {⍎∊,/⍕¨(2*⍨⍎¨⍕⍵)}9113
81119
``````

Wrapping it into a named defun, it’s not all that bad

``````      squaredigits←{⍎∊,/⍕¨(2*⍨⍎¨⍕⍵)}
squaredigits 9113
81119
``````

Is it as nice as the Julia solution?

``````parse(Int, join(reverse(digits(num)).^2))
``````

or, as mentioned in a reply

``````using Chain
@chain num digits reverse _.^2 join parse(Int, _)
``````

No - I think in this case Julia does a much nicer job; easier to reason and interpret but that comes from having nice wrappers for things like `digits` (which returns them in reverse order, requiring the `reverse`). I could absolutely do that in APL, I’ve just been trying to do it entirely with primitives, but nice wrappers are nice…

``````      digits←⍎¨⍕
digits 9113
9 1 1 3
``````

same for `join`

``````      join←⍎∘∊(,/⍕¨)
join 81 1 1 9
81119
``````

and heck, square

``````      square←{2*⍨⍵}
square 9
81
``````

or, since I no longer need the arguments in that order, simply

``````      square←{⍵*2}
square 9
81
``````

so then the APL solution, via composing these three functions, becomes simply

``````      squaredigits←join∘square∘digits
squaredigits 9113
81119
``````

And yes, it’s still a number

``````      1+squaredigits 9113
81120
``````

Want to see how it works? APL prints out the AST for a function like this

``````squaredigits
∘
┌┴┐
∘ ¨
┌─┴──┐
┌─┴──┐ {⍵*2}
∘  ┌─┴─┐
┌   /   ¨
∊ ┌─┘ ┌─┘
,
``````

I’m not nearly done loving what APL can do.