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


12

Este é um desafio de . 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 , 2 , 3 , 11,2,3,

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 . 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".nnn

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 .nnn

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.


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

Respostas:



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.x6undefined||22

Teste

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

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

Como alternativa, experimente online!


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

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

ppap

(1)ap11(modp)

Em particular, para :a=2

2p11(modp)

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

2p1=kp+1

O que leva a:

2p=2kp+2
2p1=2kp+1
(2)2p11(modp)

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=22

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 .an11(modn)na

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

2 341 - 1 1

234111(mod341)
234111(mod341)

Isto significa que o nosso algoritmo vai retornar em vez dos 69 esperados th nobre .347341347

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 :2 1 - 1 012110(mod1)

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.


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.x 7sin(x)x7



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:n > 200n20ceiling(realToFrac n/2)div(n+1)2n>20

b 42=0

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.


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 .n = 128 127 1260n120n=128127126

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


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(','))

Como alternativa, experimente online!


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.15n1415x=>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(","))

Como alternativa, experimente online!


1

Husk , quebrando 5 byter do BMO com  3  2 bytes

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

Experimente online!

O comprimento digital dos números triangulares * corresponde e difere a ... quando produz enquanto produz .a ( 24 ) 3 4a(0)a(23)a(24)
3←d+164

* Onde tem um comprimento digital de (não )1 0T(0)=010


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


0

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

0n14

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.

n14

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

21 bytes

NaNn14

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

Experimente online!

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.