Ladrões: a subcadeia OEIS oculta

23

Este é um desafio de policiais e ladrões. Este é o fio do ladrão. A discussão do policial está aqui .

Os policiais escolhem qualquer sequência do OEIS e escrevem um programa p que imprime o primeiro número inteiro dessa sequência. Eles também encontrarão algumas cordas s . Se você inserir s em algum lugar em p , esse programa deverá imprimir o segundo número inteiro da sequência. Se você inserir s + s no mesmo local em p , este programa deverá imprimir o terceiro número inteiro a partir da sequência. s + s + s no mesmo local imprimirá o quarto, e assim por diante. Aqui está um exemplo:

Python 3, sequência A000027

print(1)

A cadeia oculta é de dois bytes .

A cadeia é +1, porque o programa print(1+1)imprimirá o segundo número inteiro em A000027, o programa print(1+1+1)imprimirá o terceiro número inteiro etc.

Os policiais devem revelar a sequência, o programa original p e o comprimento da sequência oculta s . Os ladrões quebram uma submissão encontrando qualquer sequência com esse comprimento e o local para inseri-la e criar a sequência. A sequência não precisa corresponder à solução pretendida para ser um crack válido, nem o local em que está inserida.

Se você quebrar uma das respostas da polícia, poste sua solução (com a string e o local ocultos revelados) e um link para a resposta. Em seguida, comente a resposta da polícia com um link para o seu crack aqui.

Regras

  • Sua solução deve funcionar para qualquer número na sequência, ou pelo menos até um limite razoável em que falha devido a restrições de memória, excesso de número inteiro / pilha, etc.

  • O ladrão vencedor é o usuário que racha mais entradas, sendo o desempate quem atinge esse número de rachaduras primeiro.

  • O policial vencedor é o policial com a menor corda s que não está quebrada. O desempatador é o menor p . Se não houver envios sem rachaduras, o policial que teve uma solução sem rachaduras por mais vitórias.

  • Para ser declarada segura, sua solução deve permanecer sem quebra por 1 semana e, em seguida, ter a sequência oculta (e o local para inseri-la) revelada.

  • s não pode ser aninhado, deve concatenar de ponta a ponta. Por exemplo, se s fosse 10, cada iteração seria executada em 10, 1010, 101010, 10101010...vez de10, 1100, 111000, 11110000...

  • Todas as soluções criptográficas (por exemplo, verificando o hash da substring) são proibidas.

  • Se s contiver caracteres não ASCII, você também deverá especificar a codificação que está sendo usada.

DJMcMayhem
fonte

Respostas:

13

Python 2 , sequência A138147 por xnor

Original:

print 10

Rachado:

print "1%s0"%10
      ^^^^^^^

Experimente online!

hobbs
fonte
3
Você entendeu! Essa é a solução que eu estava pensando. Acho interessante que funcione, dado que %os associados de esquerda.
xnor 11/07
Sim, mas uma string de formato é uma string e "1% s0"% "1% s0" é "11% s00", o que ainda é o que queríamos que acontecesse.
hobbs 12/07
10

Flak cerebral , A000984 por Nitrodon

({({}<>({}))<>}<>){({}<>)<>}<>

Isso tem apenas 30 bytes, não sei o que o Nitrodon tinha em mente.

Experimente online!

Explicação

Eu tentei muitas coisas, mas aqui está o que funcionou. Os termos de A000984 são os elementos centrais do triângulo de Pascal.

Elementos centrais

Agora eu descobri que posso obtê-los somando as diagonais acima deles:

Por exemplo:

1+3+6+10=20

Montantes centrais

E como a ação final no programa de Nitrodon é resumir tudo isso parecia um bom candidato (mais como eu tentei várias coisas, mas essa acabou funcionando).

Então, queremos um programa que tome uma soma parcial e produza a próxima. Felizmente, existe uma maneira bem interessante de passar de uma dessas para a seguinte. Cada linha é o delta da próxima linha. Que é o n º mandato consecutivo é a diferença entre o n º e n1 ª termos na próxima linha.

Fórmula da próxima linha

O único problema é que não temos o suficiente da última linha para calcular a linha que queremos. Como cada linha é uma mais longa que a última, se tivermos uma linha, não podemos obter o último membro da próxima linha com esse método. No entanto, aqui temos outro truque, o último membro de cada linha é igual a todos os membros anteriores dessa linha!

1+3+6=10

Fórmula do último membro

E se você estiver familiarizado com o Brain-Flak, isso deve se destacar como algo que será realmente fácil de fazer.

Agora, o código:

Para começar, fazemos o cálculo da próxima linha em que cada novo membro é a soma de dois membros antigos adjacentes. Isso pode ser feito com:

{({}<>({}))<>}<>

O que basicamente move um elemento e adiciona (sem exclusão) o que já estava em cima dele. No entanto, isso reverte tudo e, para a próxima vez que tivermos uma linha, precisamos colocá-la de volta.

{({}<>({}))<>}<>{({}<>)<>}<>

Agora precisamos calcular o último membro da linha. Como eu disse antes, isso é super fácil. Como tivemos um loop sobre todos os elementos da linha, podemos simplesmente pegar essa soma e pressioná-la. Empurramos antes do segundo loop para que ele acabe no fundo.

({({}<>({}))<>}<>){({}<>)<>}<>

E é isso.

Assistente de Trigo
fonte
1
Ainda melhor do que eu tinha em mente. Porém, uma correção para sua explicação: para passar de uma diagonal para a próxima, você está adicionando um número antigo a um novo número (calculando somas cumulativas da diagonal antiga), sem adicionar dois números antigos.
Nitrodon 12/07
@Nitrodon Explicação corrigida. Se eu tivesse lido meu próprio código, seria capaz de ver que estava errado.
Wheat Wizard
6

Brain-Flak, A000290 , por Sriotchilism O'Zaic

Original:

((()))({}<>)

Rachado:

((()))({}([])[]<>)
         ^^^^^^

Experimente online!

Alternativamente:

((())([])[])({}<>)
     ^^^^^^

Experimente online!

jimmy23013
fonte
Essa é a minha corda escondida! mas não é onde eu estava colocando. Bom trabalho, sem restrições!
Wheat Wizard
1
@ SriotchilismO'Zaic Então este deve ser o original.
jimmy23013 10/07
6

MATL , sequência A005206 de Luis Mendo

Original:

voOdoO

Experimente online!

Rachado:

voOdoOdNq17L/k
      ^^^^^^^^

Não sou especialista em MATL, mas pelo que entendi, o original voOdoOcria duas matrizes vazias e uma matriz [0]na pilha. [0]é isso que é impresso sem colchetes como o primeiro elemento da sequência. O crack / solução faz o seguinte:

  • dretira um elemento da pilha e (assumindo que seja um número ou uma matriz de tamanho 1) a transforma em uma matriz vazia. Essas matrizes vazias não são impressas, mas contribuem para o tamanho da pilha
  • Nqconta o tamanho da pilha e subtrai um. Esse é o n+1termo ao avaliar a função (uma vez que começa em 2 e aumenta em um a cada iteração devido aod adição de itens invisíveis à pilha)
  • 17L essa é a constante Phi = (1+sqrt(5))/2
  • /kisso executa floor((n+1)/Phi)qual é uma das fórmulas que calcula os elementos da sequência. Esta fórmula está listada no OEIS, a(n) = floor(sigma*(n+1)) where sigma = (sqrt(5)-1)/2exceto que usamos a identidade(sqrt(5)-1)/2 = 1/Phi
SamYonnou
fonte
Não sou especialista em MATL Bem, acho que você se tornou um - :) Para referência, minha string oculta era \N17L/k&(observe os dois usos diferentes &no meio e no final do código), mas sua solução é mais simples e mais elegante
Luis Mendo
5

Python 3 - A__

print(100+-1)

Experimente online!

100 garrafas de cerveja, adicione -1para obter o próximo número 99, etc.

Giuseppe
fonte
Bata-me por 7 segundos. :) Além disso, as regras dizem que encontrar qualquer string com esse comprimento para que você possa fazer isso -1. Vou deixar isso mais explícito.
DJMcMayhem
@DJMcMayhem eu li isso depois que eu enviei, mas é mais divertido colocar restrições adicionais para um crack tão fácil :-)
Giuseppe
5

Barril , sequência A000045 , de A__

Original:

0.

Rachado:

01":&+.
 ^^^^^

Observe que o desafio foi encontrar uma substring de comprimento <= 6, mas a cadeia encontrada tem comprimento 5.

Definição dos comandos para quem tem preguiça de procurar a especificação Keg: 0e 1empurre o número respectivo para a pilha; "move o topo da pilha para o fundo da pilha (rolo); &coloca a parte superior da pilha no registrador se estiver vazia; caso contrário, esvazia o registrador na pilha; +adiciona os dois principais valores da pilha.

A inicial 1"apenas insere um 1 na parte inferior da pilha. Essa lista crescente de 1s desempenha apenas um papel na primeira iteração, onde nos permite assumir que a pilha é iniciada 1 0e não apenas 0. De fato, o programa 10:&+., onde o:&+ peça é repetida, tem exatamente o mesmo comportamento da solução acima, exceto que não possui uma lista crescente de 1s na parte inferior.

Como &é usado apenas uma vez na parte de repetição e tem comportamento alternado, o comportamento de 1":&+depende da paridade da iteração.

Agora, este programa realmente não imprime a sequência de Fibonacci, começando com 0, 1 desde o início; na verdade, imprime a sequência 1, 0 de Fibonacci do segundo lugar, ou seja, do 0. (Isso resulta na mesma sequência.) Sabendo disso, o programa é facilmente analisado:

  • Na primeira, terceira, ... iteração, o estado começa como [a, b]e termina como a+b (&=b).
  • Na segunda, quarta, ... iteração, o estado começa como [b] (&=a)e termina como [b, b+a].

Isso realmente calcula a sequência conforme necessário.

tomsmeding
fonte
1
Bom, agora há alguém usando Keg como eu.
A
@A__ Qual era a sua string original de 6 caracteres? :)
tomsmeding 11/07
Na verdade, é muito semelhante à sua string; a única diferença é que eu adicionei um :comando no início da string.
A
É a string inserida mais curta possível que você pode encontrar?
A
2
Argh. Encontrei este, mas quando o desafio era <= 4 bytes.
Khuldraeseth na'Barya 11/07
4

Pyret , sequência A083420 , de MLavrentyev

fold({(b,e):(2 * b) + 1},1,[list: 0,0,])
                                  ^^^^

Você pode executá-lo aqui, mas ainda não descobri como vincular o código. Você terá que copiar e colar.

A função fornecida ignora seu segundo argumento. Dobra o primeiro e adiciona um, o que gerará a 2^n - 1sequência necessária aqui - tudo o que preciso fazer é dizer quantas vezes para executar essa operação, alterando o comprimento da lista dobrada. Felizmente, Pyret não reclama da vírgula.

Khuldraeseth na'Barya
fonte
4

Python 3 , sequência A268575 de NieDzejkob

Original:

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW")
print(len(W))

Rachado (100 bytes):

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW");A=-1,1,0;*X,=F(lambda a:(S(a,x)for x in product(A,A)),W);W={p for p in X if 2<X.count(p)<4+({p}<W)}
print(len(W))

Experimente online!

Pelo que pude entender, o código original está configurando definições para tornar a cadeia oculta o mais abreviada possível e, em seguida, definindo o padrão inicial do Jogo da Vida. A cadeia oculta é equivalente a escrever uma iteração do Jogo da Vida de Conway em 102 bytes.

Para os propósitos desse crack, Sé uma função que soma os elementos em seus argumentos (que são iteráveis) e Faplica uma função retornando um iterável a todos os elementos de uma lista e esmaga todos os resultados juntos.

  • ;A=-1,1,0;finaliza a instrução anterior e abrevia a tupla (-1,1,0) com A, que é usado product(A,A)para fornecer todos os vizinhos em relação a uma determinada célula, bem como a própria célula.
  • *X,=F(lambda a:(S(a,x)for x in product(A,A)),W);cria uma nova lista Xmantendo todos os vizinhos das células We as células em Wsi adicionando as posições relativas dos vizinhos a cada célula e juntando-os em uma lista.
  • W={p for p in X if 2<X.count(p)<4+({p}<W)}percorre esta lista Xe determina se cada célula Xpertence ao conjunto de células na próxima iteração. Isso foi tirado quase literalmente deste jogo de golfe da vida .
Liresol
fonte
Fiquei tão impressionado com a resposta de NieDzejkob (sequência oculta de 102 bytes!) Que entrei no StackExchange para tentar decifrá-lo, mas acontece que minha nova conta não pode comentar nas postagens de outras pessoas, por isso não posso cumprir totalmente as regras ( que é minha culpa)
Liresol
Bem-vindo ao CGCC! Eu comentei a resposta do policial para você. Espero que fique por perto!
Jo King
Obrigado! Eu realmente não tentei desafios de código como esses, mas fazer isso foi uma explosão.
Liresol 16/07
Bom trabalho! Vou revelar a minha corda pretendida quando encontrar o tempo.
NieDzejkob
3

Haskell, A014675 por Khuldraeseth na'Barya

Código original

main=print$uncurry(!!)([2],0)

Com substring

main=print$uncurry(!!)                                   ([2],0)
                      $(\(a,n)->(a>>= \e->2:[1|e>1],n+1))

Experimente online!

nimi
fonte
Isso faria isso! Eu tinha em flip take[1,2]vez daquela lambda interna. Caso contrário, idêntico.
Khuldraeseth na'Barya 14/07
1
@ Khuldraesethna'Barya: (`take`[2,1])é ainda mais um byte a mais
nimi
Isso dói. Talvez eu pudesse ter este por mais tempo se eu tivesse percebido isso. (`take`)encontrou um erro de compilação, então achei que (`take`[2,1])sim. :(
Khuldraeseth na'Barya 14/07
2

Calculadora de mesa, A006125 , de A__

Original:

1n

Rachado:

1 2lx1+dsx^*n
 ^^^^^^^^^^^

Experimente online!

Implementação direta.

jimmy23013
fonte
Minha string original é Sa2Lad1-*2/^, caso alguém me pergunte sobre isso.
A
2

cQuents , sequência A003617 de Stephen

=10#2:pZ
  ^

Experimente online!

Comece com o número mais baixo de n + 1 dígito, um seguido por n zeros. o#2 especifica que apenas o segundo termo da sequência, o que é a definição sequência uma vez aplicado à semente, serão impressos; essa definição de sequência simplesmente encontra e retorna o próximo primo.

Khuldraeseth na'Barya
fonte
2

Python 3 - agtoever

from sympy import isprime, primerange
from itertools import count
r=1
r+=1
while isprime(r-2)or r&1<1and r>3:r+=1
print(r)

Experimente online!

NieDzejkob
fonte
2
A razão que eu perguntei sobre a conjectura de Goldbach é que uma solução como esta isso não é correto se houver uma entrada, mesmo na série além 2. Eu acho que este funciona se você não pode assumir a conjectura, mas ele usa o mesmo básica idéia (sinta-se livre para deixar isso como o crack, eu só quero ser pedante).
FryAmTheEggman 12/07
Ótima solução. Mais curto que o meu. Vou postar o meu amanhã (CET). Eu não tenho meu código em mãos agora. Minha solução usa uma expressão de gerador e não depende da conjectura de Gb, mas isso ainda deixa isso como uma resposta bem fundamentada (e na minha opinião qualificada).
agtoever 12/07
1
@FryAmTheEggman Sim, a seção "fórmula" da OEIS não mencionou que depende de uma conjectura ... brb com uma prova;)
NieDzejkob
2

MATL , sequência A000796 de Luis Mendo

Original:

'pi'td1_&:_1)Y$J)

Experimente online!

Rachado:

'pi'td1_&:|SQ_1)Y$J)
          ^^^

O autor original sorrateiramente criou a matriz [-7:-1]e depois extraiu e negou o primeiro elemento a ser obtido 7. Ele então usou isso para obter o 7º dígito arredondado de pi (que é 3) e o apresentou como o primeiro dígito de pi. A adição |SQtorna a matriz original positiva, classifica e adiciona uma a tudo. Isso significa que, depois de tudo, em vez de obter o índice, 7ele obtém o índice -2após um aplicativo, -3após dois aplicativos e assim por diante. O -é importante porque diz à Y$função para não arredondar os dígitos.

SamYonnou
fonte
Minha exata corda escondida! Bem feito!
Luis Mendo
2

Adiante (gforth) , A000042 , por NieDzejkob

.( 1)1 .
^^^^^

Experimente online!

O trivial 1 byter está simplesmente estendendo o literal. O problema é que isso excede 64 bits desde o décimo nono dígito. Solução fácil é imprimir o dígito único repetidamente, certo? Sim, mas não é tão fácil assim. Embora a aderência 1 .ao final realmente imprima os dígitos adicionais necessários, eles serão separados por espaços. Isso não vai funcionar.

Agora, de acordo com a Wikipedia, " .((ponto-paren) é uma palavra imediata que analisa uma string delimitada por parênteses e a exibe". Felizmente, essa exibição não possui outros caracteres estranhos, portanto, usar .(para imprimir um único 1 deve ser suficiente. E faz. Não é necessário espaço após o fechamento, então esses cinco caracteres (há um espaço após o fechamento) podem ser repetidos para o conteúdo de nossos corações. Para demonstrar, incluí no TIO um exemplo que teria estourado várias vezes um int de 64 bits. Funciona como um encanto.

Khuldraeseth na'Barya
fonte
Bom trabalho! Essa é exatamente a minha corda.
NieDzejkob 14/07
2

Unefunge-98 (PyFunge) , sequência A000108 , de NieDzejkob

1# 2g1+:2p4*6-*2g/.@
 ^^^^^^^^^^^^^^^^^

Experimente online!

Repetido seis vezes

Dois bytes de sobra dos dezenove permitidos! O que parece ser um espaço, na verdade, existe um caractere 0x01 Start Of Header.

Explicação:

Este desafio é tudo sobre a geração a(n)de a(n-1)e talvez n. OEIS fornece a fórmula explícita a(n) = (2n)!/(n!(n+1)!), que é facilmente convertida ema(n) = a(n-1) * (4n-6) / n . Agora, para implementar isso no Funge.

Devo estar inserindo código entre o 1e o .. Isso é metade do quebra-cabeça já feito. Tudo o que resta é qual código inserir? O Funge está faltando notavelmente nas ferramentas de manipulação de pilha, portanto a parte inferior da pilha está fora dos limites; Eu preciso rastrear ambos nea(n) sem aumentar a pilha. E qual a melhor maneira de fazer isso do que com o espaço Funge?

Esse personagem 0x01 é o meu contador n. Eu continuo a(n)na pilha, como deve estar na pilha depois que minha parte termina a execução.

1# 2g1+:2p4*6-*2g/.@
1                       Push 1. This is a(0).
 #                        Skip the next instruction. Without this, I believe the instruction pointer will reverse direction upon encountering 0x01.
   2g                     Push the third character in the source, which starts out as 1.
     1+                   Increment it...
       :                  ...copy it...
        2p                ...and put it back. One copy remains atop the stack.
          4*6-            Multiply by four. Subtract six.
              *           Multiply by a(n), leaving the result alone on the stack.
               2g         Push n again...
                 /        ...and divide our intermediate result by it. Ta-da!
                          At this point, the stack is the same as at the start of the indented block, except the one item has been advanced one place in the sequence.
                          The source of the program has changed; the third character holds the number of times this indented block has run.
                  .@    Print and terminate.
Khuldraeseth na'Barya
fonte
2

V, A000290 , por DJMcMayhem

é*Ä2é*Ø.
  ^^^^

produz os quadrados de 1.

Experimente online!

A base é*insere *e Ø.conta o número de caracteres que não são de nova linha no buffer inteiro. A inserção Äduplica a linha superior para sua própria linha, na qual é 2é*inserida **. As concatenações das inserções produzem números ímpares sucessivos, com o maior no topo. O final final Ø.soma os primeiros n números ímpares, produzindo assim o n-ésimo quadrado.

Kritixi Lithos
fonte
Ahh, somando números ímpares, não pensei nisso. Bem feito :) peguei a frase números quadrados muito mais literalmente comÄÎé*<CR>
DJMcMayhem
@DJMcMayhem Eu pensei da mesma forma no começo, mas confundi algo / obtive 6 bytes, então tentei essa outra abordagem inspirada na construção de números quadrados do wiki brainflak através da soma de números ímpares.
Kritixi Lithos 16/07
2

AsciiDots , sequência A019523 de Alion

\ +++ /
// \ / \

Uma vez!

Duas vezes!

Dez vezes!

Enquanto tentava descobrir como o código / linguagem funciona, aprendi que as duas primeiras linhas do código existente fazem todo o trabalho de gerar a sequência de Fibonacci infinitamente. O código termina quando qualquer ponto atinge o &, então eu só precisava adicionar mais atraso nas linhas restantes para permitir o número apropriado de entradas a serem exibidas.

Após algumas tentativas, erros e observações, descobri que o intervalo de atraso correto é de 16 unidades de tempo por número. Ajustar caracteres suficientes em uma única linha parecia inviável, então eu precisaria colocar o atraso em 2 linhas, deixando 10 caracteres para o atraso real. Para que o padrão se igualasse, as duas linhas precisavam ter 5 caracteres e, como os três caracteres do meio em uma linha podem ser percorridos duas vezes, isso fornece 16 unidades de tempo, conforme desejado.

O requisito de combinar isso com o &da oitava coluna parecia tornar isso impossível, até que percebi que poderia começar com uma nova linha no interior da terceira linha. Isso torna a penúltima linha do comprimento certo e remove a extremidade agora redundante da terceira linha.

Nitrodon
fonte
1
O seguinte também funciona: \v/v>-----)
SamYonnou
Bom trabalho, vocês dois. @SamYonnou estava mais perto da solução pretendida . Além disso, fico feliz que o processo de pensamento tenha sido semelhante ao pretendido, apesar de levar a uma solução diferente!
Alion
2

Brachylog , sequência A114018 de String não relacionada

Programa original:

≜ṗ↔ṗb&w

String para inserir:

≜ṗ↔ṗẹbb&w
    ^^

Experimente online!

Explicação

Aqui está primeiro a explicação do programa original (sabendo que a sequência usada é "primo com menos n dígitos cuja reversão também é primo")

≜         Assign an integer value to a variable named ? 
            (try 0, then 1, then -1, then 2, etc.)
 ṗ        ? must be prime
  ↔ṗ      The reverse of ? must be prime
    b     Remove the first element of ?
     &    Ignore that we removed that element
      w   Write ? to STDOUT

Como você pode ver, o programa é bastante direto, exceto por uma coisa: existe uma completamente inútil b - behead chamada de predicado , que remove o primeiro elemento do reverso do nosso número, com o qual não fazemos nada.

Esta é uma pista definitiva de como podemos encontrar a string. A idéia é que, como queremos aumentar o comprimento do número em 1 dígito cada vez que adicionamos a string, precisamos de uma string que "avalie" o comprimento desse número de alguma forma, usando esse inútil b.

A solução é usar ẹb: primeiro, ẹ - elementstransformará o número em uma lista de dígitos; então, b - beheadremoverá seu primeiro elemento. O truque é que bfalhará se a lista de dígitos estiver vazia. Portanto, toda vez que anexamos a b, aumentamos o comprimento do número necessário em 1 (porque ele falhará até que o valor atribuído ?seja alto o suficiente para conter muitos dígitos suficientes para que o últimob seja aplicado em uma lista de um dígito).

Reaplicar cada vez não tem efeito, porque já é uma lista de dígitos. Só precisamos dele uma vez no início, porque se decapitarmos um número como, em 9001vez da lista de seus dígitos, obteremos o 001 = 1que perderá informações sobre o número de dígitos.

Fatalizar
fonte
1
Muito bem feito. Eu nunca pensei no 9001b1assunto, na verdade, acabou que, emborab falhe se a lista de dígitos estiver vazia, não falhará se você nunca tiver uma lista, porque números de um dígito decapitam 0, incluindo o próprio 0 .
String não relacionada
1
@UnrelatedString Resumindo: b é estranho
Fatalize 17/07
2

VDM-SL , A000312 , por Data de validade

let m={1|->{0}}in hd reverse[let x=x+1 in x**x|x in set m(1)&x<card m(1)]
                             ^^^^^^^^^^^^^

Como as expressões do VDM-SL letpodem reconfigurar variáveis ​​que já estão vinculadas em um escopo anexo, elas x**xpodem ser avaliadas arbitrariamente profundamente aninhadas em escopos nos quais xé mais um que no escopo anterior, enquanto o original xainda é menor que a cardinalidade de m(1).

String não relacionada
fonte
Eu testei até n = 11 e funcionou bem
String não relacionada
... é suposto ser apenas um número. If you insert s somewhere into p, this program must print the second integer from the sequence. If you insert s + s into the same location in p, this program must print the third integer from the sequence. Observe o comportamento do exemplo print(1).
String não relacionada
Ah rip, compreensível
Não relacionado String
1
Não pense que isso é super trivial, ainda é muito legal!
Data de
1
Usar ++para substituir o mapa
Data de validade expirada
2

Haskell , A000045 (Fibonacci) , pela transformada de Fourier de Rin

f = head $(flip(:)<*>sum.take 2)[0, 1]
         ^^^^^^^^^^^^^^^^^^^^^^^

Experimente online!

23 bytes exatamente.

Este foi divertido e um pouco complicado. Os 0 e 1 invertidos me tiraram um pouco antes que eu percebesse que não era um problema. A falta de $no original me fez tentar coisas incompletas como $...$id(um byte muito longo) antes que me ocorresse que eu poderia colocar tudo entre parênteses. Em suma, um belo quebra-cabeça.

H.PWiz assinala que a correspondência de padrão poderia ter me salvou pelo menos cinco bytes: $(\[x,y]->[y,x+y]). Esse maldito desafio sem ponto me faz pensar sem ponto em qualquer lugar.

Khuldraeseth na'Barya
fonte