Undesigned unfriendly page

 {&'#.' @ (2:<|) @ ((+*:)^:400 0:)  (18 %~ i:_20) j.~/ 28 %~ _59+i.75
...........................................................................
...........................................................................
...........................................................#...............
...........................................................................
........................................................#..................
.......................................................##..................
.....................................................######................
.....................................................######................
......................................................####.................
............................................#....##############............
............................................##.##################.###......
.............................................#######################.......
.........................................#.#########################.......
..........................................###########################......
........................................###############################....
...............................#........##############################.....
...........................########....################################....
..........................###########..###############################.....
.........................#############.##############################......
......................#..#############.##############################......
...################################################################........
......................#..#############.##############################......
.........................#############.##############################......
..........................###########..###############################.....
...........................########....################################....
...............................#........##############################.....
........................................###############################....
..........................................###########################......
.........................................#.#########################.......
.............................................#######################.......
............................................##.##################.###......
............................................#....##############............
......................................................####.................
.....................................................######................
.....................................................######................
.......................................................##..................
........................................................#..................
...........................................................................
...........................................................#...............
...........................................................................
...........................................................................

Current Mood: creative

class Person
  attr_accessor :name, :age
  def initialize(name, age)
    @name = name
    @age  = age.to_i
  end
  def inspect
    "#@name (#@age)"
  end
end

p1 = Person.new('elmo', 4)
p2 = Person.new('zoe', 7)

p1               # -> elmo (4)
p2               # -> zoe (7)

class Person
  attr_accessor :name, :age
  def initialize(name, age)
    @name = name
    @age  = age.to_i
  end
  def inspect
    "#@name (#@age)"
  end
end

p1 = Person.new('elmo', 4)
p2 = Person.new('zoe', 7)

p1               # -> elmo (4)
p2               # -> zoe (7)

<table><tr><td bgcolor="gray">&nbsp;</td><td>&nbsp;</td><td><pre>
тут идёт кусок кода
</pre></td></tr></table>

Current Mood: creative

   t =. 4 : '0 (x.) } y.'
   2 t i.5
0 1 0 3 4

Current Mood: creative

Эту штуку я запнул на rsdn в "Декларативное программирование", но для полноты картины сюда тоже решил. Взять запостить в список рассылки erlang-questions, что ли. Может быть аффтару, Urban Boquist-у будет приятно...

Итак, что мы видим сначала? Большую буковку "ё".

                             -module(e).
                         -export([main/1]).
                       -import(lists,[all/2]).
                         -define(t(A,B),B
                            andalso A).

f(E,R,L,A,N,G) ->

         if E>G->{c,N};L>G->f(E+1,R,R,R,N,G);A>G->c(
       R,N,G);true->case g(E,L,N)of g->f(E,R,L+1,R,N,G
     );_->b(G,E,A,R,N,L)end end. d(A,B)->h(3#21,B,A). h(
    A,B,C)->case f(C,             C,C,C,[{C-1,C-1,a}|B],A
   +2)of{c,D}->e(A+                 1,TL(lists:sort((D))));
 _->fail end. main                   (A)->d(1,A). b(E,R,L,A,
 N,G)when L>E->f(                     R,A,G,L,N,E);b(L,A,N,G,
 E,R)->V=round(math:sqrt(L)),C=fun(I)->(I-1)div V*V end,D=fun
 ({_,_,Q})->N/=Q end,case?t(all(D,[{I,O,S}||{I,O,S}<-E,A==I]),
 ?t(all(D,[{I,S,O}||{I,S,O}<-E,R==S]),all(D,lists:filter(fun({
 O,S,_})->?t(C(A)
 <O,?t(O=<C(A)+V,
 ?t(C(R)<S,S=<C(R
 )+V)))end,E))))of                                true
  ->f(A,G,R+1,G,[{A                              ,R,N}|E
   ],L);_->b(L,A,N+1,                           G,E,R)end.
    a(D,{C,A})->[[B||                          {_,_,B}<-C]|
      e(D-1,A)]. e(_,[                        ])->[];e(E,L)
        ->a(E+1,lists:split(E+1,L)). c(_,[{_,_,a}|_],_)->b
         ;c(B,[{R,K,N}|S],A)->f(R,B,K,N+1,S,A);c(_,[],_)
           ->b. g(B,A,[{B,A,_}|_])->g;g(_,_,[])->h;g(B
                ,A,[_|C])->g(B,A,C).

-module(e).
-export([main/1]).
-import(lists, [all/2]).

-define(t(A, B), B andalso A).

f(E, R, L, A, N, G) ->
    if 
        E > G -> {c, N};
        L > G -> f(E+1, R, R, R, N, G);
        A > G -> c(R, N, G);
        true -> case g(E, L, N) of
            g -> f(E, R, L+1, R, N, G);
            _ -> b(G, E, A, R, N, L)
        end
    end.

d(A, B) -> h(3#21, B, A).

h(A, B, C) ->
    case f(C, C, C, C, [{C - 1, C - 1, a} | B], A + 2) of
        {c, D} -> e(A + 1, tl(lists:sort((D))));
        _      -> fail
    end.

% A is list like [{1,3,8},{1,4,4},{1,7,3},{1,8,5},{2,6,1}, ... ].
main(A) -> d(1, A).

b(E, R, L, A, N, G) when L > E->
    f(R, A, G, L, N, E);
b(L, A, N, G, E, R) ->
    V = round(math:sqrt(L)),
    C = fun(I) -> (I - 1) div V * V end,
    D = fun({_, _, Q}) -> N /= Q end,
    case
        ?t(all(D, [{I, O, S} || {I, O, S} <- E, A == I]),
        ?t(all(D, [{I, S, O} || {I, S, O} <- E, R == S]),
        all(D, lists:filter(
            fun({O, S, _}) -> 
                ?t(C(A) < O, ?t(O =< C(A) + V, ?t(C(R) < S, S =< C(R) + V)))
            end, E))))
    of
        true -> f(A, G, R + 1, G, [{A, R, N} | E], L);
        _    -> b(L, A, N + 1, G, E, R)
    end.

a(D, {C, A}) -> [[B || {_, _, B} <- C] | e(D - 1, A)].

e(_, []) -> [];
e(E, L) -> a(E + 1, lists:split(E + 1, L)).

c(_, [{_, _, a} | _], _) -> b;
c(B, [{R, K, N} | S], A) -> f(R, B, K, N + 1, S, A);
c(_, [], _) -> b.

g(B, A, [{B, A, _} | _]) -> g;
g(_, _, []) -> h;
g(B, A, [_|C]) -> g(B, A, C).

main(List) -> h(7 + 2, List, 1).

h(Size, List, I) ->
    case f(I, I, I, I, [{I - 1, I - 1, a} | List], Size) of
        {c, D} -> e(Size - 1, tl(lists:sort((D))));
        _      -> fail
    end.

(3#21 это просто число 7, такой вот способ записи, явно для запудривания мозгов).

Далее рассматриваем мешанину символов... Вдруг - о! - что-то знакомое: функция g - это явно поиск пары в списке. Эта функция вызывается только из f. Первые 2 параметра у g - это номера строки и столбца ячейки. Следовательно, список параметров f уточняется до:

f(Rw, R, Cl, A, L, Size) -> ...

find_cell(Rw, Cl, [{Rw, Cl, _} | _]) -> found;
find_cell(_, _, []) -> not_found;
find_cell(Rw, Cl, [_|L]) -> find_cell(Rw, Cl, L).

Смотрим на параметр R у функции f. Он при первом вызове получает значение 1, затем появляется в функции b под именами A (первое "тело") и G (второе "тело") и в функции с под именем B, но при этом никогда не принимает нового значения! Переименовываем его в I (потому что I похожа на единичку) где только можно. Нужно только позаботиться об отсутствии коллизии имён в функции b.

Мешает макрос. Макрос в баню, тогда условие в case можно записать так (здесь я уже переименовал A->Rw и R->Cl исходя из соответствия функции f):

all(D, [{I, O, S} || {I, O, S} <- E, Rw == I] andalso
all(D, [{I, S, O} || {I, S, O} <- E, Cl == S] andalso
all(D, lists:filter(
    fun({O, S, _}) -> 
        C(Rw) < O andalso O =< C(Rw) + V andalso C(Cl) < S andalso S =< C(Cl) + V
    end, L))

1> C=fun(X)->(X-1) div 3 * 3 end.
#Fun<erl_eval.6.43886099>
2> lists:map(C, lists:seq(1,9)).
[0,0,0,3,3,3,6,6,6]

Ага! А функция D проверяет, не равна ли ячейка числу N. Да, это оно! Это условие выражает основное правило Судоку: число в текущей ячейке не должно совпадать ни с одним из чисел в строке, ни в столбце и ни в соответствующем текущей ячейке квадрате.

Теперь _очень пристально_ смотрим на параметр A у функции f. Видно, что он используется очень активно и он попадает в функцию b (2 тело) под именем N, на котором и завязано условие. Всё ясно - это номер в текущей ячейке.

Далее, переименовываем параметры у функций b и c так, чтобы они соответствовали параметрам f. Получим (опуская несущественные пока детали):

f(Rw, I, Cl, Nm, L, Size) -> ....
b(Size, Rw, Nm, I, L, Cl) -> ....
...
c(I, [{Rw, Cl, Nm} | L], Size) -> f(Rw, I, Cl, Nm + 1, L, Size);
...

Итак, ещё раз: Rw, Cl - координаты текущей ячейки, Nm - текущий номер, L - список троек, Size - в данном случае всегда 9, I - в данном случае всегда 1.

Снова пристально смотрим на f, что же она делает:
1. Если текущая координата строки большая - то выдаёт решение;
2. Если текущая координата столбца большая - то переходит к следующей строке;
3. Если текущий номер в ячейке большой - то вызов функции c(...);
4. Ищет текущую ячейку в списке,
4.1 если нашлась - то переходит к следующей ячейке в текущей строке;
4.2 если не нашлась - то вызывает b с текущей ячейкой и номером == 1.

Пристально смотрим на b, что делает она:
0. Если текущий номер слишком большой, то вызывает f (это срабатывает тело с гвардом);
1. Для данного номера проверяет, можно ли вписать его в текущую ячейку,
1.1. если можно, то добавляет ячейку в список и вызывает f;
1.2. если нельзя, то вызывает себя со следующим номером.

Теперь по-русски. Функция f двигается по матрице справа налево, сверху вниз. Если в ячейке ещё пусто, то вызывается функция b. Функция b последовательно подбирает номер в текущей ячейке начиная с 1. Подбор заканчивается либо добавлением новой ячейки в список, либо передачей в f параметра Nm == 10. В последнем случае срабатывает условие:

    Nm > Size -> c(I, L, Size);

Теперь понятно, что делает функция c. Функция c - это откат. Если головоломка не совсем банальная, то однажды процесс заткнётся тем, что в текущую ячейку невозможно будет вписать никакой номер от 1 до 9. В этом случае происходит откат: от списка "откусывается" головной элемент, и подбор продолжается со следующего номера.

Остаются мелочи - функции a и e. e - это просто преобразование списка троек в матрицу. Список троек должен быть полным, иначе функция завалится. Функция a "откусывает" 9 троек и вытягивает их в линейный список. Можно избавиться от E+1, заменив на просто E, но тогда соответственно поменять и вызов в функции h.

Долго ли, коротко ли, но окончательный вариант этого рефакторинга превратился в:

-module(e).
-compile(export_all).
%-export([main/1]).

% (1..10), 1, (1..10), (1..10), List, 9
set_cell(Rw, I, Cl, Nm, L, Size) ->
    if 
        Rw > Size -> {done, L};
        Cl > Size -> set_cell(Rw+1, I, I, I, L, Size);
        Nm > Size -> rollback(I, L, Size);
        true -> case find_cell(Rw, Cl, L) of
            found -> set_cell(Rw,   I, Cl+1, I, L, Size);
            _     -> try_number(Size, Rw, Nm, I, L, Cl)
        end
    end.

% 9, List, 1 
start(Size, List, I) ->
    case set_cell(I, I, I, I, [{I - 1, I - 1, a} | List], Size) of
        {done, L} ->
            io:format("~w~n", [lists:sort(L)]), % отсебятина :-)
            list2matr(Size, tl(lists:sort((L))));
         _        -> fail
    end.

% List is list like [{1,3,8},{1,4,4},{1,7,3},{1,8,5},{2,6,1}, ... ].
main(List) -> start(9, List, 1).

try_number(Size, Rw, Nm, I, L, Cl) when Nm > Size ->
    set_cell(Rw, I, Cl, Nm, L, Size);
try_number(Size, Rw, Nm, I, L, Cl) ->
    V = round(math:sqrt(Size)),
    Cvv = fun(X) -> (X - 1) div V * V end,
    Neq = fun({_, _, X}) -> Nm /= X end,
    case
        lists:all(Neq, [{R, C, N} || {R, C, N} <- L, Rw == R]) andalso 
        lists:all(Neq, [{R, C, N} || {R, C, N} <- L, Cl == C]) andalso
        lists:all(Neq, lists:filter(
            fun({R, C, _}) -> 
                Cvv(Rw) < R andalso R =< Cvv(Rw) + V andalso 
                Cvv(Cl) < C andalso C =< Cvv(Cl) + V
            end, L))
    of
        true -> set_cell(Rw, I, Cl + 1, I, [{Rw, Cl, Nm} | L], Size);
        _    -> try_number(Size, Rw, Nm + 1, I, L, Cl)
    end.

% L1, L2 - lists, E - integer
extr_row(E, {L1, L2}) -> [[N || {_, _, N} <- L1] | list2matr(E, L2)].

% E - integer, L - list
list2matr(_, []) -> [];
list2matr(E, L) -> extr_row(E, lists:split(E, L)).

% 1, List, 9 
rollback(_, [{_, _, a} | _], _) -> fail;
rollback(I, [{Rw, Cl, Nm} | L], Size) -> set_cell(Rw, I, Cl, Nm + 1, L, Size);
rollback(_, [], _) -> fail.

% (1..9), (1..9), List
find_cell(Rw, Cl, [{Rw, Cl, _} | _]) -> found;
find_cell(_, _, []) -> not_found;
find_cell(Rw, Cl, [_|L]) -> find_cell(Rw, Cl, L).

1. Поиск здесь в глубину с возвратом, однако возврат выражается только в удалении новых троек из (текущего) списка. Сами вызовы в течение этого поиска "забираются" всё глубже и глубже в рекурсию. Тем не менее с памятью вообще и стеком в частности всё в порядке, потому что железно работает last call optimization. Слегка непривычно, совсем не так как в С??, где для отката нужно было бы выходить из текущего уровня рекурсии. (Но там и таскать с собой текущий список в качестве параметра тоже не нужно было бы). Хотя есть и альтернативные варианты: сделать так, чтобы функции set_cell и try_number возвращали пару {List, result}, или принимали List, а возвращали result. Тогда глубина рекурсии должна существенно уменьшиться.

2. Даже обфусцированные функциональные программы по-прежнему доступны для понимания, поскольку результат работы функции целиком зависит от параметров и можно на мгновение забыть вообще обо всей программе сконцентрировавшись только на этой функции. Также сильно облегчает анализ неизменность "забинженных" переменных - то бишь прозрачность ссылок (внутри функции куда ни ткни - везде Nm это Nm). Трудности пожалуй могут возникнуть в случаях"большой-пребольшой функции у которой много-премного параметров" и "много-премного переплетённых (взаимно-рекурсивных) функций у которых много-премного параметров".

Собстно вот, ду хаст!

Current Mood: creative

   pitriang =. ([:#~odd) ,/. pilist
   pitriang 5
3
141
59265
3589793
238462643
   u =. (- @ |."1 @ i.)
   pitree = u |."0 1 pitriang
   pitree 5
    3
   141
  59265
 3589793
238462643

   u 5
_4 _3 _2 _1 0
   -i.- 5
_4 _3 _2 _1 0

Current Mood: creative

   pprod =: +/ /. @ (*/)
   1 2 pprod 1 3 1
1 5 7 2

   x (P Q@R) y
+-------------+
|x _P_ Q_ R_ y|
+-------------+
   NB. в данном случае (+/ это P, /. это Q, */ это R

   1 2 +/ (/. (*/) 1 3 1)
|syntax error
|   1 2+/(    /.(*/)1 3 1)

   pprod
+----------+-+-----+
|+-----+--+|@|+-+-+|
||+-+-+|/.|| ||*|/||
|||+|/||  || |+-+-+|
||+-+-+|  || |     |
|+-----+--+| |     |
+----------+-+-----+

   x (P Q R) y
(x _P_ y) _Q_ (x _R_ y)

Current Mood: creative

   pi=: [: ": [: <.@o. 10x"_^]
   pi_list=: [: pi [: <: [: *: ]
   pi_triangle=: ([: #~ odd) ,/. pi_list
   odd=: 1: + 2: * i.
   pi_tree=: ([: - [: i. -@]) |."0 1 pi_triangle
   pi_tree 16
               3               
              141              
             59265             
            3589793            
           238462643           
          38327950288          
         4197169399375         
        105820974944592        
       30781640628620899       
      8628034825342117067      
     982148086513282306647     
    09384460955058223172535    
   9408128481117450284102701   
  938521105559644622948954930  
 38196442881097566593344612847 
5648233786783165271201909145648

Current Mood: creative