Em um acidente muito incomum envolvendo uma pequena amostra de rádio, uma baleia eletrocutada e três ursinhos de goma, parte do código-fonte do The Management ™ foi modificada. Mal sabe o chefe da gerência ™, foram os policiais que foram os responsáveis, na tentativa de frustrar os planos "maus" da gerência. Então os Robbers® foram contratados na tentativa de recuperar o código original, porque quem não gosta de ser mau às vezes?

nota: Esse desafio foi fortemente inspirado em Desembaralhar o código-fonte .

Descrição

Este é um desafio de policiais e ladrões .

• Os policiais gravam um programa (o código mutado) que executa a Tarefa 1 (e também escrevem um programa que executa a Tarefa 2, mas é mantido em segredo).
• Os ladrões tentarão reverter a "mutação" e alterar esse código original em código que executa a tarefa nº 2.

Nesse desafio, a tarefa nº 1 será a saída do nnúmero th prime , e a tarefa nº 2 será a saída do nnúmero th de Fibonacci (que de alguma forma é ruim, de acordo com o Cops ©). A sequência de Fibonacci é definida como ( n=1→ 1; n=2→ 1; n=3→ 2; ...), e os números primos são definidos como ( n=1→ 2; n=2→ 3; n=3→ 5; ...).

O objetivo da polícia é minimizar a diferença entre os programas que concluem a Tarefa nº 1 e a Tarefa nº 2, enquanto impede os ladrões de recriar o código que conclui a Tarefa nº 2.

Regras da polícia

Os policiais escreverão dois programas (um que conclui a tarefa nº 1 e outro que conclui a tarefa nº 2) e tornarão públicas as seguintes informações:

• O primeiro programa (que exibe o nnúmero primo)
• A distância de edição de Levenshtein entre o primeiro programa e o segundo programa
• A linguagem de programação na qual os dois programas foram escritos (deve ser a mesma linguagem para os dois programas)

As seguintes restrições se aplicam aos dois programas:

• Eles devem ter 128 caracteres ou menos.
• Eles devem usar apenas ASCII imprimível (além de novas linhas, que também são permitidas).
• Eles devem levar menos de 10 segundos para serem executados n=45e não são necessários para produzir a saída correta para nenhum n>45.
• Eles não devem usar nenhuma função de hash ou criptográfica.

Regras de ladrão

O ladrão tentará alterar o programa do policial (que conclui a Tarefa 1) em um programa que conclui a Tarefa 2 (não necessariamente o programa original escrito pelo policial) na distância de edição especificada pelo policial.

Um envio já quebrado não pode ser quebrado novamente (somente o primeiro ladrão que quebra um pedido recebe crédito).

Depois de quebrar uma submissão, faça o seguinte:

• Poste uma resposta para a pergunta que acompanha o desafio (link) , fornecendo o idioma, sua solução e um link para a resposta original.
• Deixe um comentário com o texto "Rachado" que vincula a sua resposta postada.
• Edite a resposta do policial se você tiver privilégios de edição (caso contrário, aguarde até que alguém com os privilégios necessários o faça por você ou sugira uma edição).

Pontuação

Se o programa de um policial permanecer sem quebra por 1 semana, ele poderá postar o código original que conclui a Tarefa nº 2 (na distância de edição especificada) e o envio será considerado "seguro" a partir de então. O envio seguro que tiver a menor distância de edição vencerá. Em caso de empate, o programa mais curto (o original que conclui a Tarefa nº 1) vence. Se dois envios ainda estiverem empatados, o que foi postado anteriormente vence.

Se um assaltante quebrar com êxito o envio de um policial, a pontuação do assaltante aumentará a distância de edição desse envio. Por exemplo, um ladrão que quebra uma submissão com uma distância de edição de 3 e um com uma distância de 5 ganha 8 pontos. O ladrão com a maior pontuação vence. Em caso de empate, o ladrão que obteve a pontuação vence primeiro.

Entre os melhores

1. Rubi, 6 (histocrata)

Uma pequena ferramenta para calcular a distância de Levenshtein

var f=document.getElementById("f"),g=document.getElementById("s"); function h(){var a=f.value,e=g.value;if(128<a.length)a="<span style='color:red'>First program is too long!</span>";else if(128<e.length)a="<span style='color:red'>Second program is too long!</span>";else{if(0===a.length)a=e.length;else if(0===e.length)a=a.length;else{var d=[],b;for(b=0;b<=e.length;b++)d[b]=[b];var c;for(c=0;c<=a.length;c++)d[0][c]=c;for(b=1;b<=e.length;b++)for(c=1;c<=a.length;c++)d[b][c]=e.charAt(b-1)===a.charAt(c-1)?d[b-1][c-1]:Math.min(d[b-1][c-1]+1,Math.min(d[b][c-1]+1,d[b-1][c]+ 1));a=d[e.length][a.length]}a="Distance = <strong>"+a+"</strong>"}document.getElementById("d").innerHTML=a}f.onkeyup=h;g.onkeyup=h;

<h3 id=ft>First program</h3>
<textarea id=f rows=7 cols=80 style="width:100%"></textarea>
<h3 id=st>Second program</h3>
<textarea id=s rows=7 cols=80 style="width:100%"></textarea>
<p id=d></p>

Python 2, distância = 8 [ rachado ]

from fractions import*
n=input()
k,=P=[2]
while n>len(P):k+=1;z=reduce(lambda x,y:x*y,P,1);P+=[k]*(gcd(z,k)<2)
print P[-1]

Finalmente consegui este abaixo do limite de caracteres. Não deveria ser muito difícil, mas achei a ideia interessante.

Solução pretendida:

from fractions import* n=input() k,=P=[1] while n>len(P):k+=1;z=reduce(lambda x,y:x+y,P[:-1],1);P+=[z]*(gcd(z,k)<2) print P[-1]

A idéia era usar isso F(n+2) = 1 + (sum over F(k) from k = 1 to n)e o fato de números consecutivos de Fibonacci serem coprimes. O 1argumento no reduzir deveria fornecer o +1.

Parece que o feersum encontrou uma linha de ataque diferente!

J, distância = 5 [ Rachado ]

f=:3 :'{.p:|.i.y'

Uso:

> f 45
197

Ruby, distância 6 [segura]

require'prime';p Prime.take(n=gets.to_i)[-1]
#p (((807462154311276410)**n/(5**0.5)).round)

Criar pares de fórmulas com distâncias curtas de edição é divertido, mas parece que essa abordagem pode ser mais eficaz / irritante. Você pode entender exatamente o que eu fiz, mas isso não significa que você pode revertê-lo.

Solução:

require'prime';p=Prime.take(n=gets.to_i)[-1] p (((0742154311276/4e10)**n/(5**0.5)).round)

Explicação:

O código gera a Proporção áurea com 11 casas decimais e a utiliza para calcular diretamente a sequência Fibbonaci. É apenas precisão suficiente para acertar o número necessário de termos. Essa parte não foi ofuscada, se você souber a fórmula. Para tornar mais difícil a força bruta reverter minhas mutações e recuperar a constante, usei a notação octal (o 0 inicial) e a notação científica (4e10). Dividir por 4e10 em vez de 1e11 faz parecer que estou dividindo algo .0para forçar a divisão de flutuação, quando na verdade qualquer coisa na notação científica é, por algum motivo, sempre um flutuador em Ruby, mesmo quando um Bignum parece fazer mais sentido. Eu pensei que estava sendo inteligente com as p=coisas, mas da maneira que escrevi, você pode simplesmente excluir o arquivo p. Eu poderia'p=solução usando em p&&vez de #na segunda linha, mas não pensei nisso.

Python 2 - LD = 13 rachado

n=1;j=input();
while j>0:
    n+=1;j-=1;
    while~-all(n%i for i in range(2,n)):n+=1;
print n

Um bom, fácil (espero que não seja muito fácil) para começar :)

Parece que foi muito fácil;) Eu me sinto meio boba por ter esquecido que você poderia usar comentários: /

Haskell, distância = 13

import Data.List
x=id=<<snd(mapAccumL(\m n->(,)=<<(++m)$[n|and[n`mod`m1/=0|m1<-m]])[1+1][3..])
main=print.(!!)(0:2:x)=<<readLn

Isso poderia ser mais legível, mas ele importcomeu muitos bytes, então eu tive que jogar um pouco.

Rubi, distância 14 ( rachada )

p [x=2,y=1,*(1..200).map{|i|y==(y*x**(i-1)+x%2).divmod(i)[x-1]?i:1}].-([x-1])[gets.to_i-1]

CJam, distância 10 (rachada)

1l~{{)_mp!}g}*

Basta colocar nSTDIN. Teste aqui.

Para referência, a solução original usou os raros j.

Original:

T1]l~\{(_j\(j+}j

J, distância = 4 [segura]

f =: 3 :  '{. (p:) (+) / 0 , y - 1x'

Solução:

f =: 3: '{. 2 (x :) (+%) / 0, y $ 1x '

Método:

Denominador {. 2(x:)da fração continuada (+%)1 + 1 / (... (1 + 1 / (1 + 1 / (1 + 1 / (1))))).

Python 3, distância = 14 [ rachado ]

n = int(input())
P = [2]
k = 2
while n > len(P):
 k += 1
 for x in P:
  if k%x == 0: break
 else: P += [k]
print(k)

Eu tinha alguns caracteres extras, então coloquei um espaço em branco para maior clareza :)

JAGL Alpha 1.2 - Distância = 16 [ Rachado ]

T~2S]{]S1{D[dmn}wDS}wSP

Não deve ser muito difícil, vamos ver o que acontece ...

TI-BASIC , distância 38

Input N:{2>L1:For(A,3,E99:If min(1=gcd(A,seq(A,A,2,$(A:A>L1(1+dim(L1:End:L1(N

>representa a STO→chave e $o símbolo da raiz quadrada.

Python 2 - distância = 12 [ Rachado ]

Estou meio feliz com o resultado.

f=lambda p,i:p if p[45:]else f(p+[i]if all(i%q for q in p[1:])else p,-~i)
print f([1,2,3],2)[input()]

Vamos ver quanto tempo leva ... Suponho que ainda estará rachado.

Editar: código encurtado um pouquinho, sem efeito na operação / distância.

Solução pretendida

Tentei não comentar ou alterar as novas linhas.

f=lambda p,i:p if p[45:]else f(p+[p[i]+p[-2]]if all(i|q for q in p[1:])else p,-~i) print f([1,1,1],2)[input()]

Python 3 - Distância = 14 [ Rachado ]

a,c,n=1,2,int(input())
while n-1:
 c+=1
 while 1!=list(map(c.__mod__,range(2,46))).count(0):
  c,a=a+c,a
 n-=1
print(c)

Vamos ver quanto tempo isso dura ...