n == 1 = (n:ns)

n == 1 = 1

Я хаскелей не знаю, но...

Зачем нужен хаскель?

(defun f (&optional (start 27))
  (loop for n = start then (if (oddp n)
                             (1+ (* 3 n))
                             (ash n -1))
        collect n
        until (= n 1)))

(format t "[~{~a~^, ~}]" (f))

На хаскелле это через рекурсию делается гораздо проще и быстрее чем в вашем варианте.

Но зачем нужен хаскелл?

def geb_seq(n):
    while n != 1:
        yield n
        n = 3 * n + 1 if n % 2 else n / 2
    yield n

print list(geb_seq(27))

Зачем нужен хаскель? (с)

long n = 27;
while( n != 1 )
	n = n % 2 ? 3 * n + 1 : n / 2, printf( "&d", n );

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

>сходимость

вообще-то не сходимость, но это и так понятно.

project euler?

по хорошему - да, тут нужно подключать gmplib, например, но опять же такие детали оговариваются особо, как и действия при попадании в бесконечную рекурсию

Haskell гораздо красивее и позволяет гораздо более математические записи делать.

collatzSteps :: Integer -> [Integer]
collatzSteps n =
  let nextElement n
          | odd n = 3*n + 1
          | otherwise = n `div` 2
  in n : map nextElement (collatzSteps n)

gebseq :: Integer -> [Integer]
gebseq n = takeWhile (/=1) (collatzSteps n) ++ [1]

Так, уже интереснее. Спасибо.

Зачем нужен CL?

(define (f (n 27))
  (let ((nn (if (odd? n)
              (+ 1 (* 3 n)) 
              (/ n 2))))
    (cons nn
          (if (> nn 1)
            (f nn) 
            null))))

(f)

Спасибо :-)

>но опять же такие детали оговариваются особо

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

Круто!

я ж не спорю :), вот вам новый вариант - с длинными числами и все так же в три строки:

mpz_class n = 27;
while( n != 1 )
    n = n % 2 ? 3*n+1 : n/2, cout << n.get_str(); 

>Haskell гораздо красивее и позволяет гораздо более математические записи делать.

это чтобы получить возможное переполнение стека?

Впрочем, и Схема не нужна.

-module(f).
-export([f/1]).

f(1) ->
    []; 

f(N) when is_number(N) ->
    NN = if
        N rem 2 == 1 ->
            1 + 3 * N;
        true ->
            N div 2
    end,
    [NN|f(NN)].

ага... как и такой код на Erlang :)

gebseq(N) -> 
    geb(N, []).

geb(1, Res) -> 
    lists:reverse([1|Res]);
geb(N, Res) when N rem 2 == 1 ->
    gebseq(1 + 3 * N, [N|Res]);
geb(N, Res) ->
    gebseq(N div 2, [N|Res]).

мда...

 
gebseq(N) ->  
    geb(N, []). 
 
geb(1, Res) ->  
    lists:reverse([1|Res]); 
geb(N, Res) when N rem 2 == 1 -> 
    geb(1 + 3 * N, [N|Res]); 
geb(N, Res) -> 
    geb(N div 2, [N|Res]). 

Очевидно, по той причине, что то, что ты накатал, мало того, что выглядит как говно, так еще и не справляется с задачей(внятный вывод).

Вот, кстати, кто еще тут сомневается в превосходстве CL? Из всех приведенных вариантов, на нем - единственный понятный и читаемый, и к тому же самый простой и, практически, самый эффективный.

В отличие от вот такого говна

yield n 
        n = 3 * n + 1 if n % 2 else n / 2 
    yield n 

вот такого говна

n = n % 2 ? 3 * n + 1 : n / 2, printf( "&d", n ); 

или какого-нибудь хаскельного отблева из буковок, за один вид которого очень хочется настучать как автору кода, так и автору языка по голове

obvious fix

> или какого-нибудь лиспового отблева из скобочек, за один вид которого очень хочется настучать как автору кода, так и автору языка по голове

Это я к тому что толсто

Какой отблев из скобочек, дурень?

Где ты вот тут его увидел?

(loop for n = start then (if (oddp n)
                           (1+ (* 3 n))
                           (ash n -1))
      collect n
      until (= n 1))

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

PS из всех кусков кода в этом треде ЭТО я бы назвал понятным в последнюю очередь

LongInteger n = 27;

while( n != 1 )
{
    if( odd( n ) )
        n = 3 * n + 1;
    else
        n /= 2;
}

вот код на говно-с++, чем он не такой «литературный английский» как вариант на лиспе?

Т.е. ты возражаешь против того, что у хаскеля блевотный засахаренный синтаксис(про то, что он скрывает еще более блевотную семантику сейчас не будем)? Ты на нем много кода видел? Да с ним же только разве перл да c++ с шаблонами по отвратительности соперничать могут.

PS из всех кусков кода в этом треде ЭТО я бы назвал понятным в последнюю очередь

А вот это вот реально троллинг. И ты еще меня троллем называешь?

Ты утрируешь. Во-первых, это код на Си. Во-вторых, до определенного предела, и при должном форматировании, код на Си действительно приятно читать, особенно если не используются указатели, гыгы. Хотя, опять же, парсить мозгом operator precedence - дикая головная боль, иногда.

> Во-первых, это код на Си

таки С++ - LongInteger это typedef на класс mpz_class,

Как я могу возражать против твоих субъективных суждений? Пока ты не написал ни одного объективного высказывания, которое можно было бы обсудить.

Я в свою очередь высказал свое субъективное мнение о твоем примере

Пример объективного высказывания: код на лиспе обычно нечитаем для не-лиспера (впрочем это применимо почти к любому языку)

За объективные суждения у меня и так уже много наминусовано в score :)

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

Более того, т.к. CL может менять семантику и синтаксис до неузнаваемости, и в этом собственно его суть, спорить о читаемости кода на нем - просто глупо.

Мне почему-то кажется, что если показать этот тред не-программисту, то он сможет понять смысл разве что куска кода на C

>Меня

Мне

Когда «кажется», надо сниматься транквилизаторами, ага.

Ну давай проведем эксперимент)

(тяну обе руки) я доброволец из зала - возьмите меня!

Это же псевдокод практически, чуть ли не литературный английский

| n out |
n   := (Smalltalk getArgv: 1) asInteger.
out := [:x | Transcript << x << ' ' ].

out value: n.

[n ~= 1] whileTrue: [
  n odd
    ifTrue:  [ n := 3 * n + 1 ]
    ifFalse: [ n := n / 2 roundTo: 1 ].
  out value: n]

Это же псевдокод практически, чуть ли не литературный английский.

код на хаскеле: пока элемент не равен 1, генерировать его по правилу %правило%

код на CL: цикл по элементу начать тогда %правило% собирать пока элемент не равен 1

я не сомневаюсь, что на CL можно писать «почти на литературном английском», но в твоём коде я его в упор не вижу

Цикл.
Пусть 'n' [сначала] принимает значение 'start', потом - если 'n' нечетно, {1 плюс {умножить три на 'n'}}, в противном случае - {арифметический сдвиг 'n' влево на -1}
собирай 'n' [в список]
до тех пор пока не выполнится условие
                              равенста 'n' и 1

Код на хаскеле у меня проговорить таким образом язык не поворачивается.

Код на хаскеле у меня проговорить таким образом язык не поворачивается.

возможно, дело привычки. в любом случае, объективность подобных утверждений сильно хромает

> Это же псевдокод практически, чуть ли не литературный английский.

Lmao. Это что угодно, но не псевдокод. Код выше на пайтоне и то понятнее, так как в твоём варианте слишком много сахара (и цикл дурацкий, да)

А так:

[code] import List

collatz = unfoldr collatzStep where collatzStep 0 = Nothing collatzStep 1 = Just (1, 0) collatzStep x = if odd x then Just (x, 3 * x + 1) else Just (x, x `div` 2) [/code]

Из всех приведенных вариантов, на нем - единственный понятный и читаемый мною

fixed

Код на хаскеле у меня проговорить таким образом язык не поворачивается.

Естественно, ибо он проговаривается гораздо проще, без всяких ненужных «циклов».

> ага... как и такой код на Erlang :)

Ну извиняйте. В (почти) 3 часа ночи осилил только построчный перевод со Схемы.