Копій нитка

У цьому потоці ваше завдання - зробити програму / функцію на основі рекурсії для створення будь-якого цілого ряду. Розбійники спробують знайти коротше нерекурсивне рішення в потоці грабіжників .

Виклик конспекту

У багатьох мовах рекурсивні функції можуть значно спростити завдання програмування. Однак синтаксис накладних витрат для правильної рекурсії може обмежити його зручність використання у коді-гольф.

В копи будуть створювати програму або функцію , беручи одне ціле число n, яке буде генерувати перші nзаписи целочисленного ряду, використовуючи тільки рекурсії ¹ . Вони також повинні переконатися, що існує коротший нерекурсивний спосіб генерування послідовності, щоб позначити їх запис безпечним.

У розбійників намагатимуться знайти більш коротку програму або функцію на тій же мові, генеруючи той же ціле ряд, не використовуючи рекурсії ² .

Якщо подання поліцейських не буде розправлено протягом десяти днів (240 годин), поліцейський доведе, що насправді було можливим коротший нерекурсивний підхід шляхом виявлення власного рішення. Потім вони можуть відзначити їх подання як безпечне .

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

Переможцем виклику грабіжників стане розбійник, який зламав більшість рішень.

^{1: Він має бути лише рекурсивним у синтаксисі; вам не потрібно хвилюватися, наприклад, оптимізація хвостових викликів.}

^{2: Знову нерекурсивно в синтаксисі; тому ви не можете опублікувати рекурсивне рішення та заявити, що його складено у циклі завдяки оптимізації виклику хвоста.}

Вимоги до подання

Кожне подання буде приймати одне ціле число n(нульове або одне на основі). Потім подання виводить або повертає перші nзаписи цілого ряду вибору. (зауважте, що цей цілий ряд не повинен залежати від n). Метод введення та виведення може відрізнятися між рекурсивним та нерекурсивним підходом. Цілий ряд може бути будь-яким детермінованим рядом довжиною не менше 5. Серії повинні бути пояснені належним чином.

Ваше подання не повинно працювати для довільного великого розміру n, але має працювати принаймні n=5. Нерекурсивний підхід повинен бути здатний працювати принаймні так само, nяк рекурсивний підхід, або до n=2^15-1того, що є меншим.

Рекурсія

Задля цього завдання рекурсія визначається як створення потрібної послідовності за допомогою функції (або функціональної конструкції), яка викликає себе (або викликає послідовність функцій, яка закінчує виклик себе; сюди входять такі конструкції, як Y-комбінатор). Глибина рекурсії повинна йти до нескінченності, як і nдо нескінченності. Нерекурсивний підхід - це все, що не є рекурсивним.

Python 3 , 65 байт (безпечно)

f=lambda n,a=3,b=0,c=6,d=6:n*[1]and[a+b]+f(n-1,c,d,2*c+d,2*a+3*b)

Спробуйте в Інтернеті!

Ще одна спроба в Python.

Послідовність - «кількість способів заповнити 2-х по дошці доміно в трьох кольорах, щоб жодне одноколірне доміно не торкалося одне одного». Не на OEIS.

Скажімо n=6. Дошка виглядає так:

######
######

і це дійсні облицювання доміно в трьох кольорах ( 1-3представляють кольори кожен):

123123 122331 212332 212121 113311
123123 133221 212112 212121 331133

але це не так (два одноколірні доміно торкаються один одного):

112323 332333 211113
112323 112311 233223

Послідовність підраховує всі можливі облицювання доміно, які відповідають правилам для кожного n.

Розраховане рішення, 58 байт

n=int(input());a=3;b=12
for _ in[0]*n:print(a);a,b=b,a*4+b

Спробуйте в Інтернеті!

На жаль, схоже, що ніхто не заважав спростити відновлення рецидивів, що було чітко показано в рекурсивному коді. Зробити програму із заданим подвійним повторенням як - це не працює, оскільки це Python 3.

Октава , 47 байт, потріскана l4м2

@(n)(f=@(r,m){@()[r(r,m-1),m],[]}{~m+1}())(f,n)

Спробуйте в Інтернеті!

Як приклад, ось запис Octave, який генерує перші nдодатні цілі числа, https://oeis.org/A000027 .

Python 3 , 75 байт, розламаний xnor

f=lambda n,a=[1]:a*n and[a[0]]+f(n-1,sorted({*a[1:],a[0]*2,a[0]*3,a[0]*5}))

Спробуйте в Інтернеті!

Знамениті номери Хеммінга, він же 5-гладкі числа ( A051037 ).

Розтрісканий розчин, 51 байт

lambda n:[k for k in range(1,2**n)if 60**k%k<1][:n]

Спробуйте в Інтернеті!

Розраховане рішення, 74 байти

lambda n:sorted(2**(i%n)*3**(i//n%n)*5**(i//n**2)for i in range(n**3))[:n]

Спробуйте в Інтернеті!

Четвертий (gforth) , 39 байт, розламаний NieDzejkob

: | dup 1 > if dup 1 - recurse then . ;

Спробуйте в Інтернеті!

Roda , 40 байт

f x,a=1,b=2{[a];f x-1,a=b,b=a+b if[x>1]}

Спробуйте в Інтернеті!

Ця функція дає таку кінцеву послідовність (90 перших чисел Фібоначчі):

1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765
10946
17711
28657
46368
75025
121393
196418
317811
514229
832040
1346269
2178309
3524578
5702887
9227465
14930352
24157817
39088169
63245986
102334155
165580141
267914296
433494437
701408733
1134903170
1836311903
2971215073
4807526976
7778742049
12586269025
20365011074
32951280099
53316291173
86267571272
139583862445
225851433717
365435296162
591286729879
956722026041
1548008755920
2504730781961
4052739537881
6557470319842
10610209857723
17167680177565
27777890035288
44945570212853
72723460248141
117669030460994
190392490709135
308061521170129
498454011879264
806515533049393
1304969544928657
2111485077978050
3416454622906707
5527939700884757
8944394323791464
14472334024676221
23416728348467685
37889062373143906
61305790721611591
99194853094755497
160500643816367088
259695496911122585
420196140727489673
679891637638612258
1100087778366101931
1779979416004714189
2880067194370816120
4660046610375530309

Я знаю, що він може генерувати більше чисел Фібоначчі, але для цілей цього завдання достатньо створити ці числа.

JavaScript (Node.js) , 91 байт, Зламаний l4m2

f=x=>[w=~-x&&(g=(n,y=2)=>~-n&&(n<y?1:n%y?g(n,y+1):1+g(n/y,y)))(x)+f(x-1),console.log(w)][0]

Спробуйте в Інтернеті!

Друкує перші n строків послідовності OEIS A022559 (починаючи з i = 1).

l4m2 помістив 3 для циклу в 74 72 байти і зламав мій пост поліції :

n=>{for(i=s=0;j=i++<n;console.log(s))for(x=i;j++<i;)for(;x%j<1;x/=j)s++}

Однак у моїй призначеній відповіді насправді є лише 2 для циклу:

n=>{for(i=c=0;i++<n;console.log(c))for(p=2,z=i;p<=z;z%p?p++:(z/=p,c++));}

Спробуйте в Інтернеті!

x86 .COM функція, 12 байт, тріщиною NieDzejkob

0000 52                     push dx
0001 4A                     dec dx
0002 7403                   je 0007
0004 E8F9FF                 call 0000
0007 58                     pop ax
0008 F7E0                   mul ax
000A AB                     stosw


000B C3                     ret

Вхід DX, вихід [DI] ~ [DI + 2 * DX-1]

Рішення Крекера:

0: 31 C0    xor ax, ax
2: BF 01 00 mov di, 1
5: 01 F8    add ax, di
7: AB       stosw
8: E2 FB    loop 5
A: C3       ret

Задумане рішення:

  xor bx,bx
c:inc bx
  mov ax,bx
  mul ax
  stosw
  loop c
  ret

Python 3 , 62 байти, тріщини mwchase

def f(x):
 if(x<1):return[1]
 return f(x-1)+[sum(f(x-1)[-2:])]

Спробуйте в Інтернеті!

Я відчуваю, що це буде занадто легко ...

Послідовність - це послідовність Фібоначчі f(n) = f(n-1) + f(n-2)зf(0) = f(1) = 1

Gol> <> , 15 байт, тріщини по mbomb007

I1AZZ;
M:K:?ZNB

Спробуйте в Інтернеті!

Серія є, 0,1,2,3,4,5але за кожним елементом слідує стільки 0.

Наприклад, перші кілька значень:

 1: 0  First element, followed by 0 zeroes
 2: 1  Followed by 1 zero
 3: 0
 4: 2  Followed by 2 zeroes
 5: 0
 6: 0
 7: 3  Followed by 3 zeroes
 8: 0
 9: 0
10: 0
    etc.

JavaScript, 63 байти, тріщини

f=x=>(x?[f(x-1)[0]&&1?3*f(x-1)[0]+1:f(x-1)[0]/2,...f(x-1)]:[7])

Спробуйте в Інтернеті!

Повертає перші n елементів у зворотному масиві

Windows .BAT, 80 байт

@set /a n=%1-1
@echo 8%3
@if 0 neq %n% @call %0 %n% 2%3 6%2%3

Використання:

CD <PATH>
<FILENAME> <N_1>
<FILENAME> <N_2>
<FILENAME> <N_3>

Версія циклу може припускатись у поточному словнику, але повинна ініціювати чи скинути

Пітон, 82 байти; тріснув

Це рекурсивна реалізація Python послідовності OEIS A004001 в 82 байти. Більше інформації про цю серію можна знайти в Mathworld Вольфрама .

def A(n):
 if n in[1,2]:return[1]*n
 S=A(n-1);return S+[S[S[n-2]-1]+S[n-S[n-2]-1]]

Першими 30 числами в цій послідовності є:

1, 1, 2, 2, 3, 4, 4, 4, 5, 6, 7, 7, 8, 8, 8, 8, 9, 10, 11, 12, 12, 13, 14, 14, 15, 15, 15, 16, 16, 16