Este é um desafio de policiais e ladrões . Para o tópico da polícia, 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.

Os policiais estão construindo o código A que produz S ₁ e dando um número X que eles afirmam ser a melhor distância possível de Levenshtein (em caracteres) para criar B que produz S ₂ .

O desafio dos ladrões

Para quebrar a submissão de um policial em particular, os ladrões devem criar um programa C no mesmo idioma (e versão) que a resposta que produz S ₂ (n) e 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. As submissões dos assaltantes devem aderir ao mesmo índice 0 ou 1, conforme especificado pela submissão do policial.

Se você conseguir isso, poste uma resposta com a solução, vinculando-a à resposta do policial e deixe um comentário sobre a resposta do policial voltando para a sua.

Cada resposta policial pode ser quebrada apenas uma vez e, é claro, você não tem permissão para quebrar sua própria resposta. Se a resposta do policial for inválida antes ou depois de ser quebrada, ela não será contabilizada na pontuação do ladrão.

Vencendo e Pontuação

Os ladrões são pontuados por (X - Y)*5 + 5cada uma de suas rachaduras e o ladrão com a maior pontuação geral vence.

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 ambas as seqüências.
• A calculadora definitiva para a distância de Levenshtein para esse 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.

Pyke, Levenshtein distância de 1, A036487 , A135628 - pontuação 5

Rachadura de uma entrada por muddyfish

wX*e

Experimente aqui!

O código original X*e, ao quadrado da entrada, Xmultiplica isso pela entrada *e divide pela metade o resultado e,.

O truque é que 'X'56 na representação de base 96 de w, portanto, wXgera 56, multiplique que pela entrada então desça e reduza pela metade e você obtém 28 vezes a entrada conforme necessário.

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

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

Essa resposta foi descoberta com a ajuda de um bruto, que gerou 35.000 programas possíveis (muitos deles estavam desequilibrados e, portanto, código de falha cerebral inválido, mas eu rolei com o bug e encontrei a resposta de qualquer maneira). Isso foi por volta do vigésimo milésimo programa testado e demorou cerca de uma hora para ser descoberto (embora eu não saiba exatamente quanto tempo estive ausente quando ele terminou).

Eu meio que ainda não queria postar esta resposta, pois ainda não tenho um entendimento completo de como esse programa funciona. No entanto, a resposta está prestes a ser segura, então não quero que ela expire. Espero atualizar esta resposta mais uma vez que eu a entenda completamente, além de postar o código que eu usei para encontrar essa resposta. Mas, por enquanto, vou apenas postar uma explicação parcial.

#Push the sum of:
(

    #The (n-1)th triangular number, and the range [1, n] (The range doesn't count towards the sum I believe)
    ({(({})[()])}{})

    #Triangulate every number on the stack
    {{({}[()])}{}}

)

Isso faz sentido porque o OEIS afirma:

Para n> 0, os termos desta sequência estão relacionados a A000124 por a (n) = soma (i * A000124 (i), i = 0..n-1). [Bruno Berselli, 20 de dezembro de 2013]

E A000124 são os números triangulares + 1. No entanto, não sei exatamente o que é o forumla, por isso não posso explicar completamente como isso funciona.

Perl 6, 19 bytes, X = 1, A000045 → A000035

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

+>no lugar de +<também funcionaria.

Experimente online!

Como funciona

infix ... é bastante útil para seqüências recursivas simples. A (0,1,*+*...*)parte do código original, que é uma abreviação de

(0, 1, -> $x, $y { $x + $y } ... *)

especifica uma sequência que começa com 0 e 1 e adiciona itens calculando a soma dos dois primeiros itens da sequência.

Por outro lado, (0,1,*+<*...*)usa o deslocamento de bits esquerdo (o deslocamento de +>bits direito também funcionaria) para construir a sequência de paridade. Como deslocar 1 unidade zero para a esquerda é 1 e deslocar 0 uma unidade para a esquerda é 0 , obtemos os padrões alternados desejados de uns e zeros.

Perl 6 , 10 bytes, distância 1 - pontuação 5

Rachadura de uma entrada por smls

*[0]o 1***

Torna-se:

*[0]o 1*+*

Experimente Online!

Perl 6 , distância 2, smls

Original:

+(*%%2)

Rachadura:

+(*+0%2)

Experimente online!

WolframAlpha, Distância 1, Greg Martin , A002378 , A000537

(sum1to#of n^1)^2&

Como funciona

Percebi que, curiosamente, (n * (n + 1) / 2) ^ 2 é uma fórmula para a segunda sequência. Como soma (1 a n) é equivalente a n * (n + 1) / 2, eu apenas precisei mudar o * para a ^.

Flak cerebral , 20 bytes, DJMcMayhem

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

Experimente online!

Adicionado a ({})no início do loop para dobrar o valor em cada iteração.

JavaScript, Distância 4, LliwTelracs

Original:

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

Rachadura:

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

Experimente online!

JavaScript (ES6), Distância 1, Avançado

Original:

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

Rachadura:

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

Experimente online!

ou

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

Experimente Online!

De alguma forma, eu consegui fazer com que ele se comportasse de maneira diferente entre TIO e repl.it (absolutamente nenhuma pista do porquê 2 * 1 ^ ... seria igual a 0, de acordo com repl.it)

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

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

Experimente online!

Java, Distância 4, Peech , A094683 , A000290

Original:

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;}

Rachadura:

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%1==(int)Math.log10(Math.E)/Math.log((double)'H'-'@')?(int)n*n:k;}
                                                                                                                                                          ^                                                         ^^^

retorna n * n

Javascript, Advancid , distância de 2, A059841 e A000004

Apenas deixando o código para trás do link do TIO, porque parece estar quebrando o site.

Graças a @nderscore, cujo código eu usei para descriptografar o código inicial

Havia algum código redundante, como usar !! [] + [] + [] em vez de !! [] + [].

A adição de! + [] - (! + []) (+ 1-1) inicialmente impediu a descriptografia.

Experimente Online

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

'SS^

Experimente aqui!

Como funciona

Isso faz conversão de base mista.

'Sagarra a entrada n e se aplica, pressionando [1, ..., n] na pilha. O próximo Spega a entrada n e empurra a mesma matriz mais uma vez. 'parece causar o próximo comando a ser aplicado ao topo anterior da pilha; Estou um pouco confusa com os detalhes.

Finalmente, ^aplica a conversão de base mista, de modo que [1, ..., n] [1, ..., n] f calcula
a (n): = [1] n + n + (n) (n-1) .. . + [n!] 1 onde os colchetes indicam o valor do local e o número à direita do dígito.

Agora, a (n) = (1 + (1) (n-1) + (n-1) (n-2) (n-3) + ... + (n-1)!) N = n ( a (n) + 1) , que é a mesma fórmula recursiva que define a (n) em [A007526]. Como uma soma vazia é zero, a (0) = 0 e o caso base também coincidem.