C'est le fil des flics. Le fil des voleurs va ici .

Le dernier fil des flics-et-voleurs était déjà il y a 4 mois .

La tâche du flic

• La tâche du policier consiste à écrire un programme / une fonction prenant un entier positif (ou non négatif) et produisant / renvoyant un autre entier.
• Le flic doit l'indiquer si le programme est intolérant vers zéro.
• Le flic fournira au moins 2 échantillons d'entrées / sorties.
• Par exemple, si j'ai décidé d'écrire la séquence de Fibonacci , j'écrirais ceci dans ma réponse:

a (0) renvoie 0
un (3) retourne 2

• Le nombre d'exemples est à la discrétion du policier.
• Cependant, la séquence doit effectivement exister dans l'encyclopédie en ligne d'Integer Sequences® , donc aucun générateur de nombre pseudo-aléatoire pour vous.:(
• Le flic peut cacher autant de caractères qu'il le souhaite.
• Par exemple, si mon programme est:

function a(n)
    if n>2 then
        return n
    else
        return a(n-1) + a(n-2)
    end
end

• Alors je cacherais ces caractères comme je veux:

function a(n)
    if ### then
        ########
    else
        ######################
    end
end

La tâche du voleur

• est évidemment de trouver le code source original.
• Cependant, tout code source proposé produisant le même ensemble de sorties est également considéré comme valide, tant qu'il se trouve également dans OEIS.

Conseils pour les flics

• La fonction de recherche dans OEIS ne fonctionne que pour des termes consécutifs. Par conséquent, si vous souhaitez masquer votre séquence, laissez un trou n'importe où.
• Apparemment, il n'y a aucun moyen de cacher la séquence. Gardez cela à l’esprit lorsque vous choisissez la séquence.

Votre score est le nombre d'octets dans votre code.

Le gagnant sera la soumission avec le score le plus bas qui n’a pas été craqué depuis 7 jours.

Seules les soumissions publiées en avril 2016 sont éligibles. Les soumissions postées plus tard sont les bienvenues, mais ne peuvent gagner.

Pour réclamer la victoire, vous devez révéler le code complet et la séquence OEIS (après 7 jours).

Votre message devrait être formaté comme ceci (NN est le nombre de caractères):

Lua, 98 octets

Sortie:

a(0) returns 0
a(3) returns 2

Code ( #marque les caractères non révélés):

function a(n)
    if ### then
        ########
    else
        ######################
    end
end

Si le code est fissuré, insérez-le [Cracked](link to cracker)dans l'en-tête. Si la soumission est sécurisée, insérez "Safe" dans l'en-tête et affichez le code complet dans votre réponse. Seules les réponses ayant révélé le code complet seront éligibles.

Vim, 36 frappes - Sécuritaire!

i****<esc>:let @q="^*i****$**@***"<cr><n>@qbD

(Remarque: <n>est l'endroit où vous tapez votre entrée)

Voici le code sans rapport avec la génération de numéro:

          :let @q="              "<cr><n>@qbD

Ce qui signifie que je révèle 5 caractères sur 19.

<n>est l'entrée. Voici quelques exemples de résultats:

1@q:    1
2@q:    3
6@q:    18

Répondre

Ce code imprime les numéros Lucas ( A000032 ), qui sont tout comme la séquence Fibonnaci, sauf qu'il commence à la 2, 1place de 1, 1. Voici les 15 premiers chiffres:

2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, 199, 322, 521, 843

Voici le code révélé:

i2 1 <esc>:let @q="^diwwyw$pb@-<c-v><c-a>"<cr><n>@qbD

Explication:

i2 1 <esc>                          "Insert the starting numbers
          :let @q="....."<cr>       "Define the macro 'Q'

Explication de la macro:

^                      "Move to the first non-whitespace character on the line.
 diw                   "(d)elete (i)nner (w)ord. This is different then 'dw' because it doesn't grab the space. 
                      "It also throws people off since 'i' is usually used for inserting text.
    wyw$               "Move to the next number, yank it then move to the end of the line 
        pb             "(p)aste the yanked text and move (b)ack
          @-     <c-a> "@- is the register holding the word we deleted. Increment the current number that many times.
            <c-v>      "Since we're adding <c-a> this from the command line, we need to type it as a literal.

Maintenant, il ne reste plus qu’à supprimer le deuxième numéro, car le premier numéro correspond au numéro de Lucas que nous voulons. Donc nous faisons

b   "move (b)ack
 D  "(D)elete to the end of the line.

De plus, si je ne me trompe pas, il s'agit de la première soumission sécurisée! C'est plutôt cool.

05AB1E , 5 octets, coffre-fort

Dernier pour aujourd'hui: p. Sortie:

a(0) = 9
a(5) = 4
a(10) = 89

Code:

___m_

Les caractères masqués sont signalés par _. Essayez-le en ligne! -lien. Utilise le codage CP-1252 .

Solution:

žhžm‡

Explication:

žh       # Short for [0-9].
  žm     # Short for [9-0].
    ‡    # Translate.

Essayez-le en ligne! ou Essayez pour tous les cas de test! .

Element , 7 octets, fissuré

Sortie:

a(3) = 111
a(7) = 1111111

Les caractères #sont cachés et sont tous imprimables en ASCII. Je pense que celui-ci est en fait assez difficile (pour n'avoir que 5 caractères manquants).

###,##}

Pour plus de commodité, voici les pages wiki Try It Online et Esolang .

Mon programme original était:

_'[,$ ` }

Le truc c'est que

]et }sont fonctionnellement identiques (les deux se traduisent }en Perl). En outre, j’ai eu l'habitude ,$de créer une 1confusion supplémentaire, bien qu'il soit possible de l'ignorer ,complètement en le faisant ,1.

Jolf , 5 octets, fissuré

Sortie:

a(2) = 8
a(10) = 4738245926336

Tout cela est crucial, et j'ai montré 1 sur 5.

####x

Code d'origine:

mPm$x
mP     cube
  m$   catalan number
    x  input

Essayez-le en ligne!

JavaScript (ES7), 10 octets, fissuré

Sortie

f(0) -> 1
f(1) -> -1

Code

t=>~t##**#

Testez-le dans Firefox tous les soirs. Le code est une fonction anonyme. Ce sera probablement facile car il n'y a que trois caractères cachés, mais au moins c'est court! : P

Mon code d'origine était:

t=>~top**t

mais après avoir forcé mon propre code pour trouver une solution, j'ai vite réalisé

t=>~t.x**t(où xpeut être n'importe quel caractère de nom de variable)

pourrait également être utilisé. Cela fonctionne parce que

Dans la spécification initiale de l'opérateur ES7 d'exponentiation, l'opérateur avait une priorité inférieure à celle des opérateurs unaires (contrairement aux mathématiques classiques et à la plupart des autres langages). ~effectue un NOT au niveau des bits sur t.x( undefined) ou top( Object) qui les transforme en un entier signé de 32 bits (les non diffusables comme ceux-ci deviennent 0) avant de faire le NON (le 0devient ainsi -1). J'ai examiné la question plus en profondeur et très récemment, la spécification a été modifiée pour interdire les références ambiguës (ce qui n'est pas le cas pour le golfing D:), mais la plupart des moteurs ES7 ne sont pas encore mis à jour avec la dernière version de la spécification.

05AB1E, 4 octets ( fissuré )

Exemple de sortie:

a(5) = 51
a(8) = 257

Et pour le code:

###^

J'ai révélé le dernier. Devrait être assez facile cependant, j'ai eu beaucoup de mal à trouver une séquence :(

Tous les caractères cachés sont imprimables.

MATL , 5 octets, fissuré

Les caractères cachés sont indiqués par % .

%5%*%

Sortie:

a(1) = 3
a(2) = 6
a(4) = 12

Contribution 0 est valide.

Code d'origine:

35B*s

C'est,

35    % push number 35
B     % convert to binary: array [1 0 0 0 1 1]
*     % multiply element-wise by implicit input n: gives [n 0 0 0 n n]
s     % sum of array: gives 3*n

SWIFT, 55 octets, fissuré

func M(n:Int)->Int{
return(n*****) ?M(**n****):n***;
}

* marque un personnage caché

Sortie:

M(30) -> 91
M(60) -> 91
M(90) -> 91
M(120)-> 110
M(150)-> 140

La fonction accepte 0

Ruby, 46 bytes, safe

Modifier pour ajouter une clause de non-responsabilité / des excuses: cette séquence commence par f [0], tandis que l'entrée OEIS commence par f [1]. Les valeurs sont les mêmes.

Code masqué ( #n'importe quel caractère):

->####or x##1###(#..##0#);x*=3;end;#.###ect:+}

Appeler comme

->####or x##1###(#..##0#);x*=3;end;#.###ect:+}[3] (returns 39)

Sortie:

f[0] = 0
f[1] = 3
f[2] = 12
f[3] = 39
f[4] = 120
f[5] = 363
f[6] = 1092
f[7] = 3279
f[8] = 9840
f[9] = 29523

Solution:

f=->*x{for x[-1]in(0..x[0]);x*=3;end;x.inject:+}

Séquence:

http://oeis.org/A029858

Explication:

Le truc mineur ici est que nous déclarons le paramètre *xplutôt que x. Cela signifie que si vous passez 2, xest réglé sur [2]... au début. L' astuce majeure exploite une syntaxe bizarre, et simplement obscure, Ruby, dans laquelle vous pouvez définir l'itérateur dans une boucle for sur n'importe quel côté gauche valide d'une expression d'affectation, au lieu d'une variable itérateur i. Donc, cela passe de 0 à (dans cet exemple) 2, en assignant chaque nombre à x[-1], ce qui signifie qu'il écrase la dernière valeur de x. Ensuite, le corps de la boucle x*=3mute x en le concaténant 3 fois. Donc, d'abord x devient [0], alors [0,0,0]. Dans la boucle suivante, cela devient [0,0,1]alors . Nous additionnons ensuite le résultat en utilisant le[0,0,1,0,0,1,0,0,1] . Finalement on passe en 2 et ça devient [0,0,1,0,0,1,0,0,2], alors[0, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 1, 0, 0, 2]inject méthode, ce qui réduit le tableau en appliquant +(la méthode transmise) à chaque élément. Si nous considérons comment chaque itération modifie la somme, nous voyons que nous ajoutons effectivement 1 (en écrasant le dernier élément avec un élément supérieur), puis multiplions par 3. Depuis 3*(n+1) = 3*n + 3, cela implémente la relation de récurrence d'Alexandre Wajnberg pour la séquence décrite à la page.

05AB1E , 3 octets, fissuré

Sortie:

a(9) = 165
a(10) = 220

Code caché:

##O

Essayez-le en ligne pourrait être utile.

Hexagony , 7 octets, fissuré

Sortie:

a(1) = 2
a(2) = 4

Code caché:

?#####@

Ou bien:

 ? #
# # #
 # @

Essayez-le en ligne pourrait être utile.

PHP, 41 octets, fissuré

Ouais, enfin un autre défi Cops and Robbers. J'espère que je ne l'ai pas rendu facile.

Sortie

a(5)   = 0
a(15)  = 1
a(35)  = 0
a(36)  = 1
a(45)  = 1

La source

____________________$argv[1]____________;
####################        ############

Remarques

• C'est un programme complet, pas une fonction.
• Lit l'entrée de la ligne de commande (évidemment).
• Ne contient pas de balise d'ouverture PHP .

Fissuré

J'ai évidemment rendu la tâche facile et n'ai pas fourni suffisamment d'exemples. La séquence que j'avais en tête était A010054 :

a (n) = 1 si n est un nombre triangulaire sinon 0.

Voici mon code source d'origine:

echo(int)($r=sqrt(8*$argv[1]+1))==$r?1:0;

Il teste si l'entrée est un nombre triangulaire et les sorties 1ou en 0conséquence.

Jolf, 11 octets, fissuré , A011551

c*______x__

c*mf^+91x~P

Code d'origine:

c*^c"10"x~P

Exemples:

0 -> 1

12 -> 1618033988749

MATL, 9 octets, fissuré

Code:

3#2###*##

Sortie:

a(1)  = 3
a(2)  = 6
a(4)  = 12
a(12) = 37

a(0) est valable.

Fissuré

Séquence originale: A059563

Code d'origine:

3L2^Ze*sk
3L          % Push [1 -1j] from the clipboard
  2^        % square
    Ze      % exp
      *     % times input
       s    % sum
        k   % floor

Java, 479 octets, fissuré

Les sorties:

a(10) = 81
a(20) = 35890

(Les entrées sont fournies via des arguments de ligne de commande)

Code ( #marque les caractères cachés):

import java.util.*;
public class A{

    public static int#########
    public boolean###########

    static A a = new A();

    public static void main(String[] args){
        int input = Integer.parseInt(args[0]);

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);
        l.add(0);
        l.add(0);

        for(int ix = 0; ################if(##>##{
            ###########d#
            #######+##p##########+##########(#######
        }

        System.out.println(#########################
            ###(A.#############(#5#####)));
    }
}

Le programme commence à l'index 0.

(Notez que SE remplace tous les \tretraits par 4 espaces, ce qui porte le total d'octets à 569. Cliquez ici pour voir le programme avec des \tretraits au lieu des espaces.)

Code d'origine:

import java.util.*;
public class A{
    public static interface B{
    public boolean C(int i);} 

    static A a = new A();

    public static void main(String[] args){
        int input = Integer.parseInt(args[0]);

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);
        l.add(0);
        l.add(0);

        for(int ix = 0; ix<input; ix++)cif(i->  {
            return l.add(
            l.pop()+l.peekFirst()+l.peekLast());});{    
        }

        System.out.println(l.get(1));}static boolean 
            cif(A.B b5){return (b5.C((0)));
    }
}

(Même code, mais formaté normalement):

import java.util.*;

public class A {
    public static interface B { //functional interface for lambda expression
        public boolean C(int i); //void would have given it away
    }

    static A a = new A(); //distraction

    public static void main(String[] args) {
        int input = Integer.parseInt(args[0]);//Input

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);//Set up list
        l.add(0);
        l.add(0);

        for (int ix = 0; ix < input; ix++)
            cif(i -> { //Fake if statement is really a lambda expression
                return l.add(l.pop() + l.peekFirst() + l.peekLast());
            });
        { //Distraction
        }

        System.out.println(l.get(1));//Output
    }

    static boolean cif(A.B b5) { //Used to pass in lambda expression.
                  //The A. and b5 were both distractions
        return (b5.C((0)));
    }
}

Octave, 34 octets, fissuré

@(m)(m###m#####m##)&isprime(#)####

Les sorties:

ans(1) = 0
ans(6) = 5
ans(7) = 10
ans(8) = 15

La séquence commence à ans(1)OEIS.

C, 71 octets fissurés

############
#####
main(){
 scanf("%d",##);
 ###6#;
 printf("%d",##);
}

Sortie:

a(1) = 0   a(2) = 0   a(5) = 1
a(6) = 1   a(7) = 1   a(9) = 2

Cela fonctionne avec gcc, et est un programme complet. Il accepte 0 en entrée.

Pyth, 70 octets, fissuré

DhbI|qb"#"qb"#"R!1Iqb"#"#####+""s####2###;##lY+Q1Ih+""Z#####)=Z+Z1;@YQ

# sont les personnages cachés

A été craqué, donc voici la version sans caractères cachés:

DhbI|qb"4"qb"0"R!1Iqb"1"R!0Rh+""sm^sd2cb1;W<lY+Q1Ih+""Z=Y+YZ)=Z+Z1;@YQ

Exemples de sortie:

a(2) -> 10
a(4) -> 19

Bonne chance de trouver ceci sur OEIS, je n'ai personnellement pas réussi à le trouver à partir de ces exemples (même si la séquence est assez facile à repérer.)

Ruby, 38 octets, fissuré

Code obscurci (# peut être n'importe quel caractère):

->#{(s=#########).sum==#3333&&eval(s)}

Sortie:

Multiplie l'entrée par 10 (A008592). Fonctionne pour tout nombre entier, y compris 0. p.ex.

->#{(s=#########).sum==#3333&&eval(s)}[3]  => 30
->#{(s=#########).sum==#3333&&eval(s)}[10] => 100

05AB1E , 5 octets, fissuré

Sortie:

a(0) = 0
a(1) = 0
a(2) = 1
a(3) = 1
a(4) = 1
a(5) = 1
a(6) = 1
a(7) = 1
a(8) = 1
a(9) = 1
a(10) = 0
a(11) = 0

Code obscurci:

_____

Essayez-le en ligne! -lien.

05AB1E , 4 octets, fissuré

Bien alors, je pense que je suis accro au CnR ... Code obfusqué ( _indique un joker):

____

Séquence:

a(1) = 2
a(4) = 6720

La séquence dans OEIS commence à a (1) = 2.

Essayez-le en ligne! -lien

Lua, 45 octets, fissuré

Un petit indice:

a(0) will make the program crash :)

Sortie

a(1)=>0
a(2)=>1

Code

Utilise #pour cacher le code :).

a=function(n)#####n###### and #or ########end

J'utilisais l'OEIS A007814 , avec le code suivant:

a=function(n)return n%2>0 and 0or 1+a(n/2)end

Pyke , 15 octets, SAFE

Sortie

a(2) = 21
a(15) = 17

Code révélé:

#R#D######+##)#

Solution:

OEIS A038822
wR}DSR_Q*L+#P)l
J'ai utilisé deux couples de harengs rouges ici wR}pour générer le nombre 100 et révéler le caractère Rnormalement utilisé pour faire pivoter la pile. J'ai également utilisé #P)lau lieu du plus simple mPspour compter le nombre de nombres premiers dans la séquence.

C, 82 octets, coffre-fort

####=############
main(i){scanf("%d",##);
for(i=1;i++/4<#;)##=2;
printf("%d",##);}

Fonctionne avec gcc, et c’est un programme complet qui lit son entrée depuis stdin et imprime sa sortie sur stdout. Ici, la séquence est A004526, sol (n / 2) .

a(0) = 0    a(1) = 0    a(2) = 1
a(3) = 1    a(4) = 2    a(5) = 2
a(6) = 3    a(7) = 3    a(8) = 4

Solution:

a;*b=(char*)&a+1;
main(i){scanf("%d",&a);
for(i=1;i++/4<2;)a*=2;
printf("%d",*b);}

Cela ne fonctionne que sur les petites machines Endian, et seulement si la taille charest de 1 octet.
Et uniquement si l'octet supérieur à l'octet de poids fort aa la valeur 0. Je pense que cela est vrai pour gcc car, par défaut, les variables globales non initialisées sont placées dans le segment bss et les variables globales initialisées dans le segment de données (voir https: // stackoverflow.com/questions/8721475/if-a-global-variable-is-initialized-to-0-will-it-go-to-bss ).
Donc, ne ava que dans bss (la seule autre variable globale best initialisée et va donc dans le segment de données). Si an'est pas à la fin de bss, l'octet supérieur à l'octet le plus élevé aest également dans bss et a donc la valeur 0.

05AB1E, 1 octet, fissuré

_

_ dénote le code caché.

f(1) == 1
f(18) == 6

Élément , 10 octets, fissuré

Sortie:

a(3) = 6561
a(4) = 4294967296

Il n'y a probablement que quelques façons de calculer cette séquence dans Element. J'ai trouvé une solution à 9 caractères, mais je me suis dit que cette solution à 10 caractères est en réalité plus difficile. Les #sont des personnages cachés.

#_####@^#`

Pour plus de commodité, voici les pages wiki Try It Online et Esolang .

L'original était

2_3:~2@^^`

Pyth , 18 octets

# marque des personnages non révélés.

L?Jtb##5#m##S#2 #y

Sorties (à partir de 1):

1 -> 2
2 -> 3
3 -> 5
4 -> 7

Interprète en ligne

05AB1E , 5 octets, fissuré

J'espère que cette soumission n'est pas aussi facile que les autres: p. Les sorties:

a(0) = 0
a(1) = 1
a(2) = 6
a(3) = 24
a(4) = 80
a(5) = 240

Code obscurci:

####O

Contient cependant des caractères non-ASCII, utilise le codage CP-1252 .

Essayez-le en ligne! pourrait être utile: p.

Jolf , 11 octets, fissuré .

Sortie:

a(10) = 4
a(20) = 6
a(30) = 8

Et le code partiellement caché:

####xd###x#

Allusion:

Quand j'ai regardé les séquences dans l'ordre, je ne suis pas allé très loin avant de trouver celle-ci.

La version fissurée n'est pas tout à fait la même que mon code d'origine. Je ne suis pas actuellement sur mon ordinateur, je ne l'ai donc pas exactement, mais c'était à peu près comme ceci:

l fzxd!m%xH

(La seule partie dont je ne suis pas sûr est la !m . C'est ce qui vérifie si une variable est égale à zéro.)

Pyke , 6 octets, fissuré

###X#s

Sortie:

a(2) = 8
a(8) = 80
a(10) = 120

Cela ne fonctionne pas avec N <1

Solution originale:

hSmX$s