C'est le fil des voleurs de ce défi

Les flics choisissent une séquence OEIS et écrivent deux programmes complets dans deux langues différentes qui produisent ce nième élément de la séquence lorsqu'ils reçoivent un n via STDIN. Les deux programmes doivent être des anagrammes l'un de l'autre, ce qui signifie que chacun peut être réorganisé à partir des lettres de l'autre.

Ils présenteront le nombre OEIS, le code source et le nom d' une langue est en.

Vous devez trouver une anagramme de la soumission originale du flic qui s'exécute dans une langue autre que celle utilisée par le flic. Pour déchiffrer une réponse, vous ne devez trouver que la langue et le programme qui produisent la séquence et est une anagramme de l'original, pas nécessairement la réponse à laquelle le flic pensait.

Vous pouvez sortir par code de caractère ou inclure STDERR dans votre solution, mais seulement si le flic a indiqué que sa solution cachée le fait. La sortie décimale vers STDOUT est toujours une fissure valide.

Ainsi, les flics sont incités à faire en sorte qu'il soit aussi difficile que possible de trouver une langue qui fait la tâche en utilisant leur liste de symboles.

Notation

La personne avec le plus de fissures sera la gagnante de cette section. Seule la première fissure pour chaque solution comptera pour son score.

Classement

Un grand merci à tous ceux qui ont participé à ce défi.

Voici le tableau des leaders tel quel

Place  User             Score
-----------------------------
1      Adnan            3
1      Kritixi Lithos   3
1      Emigna           3
1      milk             3
5      Steven H.        2
5      Wheat Wizard     2
5      jimmy23013       2
8      ETH Productions  1
8      Dennis           1
8      alleks           1
8      Martin Ender     1
8      Oliver           1
8      Conor O'Brien    1

05AB1E , 38 octets, Loovjo , A000290

nXtdief e():return X*X
pr e(input())##

Essayez-le en ligne!

Très probablement pas la solution prévue, mais cela fonctionne.

Explication

n      # square input
 X     # push 1
  t    # push sqrt(1)
   d   # push is_number(1.0)
    i  # if true do the rest of the code (1.0 is not a number so it will never execute)

Jolf, 15 octets, Adnan , A000290

*&"?!#$|<=@\^{}

Essayez-le ici! Certainement pas la solution prévue, mais bon, ça marche.

Explication

*&"?!#$|<=@\^{}
*                multiply
 &               the two inputs to this func, x, y: x && y
                 returns y if x and y, or the falsey argument.
  "?!#$|<=@\^{}  this string is always truthy, so the second arg is used.
                 two implicit inputs are taken, both equal to the first arg
                 so, this corresponds to *xx, which is x^2.

05AB1E , 49 octets, Wheat Wizard , A000290

En fait la même approche que le crack d'Emigna: p.

n4i<({({)({[()]){))()()()turpetne/"*"*splint>}}}}

Explication:

n          # Square the input
 4i        # If 4 == 1, do the following...
   <({...

Essayez-le en ligne!

05AB1E , 35 octets, Oliver , A000290

Les flics devraient arrêter de publier des n^2défis en python ...

n0iprt(input()**(1+1))
"'1°3¢','m'"

Essayez-le en ligne!

Explication

n    # square input
 0i  # if 0 == 1 do the rest of the code

2sable , 7 octets, Kritixi Lithos , A005843

Code:

r^#ei2*

Explication:

r         # Reverse the stack, which is a no-op
 ^        # XOR the input with itself, always leading to 0
  #       # If 1, break (which stops the program)
   e      # Compute input nPr input, which always leads to 1
    i     # If equal to one, do the following..
     2*   #   Multiply the input by 2.

Essayez-le en ligne!

Hexagonie , 13 octets, Adnan , A002378

?"&\>=})\*!@<

Essayez-le en ligne!

Déplié:

  ? " &
 \ > = }
) \ * ! @
 < . . .
  . . .

Pas à 100% que ce soit l'original, car le coin supérieur gauche \n'est pas utilisé.

Ce ne <\>sont que des miroirs, donc le programme est en fait entièrement linéaire:

?"&)}=*!@

?          Read input.
 "         Move back and left.
  &        Copy input.
   )       Increment copy.
    }=     Move forward and right and turn around (to face the n and n+1 edges).
      *    Multiply.
       !   Print.
        @  Terminate.

V , 13 octets, DJMcMayhem , A002275

v!:x]''"
@ai1

Essayez-le en ligne!

Cela pourrait être la première solution dans la langue souhaitée par l'auteur.

Explication

v!:x]''"   Does nothing
@ai1       inserts 1 a times

2sable, Conor O'Brien , A000290

~*

Essayez-le en ligne!

Je ne sais pas comment cela fonctionne, il n'y a vraiment qu'un seul programme qui réponde aux exigences et je viens de me forcer à trouver la langue dans laquelle il fonctionnait.

Après avoir parcouru les documents, je suis en mesure de trouver une explication:

~         Push Input OR Input (always pushes the input)
 *        Multiply that by Input 

Pyth , 26 octets, Steven H. , A023443

Code:

tQ.qly 7:esau0euii s uxC !

Essayez en ligne .

Assez simple:

 Q                            Reads input
t                             Substracts 1 from it
  .q                          Quits program (implicit print)
    ly 7:esau0euii s uxC !    None of this ever plays a part...
                                I just thought it'd be fun to scramble it.

Python 3, 118 octets, ETHproductions, A042545

s,a=801**.5-28,[0,0==0]
for i in range(int(input())):a+=[a[i]+a[-1]*int(1/s)];s=1/s-1//s
(print(a[-2]),) #.0fhlmop|

Testez-le sur Ideone .

Soumission de flic

i=input();s=1/(801**.5-28);a=[0,1]
for p in range(i):a+=[a[-2]+a[-1]*int(s)];s=1/(s-int(s))
print a[i]#,,,.//000fhlmo|

Qu'est ce qui est different

La soumission du flic ne fonctionne pas dans Python 3 pour deux raisons.

• La fonction d' entrée de Python 2 évalue automatiquement une ligne d'entrée, tandis que l'homologue de Python 3 renvoie simplement la ligne sous forme de chaîne. Nous pouvons simplement appeler int pour résoudre ce problème.

• print était une instruction en Python 2, mais c'est une fonction en Python 3. En particulier, cela signifie que nous devons entourer son argument de parenthèses.

Cela signifie que nous avons besoin de int()et (), mais ces personnages ne font pas tous partie du commentaire. Cela signifie que nous devons apporter quelques modifications.

Au lieu de la fraction s , nous gardons une trace de 1 / s .

L'initialisation de s - s=1/(801**.5-28)- devient s=801**.5-28, la sauvegarde des caractères 1/().

Le facteur d' un [-1] dans la mise à jour d' un - int(s)- devient int(1/s), coûtant les caractères 1/.

La mise à jour de s - s=1/(s-int(s))- devient s=1/s-1//s, coûtant les personnages 1//, mais sauvegardant les personnages (int()).

Les caractères enregistrés ()(int())couvrent ceux dont nous avions besoin pour porter le code sur Python 3, mais leur obtention nous a coûté 1//. Nous pouvons tirer //du commentaire, mais nous devrons enregistrer 1ailleurs.

Une façon (la seule?) D'économiser le nécessaire 1est de remplacer le 1dans l'initialisation d' un avec 0==0. Cela coûte ces quatre caractères, mais nous pouvons tirer 00du commentaire.

Jusqu'à présent, nous avons le code suivant.

i=int(input());s=801**.5-28;a=[0,0==0]
for p in range(i):a+=[a[-2]+a[-1]*int(1/s)];s=1/s-1//s
print(a[i]) #,,,.()0fhlmo|

Pour récupérer l'un des =nous "devons", nous pouvons réécrire l'initialisation de s et de a avec une seule affectation: en s,a=801**.5-28,[0,0==0]outre, cela enregistre un ;et coûte un ,, qui peut être ajouté et supprimé du commentaire.

La seconde =peut être sauvegardée en ne stockant pas l'entrée dans une variable, c'est-à-dire en écrivant à la range(int(input()))place, en enregistrant les caractères i=. Nous utilisons également i après la boucle, mais le i ^ème élément de a est juste le deuxième à partir de la droite, nous pouvons donc le remplacer ipar -2. Pour la même raison, a[-2]le corps de la boucle peut être remplacé par i.

Nous avons maintenant une permutation dans le code Python 3 fonctionnel:

s,a=801**.5-28,[0,0==0]
for i in range(int(input())):a+=[a[i]+a[-1]*int(1/s)];s=1/s-1//s
print(a[-2]) #,.()0fhlmop|

Cependant, ce code fonctionne également en Python 2! Une façon de résoudre ce problème consiste à remplacer print(a[-2])par (print(a[-2]),); nous avons les personnages dont nous avons besoin dans le commentaire. Comme mentionné précédemment, print est une fonction en Python 3, donc cela construit le tuple ( None ,) . Cependant, l' instruction print de Python 2 est une SyntaxError dans un littéral de tuple.

CJam, 39 octets, lait , A000007

l~0{"e.bockj(>=@$t0)@$t0+(<7)??0t:"};1?

Essayez-le ici.

Pyth, 7 octets, Luis Mendo , A000217

x:{ps}1

Comme demandé, le programme se pferme avec erreur après avoir imprimé la bonne réponse.

Essayez-le en ligne ici !

05AB1E , 12 octets, tuskiomi , A000012

1,(FI1=1=1,)

Essayez-le en ligne!

Explication

1,            # print 1
  (           # negate input
   F          # that many times do (i.e. no times)
    I1=1=1,)  # the rest of the code

05AB1E , 38 octets, Conor O'Brien , A000290

n2iJ=>eval(Array(J).fill(J).jo`+`)|-2;

Essayez-le en ligne!

Explication

Ceci est basé sur le crack d'Emigna ici .

n   #Squares the number
 2i #Runs the rest of the code if 2==1

05AB1E, 27 octets, boboquack , A000012

1 1pif:
    if :
        rint( '1' )

Essayez-le en ligne

Comment ça marche:

1                     # push 1
  1                   # push 1
   p                  # pop (1), push is_prime(1)
    i                 # pop (is_prime(1), false), if is false so don't execute rest

CJam, 70 octets, Shebang , A000217

ri),:+








e#|  d00->1@@@++-^,[o=input(v=0i=1whil o v=i i+=1pnt v

Essayez-le ici.

Convexe, 75 octets, boboquack , A004526

2/Q2 2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2*2*2*; 2*;                 2; 2; 2;

Essayez-le en ligne

Comment ça marche:

2  e# push 2
 / e# pop first 2, divide, push result
   e# push a bunch of garbage but discard it all with semi-colons (;)
  Q2 2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2*2*2*; 2*;                 2; 2; 2;

Dip , 9 octets, Kritixi Lithos

Certainement pas la réponse souhaitée.

1^,-$)×1*

Explication:

1$^,-)×   # Basically does nothing
       1* # Repeat "1" n times

Pip , 6 octets, DLosc , A000012

.()49o

Je pensais que j'essaierais d'abord l'esolang de l'OP ;-)

Essayez-le en ligne.

05AB1E , 25 octets, Mego , A000583

Code:

nnYi=put("");prit`Y**4`,X

Explication:

n       # Square the input
 n      # Square the squared input
  Y     # Constant that pushes 2
   i    # If equal to 1, do the following:
    =put...

Essayez-le en ligne!

Dip , 8 octets, Oliver , A000042

(1J&F},1

Explication

              #Implicit Input
(             #Start range loop
 1            #Push 1 to the stack
  J           #Join all the elements in the stack
   &          #End program
    F},1      #These are ignored

Le plus drôle, c'est que c'était la langue voulue! Dip est un esolang créé par Oliver.

Cas de test et exécution de Dip à partir de la ligne de commande

$python3 dip.py
Dip v1.0.0 by Oliver Ni.
>>> (1J&F},1
> 4
1111
>>> (1J&F},1
> 7
1111111

2sable, 14 octets, Dopapp , A121377

Q@5 2*%6 8*+.&

Essayez-le en ligne.

Comment ça marche (plus ou moins):

Q@
  5              # Push 5
    2            # Push 2
     *           # Pop (2), pop (5), push 5*2=10
      %          # Pop (10), pop (input), push input%10
       6         # Push 6
         8       # Push 8
          *      # Pop (8), pop (6), push 8*6=48
           +     # Pop (48), pop (input), push input+48
            .&

05AB1E , 4 octets, Oliver , A000012

p¥_1

Essayez-le en ligne!

Il s'agit d'une séquence de l' 1art.

              # Implicit input
p¥_           # Does nothing
   1          # Pushes 1 to the stack
              # Implicit output

Cela sort 1quelle que soit l'entrée.

Dip , 5 octets, Oliver , A000012

`¸WW/

La séquence s'imprime juste 1quelle que soit l'entrée. La réponse d'Oliver imprime a 1.0. Ce programme imprime également un fichier 1.0. C'est apparemment la solution envisagée.

Explication

`¸                  # push character `¸`
  W                 # pushes 1000000
   W                # pushes 1000000 also
    /               # divides the last two items in stack resulting in 1.0
                    # implicit output (1.0)

Solution alternative (gracieuseté de @milk)

Convexe , 5 octets

WW¸`/

Essayez-le en ligne!

Explication

                  // implicit input
W                 // pushes -1
 W                // pushes -1 also
  ¸               // calculates the LCM of the two numbers (which evaluates to 1)
   `              // finds its string representation
    /             // slices the string (so that it would evaluate to "1")
                  // implicit output