Tópico dos policiais

Nesse segmento, sua tarefa é criar um programa / função baseado em recursão para gerar qualquer série inteira. Os ladrões tentarão encontrar uma solução não recursiva mais curta no segmento dos ladrões .

Sinopse do desafio

Em muitos idiomas, as funções recursivas podem simplificar significativamente uma tarefa de programação. No entanto, a sobrecarga de sintaxe para uma recursão adequada pode limitar sua usabilidade no código-golfe.

Os policiais criarão um programa ou função usando um único número inteiro n, o que gerará as primeiras nentradas de uma série inteira, usando apenas a recursão ¹ . Eles também devem garantir que haja uma maneira não-recursiva mais curta de gerar a sequência para marcar sua entrada como segura.

Os ladrões tentarão encontrar um programa ou função mais curto no mesmo idioma, gerando a mesma série inteira, sem recursão ² .

Se o envio dos policiais não for decifrado dentro de dez dias (240 horas), o policial provará que era de fato possível ter uma abordagem não recursiva mais curta, revelando sua própria solução. Eles podem então marcar sua submissão como segura .

O vencedor do desafio da polícia será o envio mais curto (de acordo com o código-golfe ) baseado em recursão marcado como seguro.

O vencedor do desafio dos ladrões será o ladrão que quebrou mais soluções.

^{1: ele só precisa ser recursivo na sintaxe; você não precisa se preocupar, por exemplo, com a otimização da chamada de cauda.}

^{2: Novamente, não-recursivo na sintaxe; portanto, você não pode publicar uma solução recursiva e reivindicá-la compilada em um loop, graças à otimização da chamada de cauda.}

Requisitos de envio

Cada envio terá um único número inteiro n(com base em zero ou um). O envio produzirá ou retornará as primeiras nentradas de uma série inteira de escolha. (observe que essa série inteira não deve depender n). O método de entrada e saída pode diferir entre a abordagem recursiva e não recursiva. A série inteira pode ser qualquer série determinística com um comprimento de pelo menos 5. A série deve ser explicada corretamente.

Seu envio não precisa ser arbitrário n, mas deve funcionar pelo menos n=5. A abordagem não recursiva deve ser capaz de trabalhar pelo menos da mesma maneira nque a abordagem recursiva, ou até o n=2^15-1que for menor.

Recursão

Para esse desafio, recursão é definida como a criação da sequência desejada usando uma função (ou construção semelhante a uma função ) que se chama (ou chama uma sequência de funções que acaba se chamando; isso inclui construções como o combinador Y). A profundidade da recursão deve ir para o infinito como nvai para o infinito. A abordagem não recursiva é algo que não é recursivo.

Python 3 , 65 bytes (Seguro)

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)

Experimente online!

Outra tentativa em Python.

A sequência é "o número de maneiras de preencher um tabuleiro 2 por n com dominós em três cores, de modo que nenhum dominó da mesma cor se toque". Não no OEIS.

Vamos dizer n=6. O quadro se parece com:

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

e essas são inclinações de dominó válidas em três cores ( 1-3representam uma cor cada):

123123 122331 212332 212121 113311
123123 133221 212112 212121 331133

mas não são (dois dominós da mesma cor estão se tocando):

112323 332333 211113
112323 112311 233223

A sequência conta todas as possíveis inclinações de dominó que atendem às regras de cada uma n.

Solução pretendida, 58 bytes

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

Experimente online!

Infelizmente, parece que ninguém se incomodou em simplificar a relação de recorrência, o que foi claramente mostrado no código recursivo. Criar um programa com a recorrência dupla fornecida como está não funciona, pois é o Python 3.

Oitava , 47 bytes, quebrada por l4m2

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

Experimente online!

Como exemplo, aqui está uma entrada de oitava que gera os primeiros nnúmeros inteiros positivos, https://oeis.org/A000027 .

Python 3 , 75 bytes, quebrado pelo 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}))

Experimente online!

Os famosos números de Hamming, também conhecidos por números 5 suaves ( A051037 ).

Solução rachada, 51 bytes

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

Experimente online!

Solução pretendida, 74 bytes

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

Experimente online!

Quarto (gforth) , 39 bytes, quebrado por NieDzejkob

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

Experimente online!

Röda , 40 bytes

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

Experimente online!

Esta função fornece a seguinte sequência finita (os 90 primeiros números de Fibonacci):

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

Sei que pode gerar mais números de Fibonacci, mas, para fins desse desafio, é suficiente produzir esses números.

JavaScript (Node.js) , 91 bytes, Rachado por 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]

Experimente online!

Imprime os primeiros n termos da sequência OEIS A022559 (a partir de i = 1).

l4m2 coube 3 para loops em 74 72 bytes e rachou meu posto de policial:

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

No entanto, minha resposta pretendida realmente tem apenas 2 para loops:

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

Experimente online!

Função x86 .COM, 12 bytes, Rachada por 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

Entrada DX, Saída [DI] ~ [DI + 2 * DX-1]

Solução do cracker:

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

Solução pretendida:

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

Python 3 , 62 bytes, rachado por mwchase

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

Experimente online!

Eu sinto que este vai ser fácil demais ...

A sequência é a sequência de Fibonacci f(n) = f(n-1) + f(n-2)comf(0) = f(1) = 1

Gol> <> , 15 bytes, quebrado por mbomb007

I1AZZ;
M:K:?ZNB

Experimente online!

A série é 0,1,2,3,4,5 mas cada elemento é seguido por muitos 0s.

Por exemplo, os primeiros valores são:

 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 bytes, Rachado

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

Experimente online!

Retorna os primeiros n elementos em uma matriz invertida

Windows .BAT, 80 bytes

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

Uso:

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

A versão do loop pode assumir no dicionário atual, mas precisa iniciar ou redefinir

Python, 82 bytes; rachado

Esta é uma implementação Python recursiva da sequência OEIS A004001 em 82 bytes. Mais informações sobre esta série podem ser encontradas em Mathworld da Wolfram .

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]]

Os 30 primeiros números nesta sequência são:

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