È una partita a tre giocatori, gioca con una mano.

Allo stesso tempo, ogni giocatore mostra la sua mano con 0-5 dita estese.

Se tutti i giocatori mostrano lo stesso tipo di numero (pari o dispari), non c'è vincitore. Altrimenti, il giocatore che mostra tipi diversi vince gli altri due.

 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

Lo strumento richiesto potrebbe usare argomenti (3 argomenti come numerici compresi tra 0 e 5) o STDIN (3 valori per riga, separati da spazi).

Non è necessario controllare l'input: l'input irregolare potrebbe produrre output imprevisti.

Argomenti o valori on line è dato da sinistra a destra, da giocatore A per il giocatore C .

L'output deve contenere solo A, Bo C(in maiuscolo) o la stringa no one(in minuscolo, con uno spazio regolare).

Lo strumento può funzionare solo una volta o come filtro su tutte le righe di input.

Vincita del codice più breve.

APL ( 34 30)

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

Spiegazione:

• 2|⎕: leggi una riga di input, prendi il mod-2 di ogni numero (dando un elenco, cioè 1 0 1)
• ∘.=⍨: confronta ogni elemento nel vettore con ogni elemento nel vettore, dando una matrice
• +/: somma le righe della matrice, fornendo per ogni elemento quanti elementi era uguale. Se ce ne fossero due uguali e uno diverso, ora abbiamo un vettore come 2 1 2dove il 1denota chi era diverso. Se fossero tutti uguali, otteniamo 3 3 3.
• 1⍳⍨: trova la posizione di 1. Se non c'è 1, questo restituisce uno in più della lunghezza del vettore, in questo caso 4.
• ⊃'ABC',⊂'no one': visualizza la stringa in corrispondenza dell'indice indicato.

Mathematica, 45 43 42 41 caratteri

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

Esempio:

f[{0 ,0, 0}]

nessuno

f[{1, 3, 5}]

nessuno

f[{2, 3, 5}]

UN

f[{2, 3, 4}]

B

Un'altra soluzione con 43 42 caratteri:

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 caratteri

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

Usa l'espressione intelligente di Fors per radere ancora qualche personaggio in più. Ora a linea singola (cioè compatibile con Unefunge)! Legge fino a quando una partita è vinta; aggiungere @alla fine per un programma one-shot.

Considera input mod 2 come un numero binario, come con la mia risposta JS, quindi si basa sulla ricerca di AC e ricade su "nessuno" se fuori limite (testando se il carattere è ≥ "A", che mi consente per usare il codice vicino come dati: D).

Variazione che legge una riga di input, produce output, legge una nuova riga di input, ecc. Fino a quando non viene deciso un gioco (cioè non "nessuno"):

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

APL, 30

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

Se mi è consentito modificare le variabili di sistema in base alla configurazione, è possibile eliminare 2 caratteri. (In particolare, cambiando l'origine dell'indice ⎕IOsu 0)

La parte cruciale

Se rappresentiamo tutte le probabilità allo stesso modo e tutte uguali allo stesso modo, un'operazione di uguaglianza in coppia può distinguere tutti e 4 i casi: 0 0per vittorie B, 0 1per vittorie A, ecc.

Spiegazione

2|⎕Accetta input e mod 2
2=/Uguaglianza di coppia
1+Aggiungi 1 per l'indicizzazione (le matrici APL sono basate su 1 per impostazione predefinita)

'BA'('C',⊂'no one')Array nidificato
⊃Elimina l'elemento corretto dall'array nidificato

C: 88 caratteri

Sfortunatamente C, come sempre, richiede parecchia spazzatura inutile. Ma ancora, in quale altra lingua si può scrivere =**++b+**(++e in realtà significa qualcosa? Abbastanza semplicemente sublime.

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

Basta passare tre numeri come argomenti e voilà!

GolfScript (31 caratteri)

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

Logica molto semplice: ridurre l'input modulo 2, quindi ordinare una copia. L'elemento centrale dell'array ordinato è nella maggioranza, quindi cerca un indice diverso (e quindi in minoranza).

Rubino (corpo funzione), 42 caratteri

Supponendo 3 argomenti numerici a, be c:

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

Ruby (strumento da riga di comando), 61 caratteri

La versione 1 arriva a 62 caratteri:

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

Ma, abbandonando la risposta di Darren Stone , la versione 2 scende a 61 caratteri:

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

Rubino, 61 caratteri

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

JavaScript (nodo), 87 caratteri

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

Per far rotolare la palla ... si aspetta un input come tre argomenti extra. Utilizza il seguente modello per input / output ( /rappresenta "nessuno"):

  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 caratteri

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

Accetta input come descritto da STDIN. Puoi anche testare il codice online .

Perl, 84 caratteri.

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

• <>=~/(\d)/g analizza la riga di input in cifre distinte
• map{$_%2 prende questo elenco e calcola il valore mod 2 (pari o dispari)
• oct"0b".join"", prende questo elenco di valori mod, li unisce in una stringa, aggiunge un identificatore ottale e converte la stringa in un numero.

Fondamentalmente quello che ho fatto è stato creare una tabella della verità, e poi riordinarla attentamente in modo da eseguire un'operazione di inversione $x == 4. Quindi $x >=4, se abbiamo fatto l'inversione [$x>=4?7-$x:$x]che abbiamo usato per indicizzare nell'array('no one','C','B','A')

Non è il codice più breve possibile, ma in realtà non è il rumore di linea ... che è notevole di per sé.

Perl: 74 caratteri + 3 bandiere = 77, corri con perl -anE '(code)'

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

Questo è un miglioramento, sfruttando l'autosplit (la -a), diciamo (la -E), e infine capendo cosa non andava nel confronto.

Lisp comune, 114 106 70 caratteri

Dai tre valori creare una coppia che rappresenta la differenza nella parità tra elementi adiacenti. Consideralo come un numero binario da indicizzare nell'elenco dei risultati.

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

Algoritmo precedente:

(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"]&

analisi

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

"nessuno"
"nessuno"
"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 caratteri

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

Non è breve come la mia risposta di Ruby, ma ne sono contento, considerando l' maininnesto.

Pesce - 41

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

Ha rubato la risposta befunge di FireFly e l'ha trasferito sul pesce perché l'uso dei registri nel pesce ci consente di radere alcuni personaggi. Persi alcuni personaggi per non avere l'operatore orizzontale se però.

Questo accetta parametri attraverso argomenti.

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 caratteri

[: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']]

invia value:con una raccolta

JavaScript (ES6) / CoffeeScript, 50 byte

Utilizza la tabella della verità secondo la risposta di Firefly ma adotta un approccio più diretto nell'accesso ai personaggi:

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

dimostrazione

// 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")

Due metodi diversi in due lingue diverse + variazioni -> 6 risposte

Esistono essenzialmente 2 modi per questa operazione:

• array basato: costruito un numero binario di 3 cifre, che accetta la risposta da un array
• count basato: conta pari e dispari e guarda se c'è un count == 1

Perl 71 (basato su array + variazione)

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

Uno dei miei perl più brevi:

• s/(.)\s*/$1&1/eg;trasforma una stringa come 1 2 3in101
• $==oct"0b".$_; trasforma binario in ott (uguale a dec, sotto 8)
• $==$=>3?7-$=:$=;se > 3oper 7-. (Da lì no one== 0)
• say$=?chr 68-$=:"no one"in caso contrario 0, stampa il carattere dal valore, altrimenti stampa no one.

Perl 71 (basato su array)

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

leggermente diverso nella fase di stampa: l'output si basa su un "array" .

Perl 81 (basato sul conteggio)

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

Significato diverso:

• $c=A Inizializza un contatore c con A.
• map{$a[$_%2]=$c++;$b[$_%2]++}splitContatore b conta pari e dispari, un solo negozio quale
• say$b[0]==1?$a[0]: se anche counter == 1? stampa anche il lettore.
• $b[0]==2?$a[1]:se anche counter == 2? stampa anche un lettore dispari .
• :"no one"altro stampa no one.

Bash 85 (basato su array)

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

Questo si basa sulla mia seconda versione perl:

• c=$((($1%2)<<2|($2&1)*2+($3%2))) rendere l'indice pos.
  • $ 1% 2 trasforma il primo argomento in binario usando mod
  • $ 2 e 1 trasformano il secondo arg in binario usando and
  • << 2 spostamento a sinistra è uguale a*4
  • * 2 moltiplicare per 2 è uguale a <<1.
• ((c>3))&&c=$((7-c)) se c> = 4 allora c = 7-c.
• o=() dichiarare un array
• echo ${o[c]} basato su array

Bash 133 (basato sul conteggio)

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]=Cmemorizzare il giocatore nella variabile a [pari] e [dispari]
• ((b[$1&1]++));((b[$2&1]++));((b[$3&1]++)) contare pari / dispari in b.
• case $b in 1) echo ${a[0]} in caso di contatore pari == 1 stampa il giocatore pari
• 2)echo ${a[1]};; case even counter == 2 stampa lettore dispari
• *)echo no one;esacaltro stampa no one.

Bash 133 (basato sul conteggio)

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)

Stessa versione, usando la condizione di bash e il gruppo di comandi invece di case ... esac

Game Maker Language, 116

La mia nuova risposta si basa fortemente sulla formula di 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)]

Il vecchio codice compilato con variabili non inizializzate come 0, 183 caratteri:

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

Modifica n. 1 - Codice completamente diverso

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

chiama con ?z(1,2,3)o assegna a una variabile con q=z(1,2,3), o addirittura usa come UDF all'interno di Excel, e usa =z(1,2,3)nella tua formula Excel

Python 3, 80 caratteri

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

Nota: l'ingresso deve essere '1' [dispari] o '0' [pari]. Per esempio:

> 1 1 0
C
> 1 1 1
no one

Java, 226 caratteri

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, probabilmente l'esempio più banale (alcune operazioni ternarie):

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