28

C'est un défi de flics et de voleurs . Le fil des voleurs est ici .

Une question intéressante à considérer est la suivante:

Si j'ai une séquence de nombres, combien dois-je fournir avant de savoir de quelle séquence je parle?

Par exemple, si je veux parler des entiers positifs dans l'ordre à partir de , je pourrais dire , mais est-ce vraiment suffisant? $1$ $1,2,3, \dots$

J'ai une façon de répondre à cette question, et en tant que golfeur de code, cela implique le golf de code. Vous avez fourni suffisamment de termes d'une séquence si le code le plus court qui produit ces termes produit tous les termes de la séquence. Si nous pensons à cela en termes de code-golf, cela signifierait que vous avez fourni suffisamment de cas de test pour que le code le plus court qui réussit les cas de test fasse la tâche souhaitée.

Défi

Ce défi est un défi de flics et de voleurs . Dans lequel les flics présenteront des cas de test et les voleurs devront trouver un moyen plus court d'usurper les cas de test autres que la séquence prévue. Les flics présenteront les choses suivantes:

Un morceau de code qui prend un entier non négatif en entrée et produit un entier en sortie. Ce code définira votre séquence. Votre code n'a pas besoin de prendre en charge 0 comme entrée, en choisissant plutôt de prendre 1 comme entrée la plus petite. Il devrait être clair si tel est le cas dans votre réponse.
Toute exigence de plate-forme ou de langue pertinente pouvant affecter la sortie, par exemple la taille de l'entier long.
Un nombre , ainsi que les premiers termes de la séquence tels que calculés par le code. Ceux-ci serviront de "cas de test". $n$ $n$

Nous vous encourageons à expliquer ce que fait votre séquence et à lier OEIS si elle existe, mais c'est votre code qui définit la séquence et non la description.

Les voleurs trouveront un programme dans le même langage qui est plus court que celui présenté et réussit tous les cas de test (produit la même sortie pour les premières entrées que le code du flic). Le code du voleur doit également différer en sortie du programme du flic pour un nombre supérieur à . $n$ $n$

Les flics doivent être capables de déchiffrer leurs propres réponses avant de les soumettre.

Après une semaine, un flic peut révéler son crack et marquer sa réponse comme Sûr. Les réponses marquées comme telles ne peuvent plus être craquées.

Notation

Les réponses des flics seront notées par le nombre d'octets avec moins d'octets étant meilleurs. Les réponses fissurées marquent un score infini.

code-golf sequence cops-and-robbers

— Assistant de blé
source

Il est clair qu'il existe des moyens de résoudre un problème de manière non mathématique, comme simplement imprimer tous les cas de test, mais ce problème est conditionnel aux cas fournis par les flics. Devrait-il y avoir une règle à ce sujet? Y a-t-il une restriction contre la calculabilité des séquences ou quoi que ce soit de la théorie de Ramsey? (c.-à-d. avez-vous besoin de pouvoir craquer sur votre machine?)

— theREALyumdub

2

@theReallyumdub la question stipule que vous devez être capable de déchiffrer votre propre soumission.

— Wheat Wizard

@CatWizard Merci, je suis allé de l'avant et c'est déjà sur un meta post évident, cela empêche apparemment certains de ces gars. Donc, ce n'est pas dans l'esprit du tag de faire une fissure prendre plus d'une heure pour calculer ou quelque chose

— theREALyumdub

4

spikedmath.com/062.html

— Giuseppe

Existe-t-il une condition "bien que théoriquement votre solution doive fonctionner pour tous les nombres dans la pratique, elle ne doit fonctionner que pour ..."?

— user202729

6

cQuents , 4 octets ( fissuré )

"::$

Essayez-le en ligne!

Voici huit ( n=8) cas:

Explication du code:

"      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

Ainsi, la séquence est 1,2,3,4,5 ..., elle est jointe ""pour devenir 12345 ..., et ::signifie qu'elle imprime jusqu'à l'entrée.

— Stephen
source

Fissuré.

— Bubbler

5

Python 3 , 66 57 octets ( fissuré )

cracké par xnor
également cracké par Cat Wizard avant une modification

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

Essayez-le en ligne!

Bonjour! Voici une séquence à craquer pour . Il donne ces 40 premiers éléments avec une indexation 0, ce n'est pas une séquence 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
source

J'ai oublié de supprimer l'espace, je ne suis pas encore un golfeur expert: p Cela vous dérange si je modifie pour résoudre ce problème?

— crashoz

Bien sûr vas y. Je vais retirer ma fissure.

— Wheat Wizard

Cracked

— xnor

5

Python 2 , 44 octets ( craqué )

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

Essayez-le en ligne!

Les nombres premiers. Quelle séquence pourrait être plus pure? Ou plus exagéré ? Votre objectif est de produire les 50 premiers nombres premiers de n=1to n=50.

Le code est un générateur de théorème de Wilson copié exactement à partir de cette astuce .

Les différentes valeurs de la séquence alternative ne sont pas dues aux limitations de la machine comme les débordements et la précision. Pas de bibliothèques tierces.

Fissurée par Arnauld, @PoonLevi, et M. Xcoder.

— xnor
source

Je suis sûr que vous ne vouliez pas vous faire craquer par ça ; peut-être spécifier "Python (sans bibliothèques tierces)" ou "Python (sans importations)" ou quelque chose?

— Jonathan Allan

@JonathanAllan Merci, j'ai édité qu'il n'y a pas de bibliothèques tierces.

— xnor

Je n'ai pas encore réussi à résoudre ce problème (ma meilleure tentative pour le moment est de 47 octets environ), mais je pense qu'il y a quelque chose d'intéressant à noter à propos de ces nombres premiers particuliers. Pour chaque

, avec

, cela vaut:

. En même temps, cela n'est pas vrai pour tout nombre qui n'est pas premier (dans la plage notée ci-dessus), mais cela ne

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)$ donc pour des valeurs plus élevées. Je laisse cette idée ici afin que d'autres puissent essayer une fissure en utilisant la technique mentionnée, et peut-être obtenir un meilleur score :)

— M. Xcoder

@ Mr.Xcoder Voici ma meilleure tentative basée sur votre méthode proposée. Il diverge avec succès à N = 69, renvoyant 341 (le premier pseudoprime de Fermat à la base 2, ou premier nombre de Poulet) mais il échoue également pour N = 1. Je doute que je puisse le réparer moi-même, alors j'ai pensé que je ferais mieux de partager ce que j'ai. (Ma meilleure solution est de 46 octets ...)

— Arnauld

1

@Arnauld J'ai trouvé une solution de 44 octets en utilisant cette méthode. Je n'arrive pas à aller plus loin. Peut-être que quelqu'un d'autre pourra comprendre cela.

— Poon Levi

4

Wolfram Language (Mathematica) , 39 34 octets (sûr)

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

Essayez-le en ligne!

Semble simple, la solution devrait être difficile.

1 indexé et . Cette séquence n'est pas disponible sur l'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}

Cette liste ci-dessus est égale à:

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

Voici un modèle pour vérifier votre solution: Essayez-le en ligne!

Fissure prévue

Le problème ici est que la sortie augmente de 1 lorsque le nombre de chiffres augmente de 1, à l'exception des trois premiers termes; la solution envisagée a quelque chose à voir avec la conversion de chaînes.

Par conséquent, en lisant la documentation sur la conversion entre expressions et chaîne , on pourrait trouver la fonction SpokenString.

La solution est simplement la longueur de la version de chaîne parlée de l'expression x^npour diverses entrées:StringLength@SpokenString[x^#]&

— JungHwan Min
source

3

Haskell , 29 octets (fissuré: 1 , 2 )

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

Essayez-le en ligne!

C'est A093005 : . $a(n)=n\lceil \frac{n}{2} \rceil$

Cas de test pour , soit : $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]

Solution prévue (20 octets)

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

Essayez-le en ligne! Diffère à , avec et . $n=23$ $a(23) = 276$ $b(23) = 253$

Cette fonction équivaut à . Grâce au plafond, les deux fonctions se chevauchent pour des arguments entiers compris entre et : $b(n) = n\ len(3^n) = n \lceil log_{10}(1+3^n)\rceil$ $0$ $22$

_{la source}

— Laikoni
source

fissurée

— ბიმო

@Laikoni, si la fissure voulue est plus courte, alors quelqu'un d'autre pourrait potentiellement réclamer le voleur de BMO.

— fəˈnɛtɪk

@ fəˈnɛtɪk Merci, je n'étais pas au courant de cette règle.

— Laikoni

@BMO re-cracké

— Ørjan Johansen

2

@BMO Et voilà :)

— Laikoni le

2

JavaScript (ES6), 12 octets ( fissuré )

Celui-ci est assez simple.

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

Essayez-le en ligne!

C'est A139275 :

une (n) = n (8 n + 1)

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

$0\le n<9$

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

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

Et selon les règles du défi, il doit diverger au-delà.

— Arnauld
source

n=>8*n*n+ndiffère pour n=94906273, est-ce une fissure valide?

— ngn

@ngn Cela me semble valide selon les règles du défi, mais peut-être devriez-vous demander au PO si la perte de précision compte comme une divergence valide? La fissure prévue diffère n=9cependant.

— Arnauld

@CatWizard ^

— ngn

Je dirais que c'est une fissure valide.

— Wheat Wizard

2

cracké ( |au lieu de +)

— ngn

2

Malbolge, 10 octets

ub&;$9]J6

Notez que le code se termine par un octet 0x14 (contrôle de périphérique 4).

Essayez-le en ligne!

La séquence indexée à fissurer est 0 [9, 19, 29].

— Poignée de porte
source

2

> <> , 276 octets ( fissuré )

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[}:{]~{<

Essayez-le en ligne! Appelez celui-ci avec -v npour obtenir le n-ième élément (1-indexé)

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[}:{]~{<

Essayez-le en ligne! Appelez avec -v npour obtenir la liste des n-1 éléments à partir de 1

Interprète de poisson en ligne

Long et complexe, il s'agit d' OEIS A004000 .

Soit a (n) = k, forme m en inversant les chiffres de k, Additionne m à k Puis trie les chiffres de la somme en ordre croissant pour obtenir a (n + 1).

Exemple: 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
source

Comment exécute-t-on le programme pour produire une sortie unique pour une donnée n(comme requis par la question)?

— Jonathan Allan

Comme il n'y a pas vraiment de "fonctions" dans fish, j'ai ajouté une version que vous pouvez appeler pour obtenir le n-ième (qui est essentiellement le même, car il doit calculer les n-1 éléments précédents)

— crashoz

Plus important encore, avez-vous une fissure qui correspond à la même indexation d'entrée qui donne la sortie unique?

— Jonathan Allan

1

1 <= n <= 34

$1<=n<=34$

n > 34

$n>34$

Cracked

— Jo King

2

Gelée , 6 octets , sûr!

<4+ạ2ȯ

Cela définit une séquence indexée zéro où:

une (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

Essayez-le en ligne! ( voici une version à valeur unique)

Ce n'est pas actuellement dans l'OEIS (bien que A34138 fonctionnera comme une fissure s'il est assez court)

Fissure prévue

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

!ÆsDL

— Jonathan Allan
source

1

JavaScript, 26 octets ( fissuré )

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))
}

Développer l'extrait

OEIS A007660

La sortie est les 6 premiers éléments avec 0 indexation (1,1,2,3,7,22)

(légèrement décalé par rapport à ce que l'OEIS a répertorié)

Il suffit de créer une réponse simple à résoudre pour lancer les choses

Essayez-le en ligne!

— fəˈnɛtɪk
source

Fissuré .

— M. Xcoder

La sortie de votre exemple d'extrait commence à 1, pas à 0?

— Paŭlo Ebermann

@ PaŭloEbermann Fixe cela

— fəˈnɛtɪk

1

JavaScript, 16 octets ( fissuré )

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

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

Développer l'extrait

$\lfloor e^n\rfloor$

Les entrées requises pour correspondre sont 0,1,2,3,4.

Essayez-le en ligne!

— fəˈnɛtɪk
source

Cracked

— M. Xcoder

1

APL (Dyalog Unicode) , 17 15 octets

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

Essayez-le en ligne!

Les 13 premiers termes (basés sur 1) sont:

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

Astuce: La solution envisagée utilise l'une des fonctions intégrées les moins utilisées.

— Bubbler
source

cracké

— ngn

@ngn Mise à jour de la soumission du flic :)

— Bubbler

1

Husk , 5 octets ( craqué par Jonathan Allan )

$16$

←d+16

Essayez-le en ligne!

$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$

Explication

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

Solution

LdΣ

— ბიმო
source

cracké

— Jonathan Allan

1

JavaScript, 25 octets ( craquage 21 octets)

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

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

Développer l'extrait

Séquence de 7,11,12,13,13 suivie de 14 infinis.

Solution prévue 22 octets:

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

Essayez-le en ligne!

— fəˈnɛtɪk
source

Cracked

— Arnauld

0

JavaScript, 22 octets ( fissuré )

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

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

Développer l'extrait

Il est indexé à 0 et la précision est requise jusqu'à une entrée de 15. Il ne peut pas être trouvé sur OEIS

Ma solution 20 octets

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

Essayez-le en ligne!

— fəˈnɛtɪk
source

Fissuré .

— M. Xcoder

0

> <> , 42 octets, fissuré

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

Essayez-le en ligne!

Séquence à craquer (index 0): 101786, 5844, 19902(pas sur OEIS).

Solution prévue , pour référence.

— Aidan F. Pierce
source

Cracked

— Jo King

Habituellement, les voleurs devraient coder en dur la sortie

— Jo King

@JoKing Votre fissure ne semble pas produire de valeurs différentes de la mienne (ou peut-être que je ne l'ai pas testée suffisamment pour trouver quelles valeurs diffèrent), mais c'est probablement facilement rectifiable. Bien qu'il ne semble pas y avoir quoi que ce soit dans les règles interdisant le codage en dur, je conviens que cela peut ne pas correspondre à l'esprit du défi - en tout cas, vous avez démontré que le codage en dur (pour un flic) comporte ses propres risques.

— Aidan F. Pierce

1

J'ai mis à jour ma réponse pour produire une valeur différente pour4

— Jo King

0

Perl 6 , 53 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui renvoie la séquence de Kolakoski indexée sur 0 ( OEIS A000002 ). Des solutions sont nécessaires pour correspondre aux 130 premiers éléments, de sorte que pour certains, n > 129il diffère de la séquence de Kolakoski.

— Jo King
source

0

Pascal (FPC) , 86 octets ( craqué )

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.

Essayez-le en ligne!

$n=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

Ma solution originale était

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

mais r_64 l'a rendu encore meilleur !

— AlexRacer
source

cracked

— Wheat Wizard

Codage en dur des flics et des voleurs (flics)

Défi

Notation

cQuents , 4 octets ( fissuré )

Python 3 , 66 57 octets ( fissuré )

Python 2 , 44 octets ( craqué )

Wolfram Language (Mathematica) , 39 34 octets (sûr)

Fissure prévue

Haskell , 29 octets (fissuré: 1 , 2 )

Solution prévue (20 octets)

JavaScript (ES6), 12 octets ( fissuré )

Malbolge, 10 octets

> <> , 276 octets ( fissuré )

Gelée , 6 octets , sûr!

Fissure prévue

JavaScript, 26 octets ( fissuré )

JavaScript, 16 octets ( fissuré )

APL (Dyalog Unicode) , 17 15 octets

Husk , 5 octets ( craqué par Jonathan Allan )

Explication

Solution

JavaScript, 25 octets ( craquage 21 octets)

JavaScript, 22 octets ( fissuré )

> <> , 42 octets, fissuré

Perl 6 , 53 octets

Pascal (FPC) , 86 octets ( craqué )