Rock, Polyglot, Ciseaux

68

Ecrivez un programme polyglotte en trois langues qui joue du rock-papier-ciseaux .

L'entrée pour toute version du programme est toujours l'une des chaînes rockou paperou scissors.

Dans la première langue, le programme doit indiquer le choix pierre-papier-ciseaux qui bat l'entrée:

Input     Output
rock      paper
paper     scissors
scissors  rock

Dans la deuxième langue, le programme doit indiquer le choix pierre-papier-ciseaux qui lie l’entrée:

Input     Output
rock      rock
paper     paper
scissors  scissors

Dans la troisième langue, le programme doit indiquer le choix pierre-papier-ciseaux qui perd à l'entrée:

Input     Output
rock      scissors
paper     rock
scissors  paper

Le code le plus court en octets gagne. Tiebreaker est une réponse plus votée.

Les entrées et / ou sorties peuvent éventuellement avoir une nouvelle ligne de fuite , mais autrement , ne devraient être la plaine rock/ paper/ scissorscordes. Vous pouvez utiliser les majuscules ROCK, PAPER, SCISSORSsi on le souhaite.

Vous ne pouvez pas utiliser différentes versions du même langage (par exemple, Python 2 et 3).

Les passe-temps de Calvin
la source
Une erreur de langue peut-elle sortir?
Kritixi Lithos
2
@KritixiLithos Allez avec le consensus méta . "Je pense que mettre fin à une erreur ou à une exception non capturée convient, à condition que cela ne produise pas de sortie parasite vers STDOUT."
Les passe-temps de Calvin
2
Jamais bien sûr avec les polyglottes, les différentes langues peuvent-elles prendre part de différentes manières?
Jonathan Allan
3
@ JonathanAllan C'est bon. Pour certains ensembles linguistiques ne comportant que certaines formes de saisie, cela serait nécessaire.
Les passe-temps de Calvin
Qu'est-il arrivé à Lizard, Spock? bigbangtheory.wikia.com/wiki/Rock_Paper_Scissors_Lizard_Spock
Ole Tange

Réponses:

60

Python, brainfuck et JavaScript, 103 99 octets Yay moins de 100 octets!

0,[.5,];p=["rock","scissors","paper"]
1//1;lambda x:p[p.index(x)-1];"""
x=>p[-~p.indexOf(x)%3]//"""

En Python, cela définit une fonction qui bat l'entrée, dans le brainfuck, ce n'est qu'un simple programme cat, et dans JavaScript, il perd. Voici une version qui donne un nom aux fonctions f, et demande également une entrée en JavaScript et en Python 3:

0,[.5,];p=["rock","scissors","paper"]
1//1;f=lambda x:p[p.index(x)-1];"""
f=x=>p[-~p.indexOf(x)%3]//"""

1//1;"""
console.log(f(prompt())) // JavaScript
1//1"""; print(f(input())) # Python

Essayez-le en ligne (ancienne version): Python , brainfuck , JavaScript

Explication:

En Python, """..."""est une chaîne multiligne pouvant être utilisée comme n'importe quel jeton. Lorsque placé seul, il ne fait rien du tout. J'utilise ceci pour "cacher" le code JavaScript de Python. La même chose vaut pour le (0,[.5,])bit, c'est juste un tuple contenant un 0et une liste 5, et aussi la 1//1partie, //en Python est une division entière, mais commence un commentaire en JavaScript. Voici le code dépouillé de ces jetons:

p=["rock","scissors","paper"]
lambda x:p[p.index(x)-1]

La première ligne est assez explicite, elle définit juste la liste ppour contenir les différents choix de ciseaux-papier-pierre. La deuxième ligne définit une fonction non nommée qui prend un argument, xet rend le choix qui bat x(par exemple, l’élément précédent p)


En JavaScript, //désigne un commentaire d'une seule ligne. De la même manière que Python, les jetons simples sont ignorés. Le code dépouillé de ces jetons est:

p=["rock","scissors","paper"]
x=>p[-~p.indexOf(x)%3]

Cela fonctionne de manière similaire à Python, en définissant d'abord la liste ppour qu'elle contienne les choix, puis en définissant une fonction anonyme qui donne le choix à perdre. -~xest le même que x+1mais avec une priorité plus élevée afin que je puisse sauter les parenthèses.


Dans brainfuck, tous les personnages sauf +-,.[]<>sont supprimés, laissant ceci:

,[.,][,,]
[.-]
>[-.]

La commande ,lit un octet d’entrée, l’ .imprime et la [...]boucle tandis que la valeur est différente de zéro. Ce programme lit ensuite l'entrée et l'imprime caractère par caractère jusqu'à ce qu'il \0soit trouvé. Comme nous n'avons pas cela dans le code, nous pouvons ignorer le reste du programme. En fait, cela fait écho à tout ce que l'utilisateur tape, ce qui le lie efficacement.

Loovjo
la source
Je travaillais sur une solution très similaire mais vous m'avez battu :). Vous devez mettre à jour le lien Javascript TIO, il est différent des deux autres.
DimP
2
x=>p[p.indexOf(x)+1]||"rock"//"""pourrait être raccourci àx=>p[(p.indexOf(x)+1)%3]//"""
Luke
13
+1 Je n'ai jamais vu Brainfuck être aussi bien caché. En général, il est évident qu'un polyglotte contient également du BF. Pas dans celui-ci!
vsz
Je pense que vous pouvez déplacer le programme BF un peu pour économiser un octet ou deux:1//1,[.5,];
ETHproductions
En fait, je pense que vous pouvez utiliser l'existant []de la deuxième ligne pour économiser davantage d'octets:1//1,;lambda x:p[p.index(x,0)+-1];"""
ETHproductions
40

Python 2, Ruby, Retina, 90 83 octets

-7 octets grâce à Value Ink

s=['rock','paper','scissors']
print s[s.index((0and gets or input()))+(0and-2or-1)]

Essayez-le en ligne: Python , Ruby , Retina

Victoires en Ruby, perd en Python et égalités en Retina. Cette solution utilise le fait que ce 0soit la vérité en Ruby mais falsey en Python. Il utilise également l'indexation négative à la fois en Python et en Ruby.

junkie de maths
la source
anda priorité sur l'opérateur or, donc s.index(0and STDIN.gets or input())fonctionne. En outre, getsest un alias pour STDIN.getsRuby.
Value Ink
10
+1 pour ne pas commenter le code de différentes manières!
leo
@ValueInk Merci! Je me suis dit qu'il devait y avoir une approche plus concise façon d'obtenir l' entrée en Ruby, et il se trouve qu'il y avait
maths drogué
21

V, Brain-flak et Python 2, 97, 86, 81, 77 , 75 octets

o='rock paper scissors'.split()
lambda s:o[o.index(s)-1]#ddt.C rHd*wywVp

Deux octets enregistrés grâce à @ nmjcman101!

C'était super amusant! J'aime beaucoup cette réponse parce que c'est un bon aperçu des langues que j'aime bien: mon éditeur préféré, mon langage préféré non ésotérique et un langage que j'ai écrit. (Techniquement, Python 3 est meilleur, mais Python 2 est plus golfeur donc ¯\_(ツ)_/¯).

Essayez-le en ligne! en Python (légèrement modifié pour que vous puissiez voir la sortie), qui affiche ce qui perd à l’entrée.

Essayez-le en ligne! dans Brain-Flak, qui imprime ce qui est lié à l’entrée.

Essayez-le en ligne! en V, qui imprime ce qui bat l'entrée.

Puisque V repose sur des caractères ASCII non imprimables, voici un hexdump:

00000000: 6f3d 2772 6f63 6b20 7061 7065 7220 7363  o='rock paper sc
00000010: 6973 736f 7273 272e 7370 6c69 7428 290a  issors'.split().
00000020: 6c61 6d62 6461 2073 3a6f 5b6f 2e69 6e64  lambda s:o[o.ind
00000030: 6578 2873 292d 315d 231b 6464 742e 4320  ex(s)-1]#.ddt.C 
00000040: 720e 1b48 642a 7779 7756 70              r..Hd*wywVp

Explication:

Python

En python, c'est très simple. Nous définissons une liste des trois éléments et renvoyons l'élément juste avant l'entrée. Depuis -1renvoie l'élément dorsal, cela fonctionne de manière circulaire, et tout cela est très simple et facile. Ensuite, tout ce qui suit #est un commentaire.

Flak cérébrale

Ceci est également extrêmement simple dans le cerveau-flak. Si nous devions gagner ou perdre, cela représenterait probablement plusieurs centaines d'octets. Mais cela fonctionne réellement sur 0 octet. Au début du programme, toutes les entrées sont chargées dans la pile. A la fin du programme, toute la pile est implicitement imprimée.

Une fois que nous supprimons tous les caractères non pertinents, le code cerveau-flak voit est

()[()]

Ce qui est simplement évalué à 1 + -1, mais puisque cette valeur n'est pas utilisée du tout, c'est un NOOP.

V

Voici où ça devient un peu bizarre. Nommer la liste de python opeut sembler arbitraire, mais ce n'est certainement pas le cas. En V, oouvre une nouvelle ligne et nous met en mode insertion. Ensuite,

='rock paper scissors'.split()
lambda s:o[o.index(s)-1]#

est inséré dans le tampon. Après cela, le code pertinent est:

<esc>ddxxf'C r<C-n><esc>Hd*wywVp

Explication:

<esc>                          " Return to normal mode
     dd                        " Delete this line. Now the cursor is on '='
       t.                      " Move the cursor forward to the "'"
         C                     " Delete everything after the "'", and enter insert mode
           r                   " From insert mode, enter '<space>r'
            <C-n>              " Autocomplete the current word based on what is currently in the buffer
                               " Since only one word starts with 'r', this will insert 'rock'
                 <esc>         " Leave back to normal mode
                      H        " Go to the first line (where the input is)
                       d*      " Delete everything up until the next occurence of the input
                         w     " Move forward one word
                          yw   " Yank the word under the cursor
                            Vp " And paste that word over the current line, delete everything else
DJMcMayhem
la source
@WheatWizard En Python, il n'y a aucune raison pour ne pas trop (sauf que c'est la même longueur). Mais ça gâche tout en V.
DJMcMayhem
@WheatWizard Cause V est une langue vraiment étrange, et c'est une tâche vraiment étrange pour elle. Tout repose énormément sur la disposition des caractères, et il .split()est plus facile de s'en débarrasser que les diverses parenthèses et citations qui apparaissent dans votre solution.
DJMcMayhem
Super mineur, mais vous pouvez retirer le xxet le remplacer par un 2pour faire la commande 2f'car le ='sera effacé par le d*plus tard de toute façon. EDIT: vous pourriez être en mesure de le faire t.?
nmjcman101
@ nmjcman101 Oooh, douce, idée géniale. Merci pour le conseil!
DJMcMayhem
16

CJam , Retina , PHP, 92 86 85 octets

ECHO["rock",0,"scissors","paper"][ORD(READLINE())%4];
#];"scissors  paper rock"S/rci=

Devrait être exécuté en PHP en utilisant le -rdrapeau.

Essayez-le dans CJam

Essayez-le dans la rétine

Essayez-le en PHP

CJam

Dans CJam, toutes les lettres majuscules sont des variables prédéfinies. Sur la première ligne, plusieurs de ces valeurs sont placées dans la pile, ainsi que des littéraux de chaîne et de tableau. Certaines incréments, décréments et autres opérations sont effectués.

Après tout cela, la pile est encapsulée dans un tableau ( ]) et dans discarded ( ;), donc rien de tout cela ne compte plus. Le programme principal de CJam est simplement:

"scissors  paper rock"S/rci=

"scissors  paper rock"        e# Push this string
                      S/      e# Split it on spaces
                        r     e# Read the input
                         c    e# Cast to char (returns the first character in the string)
                          i   e# Cast to int (its codepoint)
                           =  e# Get the index of the split array (CJam has modular arrays)

Rétine

Cela ressemble presque à de la triche ...

Retina substituera toute correspondance de l'expression rationnelle ECHO["rock",0,"scissors","paper"][ORD(READLINE())%4];dans l'entrée avec #];"scissors paper rock"S/rci=. Quelle que soit cette expression régulière, il ne correspond certainement rien dans rock, paperou scissors, si aucune substitution est faite. L'entrée non modifiée est alors implicitement sortie.

PHP

La deuxième ligne est un commentaire, donc il est ignoré.

La première ligne utilise le même algorithme que la partie CJam, mais avec un ordre de résultats différent.

Chat d'affaires
la source
1
Les fonctions PHP de TIL ne sont pas sensibles à la casse.
gcampbell
14

C, C ++, Python; 227 226 216 octets

Enregistré un octet grâce à @Mat!

#include<stdio.h>/*
f=lambda a:"rock"if a[0]=="r"else"paper"if a[0]=="p"else"scissors"
"""*/
int f(char*b){puts(sizeof'b'-1?*b=='r'?"paper":*b=='s'?"rock":"scissors":*b=='r'?"scissors":*b=='s'?"paper":"rock");}
//"""

Définit une fonction fdans toutes les langues. Victoires en C, liens en Python, perd en C ++. Comme C ++ toujours / s

La partie entre /*et */est un bloc de commentaires en C et C ++, tandis que c'est la déclaration de la fonction lambda en Python. En gros, il compare le premier caractère de l'argument de la fonction et renvoie le mouvement qui commence par cette lettre.

La partie entre les """s est une chaîne multiligne en Python alors que c'est la déclaration de fonction en C et C ++. sizeof'b'-1détermine si le langage actuel est le C ou C ++. Il a une valeur de vérité si la taille est autre que 1, une valeur de fausseté sinon. En C, les littéraux sont de type long sur 4 octets tandis qu'en C ++, ils sont d'un type à un octet. Ensuite, une fois que le langage est compris, il se contente de regarder la première lettre de l’entrée et les sorties en conséquence.

C

Essayez-le en ligne!

C ++

Essayez-le en ligne!

Python

Essayez-le en ligne!

Betseg
la source
4
"La partie entre les" "" est un bloc de commentaires en Python "C'est en fait une chaîne multiligne.
ivzem
10

C ++, R, C; 252 240 226 220 209 octets

#define b/*
M=function()cat(readline())
#*/
#import<stdio.h>
#define M()main(){int i=0;char t[9];char*u;char*s[]={"rock","paper","scissors"};scanf("%s",t);for(;*t-*s[i++];);puts(s[(i+=sizeof('a')==1)%3]);}
M()

Utilise la différence entre C et C ++, à savoir que la taille d'un littéral de caractère est de 4 octets en C et d'un octet en C ++.

C ++:

Essayez-le en ligne!

R:

Résultat:

> #define b/*
> M=function()cat(readline())
> #*/
> #import<stdio.h>
> #define M()main(){int i=0;char t[9];char*u;char*s[]={"rock","paper","scissors"};scanf("%s",t);for(;*t-*s[i++];);puts(s[(i+=sizeof('a')==1)%3]);}
> M()
rock
rock

C:

Essayez-le en ligne!

Steadybox
la source
8

Gawk, Retina, Perl; 68 octets

{eval"\$_=uc<>"}{$_=/[Sk]/?"paper":/[Pc]/?"rock":"scissors"}{print}

(avec une nouvelle ligne à la fin)

Gawk (gagnant)

Certains objets indésirables pour Perl, puis modifient le contenu de la ligne ( $_ce qui revient au même $0parce que la variable _est indéfinie) selon qu’elle contient un kou un c, puis affiche le résultat. Ignorer tout avertissement concernant les séquences d'échappement, je voulais faire cela.

{a_string_that_is_ignored}
{$_ = /[Sk]/ ? "paper" : /[Pc]/ ? "rock" : "scissors"}
{print}

Rétine (cravate)

Même astuce que Basic Sunset et autres: remplacez les correspondances de certaines expressions rationnelles stupides sur la première ligne par le contenu de la deuxième ligne, passez donc l'entrée.

Perl (perdant)

Lisez une ligne et convertissez-la en majuscule, puis choisissez un mot en fonction de la lettre qu'elle contient et imprimez le résultat. La première et la dernière étape sont encapsulées en utilisant evalpour les cacher de awk.

$_ = uc <>;
$_ = /[Sk]/ ? "paper" : /[Pc]/ ? "rock" : "scissors";
print $_

Gawk, la rétine perl -p; 57 octets

J'écris ceci comme un bonus car le commutateur de ligne de commande perl -pest supposé faire partie du programme selon les règles habituelles de ce site, ce qui en ferait un site non polyglotte.

{eval"\$_=uc"}$_=/[Sk]/?"paper":/[Pc]/?"rock":"scissors"

Encore une fois avec une nouvelle ligne finale pour Retina . Cette fois, avec l’ perl -pimpression automatique de la sortie, le temps système perl est considérablement réduit. Je peux laisser la tâche $_déclencher une impression implicite dans awk .

Gilles, arrête de faire le mal
la source
Pourriez-vous peut-être ajouter un lien TIO (ou un compilateur en ligne similaire à tester) pour chacun d'eux?
Kevin Cruijssen
@KevinCruijssen Ajouté. La sortie sur TIO pour perl -pest vide, il doit s'agir d'un bogue sur TIO.
Gilles 'SO- arrête d'être méchant'
7

> <>, Retina, Python 2: 144 127 123 octets

1 octet enregistré grâce à @Loovjo en supprimant un espace

4 octets enregistrés grâce à @ mbomb007 en utilisant à la inputplace deraw_input

#v"PAPER"v?%4-2{"SCISSORS"v?%2:i
#>ooooo; >oooooooo<"ROCK"~<
a="KRS".index(input()[-1])
print["SCISSORS","ROCK","PAPER"][a]

Publié dans TNB comme un défi , j'ai décidé d'essayer cette combinaison de langues.

> <>

Essayez-le en ligne!

La propriété intellectuelle commence à se déplacer correctement.

#                      Reflect the IP so that it now moves left and it wraps around the grid
i:                     Take one character as input and duplicate it

Les caractères possibles qui seront pris dans l’entrée sont PRS (puisque le programme ne prend que le premier caractère). Leurs valeurs ASCII sont 80, 81et 82.

2%                     Take the modulo 2 of the character. Yields 0, 1, 0 for P, R, S respectively
?v                     If this value is non-zero (ie the input was ROCK), go down, otherwise skip this instruction

Si l'entrée était rock, voici ce qui se passerait:

<                      Start moving to the left
~                      Pop the top most value on the stack (which is the original value of R and not the duplicate)
"KCOR"                 Push these characters onto the stack
<                      Move left
oooo                   Output "ROCK" as characters (in turn these characters are popped)
o                      Pop the top value on the stack and output it; but since the stack is empty, the program errors out and exits promptly.

Sinon, si l'entrée était SCISSORSou PAPER, voici ce que l'IP rencontrerait:

"SROSSICS"             Push these characters onto the stack
{                      Shift the stack, so the the original value of the first char of the input would come to the top
2-4%                   Subtract 2 and take modulo 4 of the ASCII-value (yields 2, 0 for P, S respectively)
?v                     If it is non-zero, go down, otherwise skip this instruction

Si l'entrée était PAPER, alors:

>ooooooooo             Output all characters on the stack (ie "SCISSORS")
<                      Start moving left
o                      Pop a value on the stack and output it; since the stack is empty, this gives an error and the program exits.

Sinon (si l'entrée était SCISSORS ):

"REPAP"                Push these characters onto the stack
v>ooooo;               Output them and exit the program (without any errors).

Rétine

Essayez-le en ligne!

Dans ce cas, Retina considère chaque paire de deux lignes comme une paire d’appariement et de substitution. Par exemple, il tente de remplacer tout ce qui correspond à la première ligne par la deuxième ligne, mais comme la première ligne n’est jamais appariée, il ne la remplace jamais par rien, préservant ainsi l’entrée.

Python 2

Essayez-le en ligne!

Le programme Python nécessite que les entrées soient placées entre "s.

Les deux premières lignes sont des commentaires en Python.

a="KRS".index(input()[-1])             # Get the index of the last character of the input in "KRS"
print["SCISSORS","ROCK","PAPER"][a]    # Print the ath index of that array
Kritixi Lithos
la source
Je ne pense pas que l'espace après printla dernière ligne est nécessaire.
Loovjo le
Vous pouvez utiliser input()au lieu de raw_input().
mbomb007
@Loovjo Merci pour le tuyau :)
Kritixi Lithos Le
@ mbomb007 Cela ne semble pas fonctionner
Kritixi Lithos
@KritixiLithos cela fonctionne si la partie python accepte des guillemets
undergroundmonorail
0

Ruby, Clojure, Common Lisp - 251 octets

(print(eval '(if()({(quote SCISSORS)(quote PAPER)(quote PAPER)(quote ROCK)(quote ROCK)(quote SCISSORS)}(read))(eval(quote(nth(position(read)(quote("SCISSORS""PAPER""ROCK")):test(quote string-equal))(quote(ROCK SCISSORS PAPER))))))))
;'['"'+gets+'"']))

Version plus lisible avec des espaces:

(print(eval '(if() ; distinguish between CLojure and Common Lisp
    ({(quote SCISSORS)(quote PAPER)(quote PAPER)
       (quote ROCK)(quote ROCK)(quote SCISSORS)}(read)) ; use hash-map as a function
    (eval(quote(nth ; find index of the input arg in the list
       (position(read)(quote("SCISSORS""PAPER""ROCK")):test(quote string-equal))  
    (quote(ROCK SCISSORS PAPER))))))))
 ;'['"'+gets+'"'])) ; ruby indexation

Clojure gagne toujours, Ruby dessine toujours, Common Lisp perd toujours.

Pour Ruby, tout ce qui est à l'intérieur 'est une chaîne. Il s'étend sur deux lignes. Ensuite, il utilise []opérateur avec un argument de chaîne qui renvoie la chaîne elle-même si elle est présente dans la chaîne. Le résultat est imprimé, Ruby ne fait que refléter l'entrée.

La deuxième ligne est un commentaire pour Clojure et Common Lisp. Un tas de evalet quotedoit être utilisé parce que Clojure doit s’assurer que tous les symboles sont valides. Ce serait bien de réutiliser plus de code mais même les nthfonctions ont des signatures différentes dans ces langues. Fondamentalement, Clojure est if()évalué à true et passe à la première branche lorsqu'une mappe de hachage de variantes possibles est appelée avec un argument lu à partir de stdin. Common Lisp va à la deuxième branche, il trouve la position de l'argument à partir de stdin dans la liste et retourne l'élément correspondant à partir de la liste résultante.

Je suppose que la partie Common Lisp peut être jouée plus souvent.

Voir en ligne: Ruby , Common Lisp , Clojure

cliffroot
la source
0

Scala, Javascript et Ook, 167 octets

s=>{var a="paper,scissors,rock".split(",")/*/**/a[-1]="rock"
return a[a.indexOf(s)-1];`*/a((a.indexOf(s)+1)%3)//`//Ook. Ook. Ook! Ook? Ook. Ook! Ook! Ook. Ook? Ook!
}

Essayez-le dans Scala Essayez-le en Javascript Essayez la version brainfuck de Ook

Scala - gagne

s=>{                                                      //define an anonymous function
  var a="paper,scissors,rock".split(",")                  //generate the array
  /* /* */ a[-1]="rock"                                   //scala supports nested comments,
  return a[a.indexOf(s)-1];`                              //so this comment...
  */                                                      //...ends here
  a((a.indexOf(s)+1)%3)                                   //return the winning string
  //`//Ook. Ook. Ook! Ook? Ook. Ook! Ook! Ook. Ook? Ook!  //another comment
}

Javascript - perd

s=>{                                                   //define an anonymous function
  var a="paper,scissors,rock".split(",")               //generate the array
  /*/**/                                               //a comment
  a[-1]="rock"                                         //put "rock" at index -1
  return a[a.indexOf(s)-1];                            //return the string that loses
  `*/a((a.indexOf(s)+1)%3)//`                          //a string
  //Ook. Ook. Ook! Ook? Ook. Ook! Ook! Ook. Ook? Ook!  //a comment
}

Ook! - liens

La partie Ook est un simple programme de ,[.,]félins félins traduit en Ook.

s=>{var a="paper,scissors,rock".split(",")/*/**/a[-1]="rock"   //random stuff
return a[a.indexOf(s)-1];`*/a((a.indexOf(s)+1)%3)//`//         //more random stuff
Ook. Ook. Ook! Ook? Ook. Ook! Ook! Ook. Ook? Ook!              //the program
}                                                              //random stuff
corvus_192
la source
Si vous utilisez a[(a.indexOf(s)+2)%3]alors vous n'avez pas besoin de définir a[-1]="rock". Aussi, ne pouvez-vous pas mettre le code Ook dans la chaîne JavaScript aussi?
Neil