Este é um desafio de policiais e ladrões . Para o tópico de ladrões, clique aqui .

Esse desafio envolve duas sequências OEIS escolhidas pelos policiais - S ₁ , S ₂ - e quão bem essas sequências podem ser jogadas e ofuscadas.

O desafio da polícia

Seu desafio como policial é escolher um idioma disponível gratuitamente e duas seqüências OEIS. Em seguida, escreva o código A no idioma que recebe a entrada n e produz S ₁ (n). Quando esse código é modificado por uma distância Levenshtein de caracteres X (com X não mais que 0.5 * (length A)) e transformado em código B no mesmo idioma, ele deve produzir S ₂ (n). Você deve realmente escrever esse código B , mas não o revele até que seu desafio seja seguro (veja abaixo).

Os envios dos policiais devem incluir o nome do idioma, o código completo A , a contagem de bytes de A , o valor X de quantas alterações serão alcançadas no código B secreto e os números de sequência S ₁ e S ₂ escolhidos . Você pode escolher se cada sequência é indexada com 0 ou 1, mas especifique isso em seu envio.

Para quebrar uma submissão específica, os ladrões devem criar um programa C no mesmo idioma (e versão) que produz S ₂ (n) e com o caractere Y muda de A (com Y <= X). Os ladrões não precisam necessariamente encontrar exatamente o mesmo código B que o policial (secretamente) produziu.

Vencendo e Pontuação

Se sua resposta policial não tiver sido decifrada em 7 dias (168 horas), você poderá revelar sua própria solução B , quando sua resposta será considerada segura. Contanto que você não revele sua solução, ela ainda poderá ser quebrada por ladrões, mesmo que os sete dias já tenham passado. Se sua resposta for quebrada, indique-a no cabeçalho da sua resposta, juntamente com um link para a resposta do ladrão correspondente.

Cops ganhar por ter a apresentação uncracked com o menor A . Se amarrado, o menor X será usado como desempatador. Se ainda estiver empatado, o envio anterior vencerá.

Regras adicionais

• Você não deve usar nenhum componente interno para hash, criptografia ou geração de números aleatórios (mesmo que você propague o gerador de números aleatórios para um valor fixo).
• Programas ou funções são permitidos, mas o código não deve ser um trecho e você não deve assumir um ambiente REPL.
• Você pode receber e dar saída em qualquer formato conveniente . Os métodos de entrada / saída devem ser os mesmos para as duas seqüências.
• A calculadora definitiva para a distância de Levenshtein para este desafio é esta no Planet Calc.
• Além de ser um desafio CnR, este é um código de golfe, portanto todas as regras usuais de golfe se aplicam.

Brain-Flak , 28 bytes, Distância de 4, A002817 , A090809 Rachado

Esta resposta usa a indexação 1

(({({}[()])}{}){({}[()])}{})

Experimente online

Para qualquer pessoa interessada, existem 27475 programas Brain-Flak válidos com a distância 4 de Levenshtein deste programa e 27707 com distância 4 ou menos. Portanto, uma solução de força bruta seria viável em um computador de consumo.

7 , 33 caracteres, 13 bytes, X = 10, A000124 → A000142 , Seguro

171720514057071616777023671335133

Experimente online!

A distância de Levenshtein é medida em termos de caracteres, por isso escrevi o programa em termos dos caracteres que ele contém acima (e Experimente online !, incluindo o próprio idioma, tem prazer em executar programas codificados em ASCII). No entanto, o programa é armazenado em disco usando a codificação de sub bytes de 7, o que significa que o próprio programa é realmente o seguinte hexdump (com 13 bytes de comprimento):

00000000: 3cf4 2982 f1ce 3bfe 13dc b74b 7f         <.)...;....K.

(Como a distância de Levenshtein é medida em termos de caracteres, você não está necessariamente adicionando / excluindo / alterando 10 bytes aqui, por isso é provavelmente melhor trabalhar com o ASCII original.)

O programa, como escrito, implementa A000124 (números triangulares + 1); qualquer rachadura deve implementar A000142 (fatoriais). Ambos os programas recebem entrada de stdin (como números inteiros decimais), gravam sua saída em stdout e tratam uma entrada de 1 como significando o primeiro elemento da sequência (e uma entrada de 2 como o segundo elemento, etc.).

Esperemos que o valor X muito alto impeça as pessoas de forçarem brutalmente o programa, desta vez (o que é sempre um risco com as entradas de policiais e ladrões em 7).

A solução

177172051772664057074056167770236713351353

Experimente online!

Diferenças do original:

17 172051 405707 1 61677702367133513 3
17 7 172051 77266 405707 405 61677702367133513 5 3

Eu não tenho explicações preparadas para o funcionamento delas, então levarei um tempo para obter uma explicação, pois vou ter que descobrir isso quase do zero. Esperançosamente haverá uma explicação eventualmente.

Pyke, Levenshtein distância de 1, A036487 , A135628 .

Rachado!

X*e

Experimente aqui!

Rachado!

*[0]o 1***

• S ₁ = A000012 = 1,1,1,1,1,...= A sequência de todos os 1. (Indexado 0)

• S ₂ = A001477 = 0,1,2,3,4,...= Os números inteiros não negativos. (Indexado 0)

Experimente online!

Confirmado para funcionar com o Perl 6 versão 2017.01 e com a versão do Perl6 em execução no TIO.

( A poderia ser ainda mais jogada 1***- espero que também seja permitido como é.)

Seguro!

{[+] [,] ^$_}

• S ₁ = A161680 = 0 0 1 3 6 10 15 21...= Zero seguido pelos números triangulares.
• S ₂ = A000217 = 0 1 3 6 10 15 21 28 ...= Os números triangulares.
• Indexado a zero.

Experimente online!

(Confirmado para trabalhar com a versão Perl 6 em execução no TIO.)

Solução

{[+] [\,] ^$_}

Como o original funciona:

{           }  # A lambda.
          $_   # Lambda argument.                     e.g. 4
         ^     # Range from 0 to n-1.                 e.g. 0, 1, 2, 3
     [,]       # Reduce with comma operator.          e.g. 0, 1, 2, 3
 [+]           # Reduce with addition operator.       e.g. 6

Como a solução funciona:

{            } # A lambda.
           $_  # Lambda argument.                     e.g. 4
          ^    # Range from 0 to n-1.                 e.g. 0, 1, 2, 3
     [\,]      # Triangle reduce with comma operator. e.g. (0), (0,1), (0,1,2), (0,1,2,3)
 [+]           # Reduce with addition operator.       e.g. 10

Explora o fato de que operadores numéricos como adição tratam uma lista como seu número de elementos, portanto, no exemplo, a soma é 1 + 2 + 3 + 4 = 10.

E sim, o no-op "Reduce with vírgula operator" no original está meio que contornando as regras de código de golfe, mas eu prefiro encarar isso como um algoritmo bobo que foi jogado o máximo possível (espaço em branco etc.) para o que é isso... :)

Gelatina , 11 bytes, X = 5, A005185 → A116881

ịḣ2S;
1Ç¡ḊḢ

Este é um programa completo que usa um número inteiro como argumento da linha de comando e imprime um número inteiro.

Ambas as seqüências são indexadas como no OEIS, ou seja, A005185 é indexado em 1 e A116881 é indexado em 0.

Experimente online!

Javascript, 41 bytes, Distância de 3, A061313 , A004526 , Rachado

f=x=>{return x>1?x%2?f(x+1)+1:f(x/2)+1:0}

Experimente Online

Utiliza uma indexação baseada em 1, a solução usa a indexação baseada em 0.

Mais uma vez, uma solução diferente ...

f=x=>{return x>1?x<2?f(x-1)+1:f(x-2)+1:0}

Rachado!

{(0,1,*+*...*)[$_]}

• S ₁ = A000045 = 0 1 1 2 3 5 8 13 21 34...= "Números de Fibonacci". ( Indexado 0 )
• S ₂ = A000035 =0 1 0 1 0 1 0 1 0 1... = "Período 2". ( Indexado 0 )

Experimente online!

(Confirmado para trabalhar com a versão Perl 6 em execução no TIO.)

WolframAlpha, 18 bytes, X = 1

Rachado por math_junkie!

(sum1to#of n^1)*2&

Às vezes, o WolframAlpha pode realmente exibir uma função pura como esta na forma funcional (outras vezes, fica confusa); mas pode ser chamado alegremente com uma determinada entrada - por exemplo, (sum1to#of n^1)*2&@5produz 30.

S1 = A002378 (números prônicos)

S2 = A000537 (soma dos primeiros ncubos)

Ambas as sequências são indexadas em 0.

Pyke, Levenshtein distância de 2, A008788 , A007526

Rachado!

'th^

Experimente aqui!

Vamos ficar um pouco mais difíceis, não é?

A primeira resposta é baseada em 1 e o crack é baseado em 0.

Javascript, 15704 bytes, distância de 2, A059841 e A000004 - rachado

Esta solução é extremamente longa, então você pode encontrar o código completo neste github gistub.

A resposta original (esta) é 1 indexada. (Eu sei que isso é muito longo, é apenas por diversão.)

Brain-Flak , 16 bytes, distância de Levenshtein de 4, A000217 e A002378 - Rachado por Martin Ender!

({({}[()])()}{})

Experimente online!

Isso deve ser bastante fácil de quebrar.

Javascript, 30 bytes, Distância de 4, A000290 , A000079 , - Rachado!

f=x=>{return x?2*x-1+f(x-1):0}

Indexação baseada em 0

A solução da @Kritixi Lithos era realmente diferente da minha

f=x=>{return x?f(x-1)+f(x-1):1}

Experimente online

Javascript (ES6), a distância é 1, A000079 e A000004 - quebrada

as=function(){ return 2*2**((11)*-1*~arguments[0]/11-(4-(as+[]).length%89))-(as+[]).length%7}

A resposta original (esta) é baseada em 0. Agora que foi quebrado, aqui está a função B original:

as=function(){ return 2*2**((1^1)*-1*~arguments[0]/11-(4-(as+[]).length%89))-(as+[]).length%7}

Rachado!

+(*%%2)

• S ₁ = A059841 = 1 0 1 0 1 0 1 0...= "* Período 2: Repita (1,0)". (Indexado 0)
• S ₂ = A001477 = 0 1 2 3 4 5 6 7...= "Os números inteiros não negativos". (Indexado 0)

Experimente online!

(Confirmado para trabalhar com a versão Perl 6 em execução no TIO.)

Java 7, distância de Levenshtein de 4, A094683 , A000290 , Cracked

int x{double r=1;for(int i=0;i<42;i++)r=r/2+n/r/2;int k=(int)((int)n*(float)n/Math.pow(n,(Math.sin(n)*Math.sin(n)+Math.cos(n)*Math.cos(n))/2));return n%4%2==(int)Math.log10(Math.E)/Math.log((double)'H'-'@')?(int)r:k;}

Indexado a 0.
Experimente aqui!