C'est un jeu à trois joueurs, jouez d'une seule main.

En même temps, chaque joueur montre sa main avec 0 à 5 doigts tendus.

Si tous les joueurs affichent le même type de nombre (pair ou impair), il n'y a pas de gagnant. Mais sinon, le joueur montrant un autre type gagne les deux autres.

 P l a y e r s
A      B      C       Winner

Even   Even   Even    No winner
Odd    Odd    Odd     No winner
Even   Odd    Odd     Player A
Odd    Even   Even    Player A
Even   Odd    Even    Player B
Odd    Even   Odd     Player B
Odd    Odd    Even    Player C
Even   Even   Odd     Player C

L'outil demandé pourrait utiliser des arguments (3 arguments sous forme numérique entre 0 et 5) ou STDIN (3 valeurs par ligne, séparées par des espaces).

Il n'est pas nécessaire de vérifier l'entrée: une entrée irrégulière peut produire une sortie inattendue.

Les arguments ou les valeurs en ligne est donnée de gauche à droite, du joueur A à joueur C .

La sortie ne doit contenir que A, Bou C(en majuscule) ou la chaîne no one(en minuscules, avec un espace régulier).

L'outil ne peut fonctionner qu'une seule fois ou comme filtre sur toutes les lignes d'entrée.

Victoire de code la plus courte.

APL ( 34 30)

(1⍳⍨+/∘.=⍨2|⎕)⊃'ABC',⊂'no one'

Explication:

• 2|⎕: lire une ligne d'entrée, prendre le mod-2 de chaque nombre (donner une liste, ie 1 0 1)
• ∘.=⍨: comparer chaque élément du vecteur à chaque élément du vecteur, donnant une matrice
• +/: additionne les lignes de la matrice, donnant pour chaque élément le nombre d'éléments auquel il était égal. S'il y en avait deux identiques et un différent, nous avons maintenant un vecteur comme 2 1 2où le 1dénote qui était différent. S'ils étaient tous les mêmes, nous obtenons 3 3 3.
• 1⍳⍨: trouver la position du 1. S'il n'y en a pas 1, cela renvoie un de plus que la longueur du vecteur, dans ce cas 4.
• ⊃'ABC',⊂'no one': affiche la chaîne à l'index donné.

Mathematica, 45 43 42 41 caractères

f="no one"[A,B,C]〚Mod[Tr@#-#,2].{2,1,0}〛&

Exemple:

f[{0 ,0, 0}]

personne

f[{1, 3, 5}]

personne

f[{2, 3, 5}]

UNE

f[{2, 3, 4}]

B

Une autre solution avec 43 42 caractères:

f=Mod[Tr@#-#-1,2].{A,B,C}/._+__->"no one"&

Powershell, 65

param($a,$b,$c)"@ABCCBA@"[$a%2+$b%2*2+$c%2*4]-replace"@","no one"

Befunge-98, 61 50 45 caractères

&&&:11p+2%2*\11g+2%+:"@"+#@\#,_0"eno on">:#,_

Utilise l'expression intelligente de Fors pour raser encore quelques personnages. Désormais monoligne (c'est-à-dire compatible avec Unfunge)! Lit jusqu'à ce qu'une partie soit gagnée; ajouter@ à la fin pour un programme unique.

Traite le mod d'entrée 2 comme un nombre binaire, comme avec ma réponse JS, puis s'appuie sur la recherche de AC et revient à `` personne '' si hors des limites (en testant si le caractère est ≥'A ', ce qui me permet pour utiliser le code à proximité comme données: D).

Variation qui lit une ligne d'entrée, produit une sortie, lit une nouvelle ligne d'entrée, etc. jusqu'à ce qu'un jeu soit décidé (c'est-à-dire pas «personne»):

&2%4*&2%2*&2%++1g:" "#@-#,_0"eno on">:#,_
 CBAABC

APL, 30

(1+2=/2|⎕)⊃'BA'('C',⊂'no one')

Si je suis autorisé à modifier les variables système par configuration, 2 caractères peuvent être supprimés. (Plus précisément, modification de l'origine de l'index⎕IO à 0)

Le bit crucial

Si nous représentons toutes les cotes de la même manière et que tous les événements sont identiques, alors une opération d'égalité par paire peut distinguer les 4 cas: 0 0pour B gagne,0 1 pour les victoires A, etc.

Explication

2|⎕Prend entrée et mod 2
2=/égalité par paire
1+ Ajoutez 1 pour l'indexation (les tableaux APL sont basés sur 1 par défaut)

'BA'('C',⊂'no one')Tableau imbriqué
⊃Extrait l'élément correct du tableau imbriqué

C: 88 caractères

Malheureusement, C, comme toujours, nécessite beaucoup de déchets inutiles. Mais quand même, dans quelle autre langue peut-on écrire =**++b+**(++et cela signifie réellement quelque chose? Tout simplement sublime.

main(int a,char**b){(a=**++b+**(++b+1)&1|2*(**b+**++b&1))?putchar(a+64):puts("no one");}

Passez simplement trois nombres comme arguments, et voilà!

GolfScript (31 caractères)

~]{1&}%.$1=!?)'no one
A
B
C'n/=

Logique très simple: réduisez l'entrée modulo 2, puis triez une copie. L'élément du milieu du tableau trié est majoritaire, alors recherchez un indice différent (et donc minoritaire).

Ruby (corps de fonction), 42 caractères

En supposant 3 arguments numériques a, bet c:

['zCBAABCz'[a%2*4|b%2*2|c%2],'no one'].min

Ruby (outil en ligne de commande), 61 caractères

La version 1 est disponible en 62 caractères:

$><<["zCBAABCz"[$*.reduce(0){|i,n|i*2|n.to_i%2}],'no one'].min

Mais, en se basant sur la réponse de Darren Stone , la version 2 descend à 61 caractères:

i=0;$*.map{|n|i+=i+n.to_i%2};$><<['zCBAABCz'[i],'no one'].min

Rubis, 61 caractères

w=0
$*.map{|p|w+=w+p.to_i%2}
$><<%w(no\ one C B A)[w>3?w^7:w]

JavaScript (nœud), 87 caractères

p=process.argv;console.log("ABC"[3-Math.min(x=p[2]%2*4+p[3]%2*2+p[4]%2,7-x)]||"no one")

Pour lancer la balle ... attend l'entrée comme trois arguments supplémentaires. Utilise le modèle suivant pour les entrées / sorties ( /représente "personne"):

  A B C  res  #
 ───────────────
  0 0 0   /   0
  0 0 1   C   1
  0 1 0   B   2
  0 1 1   A   3
  1 0 0   A   4
  1 0 1   B   5
  1 1 0   C   6
  1 1 1   /   7

GolfScript, 36 35 33 caractères

~]0\{1&\.++}/'no one
C
B
A'n/.$+=

Prend l'entrée comme décrit à partir de STDIN. Vous pouvez également tester le code en ligne .

Perl, 84 caractères.

$x=oct"0b".join"",map{$_%2}<>=~/(\d)/g;print"",('no one','C','B','A')[$x>=4?7-$x:$x]

• <>=~/(\d)/g analyse la ligne d'entrée en chiffres distincts
• map{$_%2 prend cette liste et calcule la valeur mod 2 (pair ou impair)
• oct"0b".join"", prend cette liste de valeurs de mod, les joint en une chaîne, ajoute un spécificateur octal et convertit la chaîne en nombre.

Fondamentalement, ce que j'ai fait était de créer une table de vérité, puis de la réorganiser soigneusement, j'ai donc eu une opération d'inversion $x == 4. Donc, si $x >=4nous avons fait l'inversion[$x>=4?7-$x:$x] que nous avons utilisée pour indexer dans le tableau('no one','C','B','A')

Ce n'est pas le code le plus court possible, mais ce n'est pas du bruit de ligne ... ce qui est remarquable en soi.

Perl: 74 caractères + 3 drapeaux = 77, exécuté avec perl -anE '(code)'

s/(\d)\s*/$1%2/eg;$x=oct"0b".$_;say"",("no one","C","B","A")[$x>3?7-$x:$x]

Il s'agit d'une amélioration, en exploitant l'autosplit (le -a), disons (le -E), et enfin en découvrant ce qui n'allait pas avec la comparaison.

Lisp commun, 114106 70 caractères

À partir des trois valeurs, créez une paire représentant la différence de parité entre les éléments adjacents. Traitez cela comme un nombre binaire à indexer dans la liste des résultats.

(defun f(a b c)(elt'(no_one c a b)(+(mod(- b c)2)(*(mod(- a b)2)2)))))

Algorithme plus ancien:

(defun f(h)(let*((o(mapcar #'oddp h))(p(position 1(mapcar(lambda(x)(count x o))o))))(if p(elt'(a b c)p)"no one")))

Python 2, 54

f=lambda a,b,c:[['no one','C'],'BA'][(a^b)&1][(a^c)&1]

Mathematica 100 94 89

f=If[(t=Tally[b=Boole@OddQ@#][[-1,2]])==1,{"A","B","C"}[[Position[b,t][[-1,1]]]],"no one"]&

Essai

f[{5, 3, 1}]
f[{2, 0, 4}]
f[{0, 1, 2}]
f[{0, 1, 3}]
f[{1, 3, 0}]

"personne"
"personne"
"B"
"A"
"C"

Haskell, 97

main=interact$(["no one","A","B","C"]!!).(\x->min x$7-x).foldr(\y x->x*2+mod y 2)0.map read.words

R 67

z="no one";c("A","B","C",z,z)[match(2-sum(x<-scan()%%2),c(x,2,-1))]

C, 85 caractères

main(int j,char**p){puts("C\0A\0B\0no one"+((**++p&1)*2+(**++p&1)^(**++p&1?0:3))*2);}

Pas aussi court que ma réponse Ruby mais j'en suis satisfait, compte tenu de la maincruauté.

Poisson - 41

:&+2%2*$&+2%+:"@"+!;$!o :?#"eno on"!;ooo<

Stole FireFly a répondu à l'improviste et l'a porté à fish car l'utilisation de registres dans fish nous permet de raser certains personnages. J'ai perdu quelques caractères si je n'avais pas l'opérateur horizontal si.

Cela prend les paramètres à travers des arguments.

python fish.py evenodd.fish -v 2 2 2  
no one
python fish.py evenodd.fish -v 2 3 2  
B
python fish.py evenodd.fish -v 2 3 3  
A
python fish.py evenodd.fish -v 3 3 4  
C

Smalltalk, 128 caractères

[:c|o:=c collect:[:e|e odd].k:=o collect:[:e|o occurrencesOf:e].u:=k indexOf:1.^(u>0)ifTrue:[#($a $b $c)at:u]ifFalse:['no one']]

envoyer value:avec une collection

JavaScript (ES6) / CoffeeScript, 50 octets

Utilise la table de vérité selon la réponse de Firefly mais adopte une approche plus directe dans l'accès aux personnages:

f=(a,b,c)=>'CBAABC'[(a%2*4+b%2*2+c%2)-1]||'no one' // JavaScript

f=(a,b,c)->'CBAABC'[(a%2*4+b%2*2+c%2)-1]||'no one'  # CoffeeScript

Démo

// Translated into ES5 for browser compatibility
f=function(a,b,c){return'CBAABC'[(a%2*4+b%2*2+c%2)-1]||'no one'}

//f=(a,b,c)=>'CBAABC'[(a%2*4+b%2*2+c%2)-1]||'no one'

for(i=6;i--;)
  for(j=6;j--;)
    for(k=6;k--;)
      O.innerHTML += i + ', ' + j + ', ' + k + ' => ' + f(i,j,k) + "\n"

<pre id=O></pre>

Python 3, 115

l=[int(x)%2for x in input().split()];0if[print("ABC"[i])for i,x in enumerate(l)if l.count(x)%2]else print("no one")

Python 3, 114

r=[0,3,2,1,1,2,3,0][int("".join(map(str,(int(x)%2for x in input().split()))),2)];print("ABC"[r-1]if r else"no one")

Deux méthodes différentes dans deux langues différentes + variantes -> 6 réponses

Il y a essentiellement 2 voies pour cette opération:

• array basé: Construit un nombre binaire de 3 chiffres, que prendre la réponse d'un tableau
• count basé: comptez pair et impair, et regardez s'il y a un count == 1

Perl 71 (basé sur un tableau + variation)

s/(.)\s*/$1&1/eg;$==oct"0b".$_;$==$=>3?7-$=:$=;say$=?chr 68-$=:"no one"

Un de mes perl les plus courts:

• s/(.)\s*/$1&1/eg;transformer une chaîne comme 1 2 3en101
• $==oct"0b".$_; transformer le binaire en oct (identique à dec, moins de 8)
• $==$=>3?7-$=:$=;si > 3opér 7-. (De làno one == 0)
• say$=?chr 68-$=:"no one"sinon 0, affichez char à partir de value, sinon print no one.

Perl 71 (basé sur un tableau)

s/(.)\s*/$1&1/eg;$==oct"0b".$_;say@{["no one",qw{A B C}]}[$=>3?7-$=:$=]

légèrement différent dans l'étape d'impression: la sortie est basée sur un «tableau» .

Perl 81 (basé sur le nombre)

$c=A;map{$a[$_%2]=$c++;$b[$_%2]++}split;say$b[0]==1?$a[0]:$b[0]==2?$a[1]:"no one"

Signification différente:

• $c=A Initialiser un compteur c avecA .
• map{$a[$_%2]=$c++;$b[$_%2]++}splitCompteur b nombre pair et impair, a seul magasin que l'on
• say$b[0]==1?$a[0]: si même compteur == 1? également imprimer même joueur.
• $b[0]==2?$a[1]:si même compteur == 2? également imprimer le lecteur impair .
• :"no one"sinon imprimer no one.

Bash 85 (basé sur la baie)

c=$((($1%2)<<2|($2&1)*2+($3%2)));((c>3))&&c=$((7-c));o=("no one" C B A);echo ${o[c]}

Ceci est basé sur ma deuxième version Perl:

• c=$((($1%2)<<2|($2&1)*2+($3%2))) faire l'index pos.
  • $ 1% 2 transforme le premier argument en binaire en utilisant mod
  • $ 2 & 1 transforment le deuxième arg en binaire en utilisant and
  • << 2 décalage vers la gauche est identique à*4
  • * 2 multiplié par 2 est identique à <<1.
• ((c>3))&&c=$((7-c)) si c> = 4 alors c = 7-c.
• o=() déclarer un tableau
• echo ${o[c]} basé sur un tableau

Bash 133 (basé sur le nombre)

a[$1&1]=A;a[$2&1]=B;a[$3&1]=C;((b[$1&1]++));((b[$2&1]++));((b[$3&1]++))
case $b in 1)echo ${a[0]};;2)echo ${a[1]};;*)echo no one;esac

• a[$1&1]=A;a[$2&1]=B;a[$3&1]=Cstocker le joueur dans une variable a [pair] et un [impair]
• ((b[$1&1]++));((b[$2&1]++));((b[$3&1]++))compter pair / impair dans b.
• case $b in 1) echo ${a[0]} dans le cas où même le compteur == 1 imprimer même le joueur
• 2)echo ${a[1]};; cas même compteur == 2 imprimer lecteur impair
• *)echo no one;esacsinon imprimer no one.

Bash 133 (basé sur le nombre)

a[$1&1]=A;a[$2&1]=B;a[$3&1]=C;((b[$1&1]++));((b[$2&1]++));((b[$3&1]++))
((b==1))&&echo ${a[0]}||(((b==2))&&echo ${a[1]}||echo no one)

Même version, en utilisant la condition et le groupe de commandes de bash au lieu de case ... esac

Langue de Game Maker, 116

Ma nouvelle réponse repose largement sur la formule de FireFly:

a[1]="no one"a[2]='A'a[3]='B'a[4]='C'return a[(3-min(b=argument0 mod 2*4+argument1 mod 2*2+argument2 mod 2,7-b)||1)]

L' ancien code compilé avec des variables non initialisées en 0, 183 caractères:

a=argument0 mod 2b=argument1 mod 2c=argument2 mod 2if((a&&b&&c)||(!a&&!b&&!c))return "no one" else{if((a&&b)||(!a&&!b))return "C" else{if((a&&c)||(!a&&!c))return "B" else return "A"}}

Edit # 1 - Code complètement différent

Clojure, 116

(fn[& h](let[a(map #(bit-and % 1)h)](["no one"\A\B\C](+(.indexOf(map(fn[x](reduce +(map #(if(= x %)1 0)a)))a)1)1))))

vba, 116

Function z(q,r,s)
a="A":b="B":c="C":d="no one"
z=Array(d,c,b,a,a,b,c,d)((q And 1)*4+(r And 1)*2+(s And 1))
End Function

appeler avec ?z(1,2,3)ou affecter à une variable avec q=z(1,2,3), ou même utiliser comme UDF dans Excel, et utiliser =z(1,2,3)dans votre formule Excel

Python 3, 80 caractères

r=int(input().replace(' ',''),2)
print(['no one','C','B','A'][7-r if r>3 else r])

Remarque: l'entrée doit être «1» [impair] ou «0» [pair]. Par exemple:

> 1 1 0
C
> 1 1 1
no one

Java, 226 caractères

void func(int a, int b, int c){
    a = a%2;
    b = b%2;
    c = c%2;
    String out = "B";
    if((a+b+c)==0 || (a+b+c)==3)
        out = "no one";
    else if(a==b)
        out = "C";
    else if(b==c)
        out = "A";
    System.out.println(out);
}

C 101 96

C, probablement l'exemple le plus trivial (quelques opérations ternaires):

main(int v,char** c){(v=c[1]==c[2]?c[1]==c[3]?0:3:c[1]==c[3]?2:1)?puts("no one"):putchar(v+64);}