28

Este é um desafio de policiais e ladrões . A discussão dos ladrões está aqui .

Uma questão interessante para se pensar é a seguinte:

Se eu tiver uma sequência de números, quantos deles eu tenho que fornecer antes que fique claro de que sequência estou falando?

Por exemplo, se eu quiser falar sobre os números inteiros positivos em ordem a partir de , eu poderia dizer , mas isso é realmente suficiente? $1$ $1,2,3, \dots$

Eu tenho uma maneira de responder a essa pergunta, e ser um jogador de código envolve código de golfe. Você forneceu termos suficientes de uma sequência se o código mais curto que produz esses termos produzir todos os termos da sequência. Se pensarmos sobre isso em termos de código-golfe, isso significa que você forneceu casos de teste suficientes para que o código mais curto que passe nos casos de teste realize a tarefa desejada.

Desafio

Esse desafio é um desafio de policiais e ladrões . Nos quais os policiais apresentarão casos de teste e os ladrões terão que encontrar uma maneira mais curta de falsificar os casos de teste, além da sequência pretendida. A polícia apresentará o seguinte:

Um pedaço de código que pega um número inteiro não negativo como entrada e produz um número inteiro como saída. Este código definirá sua sequência. Seu código não precisa suportar 0 como entrada, optando por aceitar 1 como a menor entrada. Deve ficar claro se esse é o caso em sua resposta.
Quaisquer requisitos relevantes de plataforma ou idioma que possam afetar a saída, por exemplo, o tamanho de longint.
Um número $n$ , juntamente com os primeiros $n$ termos da sequência, calculados pelo código. Eles atuarão como "casos de teste".

Você é incentivado a explicar o que sua sequência faz e vincular o OEIS, se existir, no entanto, é o seu código que define a sequência e não a descrição.

Os ladrões encontrarão um programa no mesmo idioma que seja mais curto que o apresentado e passará em todos os casos de teste (produz a mesma saída para as primeiras entradas do código do policial). O código do ladrão também deve diferir na saída do programa do policial para um número maior que . $n$ $n$

Os policiais devem ser capazes de decifrar suas próprias respostas antes de enviá-las.

Depois de uma semana, um policial pode revelar sua rachadura e marcar sua resposta como Segura. As respostas marcadas como tal não podem mais ser quebradas.

Pontuação

As respostas da polícia serão pontuadas pelo número de bytes, com menos bytes sendo melhores. Respostas rachadas têm uma pontuação infinita.

code-golf sequence cops-and-robbers

— Assistente de Trigo
fonte

Está claro que existem maneiras de resolver um problema de forma não matemática, como apenas imprimir todos os casos de teste, mas esse problema depende dos casos fornecidos pelos policiais. Deveria haver uma regra sobre isso? Existe uma restrição contra a computabilidade das sequências ou qualquer coisa da Teoria de Ramsey? (ou seja, você precisa ser capaz de quebrar sua máquina?) #

— theREALyumdub

2

@theReallyumdub a pergunta estipula que você deve ser capaz de decifrar sua própria submissão.

— Wheat Wizard

@ CatWizard Obrigado, eu fui em frente e isso já está em um meta post óbvio, isso impede alguns desses caras aparentemente. Portanto, não é no espírito da marca para fazer uma rachadura demorar mais de uma hora para computação ou algo

— theREALyumdub

4

spikedmath.com/062.html

— Giuseppe

Existe uma condição "embora, teoricamente, sua solução funcione para todos os números na prática, ela só precise funcionar para ..."?

— user202729

6

cQuents , 4 bytes ( rachado )

"::$

Experimente online!

Aqui estão oito ( n=8) casos:

Explicação do código:

"      Stringify sequence (join on "", remove it and see what happens)
 ::    Given input n, output all items in the sequence up to and including n
   $   Each item in the sequence equals the index

Portanto, a sequência é 1,2,3,4,5 ...: ela é unida ""para que se torne 12345 ...e ::significa que ela é impressa na entrada.

— Stephen
fonte

Rachado.

— Bubbler

5

Python 3 , 66 57 bytes ( rachado )

rachado pelo xnor
também rachado pelo Assistente de gato antes de uma edição

def f(n):x=n/10-2;return int(x*60-x**3*10+x**5/2-x**7/84)

Experimente online!

Olá! Aqui está uma sequência para decifrar para . Dá esses primeiros 40 elementos com indexação 0, não é uma sequência OEIS $n=40$

[-54, -56, -58, -59, -59, -59, -59, -57, -55, -53, -50, -46, -43, -38, -33, -28, -23, -17, -11, -5, 0, 5, 11, 17, 23, 28, 33, 38, 43, 46, 50, 53, 55, 57, 59, 59, 59, 59, 58, 56]

— crashoz
fonte

Esqueci de remover o espaço em branco, ainda não sou um jogador experiente: p Você se importa se eu editar para corrigir isso?

— crashoz

Claro vá em frente. Vou remover meu crack.

— Wheat Wizard

Rachado

— xnor

5

Python 2 , 44 bytes ( quebrado )

f=lambda n,i=1,p=1:n and-~f(n-p%i,i+1,p*i*i)

Experimente online!

Os números primos. Que sequência poderia ser mais pura? Ou mais exagerado ? Seu objetivo é produzir os primeiros 50 primos para n=1a n=50.

O código é um gerador de teorema de Wilson copiado exatamente desta dica .

Os diferentes valores para a sequência alternativa não se devem a limitações da máquina, como estouros e precisão. Não há bibliotecas de terceiros.

Rachado por Arnauld, @PoonLevi e Sr. Xcoder.

— xnor
fonte

Certeza de que você não quis ficar doido com isso ; talvez especifique "Python (sem bibliotecas de terceiros)" ou "Python (sem importação)" ou algo assim?

— Jonathan Allan

@ JonathanAllan Obrigado, editei que não há bibliotecas de terceiros.

— Xnor

Ainda não consegui decifrar isso (minha melhor tentativa no momento é de 47 bytes), mas acho que há algo interessante a ser observado sobre esses primos específicos. Para cada

, com

, isso vale:

. Ao mesmo tempo, isso não é verdade para qualquer número que não é primo (na faixa mencionado acima), mas faz

p_{i}

$p_i$

i \in [1, 50] \cap N

$i\in[1, 50]\cap \mathbb{N}$

2^{p_{i}} \equiv 2 (mod p_{i})

$2^{p_i}\equiv 2 (\text{mod } p_i)$ assim, para valores mais altos. Eu estou deixando esta idéia aqui para que outros possam tentar sua mão em uma rachadura usando a técnica mencionada, e talvez obter uma pontuação melhor :)

— Mr. Xcoder

@ Mr.Xcoder Aqui está minha melhor tentativa, com base no método proposto. Ele diverge com sucesso em N = 69, retornando 341 (o primeiro pseudoprime de Fermat para a base 2 ou o primeiro número de Poulet), mas também falha em N = 1. Duvido que possa consertar sozinho, então achei melhor compartilhar o que tenho. (Meu melhor correção é de 46 bytes ...)

— Arnauld

1

@ Arnauld Encontrei uma solução de 44 bytes usando esse método. Eu não consigo ir mais longe. Talvez alguém seja capaz de descobrir isso.

— Poon Levi

4

Wolfram Language (Mathematica) , 39 34 bytes (Seguro)

Check[{1,9,7}[[#]],18+Boole[#>9]]&

Experimente online!

Parece simples, a solução deve ser difícil.

1-indexados e . Esta sequência não está disponível no OEIS. $n = 99$

{1, 9, 7, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19}

Esta lista acima é igual a:

Join[{1, 9, 7}, Table[18, 6], Table[19, 90]]

Aqui está um modelo para verificar sua solução: Experimente online!

Rachadura pretendida

O problema aqui é que a saída aumenta em 1 quando o número de dígitos aumenta em 1, com exceção dos três primeiros termos; a solução pretendida tem algo a ver com a conversão de cadeias.

Portanto, lendo a documentação em Convertendo entre expressões e string , é possível encontrar a função SpokenString.

A solução é simplesmente o tamanho da versão da expressão falada x^npara várias entradas:StringLength@SpokenString[x^#]&

— JungHwan Min
fonte

3

Haskell , 29 bytes (Rachado: 1 , 2 )

a n=n*ceiling(realToFrac n/2)

Experimente online!

Este é A093005 : . $a(n)=n\lceil \frac{n}{2} \rceil$

Casos de teste para , ou seja : $0 \leq n \leq 20$ map a [0..20]

[0,1,2,6,8,15,18,28,32,45,50,66,72,91,98,120,128,153,162,190,200]

Solução pretendida (20 bytes)

b n=sum$n<$show(3^n)

Experimente online! Difere em , com e . $n=23$ $a(23) = 276$ $b(23) = 253$

Esta função é equivalente a . Graças ao teto, as duas funções se sobrepõem a argumentos inteiros no intervalo de a : $b(n) = n\ len(3^n) = n \lceil log_{10}(1+3^n)\rceil$ $0$ $22$

_fonte

— Laikoni
fonte

rachado

— ბიმო

@Laikoni, se a rachadura pretendida for mais curta, alguém poderá reivindicar o ladrão da BMO.

— f Julnɛtɪk

@ fəˈnɛtɪk Obrigado, eu não estava ciente desta regra.

— Laikoni 01/07/19

@BMO re-cracked

— Ørjan Johansen

2

@BMO Lá vai você :)

— Laikoni

2

JavaScript (ES6), 12 bytes ( rachado )

Este é bastante fácil.

n=>n*(8*n+1)

Experimente online!

Este é o A139275 :

a (n) = n (8 n + 1)

$a(n) = n(8n+1)$

$0\le n<9$

0 0, 9, 34, 75, 132, 205, 294, 399, 520

$0, 9, 34, 75, 132, 205, 294, 399, 520$

E de acordo com as regras do desafio, ele deve divergir além.

— Arnauld
fonte

n=>8*n*n+ndifere n=94906273, isso é um crack válido?

— NGN

Parece que é válido para mim de acordo com as regras do desafio, mas talvez você deva perguntar ao OP se a perda de precisão conta como uma divergência válida? A rachadura pretendida difere n=9, no entanto.

— Arnauld

@CatWizard ^

— ngn

Eu diria que é um crack válido.

— Wheat Wizard

2

rachado (em |vez de +)

— ngn

2

Malbolge, 10 bytes

ub&;$9]J6

Observe que o código termina com um byte 0x14 (controle de dispositivo 4).

Experimente online!

A sequência indexada a 0 para quebrar é [9, 19, 29].

— Maçaneta da porta
fonte

2

> <> , 276 bytes ( Rachado )

1$1-:?!v$:      1[0$          >:?!va2[$:{:@%:{$-{,]v
       >$n; v              <  ^   >~{]02.1+1+ffr+1r<
 :}[r]{  [01>:{*@@+$a*l2=?!^~]+ff+9+1g"3"=?v"3"ff+9+1pf0.
 :}[l01-$>    $:0(?v$@$:@@:@)?v@@1-$}v     >"2"ff+9+1p00.
>.       ^-1l v!?} <  .4a}$@@$<   .4a<
^26{]r0[}:{]~{<

Experimente online! Chame este com -v npara obter o n-ésimo elemento (1-indexado)

1$1-:?!;$::n84*o1[0$          >:?!va2[$:{:@%:{$-{,]v
            v              <  ^   >~{]02.1+1+ffr+1r<
 :}[r]{  [01>:{*@@+$a*l2=?!^~]+ff+9+1g"3"=?v"3"ff+9+1pf0.
 :}[l01-$>    $:0(?v$@$:@@:@)?v@@1-$}v     >"2"ff+9+1p00.
>.       ^-1l v!?} <  .4a}$@@$<   .4a<
^26{]r0[}:{]~{<

Experimente online! Ligue -v npara obter uma lista de n-1 elementos começando em 1

Intérprete de peixe on-line

Um longo e complexo, este é o OEIS A004000 .

Deixe a (n) = k, forma m Invertendo os dígitos de k, Adicione m a k Em seguida, classifique os dígitos da soma em ordem crescente para obter a (n + 1).

Exemplo: 668 -> 668 + 866 = 1534 -> 1345.

$n = 34$

1 2 4 8 16 77 145 668 1345 6677 13444 55778 133345 666677 1333444 5567777 12333445 66666677 133333444 556667777 1233334444 5566667777 12333334444 55666667777 123333334444 556666667777 1233333334444 5566666667777 12333333334444 55666666667777 123333333334444 556666666667777 1233333333334444 5566666666667777

— crashoz
fonte

Como se executa o programa para produzir uma única saída para um dado n(conforme exigido pela pergunta)?

— Jonathan Allan

Como não são realmente não "funções" em peixes, eu adicionei uma versão que você pode chamar para obter o n-th (que é essencialmente o mesmo, porque tem que calcular os n-1 elementos anteriores)

— crashoz

Mais importante, você tem uma rachadura que se encaixa na mesma indexação de entrada que produz a única saída?

— Jonathan Allan

1

1 <= n <= 34

$1<=n<=34$

n > 34

$n>34$

Cracked

— Jo King

2

Geléia , 6 bytes , Seguro!

<4+ạ2ȯ

Isso define uma sequência indexada a zero em que:

uma (n) = {\begin{cases} 1 & n < 3 \\ 2 & n = 3 \\ n - 2 & n > 3 \end{cases}

$a(n) = \begin{cases} 1 & n<3 \\ 2 & n=3 \\ n-2 & n>3 \end{cases}$

$a(0)\cdots a(15)$ 1,1,1,2,2,3,4,5,6,7,8,9,10,11,12,13

Experimente online! ( aqui está uma versão de valor único)

No momento, isso não está no OEIS (embora o A34138 funcione como um crack, se for curto o suficiente)

Rachadura pretendida

$16$ $n$
$17^{\text{th}}$ $107004539285280$ $15$ $14=a(16)$

!ÆsDL

— Jonathan Allan
fonte

1

JavaScript, 26 bytes ( rachado )

let f=x=>x>1?f(x-1)*f(x-2)+1:1

for (x of [0,1,2,3,4,5,6,7]) {
  console.log(x + ' -> ' + f(x))
}

Expandir snippet

OEIS A007660

A saída é os 6 primeiros elementos com indexação 0 (1,1,2,3,7,22)

(um pouco diferente do que o OEIS listou como)

Basta criar uma resposta simples de resolver para começar

Experimente online!

— fəˈnɛtɪk
fonte

Rachado .

— Sr. Xcoder

A saída do seu snippet de exemplo começa em 1, não em 0?

— Paŭlo Ebermann

@ PaŭloEbermann Corrigido isso

— fevnɛtɪk

1

JavaScript, 16 bytes ( rachado )

g=
x=>Math.exp(x)|0

tmp=[0,1,2,3,4]
console.log(tmp.map(g).join(','))

Expandir snippet

$\lfloor e^n\rfloor$

As entradas necessárias para corresponder são 0,1,2,3,4.

Experimente online!

— fəˈnɛtɪk
fonte

Rachado

— Mr. Xcoder

1

APL (Dyalog Unicode) , 17 15 bytes

⌈∊∘1 5+.633*5-⊢

Experimente online!

Os 13 primeiros termos (com base em 1) são:

2 1 1 1 2 2 3 4 7 10 16 25 39

Dica: A solução pretendida usa uma das funções internas menos usadas.

— Bubbler
fonte

rachado

— NGN

@ngn Actualizado a apresentação policial :)

— Bubbler

1

Husk , 5 bytes ( quebrado por Jonathan Allan )

$16$

←d+16

Experimente online!

$0 \leq n < 23$

1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3

$1,1,1,1,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3$

Explicação

←d+16  -- example input:  23
  +16  -- add 16:         39
 d     -- digits:         [3,9]
←      -- extract first:  3

Solução

LdΣ

— ბიმო
fonte

rachado

— Jonathan Allan

1

JavaScript, 25 bytes ( rachados 21 bytes)

f=
x=>[7,11,12,13,13][x]||14

for(i=0;i<15;i++)
  console.log(i+"->"+f(i))

Expandir snippet

Sequência de 7,11,12,13,13 seguida de 14s infinitos.

Solução pretendida 22 bytes:

x = Math.atan (x + 1) * 10 | 0

Experimente online!

— fəˈnɛtɪk
fonte

Rachado

— Arnauld

0

JavaScript, 22 bytes ( rachado )

f=
x=>(3-(5/63)**.5)**x|1

for(y=0;y<16;y++)
  console.log(y +"->"+f(y))

Expandir snippet

É 0 indexado e a precisão é necessária até uma entrada de 15. Não pode ser encontrada no OEIS

Minha solução 20 bytes

x => 163 ** (32 * x / 163) | 1

Experimente online!

— fəˈnɛtɪk
fonte

Rachado .

— Mr. Xcoder

0

> <> , 42 bytes, quebrado

i3%0v
642 .
840
789
159
a 1
v<<
n
l
?
\/
;

Experimente online!

Sequência de crack (indexada 0): 101786, 5844, 19902(não no OEIS).

Solução pretendida , para referência.

— Aidan F. Pierce
fonte

Cracked

— Jo King

Geralmente o ladrões devem ser de codificação duro a saída

— Jo Rei

@JoKing Seu crack parece não produzir valores diferentes dos meus (ou talvez eu não o tenha testado o suficiente para descobrir quais valores diferem), mas isso provavelmente é facilmente corrigível. Embora não pareça haver nada nas regras que proíbam a codificação codificada, eu concordo que ela pode não se encaixar no espírito do desafio - em qualquer caso, você demonstrou que a codificação codificada (para um policial) tem seus próprios riscos.

— Mayan 'Pierce

1

Atualizei minha resposta para gerar um valor diferente para4

— Jo King

0

Perl 6 , 53 bytes

{(1,2,2,{$!=++$;prepend(@,2-$!%2 xx$_).pop}...*)[$_]}

Experimente online!

Bloco de código anônimo que retorna a sequência Kolakoski indexada em 0 ( OEIS A000002 ). São necessárias soluções para combinar com os primeiros 130 elementos, de modo que, para alguns n > 129, difere da sequência de Kolakoski.

— Brincadeira
fonte

0

Pascal (FPC) , 86 bytes ( quebrado )

var n:word;begin read(n);write(n div 2+n div 4+n div 8+n div 16+n div 32+n div 64)end.

Experimente online!

$n=120$ . A sequência da entrada 0 à entrada 120 é

0   0   1   1   3   3   4   4   7   7   8   8  10  10  11  11  15  15  16  16  18  18  19  19  22  22  23  23  25  25  26  26  31  31  32  32  34  34  35  35  38  38  39  39  41  41  42  42  46  46  47  47  49  49  50  50  53  53  54  54  56  56  57  57  63  63  64  64  66  66  67  67  70  70  71  71  73  73  74  74  78  78  79  79  81  81  82  82  85  85  86  86  88  88  89  89  94  94  95  95  97  97  98  98 101 101 102 102 104 104 105 105 109 109 110 110 112 112 113 113 116

Minha solução original foi

var n,i,s:word;begin read(n);i:=2;repeat s:=s+n div i;i:=i*2until i>n;write(s)end.

mas r_64 tornou ainda melhor !

— AlexRacer
fonte

Cracked

— Assistente de trigo

Codificação dos policiais e ladrões (policiais)

Desafio

Pontuação

cQuents , 4 bytes ( rachado )

Python 3 , 66 57 bytes ( rachado )

Python 2 , 44 bytes ( quebrado )

Wolfram Language (Mathematica) , 39 34 bytes (Seguro)

Rachadura pretendida

Haskell , 29 bytes (Rachado: 1 , 2 )

Solução pretendida (20 bytes)

JavaScript (ES6), 12 bytes ( rachado )

Malbolge, 10 bytes

> <> , 276 bytes ( Rachado )

Geléia , 6 bytes , Seguro!

Rachadura pretendida

JavaScript, 26 bytes ( rachado )

JavaScript, 16 bytes ( rachado )

APL (Dyalog Unicode) , 17 15 bytes

Husk , 5 bytes ( quebrado por Jonathan Allan )

Explicação

Solução

JavaScript, 25 bytes ( rachados 21 bytes)

JavaScript, 22 bytes ( rachado )

> <> , 42 bytes, quebrado

Perl 6 , 53 bytes

Pascal (FPC) , 86 bytes ( quebrado )