470A - Crystal Ball Sequence

As usual, the first problem tests competitors' ability to do basic math, and in this case it is even easier than the sample — without any loops.

^'0-
$ 1+*3*1+.

470B - Hexakosioihexekontahexaphobia

This problem uses more advanced language concepts — loop, conditional execution and even named variables! Variables are convenient to use as loop counters and result accumulators, so as to avoid stack manipulations for the same purpose. An if-then-else in FALSE looks like this:

(true/false condition on top of stack) $ 
    [(then statements)] ?
  ~ [(else statements)] ?

Solution:

0n:    {number of 6s found uninterrupted so far}
0r:    {true, if 666 found}
[^$ 1_=~]
[ '6= $ [n; 1+ n:] ?
      ~ [0n:] ?
  n; 2 > r; | r: 
]
#
%
r; $ ["YES"] ?
   ~ ["NO"] ?

470C - Eval

This problem can be solved in two ways. You could read numbers, store them to named variables and depending on the operator use one of the operations on them. Or else you could do the other way around, store necessary operation as a function into a named variable (FALSE allows to store functions as variables) and apply it to numbers stored in stack. Here is the code of the second approach:

[0[^ $$ 47> \58\> &]['0- \ 10*+]#]
r:

r;!

$'+=[[+]f:]?
$'-=[[-]f:]?
$'*=[[*]f:]?
$'/=[[/]f:]?
$'%=[[\$@$@\/*-]f:]?
%

r;!
%
f;!.

470D - Caesar Cipher

This problem combines elements of previous problems: reading long int, reading a string and doing modulo operation (could be replaced with conditional subtraction).

0[^ $$ 47> \58\> &]['0- \ 10*+]#% k:   {read the key}

[^$ 10=~]
[ 'A- k;+ $ 25> [26-] ? 'A+ ,]
#%

470E - Chessboard

All of a sudden this problem turned out to be easier than C and D; probably a double-for loop is more simple than reading till end of line, especially with all the confusion with ends of line :-)

0[^ $$ 47> \58\> &]['0- \ 10*+]#%
n:

[\ $ @ $ @\/*-]
p:

0i:
[n;i;>]
[0j:
 [n;j;>]
 [j;i;+ 2p;!
  11* 46 \- ,
  j;1+j:]
 #
"
"
i;1+i:]
#

470F - Pairwise Sums

Next two problems use a new language construct — operator ø (a.k.a. O, not to be confused with 0), which allows random read access to stack elements. To calculate pairwise sums, one had to first read all array elements into the stak, then calculate indices of necessary elements, read them and add them up.

[0[^ $$ 47> \58\> &]['0- \ 10*+]#%] r:

r;! n:   {read the number of elements in array}

0i:
[n;i;>]
[r;! i;1+i:]
#        {read the elements of the array}

0i:
[n;i;>]
[$ n;O + . " " n;1-O i;1+i:]
#

0i:
[n;2*i;>]
[% i;1+i:]
#

470G - Hamming Distance

Same principle as in the previous problem — read characters of two strings into the stack (store the length of the strings into a named variable), then extract pairs of corresponding characters from it and accumulate the result in another named variable.

0n:
[^ $ 10=~]
[n;1+n:]
#%

[^ $ 1_=~]
[]
#%

0i:
0d:
[n;i;>]
[n;i;-1- O
 n;n;+i;- O
 =~ [d;1+d:] ?
 i;1+i:]
#

0i:
[n;2*i;>]
[% i;1+i:]
#

d;. 

470H - Array Sorting

Same as the regular sorting task, this problem can be solved in many ways.

You could write a "simple counting sort", as recommended by Egor: do an outer loop from 1 to 100, in the inner loop iterate over all array elements and print each element that equals the counter of the outer loop. Here is the code.

Or you could store array elements in named variables (since there are very few of them) and generate a code which would compare pairs of variables and swap them if needed. Thus, instead of a[0] you use variable a, instead of a[1] — b etc. The first such solution I've seen was nab's: the code.

I chose yet another approach: read array elements into a stack and use selection sort, but each time you need a swap, copy the whole array (with elements swapped already) onto the top of the stack. After at most n swaps the top of the stack will hold a sorted array. Unfortunately, stack size is limited, and with n around 20 it overflows. So I reduced array size a lot, which also allowed other approaches :-)

[0[^ $$ 47> \58\> &]['0- \ 10*+]#%] r:

r;! n:   {read the number of elements in array}

0i:
[n;i;>]
[r;! i;1+i:]
#        {read the elements of the array}

1s:      {# of array copies stored in memory}

0i:
[n;1-i;>]
[ i;m:          {index of min element between i and n-1, inclusive}
  i;1+j:
  [n;j;>]
  [ n;m;-1- O   {extract a[m]}
    n;j;- O     {extract a[j], knowing that a[m] is on top}
    >
    [j;m:] ?    {if a[j] > a[m], m := j}
    j;1+j:
  ]#

  i;m;=~
  [ 0k:
    [n;k;>]
    [ k;e:     {index of element we're extracting now}
      k;i;=
         [m;e:] ?
      k;m;=
         [i;e:] ?
      n;k;+e;-1- O
      k;1+k:
    ]#
    s;1+s:      {+1 copy of array in memory}
  ] ?           {if i != m, copy all elements, while swapping a[i] and a[m]}
   
  i;1+i:]
#

0i:
[n;i;>]
[n;i;-1- O . " "
 i;1+i:]
#

0i:
[n;s;*i;>]
[% i;1+i:]
#