12

Este é um desafio de policiais e ladrões . O tópico dos policiais para esse desafio está aqui

Uma pergunta interessante a 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 recebe um número inteiro positivo como entrada e produz um número inteiro como saída. Esse código pode ser zero ou um indexado, mas deve ficar claro qual é a indexação. Este código definirá sua sequência.
Quaisquer requisitos relevantes de plataforma ou idioma que possam afetar a saída, por exemplo, o tamanho de longint.
Um número , juntamente com os primeiros termos da sequência, calculados pelo código. Eles atuarão como "casos de teste". $n$ $n$

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$

Pontuação

Os ladrões serão pontuados no número de rachaduras que encontrarem, com mais rachaduras sendo melhores. Uma resposta pode ser quebrada novamente, encontrando uma resposta válida menor que o crack original. Se uma resposta for quebrada uma segunda vez, o ponto é dado ao segundo cracker e não ao primeiro.

sequence cops-and-robbers

— Post Rock Garf Hunter
fonte

2

Ladrões não estamos deixando vencer uns aos outros para quebrar uma resposta (crack ou seja mais curta na língua vencedora)

— fənɛtɪk

@ fəˈnɛtɪk Parece bom, eu adicionei isso.

— Post Rock Garf Hunter

6

cQuents , resposta de Stephen , 3 bytes

z~$

Experimente online!

Como funciona

z     Last item in the sequence
 ~    Concat
  $   Current index

Looks como as seqüências devem ser idênticos, mas isso dá 12345678910para n = 10enquanto "::$dá 1234567891.

— Bubbler
fonte

5

JavaScript, resposta de fəˈnɛtɪk (17 bytes)

x=>"11237"[x]||22

Bem, foi fácil codificar para obter uma pontuação muito menor ... Difere da implementação de referência para qualquer entrada , indexada 0. Isso usa um truque de golfe JS muito conhecido: a indexação em uma sequência com um número inteiro que excede os limites retorna um valor falso ( ), para que possa ser simplesmente coagido a um valor padrão usando OR lógico , neste Nesse caso , manipular o último termo da sequência, mas também os seguintes. $x\ge 6$ undefined||22

Teste

let f=x=>"11237"[x]||22

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

Expandir snippet

Como alternativa, experimente online!

— Mr. Xcoder
fonte

4

Haskell , resposta de Laikoni , 15 bytes

b n=n*div(n+1)2

Experimente online!

Normalmente, eu apontaria algo assim em um comentário, mas depois pensei que policiais e ladrões são um pouco mais agressivos.

Esta é apenas a resposta da BMO menos o caso especial b 42. Como o original de Laikoni passa por ponto flutuante, não é necessário: basta encontrar um número grande o suficiente para gerar erros de arredondamento nisso, mas não na Integeraritmética exata . Por exemplo:

a 100000000000000000000000 = 4999999999999999580569600000000000000000000000
b 100000000000000000000000 = 5000000000000000000000000000000000000000000000

— Ørjan Johansen
fonte

Eu pensei que isso fosse possível (por isso escrevi que pode ser reescrito para os termos exigidos), mas não encontrei um valor pelo qual funcione .. Muito bem!

— ბიმო

4

Python 2 , resposta do xnor , 43 bytes

$n = 69$

f=lambda n,p=2:n<1or-~f(n-(~-2**p%p<2),p+1)

Experimente online!

Créditos

Grande parte do crédito por esse crack deve ser atribuída ao @ Mr.Xcoder, que primeiro postou um comentário sobre um possível ataque usando esse método, e ao @PoonLevi, que encontrou uma solução de 44 bytes.

Quão?

Teoria

$p$ $a$ $p$

\begin{matrix} (1) & a^{p - 1} \equiv 1 (\mod p) \end{matrix}

$a^{p-1}\equiv 1 \pmod p\tag{1}$

Em particular, para : $a=2$

2^{p - 1} \equiv 1 (\mod p)

$2^{p-1}\equiv 1 \pmod p$

Portanto, existe algum número inteiro positivo tal que: $k$

2^{p - 1} = k p + 1

$2^{p-1}=kp+1$

O que leva a:

2^{p} = 2 k p + 2

$2^p=2kp+2$

2^{p} - 1 = 2 k p + 1

$2^p-1=2kp+1$

\begin{matrix} (2) & 2^{p} - 1 \equiv 1 (\mod p) \end{matrix}

$2^p-1\equiv 1 \pmod p\tag{2}$

Essa última fórmula é aquela da qual o código Python é derivado e agora vale para , mesmo que não seja relativamente primo consigo mesmo. $p=2$ $2$

Agora, para a parte mais importante: o inverso do pequeno teorema de Fermat não é verdadeiro. Podemos ter para algum número composto . Tais números são chamados pseudoprimes de Fermat para basear . Os pseudoprimes de Fermat para a base 2 também são conhecidos como números de Poulet . $a^{n-1}\equiv 1 \pmod n$ $n$ $a$

O primeiro pseudoprime de Fermat para a base (ou o primeiro número de Poulet) é , para o qual temos: $2$ $n = 341=11\times 31$

2^{341 - 1} \equiv 1 (\mod 341)

$2^{341-1}\equiv 1 \pmod{341}$

2^{341} - 1 \equiv 1 (\mod 341)

$2^{341}-1\equiv 1 \pmod{341}$

Isto significa que o nosso algoritmo vai retornar em vez dos 69 esperados ^th nobre . $341$ $347$

Implementação

O @PoonLevi encontrou a seguinte solução de 44 bytes, baseada diretamente em : $(2)$

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

Usando em <2vez de ==1, salvamos 1 byte, mas introduzimos na sequência, porque : $1$ $2^1-1\equiv 0 \pmod 1$

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

Experimente online!

Começando com , obtemos os termos esperados em 1 porque fazemos uma iteração a menos: $p=2$

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

Experimente online!

O último truque é usar em n<1orvez de n and. Isso é tão longo, mas faz com que a última iteração retorne True em vez de 0 , adicionando o deslocamento ausente a cada termo.

— Arnauld
fonte

Parabéns a todos vocês! Esta é a solução que eu tinha em mente. Acho engraçado que, a partir da motivação do desafio "Se eu tenho uma sequência de números, quantos deles eu tenho que fornecer antes que fique claro de que sequência estou falando?", Os 50 primeiros números primos aparentemente não são suficientes - um alienígena de golfe em Python assumiria que você está falando de uma sequência diferente.

— Xnor

@xnor Eu amo a idéia de um "alien Python-golfe"

— dylnan

3

Python 3 , crashoz , 45 bytes

lambda n:int(60*math.sin(n/10-2))
import math

Experimente online!

A expressão x*60-x**3*10+x**5/2-x**7/84é a série de Taylor para até o termo , multiplicado por 60. Isso é preciso o suficiente nas entradas usadas, mas para valores mais altos, os dois divergem à medida que os termos truncados se tornam mais relevantes. $sin(x)$ $x^7$

— xnor
fonte

3

JavaScript (ES6), resposta de Arnauld (10 bytes)

n=>8*n*n|n

Experimente online!

— ngn
fonte

2

Haskell , resposta de Laikoni , 26 22 bytes

_{-4 bytes por não usar infix div, graças ao Laikoni !}

b 42=0;b n=n*div(n+1)2

Experimente online!

Explicação

Para o termo pode ser reescrito, o que nos fornece bytes suficientes para a correspondência de padrões em um que leva a uma rachadura em 28 bytes: $0 \leq n \leq 20$ ceiling(realToFrac n/2)div(n+1)2 $n > 20$

b 42=0

— ბიმო
fonte

Ah, eu não pensei nisso. Eu tenho uma abordagem diferente que leva a uma rachadura de 20 bytes, caso você queira confundir um pouco mais. Também ((n+1)`div`2)-> div(n+1)2.

— Laikoni

@Laikoni: Sim, não o revele ainda! Oopsies, sim, já faz um bom tempo desde que eu jogava golfe, eu atualizo.

— ბიმო

2

> <> , resposta de crashoz 203 bytes

:l2-$g:0=?;n:





M
-
B
"
BM
",
7M
!"
BBM
!",
7CM
!"-
BBBM
!!",
7BBMM
!!,,
7BBBMM
!!,,
7BBBMM
!!!,,
7BBBBMM
!!!,,
7BBBBMM
!!!!,,
7BBBBBMM
!!!!,,
7BBBBBMM
!!!!!,,
7BBBBBBMM

Experimente online!

Eu ia fazer algo inteligente com o fato de que os números pares / ímpares acima n=20eram os mesmos, exceto por um elemento repetido no centro, mas era mais fácil codificar todos os elementos.

A entrada é via -vbandeira. Não imprime nada para elementos acima de 34.

— Brincadeira
fonte

2

Pascal (FPC) , resposta de AlexRacer , 80 bytes

var n,m:word;begin read(n);while n<>0 do begin n:=n div 2;m:=m+n;end;write(m)end.

Experimente online!

Quando as saídas são idênticas, mas quando o código acima gera , enquanto o código de AlexRacer gera . $0\le n\le 120$ $n=128$ $127$ $126$

Parece uma resposta tardia, mas de qualquer maneira agradeça ao @AlexRacer por um bom quebra-cabeça!

— r_64
fonte

1

Uau, isso é ainda mais curto do que o que eu tinha. Bem-vindo ao PPCG!

— AlexRacer

1

JavaScript, resposta de fəˈnɛtɪk (12 bytes)

Isso funciona para os valores fornecidos, mas falha em muitos outros valores (por exemplo, ) devido a erros de precisão. $x=6$

x=>2.72**x|0

Teste

g=
x=>2.72**x|0

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

Expandir snippet

Como alternativa, experimente online!

— Mr. Xcoder
fonte

1

JavaScript, resposta de fəˈnɛtɪk (17 bytes)

Você pode ver no link TIO ou no resultado do Snippet de pilha que falha nas entradas maiores que . $15$

x=>2.7182819**x|1

Se a precisão fosse necessária apenas para (os primeiros valores), também funcionaria para 16 bytes. $n\le 14$ $15$ x=>Math.exp(x)|1

Teste

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

tmp=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21]
console.log(tmp.map(f).join(","))
console.log(tmp.map(g).join(","))

Expandir snippet

Como alternativa, experimente online!

— Mr. Xcoder
fonte

1

Husk , quebrando 5 byter do BMO com 3 2 bytes

-1 graças ao BMO ( LdΣ-> LΣdesde que, quando dado a Tnum, Lexecuta "comprimento da representação de string")

LΣ

Experimente online!

O comprimento digital dos números triangulares * corresponde e difere a ... quando produz enquanto produz . $a(0)\cdots a(23)$ $a(24)$
LΣ $3$ ←d+16 $4$

_{* Onde tem um comprimento digital de (não ) $T(0)=0$ $1$ $0$}

— Jonathan Allan
fonte

Parabéns, essa foi minha solução exata! No entanto, acabei de notar que, para TNum s Le Ld são equivalentes, você economiza um byte;) #

— 30118

Ah, procurei por "dígito" no wiki para tentar encontrar o comprimento digital, mas não identifiquei as Lsubstituições como "comprimento da representação de string" Tnum.

— Jonathan Allan

(Note-se que eles são apenas equivalente para inteiros não negativos - bom o suficiente para isso.)

— Jonathan Allan

1

> <> , Resposta de Aiden F. Pierce , 36 bytes

v101786
i5844
419902
%
>l{:}g:0=?;o:

Experimente online!

Outra solução com cada valor codificado por linha. Como a resposta original também era principalmente codificada, não me sinto muito culpado por isso.

— Brincadeira
fonte

0

JavaScript, resposta de fəˈnɛtɪk , 23 bytes

$0$ $n\ge 14$

x=>14-`${73211e9}`[x]|0

Experimente online!

Quão?

A expressão se `${73211e9}`expande para a cadeia de caracteres "73211000000000", fornecendo uma tabela de pesquisa de 14 valores subtraídos de 14, que fornece a sequência esperada.

$n\ge 14$

(14 - undefined) | 0
=== NaN | 0
=== 0

21 bytes

NaN $n\ge 14$

x=>14-`${73211e9}`[x]

Experimente online!

— Arnauld
fonte

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

Desafio

Pontuação

cQuents , resposta de Stephen , 3 bytes

Como funciona

JavaScript, resposta de fəˈnɛtɪk (17 bytes)

Teste

Haskell , resposta de Laikoni , 15 bytes

Python 2 , resposta do xnor , 43 bytes

Créditos

Quão?

Teoria

Implementação

Python 3 , crashoz , 45 bytes

JavaScript (ES6), resposta de Arnauld (10 bytes)

Haskell , resposta de Laikoni , 26 22 bytes

Explicação

> <> , resposta de crashoz 203 bytes

Pascal (FPC) , resposta de AlexRacer , 80 bytes

JavaScript, resposta de fəˈnɛtɪk (12 bytes)

Teste

JavaScript, resposta de fəˈnɛtɪk (17 bytes)

Teste

Husk , quebrando 5 byter do BMO com 3 2 bytes

> <> , Resposta de Aiden F. Pierce , 36 bytes

JavaScript, resposta de fəˈnɛtɪk , 23 bytes

Quão?

21 bytes