470A - Последовательность хрустального шара

Как обычно, первая задача проверяет способность участника выполнять базовые арифметические действия языка и решается даже проще, чем пример — без единого цикла.

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

470B - Гексакосиойгексеконтагексафобия

В этой задаче используются уже более сложные структуры языка — цикл, условное выполнение и даже именованные переменные! Переменные удобно использовать в качестве счетчиков циклов и накопителей результата, чтобы не возиться со стековыми манипуляциями с той же целью. Конструкция if-then-else на FALSE выглядит следующим образом:

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

Код решения:

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

Эту задачу можно было решать двумя способами. Можно было прочитать числа-операнды, сохранить их в именованные переменные и в зависимости от оператора применить к ним одно из действий. А можно было сделать наоборот, в зависимости от оператора сохранить нужное действие в именованную переменную (прелесть FALSE в том, что функции тоже могут быть переменными), и применить его к операндам, прочитанным в стек. Код второго способа:

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

r;!

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

r;!
%
f;!.

470D - Шифр Цезаря

Эта задача по сути комбинирует приемы, освоенные в предыдущих: чтение длинного числа, чтение строки и операцию взятия остатка от деления, которую, впрочем, можно было заменить условным вычитанием. Код:

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

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

470E - Шахматная доска

Внезапно эта задача оказалась легче двух предыдущих. Возможно, двойной цикл for проще, чем чтение до конца строки :-)

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 - Попарные суммы

Две следующие задачи используют новый элемент языка — оператор ø (он же O, не путать с 0), реализующий произвольный доступ на чтение к элементам стека. Для вычисления попарных сумм нужно было сначала прочитать все элементы массива в стек, а потом вычислять индексы нужных элементов, извлекать их и суммировать.

[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 - Расстояние Хэмминга

Тот же принцип, что в прошлой задаче — прочитать в стек символы двух строк (запомнив при этом длину строк в именованную переменную), затем извлекать из него пары соответствующих символов, сравнивать их и накапливать результат в еще одной именованной переменной.

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 - Сортировка массива

Эту задачу, как и обычную сортировку, можно решать многими способами.

Можно написать "простейшую сортировку подсчетом", как рекомендует Egor: во внешнем цикле пройти от 1 до 100, во внутреннем — перебрать все элементы массива и вывести все элементы массива, равные счетчику внешнего цикла. Код

Можно хранить числа в именованных переменных, благо их немного, и сгенерировать код, который будет проверять пары значений переменных и менять их местами. Т.е. вместо a[0] использовать переменную a, вместо a[1] — b и т.д. Первое такое решение замечено у nab: код

Я выбрала третий вариант, не знаю, использовал ли его кто-то еще: прочитать элементы массива в стек и применить сортировку выбором, но каждый раз, когда нужно поменять местами два элемента массива, скопировать весь массив (уже с поменянными элементами) на верх стека. Через n обменов на верху стека окажется отсортированная копия массива. К сожалению, размер стека ограничен, и при размере массива ~20 элементов происходит переполнение стека. Поэтому я сильно уменьшила размер массива, что и позволило использовать другие способы решения.

[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:]
#