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.

Python 2 , sequência A138147 por xnor

Original:

print 10

Rachado:

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

Experimente online!

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.

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

Por exemplo:

$1+3+6+10 = 20$

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 $n-1$ ª termos na 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$

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.

Brain-Flak, A000290 , por Sriotchilism O'Zaic

Original:

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

Rachado:

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

Experimente online!

Alternativamente:

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

Experimente online!

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

Python 3 - A__

print(100+-1)

Experimente online!

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

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.

Java 8+, sequência A010686 de Benjamin Urquhart

()->System.out.println(1^4);
                        ^^

Brain-Flak, A000578 por Sriotchilism O'Zaic

Original:

((())<>)

Experimente online!

Rachado:

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

Experimente online!

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.

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 .

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!

Calculadora de mesa, A006125 , de A__

Original:

1n

Rachado:

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

Experimente online!

Implementação direta.

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.

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!

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.

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.

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.

Python 3 , A008574 por tsh

print(1*2+2)
       ^^^^

Experimente online!

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.

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.

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.

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).

Haskell, A083318 por xnor

f=length     [2]
        $show

Experimente online!

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.