Comme vous le savez, la phase de groupes de la Coupe du monde est terminée et à partir de demain, les 16 meilleures équipes entameront la phase à élimination directe:

• Brésil (BRA)
• Mexique (MEX)
• Pays-Bas (NED)
• Chili (CHI)
• Colombie (COL)
• Grèce (GRE)
• Costa Rica (CRC)
• Uruguay (URU)
• France (FRA)
• Suisse (SUI)
• Argentine (ARG)
• Nigéria (NGA)
• Allemagne (GER)
• États-Unis (USA)
• Belgique (BEL)
• Algérie (ALG)

Dans la phase à élimination directe, après chaque match, le vainqueur passe au tour suivant et le perdant rentre à la maison (il n'y a pas de match nul). Cliquez ici pour en savoir plus sur la phase à élimination directe.

Vous avez été embauché par golfbet.com, un nouveau site de paris, car vous êtes connu pour être bon en programmation et en paris sportifs. Votre tâche consiste à écrire un programme ou une fonction qui peut deviner le vainqueur d'un match. Bien sûr, tout le monde fait des suppositions différentes, cela n'a pas d'importance tant que vos suppositions sont cohérentes.

Si vous ne voulez pas deviner, vous pouvez utiliser les suppositions suivantes:

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. Le programme doit sortir le même vainqueur quel que soit l'ordre des équipes (le vainqueur du match BRA-CHI doit être le même que celui du match CHI-BRA)
2. Si une équipe perd, elle ne peut plus jouer de matchs. Cela signifie que pour les matchs qui n'ont pas lieu, vous devez l'indiquer. Par exemple, si votre programme devine le Brésil pour gagner le match BRA-CHI, alors CHI-GER doit retourner "aucun résultat", car le Chili ne jouera pas contre l'Allemagne. Voir le lien ci-dessus pour l'horaire.

Par souci de simplicité, vous n'avez pas à gérer le match de bronze (mais vous pouvez bien sûr).

Votre programme ou fonction prend deux chaînes en entrée: le code de pays à 3 lettres des deux équipes et renvoie le code de pays de l'équipe gagnante (vous pouvez utiliser une entrée / sortie standard ou deux paramètres de fonction / valeur de retour). Si les deux équipes données ne joueront pas selon vos suppositions, vous devez renvoyer autre chose (cela peut être tout sauf les codes de pays, par exemple une chaîne vide, null, un message d'erreur). Vous pouvez supposer que l'entrée est correcte (deux codes de pays différents qui sont dans la liste).

Il s'agit principalement d'un code-golf, donc le programme le plus court en octets gagne. Cependant, des solutions agréables et délicates sont également précieuses.

Exemple (bien sûr, vous pouvez faire vos propres suppositions):

entrée: BRA CHI sortie: BRA

entrée: CHI BRA sortie: BRA

entrée: CHI GER sortie: aucun résultat

Python 2.x - 368 283

Défi intéressant. Bien sûr, nous devons obtenir le classement actuel de la FIFA . Le Brésil a le soi-disant "12ème homme" car il a l'avantage de la maison donc la pondération 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'   

Les conseils pour raccourcir ce qui précède sont les bienvenus :-).

Améliorations grâce à @TheRare et @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'

Cela conduit aux résultats suivants:

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

Exemples d'appels:

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

C, 182 178 133 (ou 126)

Ce n'est pas le programme le plus court ici, mais c'est le plus court dans lequel la prédiction peut être modifiée facilement. Maintenant que tous les demi-finalistes sont connus, je mets à jour.

Il y a aussi quelques changements au code. Hormis les suggestions de Dennis dans les commentaires, le programme a été converti en fonction (comme en relisant cela est autorisé par les règles) et le hachage a été raccourci.

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

Comment ça fonctionne

les entrées aet bsont hachées par l'expression *a-a[1]%16à un seul caractère ( *aest un équivalent plus court à a[0]). Le hachage résulte pour les équipes aet best stocké dans h. Par exemple, BRA CHI devient @;. Les valeurs hachées sont les suivantes (les demi-finalistes confirmés et mon champion prédit sont marqués d'un *.)

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[]stocke mes prédictions. Les résultats des huitièmes de finale et des quarts de finale sont désormais connus. Chaque groupe de 4 équipes est ordonné de telle sorte que les 1er et 4e ont été éliminés, et le 3e est le demi-finaliste. De même pour les demi-finalistes, je prédis que les 1er et 4e seront éliminés et que le 3e demi-finaliste sera le vainqueur général. Si vous n'êtes pas d'accord avec mes prévisions, réorganisez simplement la table.

Les prédictions sont stockées dans des blocs palindromiques pour tenir compte de la possibilité que l'utilisateur entre dans les équipes dans l'un ou l'autre ordre possible. La commande rassemble les équipes gagnantes de chaque série de 4 pour disputer un troisième match. Ainsi, dans le premier groupe, GRE a Eperdu contre CRC et MEX a Hperdu contre NED. Cela configure CRC Apour jouer NEDI en quart de finale sans avoir à répéter la frappe. La chaîne est rembourrée avec un espace entre chaque groupe de 4 équipes / 7 personnages pour garantir qu'il n'y a pas de sortie pour les équipes qui ne se joueront pas.

Le vainqueur de chaque match possible dans chaque groupe de 8 caractères est la suivante: invalid,b,a,a,b,b,a,invalid. Ainsi, le bon choix du gagnant peut être fait en prenant la position de hdans t AND 2 . Malheureusement, la strstrfonction n'est pas la plus directe car elle renvoie un pointeur p, nous devons donc soustraire pde tpour obtenir la position réelle dans t.Si la correspondance n'est pas valide (introuvable dans t), pest zéro et la phrase no resultest imprimée.

Quelques améliorations douteuses, 126

2 caractères enregistrés par une expression de hachage améliorée. Malheureusement, cela nécessite que le cas des équipes soit comme indiqué dans le programme de test sous la fonction (par exemple Braau lieu de BRAcelui utilisé dans le programme ci-dessus). Je me suis assuré qu'il n'y avait aucun moyen de le faire avec un seul opérateur, donc 2 opérateurs et une constante à un seul caractère est aussi bon que possible. Notez également que la Urucorrespondance avec spaceun autre caractère |est nécessaire pour séparer les groupes de codes d'équipe.

5 caractères enregistrés en éliminant tet en traitant la chaîne de prédiction comme un littéral. Cela signifie qu'il est impossible de connaître l'adresse où la chaîne est stockée. Cependant, à condition qu'il ne soit pas stocké à zéro, nous ne sommes intéressés que p&2si le code fonctionnera si l'adresse est divisible par 4. (Notez qu'il n'est pas autorisé de traiter le pointeur pdirectement comme un entier, il doit être soustrait d'un autre pointeur . J'utilise le pointeur adonc adoit aussi être divisible par 4.) On peut être assez confiant sur un compilateur / architecture de 32 ou 64 bits les chaînes seront stockées de cette façon. Cela a bien fonctionné pour moi sur GCC / cygwin, bien qu'il refuse de compiler sur 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

Beaucoup de place pour l'amélioration:

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)

Approche regex - 116

Merci à ɐɔıʇǝɥʇuʎs d' avoir posté ce lien , cela m'a aidé à créer l'expression régulière

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 manière cq trop long)

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

Tout le monde sait que le pays dont le nom vient en premier dans l'alphabet va gagner. (Cette réponse existe juste pour commencer)

Grâce à la charité du ou des gars ici , j'ai pu raccourcir un peu ma réponse:

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

Cela suppose des équipes valides, mais n'a pas besoin d'une composition valide ( f('BRA','NED')retournerait 0 (match invalide), mais f('XNE')retournerait'XNE' . Je ne comprends pas de votre question que c'est un problème cependant. N'hésitez pas à ré-abuser cette expression régulière comme bon vous semble.

Merci @Ventero, je ne connais rien aux 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}}

Voici des matchs entre "foo" et "bar" possibles, aussi les équipes qui ne joueront pas en réel les unes contre les autres au premier tour auront un résultat (par exemple en commençant par BRA, ARG)

Il s'agit simplement d'enregistrer des équipes perdantes.

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

Appelé avec:

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

PowerShell ( 261221 )

$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

En tant qu'utilisateur PowerShell relativement nouveau, je trouve le pipeline absolument incroyable. Je pense que la prochaine étape pourrait être d'essayer de jouer avec le tableau pour, espérons-le, éliminer tous ces appels de sous-chaîne. (J'ai dû ajouter un appel à la fin, sinon il a généré les deux équipes)

Nouveau membre, première tentative de code golf!

Aurait pu coder en dur les quarts de finale, les demi-finales et les finales pour enregistrer quelques caractères, mais> ce ne serait pas aussi amusant.

Doit être assez simple à déchiffrer, mais il remplit les deux conditions: donne le même gagnant> quel que soit l'ordre entré, et ne renvoie un gagnant que pour les matchs qui ont réellement lieu!

Tout conseil d'amélioration serait grandement apprécié, merci!

Original

$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 octets

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

Ce qui précède utilise le signe d'insertion et la notation M, car le code contient des caractères non imprimables.

Au prix de six octets supplémentaires, ces caractères peuvent être évités:

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

Essayez-le en ligne.

Essai

$ 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

Comment ça fonctionne

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 octets

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

Ce qui précède utilise la notation caret, car le code contient des caractères non imprimables.

Au prix de deux octets supplémentaires, ces caractères peuvent être évités:

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

Essayez-le en ligne.

Essai

$ 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

Contexte

Nous commençons par attribuer un caractère ASCII à chaque équipe en considérant son nom comme un nombre de base 2, en prenant le modulo entier résultant 91, en ajoutant 12 (pour éviter les caractères non imprimables) et en sélectionnant le caractère correspondant au code ASCII résultant. Dans le code CJam, ceci est réalisé par2b91%c .

Par exemple, les codes de caractères de ALGsont 65 76 71. Depuis (4 × 65 + 2 × 76 + 71) = 483, 483 % 91 + 12 = 40et 40 si le code de caractère de (.

Cela donne le mappage suivant:

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

Maintenant, nous pouvons encoder les matchs des huitièmes de finale comme suit:

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

Si nous supposons que la première équipe par ordre alphabétique gagne toujours, les matchs des quarts de finale sont les suivants:

(B2;4#8[

Notez que cette chaîne peut être obtenue à partir du premier en sélectionnant chaque deuxième caractère, en commençant par le premier. Dans le code CJam, ceci est réalisé par 2%.

Partant de la même idée, les matchs des demi-finales et du match final sont les suivants:

(248
(4

Le code

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

pousse la chaîne contenant les correspondances des huitièmes de finale, puis effectue les opérations suivantes trois fois: dupliquer la chaîne, extraire chaque deuxième caractère de la copie, concaténer. Le résultat est la chaîne

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

qui contient toutes les correspondances (certaines d'entre elles plus d'une fois).

Comment ça fonctionne

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)