Come sapete, la fase a gironi della Coppa del Mondo è finita e da domani le migliori 16 squadre inizieranno la fase a eliminazione diretta:

• Brasile (BRA)
• Messico (MEX)
• Paesi Bassi (NED)
• Cile (CHI)
• Colombia (COL)
• Grecia (GRE)
• Costa Rica (CRC)
• Uruguay (URU)
• Francia (FRA)
• Svizzera (SUI)
• Argentina (ARG)
• Nigeria (NGA)
• Germania (GER)
• Stati Uniti (USA)
• Belgio (BEL)
• Algeria (ALG)

Nella fase a eliminazione diretta, dopo ogni partita il vincitore passa al turno successivo e il perdente torna a casa (non ci sono pareggi). Clicca qui per vedere di più sulla fase a eliminazione diretta.

Sei stato assunto da golfbet.com, un nuovo sito di scommesse perché sei noto per essere bravo sia nella programmazione che nelle scommesse sportive. Il tuo compito è scrivere un programma o una funzione in grado di indovinare il vincitore di una partita. Naturalmente, tutti fanno ipotesi diverse, non importa finché le tue ipotesi sono coerenti.

Se non vuoi indovinare, puoi usare le seguenti ipotesi:

BRA
        BRA
CHI
                BRA
COL
        COL
URU
                        GER
FRA
        FRA
NGA
                GER
GER
        GER
ALG
                                        GER
NED
        NED
MEX
                NED
CRC
        CRC
GRE
                        ARG
ARG
        ARG
SUI
                ARG
BEL
        BEL
USA

1. Il programma deve generare lo stesso vincitore indipendentemente dall'ordine delle squadre (il vincitore della partita BRA-CHI deve essere lo stesso della partita CHI-BRA)
2. Se una squadra perde, non può più giocare altre partite. Questo significa che per le partite che non si svolgono, devi indicarlo. Ad esempio, se il tuo programma indovina il Brasile a vincere la partita BRA-CHI, allora CHI-GER deve restituire "nessun risultato", perché il Cile non giocherà contro la Germania. Vedi il link sopra per il programma.

Per semplicità non devi fare i conti con la partita di bronzo (ma ovviamente puoi farlo).

Il tuo programma o funzione accetta due stringhe come input: il codice paese di 3 lettere dei due team e restituisce il codice paese del team vincitore (puoi utilizzare input / output standard o due parametri funzione / valore di ritorno). Se le due squadre indicate non giocheranno secondo le tue ipotesi, devi restituire qualcos'altro (questo può essere altro che i codici paese, ad esempio stringa vuota, null, messaggio di errore). Si può presumere che l'immissione sia corretta (due diversi codici paese che si trovano nell'elenco).

Questo è principalmente un code-golf, quindi vince il programma più breve in byte. Tuttavia, anche le soluzioni carine e difficili sono preziose.

Esempio (ovviamente, puoi fare le tue ipotesi):

input: BRA CHI output: BRA

input: CHI BRA output: BRA

input: CHI GER output: nessun risultato

Python 2.x - 368 283

Sfida interessante. Ovviamente dobbiamo ottenere classifiche attuali dalla FIFA . Il Brasile ha il cosiddetto "dodicesimo uomo" in quanto ha un vantaggio in casa quindi la ponderazione del 12/11.

a='BRA CHI COL URU FRA NGA ALG GER MEX NED CRC GRE ARG SUI BEL USA'.split()
d=[1242*12/11,1026,1137,1147,913,640,858,1300,882,981,762,1064,1175,1149,1074,1035]
m={}
for n in[16,8,4,2]:
 j=0
 for k in range(0,n,2):
  s=a[k] if d[k]>d[k+1] else a[k+1]
  m[a[k]+' '+a[k+1]]=s
  a[j]=s    
  j+=1
def f(s): 
 try: print m[s] 
 except: print 'no result'   

Suggerimenti per abbreviare quanto sopra sono i benvenuti :-).

Miglioramenti grazie a @TheRare e @MrLemon

a='BRA CHI COL URU FRA NGA ALG GER MEX NED CRC GRE ARG SUI BEL USA'.split()
d=15,6,10,11,4,0,2,14,3,5,1,8,13,12,9,7
m={}
for n in 16,8,4,2:
 j=0
 for k in range(0,n,2):s=a[k]if d[k]>d[k+1]else a[k+1];m[a[k]+' '+a[k+1]]=s;a[j]=s;j+=1     
def f(s):print s in m and m[s]or'no result'

Questo porta ai seguenti risultati:

BRA CHI: BRA
COL URU: URU
FRA NGA: FRA
ALG GER: GER
MEX NED: NED
CRC GRE: GRE
ARG SUI: ARG
BEL USA: BEL
------------
BRA URU: BRA
FRA GER: GER
NED GRE: GRE
ARG BEL: ARG
------------
BRA GER: BRA
GRE ARG: ARG
------------
BRA ARG: BRA

Chiamate di esempio:

f('BRA MEX')
no result
f('BRA CHI')
BRA

C, 182 178 133 (o 126)

Non è il programma più breve qui, ma è il più breve in cui la previsione può essere cambiata facilmente. Ora che tutti i semifinalisti sono noti, sto aggiornando.

Ci sono anche alcune modifiche al codice. A parte i suggerimenti di Dennis nei commenti, il programma è stato convertito in una funzione (come nella rilettura è consentito dalle regole) e l'hash è stato abbreviato.

Codice, 133

f(char*a,char*b){
  char*p,*t=" HIAEAIH N?=R=?N ;@4S4@; 5BDGDB5 B@?I?@B",h[3]={*a-a[1]%16,*b-b[1]%16};
  (p=strstr(t,h))&&puts(p-t&2?a:b);
}

Come funziona

gli input ae bsono tratteggiati dall'espressione *a-a[1]%16su un singolo carattere ( *aè un equivalente più breve di a[0]). L'hash risulta per i team ae bviene archiviato in h. Ad esempio BRA CHI diventa @;. I valori hash sono i seguenti (i semifinalisti confermati e il mio campione previsto sono contrassegnati con *.)

GRE E   CRC A   *NED I   MEX H
USA R   BEL =   *ARG ?   SUI N
URU S   COL 4  **BRA @   CHI ;
NGA G   FRA D   *GER B   ALG 5

t[]memorizza le mie previsioni. I risultati del round di 16 e quarti di finale sono ora noti. Ogni gruppo di 4 squadre è ordinato in modo tale che il 1o e il 4o siano stati eliminati e il 3o è il semifinalista. Analogamente ai semifinalisti, prevedo che il 1 ° e il 4 ° posto verranno eliminati e il 3 ° semifinalista sarà il vincitore assoluto. Se non sei d'accordo con le mie previsioni, riordina semplicemente la tabella.

Le previsioni sono memorizzate in blocchi palindromici per accogliere la possibilità che l'utente entri nelle squadre in entrambi i possibili ordini. L'ordinamento mette insieme le squadre vincitrici di ogni set di 4 per giocare una terza partita. Così nel primo gruppo GRE Eperse con CRC e MEX Hperse con NED. Questo imposta CRC Aper giocare a NED Inel quarto di finale senza dover ripetere la digitazione. La stringa è riempita con uno spazio tra ogni gruppo di 4 squadre / 7 personaggi per garantire che non ci sia output per le squadre che non si giocheranno a vicenda.

Il vincitore di ogni possibile incontro in ogni gruppo di 8 caratteri è la seguente: invalid,b,a,a,b,b,a,invalid. Quindi la scelta corretta del vincitore può essere fatta prendendo la posizione di hin t AND 2 . Purtroppo la strstrfunzione non è la più straighforward in quanto restituisce un puntatore p, quindi dobbiamo sottrarre pdal tper ottenere la posizione attuale nel t.caso la partita non è valido (non può essere trovato in t), pè pari a zero e la frase no resultviene stampato.

Alcuni dubbi miglioramenti, 126

2 caratteri salvati da un'espressione hash migliorata. Sfortunatamente, questo richiede che il caso dei team sia come mostrato nel programma di test sotto la funzione (ad es. BraAnziché BRAcome usato nel programma sopra.) Mi sono convinto che non c'è modo di farlo con un singolo operatore, quindi 2 operatori e una costante a carattere singolo sono i migliori. Nota anche che è necessario Urumappare spaceun personaggio alternativo |per separare i gruppi di codici di squadra.

5 caratteri salvati eliminando te trattando la stringa di predizione come un valore letterale. Ciò significa che è impossibile conoscere l'indirizzo in cui è memorizzata la stringa. Tuttavia, purché non sia archiviato a zero, siamo interessati solo ap&2 il codice funzionerà se l'indirizzo è divisibile per 4. (Nota che non è consentito trattare il puntatore pdirettamente come un numero intero, deve essere sottratto da un altro puntatore Uso il puntatore, aquindi adeve anche essere divisibile per 4.) Si può essere abbastanza sicuri che le stringhe di un compilatore / architettura a 32 o 64 bit vengano memorizzate in questo modo. Questo ha funzionato bene per me su GCC / cygwin, anche se si rifiuta di compilare su Visual Studio / Windows.

g(char*a,char*b){
  char*p,h[3]={*a^a[1]+3,*b^b[1]+3};
  (p=strstr("|%&626&%|+4*#*4+|(71 17(|./3$3/.|/74&47/",h))&&puts(p-a&2?a:b);
}

main(){
  char team[16][4]={"Gre","Crc","Ned","Mex", "Usa","Bel","Arg","Sui", "Uru","Col","Bra","Chi", "Nga","Fra","Ger","Alg"}; 
  int i;
  for(i=1;i<16;i++){printf("%s %s \n",team[i-1],team[i]);g(team[i],team[i-1]);g(team[i-1],team[i]);}  
}

JavaScript 215 206 120 116

Un sacco di spazio per il miglioramento:

ES5 - 215

a=prompt().split(' ');("BRACHI0COLURU0FRANGA0GERALG0NEDMEX0CRCGRE0ARGSUI0BELUSA0BRACOL0FRAGER0NEDCRC0ARGBEL0BRAGER0NEDARG0BRANED".split(0).filter(function(x){return x.match(a[0])&&x.match(a[1])})[0]||"").substr(0,3)

ES6 - 206

a=prompt().split(' ');("BRACHI0COLURU0FRANGA0GERALG0NEDMEX0CRCGRE0ARGSUI0BELUSA0BRACOL0FRAGER0NEDCRC0ARGBEL0BRAGER0NEDARG0BRANED".split(0).filter((x)=>{return x.match(a[0])&&x.match(a[1])})[0]||"").substr(0,3)

Approccio Regex - 116

Grazie a ɐɔıʇǝɥʇuʎs per aver pubblicato questo link , mi ha aiutato a creare la regex

a=prompt().split(' ').sort();a.join('').match(/LG(.R(A|G)|GE)|RG(S|BE|CR)|ELUS|AC(H|O)|OLUR|CGR|CM|FRANG|XNE/)&&a[0]

Python ( 179 148 139 cq troppo lungo)

f=lambda *l:sorted(l)[0]if"".join(sorted(l))in"BRACHI COLURU FRANGA ALGGER MEXNED CRCGRE ARGSUI BELUSA BRACOL ALGFRA CRCMEX ARGBEL BRAFRA CRCMEX ARGBEL BRAFRA ARGCRC ARGBRA"else 0

Tutti sanno che il paese con il nome che viene per primo nell'alfabeto vincerà. (Questa risposta esiste solo per iniziare le cose)

Grazie alla carità dei ragazzi qui , ho potuto abbreviare un po 'la mia risposta:

import re;f=lambda *l:sorted(l)[0]if re.match('RGB|CM|RGS|CGR|L.F|XNE|EL.S|O.UR|RGCR|B.AF|L.GE|^BRACHI$|^FRANGA$|^BRACOL$',"".join(sorted(l)))else 0

Ciò presuppone squadre valide, ma non ha bisogno di una formazione valida ( f('BRA','NED')restituirebbe 0 (partita non valida), ma f('XNE')ritornerebbe 'XNE'. Non capisco dalla tua domanda che questo sia un problema. Sentiti libero di riutilizzare questa regex come meglio credi.

Grazie @Ventero, non so nulla di regex.

import re;f=lambda*l:sorted(l)[0]if re.match('RGB|CM|RGS|CGR|L.F|XNE|EL.S|O.UR|RGCR|B.AF|L.GE|BRACHI|FRANGA|BRACOL',"".join(sorted(l)))else 0

Scala (150)

type s=String;var m=Map[s,s]();def f(x:(s,s))={var a=x._1;var b=x._2;if(b<a){b=a;a=x._1};if(m.getOrElse(a,a)=="")m.getOrElse(b,b)else{m=m+(b->"");a}}

Qui sono possibili abbinamenti tra "foo" e "bar", anche le squadre che non giocheranno l'una contro l'altra nei primi turni avranno un risultato (ad esempio a partire da BRA, ARG)

Sta solo registrando squadre perdenti.

type s=String //just aliasing for saving characters
var m=Map[s,s]() //map for storing loosing teams, a set would do too
def f(x:(s,s))={
  var a=x._1 var b=x._2
  if(b<a){b=a;a=x._1};//swap if b<a lexographically
  if(m.getOrElse(a,a)=="")//if a has loosed previously
     m.getOrElse(b,b)// return b if b was not in the map else return ""
  else{
    m=m+(b->"") //add b to the map, because a will definitly win this amazing match
    a //and return a
  }
}

Chiamato con:

f(("GER","BRA"))

PowerShell ( 261 221)

$a=Read-Host;$b=Read-Host;$x="CHIBRA","URUCOL","FRANGA","ALGGER","MEXNED","CRCGRE","SUIARG","BELUSA";0..($x.Length-2)|%{$x+=$x[2*$_].Substring(3)+$x[2*$_+1].Substring(3)};$x|?{"$a$b","$b$a"-eq$_}|%{$_.Substring(3);exit};0

Come utente di PowerShell relativamente nuovo, trovo la pipeline assolutamente sorprendente. Penso che il prossimo potrebbe essere quello di provare a giocherellare con l'array per eliminare, si spera, tutte queste chiamate di sottostringa. (Ho dovuto aggiungere una chiamata alla fine, altrimenti ha prodotto entrambe le squadre)

Nuovo membro, primo tentativo di codice golf!

Avrebbe potuto codificare i quarti di finale, le semifinali e le finali per salvare alcuni personaggi, ma non sarebbe stato altrettanto divertente.

Dovrebbe essere abbastanza semplice da decifrare, ma soddisfa entrambe le condizioni: fornisce lo stesso vincitore> indipendentemente dall'ordine inserito e restituisce un vincitore solo per le partite che si svolgono>

Qualsiasi consiglio di miglioramento sarebbe molto apprezzato, grazie!

Originale

$a=Read-Host;$b=Read-Host;$x=("CHIBRA","URUCOL","FRANGA","ALGGER","MEXNED","CRCGRE","SUIARG","BELUSA");for($c=0;$c-lt$x.length-1;$c+=2){$x+=$x[$c].Substring(3)+$x[$c+1].Substring(3)}foreach($i in $x){if($i-match$a-and$i-match$b){return $i.Substring(3)}}return 0

CJam, 64 58 byte

lS/$_0=\:+4b256b1>:ca"oM-YtM-mM-^@}gM-^VM-^U8tM-=nM-^MfM-]oM-xgM-)tM-|m@gim{g_"2/&,*

Quanto sopra usa il punto di inserimento e la notazione M, poiché il codice contiene caratteri non stampabili.

Al costo di sei byte aggiuntivi, questi caratteri possono essere evitati:

lS/$_0=\:+4b95b1>32f+:c"I8Vyv)2~N{VIEh1$IW32W)B82QBs2G"2/N*\#W>*

Provalo online.

Prova

$ base64 -d > worldcup.cjam <<< \
> bFMvJF8wPVw6KzRiMjU2YjE+OmNhIm/ZdO2AfWeWlTh0vW6NZt1v+GepdPxtQGdpbXtnXyIyLyYsKg==
$ wc -c worldcup.cjam
58 worldcup.cjam
$ for A in ALG ARG BEL BRA CHI COL CRC FRA GER GRE MEX NED NGA SUI URU USA; do
> for B in ALG ARG BEL BRA CHI COL CRC FRA GER GRE MEX NED NGA SUI URU USA; do
> [[ $A < $B ]] && echo $A - $B : $(LANG=en_US cjam worldcup.cjam <<< "$A $B")
> done; done | grep ': .'
ALG - ARG : ALG
ALG - BRA : ALG
ALG - FRA : ALG
ALG - GER : ALG
ARG - BEL : ARG
ARG - CRC : ARG
ARG - SUI : ARG
BEL - USA : BEL
BRA - CHI : BRA
BRA - COL : BRA
COL - URU : COL
CRC - GRE : CRC
CRC - MEX : CRC
FRA - NGA : FRA
MEX - NED : MEX

Come funziona

lS/$    " Read one line from STDIN, split at spaces and sort the resulting array.         ";
_0=\    " Extract the first element of a copy of the array and swap it with the array.    ";
:+      " Concatenate the strings.                                                        ";
4b      " Convert the resulting string into an integer by considering it a base 4 number. ";
256b    " Convert the integer into an array by considering it a base 256 number.          ";
1>:ca   " Drop the first element, convert into a string and create a singleton array.     ";
"…"     " Push a string of all matches encoded as explained above.                        ";
2/      " Split the string into an array of two-character strings.                        ";
&       " Intersect the two arrays. If the array is non-empty, the teams play.            ";
,*      " Multiply the string on the stack by the length of the array.                    ";

CJam, 49 48 byte

lS/$_0="^\16@&^^/+(^]^W^Y,>O?"{_2%+}3*@{2b91%c}%#1&!*

Quanto sopra usa la notazione con il cursore, poiché il codice contiene caratteri non stampabili.

Al costo di due byte aggiuntivi, questi caratteri possono essere evitati:

lS/$_0="(=BL2*;74)#%8J[K"{_2%+}3*@{2b91%C+c}%#1&!*

Provalo online.

Prova

$ base64 -d > wc.cjam <<< bFMvJF8wPSIcMTZAJh4vKygdFxksPk8/IntfMiUrfTMqQHsyYjkxJWN9JSMxJiEq
$ wc -c wc.cjam
48 wc.cjam
$ for A in ALG ARG BEL BRA CHI COL CRC FRA GER GRE MEX NED NGA SUI URU USA; do
> for B in ALG ARG BEL BRA CHI COL CRC FRA GER GRE MEX NED NGA SUI URU USA; do
> [[ $A < $B ]] && echo $A - $B : $(cjam wc.cjam <<< "$A $B"); done; done | grep ': .'
ALG - ARG : ALG
ALG - BRA : ALG
ALG - FRA : ALG
ALG - GER : ALG
ARG - BEL : ARG
ARG - CRC : ARG
ARG - SUI : ARG
BEL - USA : BEL
BRA - CHI : BRA
BRA - COL : BRA
COL - URU : COL
CRC - GRE : CRC
CRC - MEX : CRC
FRA - NGA : FRA
MEX - NED : MEX

sfondo

Iniziamo assegnando un carattere ASCII a ciascuna squadra considerando il nome come un numero di base 2, prendendo il numero intero risultante modulo 91, aggiungendo 12 (per evitare caratteri non stampabili) e selezionando il carattere corrispondente al codice ASCII risultante. Nel codice CJam, questo è ottenuto da 2b91%c.

Ad esempio, i codici carattere di ALGsono 65 76 71. Da allora (4 × 65 + 2 × 76 + 71) = 483, 483 % 91 + 12 = 40e 40 se il codice carattere di (.

Questo dà il seguente mapping:

ALG (    ARG 4    BEL #    BRA 2    CHI *    COL ;    CRC 8    FRA B
GER =    GRE J    MEX [    NED K    NGA L    SUI )    URU 7    USA %

Ora, possiamo codificare le partite del round di 16 come segue:

(=BL2*;74)#%8J[K

Se assumiamo che la prima squadra in ordine alfabetico vince sempre, le partite dei quarti di finale sono le seguenti:

(B2;4#8[

Nota che questa stringa può essere ottenuta dalla prima selezionando ogni secondo carattere, iniziando dalla prima. Nel codice CJam, questo è ottenuto da2% .

Usando la stessa idea, le partite delle semifinali e quella finale sono le seguenti:

(248
(4

Il codice

"(=BL2*;74)#%8J[K"{_2%+}3*

spinge la stringa contenente le corrispondenze del round di 16, quindi esegue la seguente tre volte: duplica la stringa, estrae ogni secondo carattere della copia, concatena. Il risultato è la stringa

(=BL2*;74)#%8J[K(B2;4#8[(B2;4#8[(248(B2;4#8[(248(248(4

che contiene tutte le partite (alcune più di una volta).

Come funziona

lS/$        " Read one line from STDIN, split at spaces and sort the resulting array.     ";
_0=         " Extract the first element of a copy of the array.                           ";
"…"         " Push the string containing the matches of the round of 16.                  ";
{_2%+}3*    " Push the remaining matches.                                                 ";
@           " Rotate the input array on top of the stack.                                 ";
{2b91%C+c}% " Perform the mapping for each team in the input array.                       ";
#           " Push the index of the match in the array of all matches (-1 for not found). ";
1&!         " Push 1 if the index is even (valid match) and 0 if it is odd.               ";
,*          " Repeat the string on the stack that many times.                             ";

JavaScript 271

t=prompt('Match?').split('-')
x=t[0],y=t[1],T='BRACHICOLURUFRANGAGERALGNEDMEXCRCGREARGSUIBELUSA'
v='\n',R='',W='No Game'
for(z=1;T!='USA';++z,T=n){R+=v+z+v,n='',r=/(...)(...)/g
while(m=r.exec(T))a=m[1],n+=b=m[2],R+=a+'-'+b+v,W=a==x&&b==y||a==y&&b==x?b:W
}
alert(W+'\n'+R)