Este é o tópico dos policiais. O fio dos ladrões vai aqui .
O último tópico de policiais e ladrões já foi há 4 meses .
A tarefa do policial
- A tarefa do policial é escrever um programa / função que pega um número inteiro positivo (ou não negativo) e gera / retorna outro número inteiro.
- O policial deve indicá-lo se o programa for intolerante em relação a zero.
- O policial fornecerá pelo menos 2 entradas / saídas de amostra.
- Por exemplo, se eu decidisse escrever a sequência de Fibonacci , escreveria isso na minha resposta:
a (0) retorna 0 a (3) retorna 2
- O número de exemplos fica a critério do policial.
- No entanto, a sequência deve realmente existir na Enciclopédia On-line de Sequências Inteiras® , portanto, nenhum gerador de números pseudo-aleatórios para você.
:(
- O policial pode ocultar quantos caracteres desejar.
- Por exemplo, se meu programa for:
function a(n)
if n>2 then
return n
else
return a(n-1) + a(n-2)
end
end
- Então eu ocultaria esses caracteres como eu quero:
function a(n)
if ### then
########
else
######################
end
end
A tarefa do ladrão
- é obviamente encontrar o código fonte original.
- No entanto, qualquer código-fonte proposto que produz o mesmo conjunto de saída também conta como válido, desde que também seja encontrado no OEIS.
Dicas para a polícia
A função de pesquisa no OEIS funciona apenas por termos consecutivos; portanto, se você deseja ocultar sua sequência, deixe um buraco em qualquer lugar.- Aparentemente, não há como ocultar a sequência. Lembre-se disso quando escolher a sequência.
Sua pontuação é o número de bytes no seu código.
O vencedor será a finalização com a pontuação mais baixa que não tenha sido quebrada em 7 dias.
Somente envios publicados em abril de 2016 são elegíveis para a vitória. Os envios publicados posteriormente são bem-vindos, mas não podem vencer.
Para reivindicar a vitória, você precisa revelar o código completo e a sequência OEIS (após 7 dias).
Sua postagem deve ter o seguinte formato (NN é o número de caracteres):
Lua, 98 bytes
Saída:
a(0) returns 0
a(3) returns 2
Código ( #
marca caracteres não revelados):
function a(n)
if ### then
########
else
######################
end
end
Se o código estiver quebrado, insira [Cracked](link to cracker)
no cabeçalho. Se o envio for seguro, insira "Seguro" no cabeçalho e revele o código completo em sua resposta. Somente respostas que revelaram o código completo serão elegíveis para a vitória.
fonte
_
, fyia(1000)
? (que é parte da sequência, mas demasiado grande para ser pesquisado em OEIS)Respostas:
Vim, 36 pressionamentos de tecla - Seguro!
(Nota:
<n>
é onde você digita sua entrada)Aqui está o código não relacionado à geração de números:
Ou seja, estou revelando 5 dos 19 caracteres.
<n>
é a entrada. Aqui estão alguns exemplos de saídas:Responda
Esse código imprime os números de Lucas ( A000032 ), que são exatamente como The Fibonnaci Sequence, exceto que ele inicia em
2, 1
vez de1, 1
. Aqui estão os 15 primeiros números:Aqui está o código revelado:
Explicação:
Explicação da macro:
Agora, só precisamos remover o segundo número, pois o primeiro número é o número de lucas que queremos. Então nós fazemos
Além disso, se não me engano, este é o primeiro envio seguro! Isso é legal.
fonte
bD
no final, a saída é apenas o número e alguns espaços em branco extras.05AB1E , 5 bytes, seguro
Última de hoje: p. Saída:
Código:
Caracteres ofuscados são indicados com
_
. Experimente online! -ligação. Usa a codificação CP-1252 .Solução:
Explicação:
Experimente online! ou Tente para todos os casos de teste! .
fonte
g°<¹-
mas não consigo descobrir nenhuma maneira de usarm
neste tamanho! D:Elemento , 7 bytes, quebrado
Saída:
Os
#
caracteres são ocultos e todos são ASCII imprimíveis. Eu acho que este é realmente razoavelmente difícil (por ter apenas 5 caracteres ausentes).Por conveniência, aqui estão as páginas wiki do Try It Online e Esolang .
Meu programa original era:
O truque é que
fonte
}
vez de]
?}
está correto, e meu programa (tanto quanto eu sei) funciona em todas as versões do Element.Jolf , 5 bytes, quebrado
Saída:
Tudo isso é crucial, e eu mostrei 1 de 5.
Código original:
Experimente online!
fonte
JavaScript (ES7), 10 bytes, Cracked
Saída
Código
Teste no Firefox todas as noites.O código é uma função anônima. Provavelmente será fácil, pois há apenas três caracteres ocultos, mas pelo menos é curto! : P
Meu código original era:
mas depois de forçar brutalmente meu próprio código para uma solução, logo percebi
também pode ser usado. Isso funciona porque
fonte
**
seja equivalente aMath.pow
, eu fiz alguns dos meus próprios testes e até tenho uma força bruta. Isso é muito difícil de decifrar!05AB1E, 4 bytes ( Cracked )
Saída de amostra:
E para o código:
Eu revelei o último. Deve ser fácil, porém, tive muita dificuldade em encontrar uma sequência :(
Todos os caracteres ocultos são imprimíveis.
fonte
MATL , 5 bytes, quebrado
Caracteres ocultos são indicados por
%
.Saída:
A entrada
0
é válida.Código original:
isso é,
fonte
SWIFT, 55 bytes, Rachado
*
marca um caractere ocultoSaída:
Função aceita
0
fonte
Ruby, 46 bytes, seguro
Editar para adicionar isenção de responsabilidade / desculpas: Esta sequência começa com f [0], enquanto a entrada OEIS começa com f [1]. Os valores são os mesmos.
Código ofuscado (
#
qualquer caractere):Ligue como
Saída:
Solução:
Seqüência:
Explicação:
fonte
05AB1E , 3 bytes, quebrado
Saída:
Código oculto:
Experimente online pode ser útil.
fonte
Hexagonia , 7 bytes, rachada
Saída:
Código oculto:
Ou alternativamente:
Experimente online pode ser útil.
fonte
0
?PHP, 41 bytes, quebrado
Sim, finalmente outro desafio de Policiais e Ladrões. Espero não ter facilitado as coisas.
Saída
Fonte
Notas
Rachado
Obviamente, facilitei e não forneci exemplos suficientes. A sequência que eu tinha em mente era A010054 :
Aqui está o meu código fonte original:
Ele testa se a entrada é um número triangular e gera
1
ou não0
.fonte
Jolf, 11 bytes, Rachado , A011551
Código original:
Exemplos:
fonte
MATL, 9 bytes, Rachado
Código:
Saída:
a(0)
é válido.Rachado
Sequência original: A059563
Código original:
fonte
Java, 479 bytes, Rachado
Saídas:
(As entradas são fornecidas por meio de argumentos de linha de comando)
Código (
#
marca caracteres ocultos):O programa inicia no índice 0.
(Observe que o SE substitui todos os
\t
recuos por 4 espaços, elevando o total de bytes para 569. Clique aqui para ver o programa com\t
recuos em vez de recuos de espaço.)Código original:
(Mesmo código, mas formatado normalmente):
fonte
i
até}
? E especifique tolerância 0.a(9)
ea(19)
oua(8)
ea(18)
, de acordo com qual versão do OEIS você tirou?Oitava, 34 bytes, quebrada
Saídas:
A sequência começa
ans(1)
em OEIS.fonte
C, 71 bytes rachados
Saída:
Isso funciona com o gcc e é um programa completo. Aceita 0 como entrada.
fonte
Pitão, 70 bytes, Rachado
#
são os caracteres ocultosFoi quebrado, então aqui está a versão sem caracteres ocultos:
Saídas de amostra:
Boa sorte para encontrar isso no OEIS, pessoalmente não consegui encontrá-lo nesses exemplos (mesmo que a sequência seja bastante fácil de identificar).fonte
Ruby, 38 bytes, quebrado
Código ofuscado (
#
pode ser qualquer caractere):Saída:
Multiplica a entrada por 10 (A008592). Funciona para qualquer número inteiro, incluindo 0. por exemplo
fonte
05AB1E , 5 bytes, quebrado
Saída:
Código ofuscado:
Experimente online! -ligação.
fonte
05AB1E , 4 bytes, quebrado
Bem, então, eu acho que sou viciado em CnR's ... Código ofuscado (
_
indica um curinga):Seqüência:
A sequência no OEIS começa em (1) = 2.
Experimente online! -ligação
fonte
Lua, 45 Bytes, Rachado
Uma pequena dica:
Saída
Código
Usa
#
para ocultar o código :).Eu estava usando o OEIS A007814 , com o seguinte código:
fonte
Pyke , 15 bytes, SEGURO
Saída
Código revelado:
Solução:
fonte
C, 82 bytes, seguro
Funciona com o gcc e é um programa completo, que lê sua entrada de stdin e imprime sua saída em stdout. Aqui a sequência é
A004526, piso (n / 2).Solução:
Isso funciona apenas em pequenas máquinas endian e apenas se o tamanho de
char
1 byte.E somente se o byte mais alto que o byte de ordem mais alta
a
tiver valor 0. Acho que isso é verdade para o gcc, pois, por padrão, variáveis globais não inicializadas entram no segmento bss e variáveis globais inicializadas entram no segmento de dados (consulte https: // stackoverflow.com/questions/8721475/if-a-global-variable-is-initialized-to-0-will-it-go-to-bss ).Portanto, apenas
a
entra em bss (a única outra variável globalb
é inicializada e, portanto, entra no segmento de dados). Sea
não estiver no final de bss, o byte superior ao byte de ordem mais altaa
também estará em bss e, portanto, terá o valor 0.fonte
05AB1E, 1 byte, Rachado
_
denota código oculto.fonte
Elemento , 10 bytes, quebrado
Saída:
Provavelmente, existem apenas algumas maneiras de calcular essa sequência no Element. Encontrei uma solução de 9 caracteres, mas achei que essa solução de 10 caracteres é realmente mais difícil. o
#
são caracteres ocultos.Por conveniência, aqui está o wiki do Try It Online e do Esolangpáginas .
O original era
fonte
Pyth , 18 bytes
#
marca caracteres não revelados.Saídas (começa em
1
):Intérprete online
fonte
05AB1E , 5 bytes, quebrado
Espero que este envio não seja tão fácil quanto os meus outros: p. Saídas:
Código ofuscado:
Contém alguns caracteres não ASCII, porém, usa o CP-1252 codificação .
Experimente online! pode ser útil: p.
fonte
Jolf , 11 bytes, Rachado .
Saída:
E o código parcialmente oculto:
Dica:
A versão crackeada não é exatamente igual ao meu código original. Atualmente, não estou no meu computador, então não o tenho exatamente, mas era algo assim:
(A única parte da qual não tenho certeza é a
!m
. É o que verifica se uma variável é zero.)fonte
Pyke , 6 bytes, Rachado
Saída:
Isso não funciona com N <1
Solução original:
fonte