Como saben, la fase de grupos de la Copa del Mundo terminó y, a partir de mañana, los 16 mejores equipos comenzarán la fase eliminatoria:

• Brasil (BRA)
• México (mex)
• Países Bajos (NED)
• Chile (CHI)
• Colombia (COL)
• Grecia (GRE)
• Costa Rica (CRC)
• Uruguay (URU)
• Francia (FRA)
• Suiza (SUI)
• Argentina (ARG)
• Nigeria (NGA)
• Alemania (GER)
• Estados Unidos (USA)
• Bélgica (BEL)
• Argelia (ALG)

En la etapa eliminatoria, después de cada partido, el ganador pasa a la siguiente ronda y el perdedor se va a casa (no hay empates). Haga clic aquí para ver más sobre la etapa eliminatoria.

Golfbet.com, un nuevo sitio web de apuestas, lo ha contratado porque se sabe que es bueno tanto en programación como en apuestas deportivas. Su tarea es escribir un programa o función que pueda adivinar el ganador de un partido. Por supuesto, todos hacen conjeturas diferentes, no importa siempre y cuando sus conjeturas sean consistentes.

Si no quieres adivinar, puedes usar las siguientes conjeturas:

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. El programa debe generar el mismo ganador independientemente del orden de los equipos (el ganador del partido BRA-CHI debe ser el mismo que el del partido CHI-BRA)
2. Si un equipo pierde, no puede jugar más partidos. Esto significa que para los partidos que no tienen lugar, debe indicarlo. Por ejemplo, si su programa adivina que Brasil ganará el partido BRA-CHI, entonces CHI-GER tiene que devolver "ningún resultado", porque Chile no jugará contra Alemania. Vea el enlace de arriba para el horario.

En aras de la simplicidad, no tiene que lidiar con el partido de bronce (pero puede, por supuesto).

Su programa o función toma dos cadenas como entrada: el código de país de 3 letras de los dos equipos y devuelve el código de país del equipo ganador (puede usar la entrada / salida estándar, o dos parámetros de función / valor de retorno). Si los dos equipos dados no jugarán de acuerdo con sus conjeturas, debe devolver algo más (esto puede ser cualquier cosa menos los códigos de país, por ejemplo, cadena vacía, nulo, mensaje de error). Puede suponer que la entrada es correcta (dos códigos de país diferentes que están en la lista).

Este es principalmente un código de golf, por lo que gana el programa más corto en bytes. Sin embargo, las soluciones agradables y difíciles también son valiosas.

Ejemplo (por supuesto, puedes hacer tus propias conjeturas):

entrada: BRA CHI salida: BRA

entrada: CHI BRA salida: BRA

entrada: salida CHI GER: sin resultado

Python 2.x - 368 283

Interesante reto. Por supuesto, necesitamos obtener clasificaciones actuales de la FIFA . Brasil tiene el llamado "duodécimo hombre", ya que tiene la ventaja de casa, por lo tanto, la ponderación 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'   

Consejos para acortar lo anterior son bienvenidos :-).

Mejoras gracias a @TheRare y @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'

Esto lleva a los siguientes resultados:

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

Llamadas de ejemplo:

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

C, 182 178 133 (o 126)

No es el programa más corto aquí, pero es el más corto en el que la predicción se puede cambiar fácilmente. Ahora que todos los semifinalistas son conocidos, estoy actualizando.

También hay algunos cambios en el código. Además de las sugerencias de Dennis en los comentarios, el programa se ha convertido en una función (como en la relectura, esto está permitido por las reglas) y el hash se ha acortado.

Código 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);
}

Cómo funciona

las entradas ay bse combinan con la expresión *a-a[1]%16en un solo carácter ( *aes un equivalente más corto a a[0]). Los resultados de hash para equipos ay bse almacenan en h. Por ejemplo BRA CHI se convierte @;. Los valores hash son los siguientes (los semifinalistas confirmados y mi campeón predicho están marcados 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[]almacena mis predicciones Ahora se conocen los resultados de la ronda de 16 y cuartos de final. Cada grupo de 4 equipos está ordenado de tal manera que el primero y el cuarto fueron eliminados, y el tercero es el semifinalista. De manera similar a los semifinalistas, pronostico que el 1 ° y 4 ° serán eliminados y el 3 ° semifinalista será el ganador general. Si no está de acuerdo con mis predicciones, simplemente vuelva a ordenar la tabla.

Las predicciones se almacenan en bloques palindrómicos para acomodar la posibilidad de que el usuario ingrese a los equipos en cualquier orden posible. El orden pone a los equipos ganadores de cada conjunto de 4 juntos para jugar un tercer partido. Así, en el primer grupo, GRE Eperdió con CRC y MEX Hperdió con NED. Esto configura CRC Apara jugar NED Ien los cuartos de final sin tener que repetir el tipeo. La cadena se rellena con un espacio entre cada grupo de 4 equipos / 7 caracteres para ayudar a garantizar que no haya salida para los equipos que no jugarán entre sí.

El ganador de cada posible coincidencia en cada grupo de 8 caracteres es el siguiente: invalid,b,a,a,b,b,a,invalid. Por lo tanto, la elección correcta del ganador se puede hacer tomando la posición de hin t AND 2 . Por desgracia, la strstrfunción no es el más directo conducir, ya que devuelve un puntero p, por lo que hay que restar pde tobtener la posición real en t.Si el partido no es válido (no se pueden encontrar en t), pes cero y la frase no resultse imprime.

Algunas mejoras dudosas, 126

2 caracteres guardados por una expresión hash mejorada. Desafortunadamente, esto requiere que el caso de los equipos sea como se muestra en el programa de prueba debajo de la función (por ejemplo, en Bralugar de BRAcomo se usa en el programa anterior). Me he convencido de que no hay forma de hacerlo con un solo operador, así que 2 operadores y una constante de un solo carácter es tan bueno como parece. Tenga en cuenta también que se necesita un Urumapa spacealternativo |para separar los grupos de códigos de equipo.

5 caracteres guardados al eliminar ty tratar la cadena de predicción como un literal. Esto significa que es imposible saber la dirección donde se almacena la cadena. Sin embargo, siempre que no esté almacenado en cero, solo nos interesa, por p&2lo que el código funcionará si la dirección es divisible por 4. (Tenga en cuenta que no está permitido tratar el puntero pdirectamente como un entero, debe restarse de otro puntero Uso el puntero, apor lo aque también debe ser divisible por 4.) Uno puede estar bastante seguro de que un compilador de 32 o 64 bits / cadenas de arquitectura se almacenarán de esta manera. Esto me ha funcionado bien en GCC / cygwin, aunque se niega a compilar en 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

Mucho margen de mejora:

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)

Enfoque Regex - 116

Gracias a ɐɔıʇǝɥʇuʎs por publicar este enlace , me ayudó a hacer la expresión regular

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 demasiado tiempo)

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

Todos saben que el país con el nombre que aparece primero en el alfabeto va a ganar. (Esta respuesta solo existe para comenzar)

Gracias a la caridad de los chicos de aquí , pude acortar un poco mi respuesta:

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

Esto asume equipos válidos, pero no necesita una alineación válida ( f('BRA','NED')devolvería 0 (partido no válido), pero f('XNE')regresaría 'XNE'. No entiendo de su pregunta que sin embargo esto es un problema. Siéntase libre de volver a abusar) esta expresión regular como mejor le parezca.

Gracias @Ventero, no sé nada sobre expresiones regulares.

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

Aquí hay coincidencias entre "foo" y "bar" posibles, también los equipos que no jugarán entre sí en la primera ronda tendrán un resultado (por ejemplo, comenzando con BRA, ARG)

Es solo grabar equipos que pierden.

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

Llamado 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

Como un usuario relativamente nuevo de PowerShell, encuentro la tubería absolutamente increíble. Creo que el siguiente paso podría ser tratar de manipular la matriz para eliminar todas estas llamadas de subcadenas. (Tuve que agregar una llamada al final o de lo contrario salieron los dos equipos)

Nuevo miembro, primer intento de código de golf!

Podría haber codificado los cuartos de final, semifinales y finales para salvar a algunos personajes, pero eso no sería tan divertido.

Debe ser lo suficientemente simple como para descifrarlo, pero cumple ambas condiciones: da el mismo ganador> independientemente del orden ingresado, ¡y solo devuelve un ganador para los partidos que realmente tienen lugar!

Cualquier consejo para mejorar sería muy apreciado, ¡gracias!

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 bytes

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

Lo anterior usa notación M y M, ya que el código contiene caracteres no imprimibles.

Al costo de seis bytes adicionales, esos caracteres se pueden evitar:

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

Pruébalo en línea.

Prueba de funcionamiento

$ 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

Cómo funciona

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 bytes

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

Lo anterior usa notación de intercalación, ya que el código contiene caracteres no imprimibles.

A costa de dos bytes adicionales, esos caracteres se pueden evitar:

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

Pruébalo en línea.

Prueba de funcionamiento

$ 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

Antecedentes

Comenzamos asignando un carácter ASCII a cada equipo considerando su nombre como un número base 2, tomando el módulo entero 91 resultante, agregando 12 (para evitar caracteres no imprimibles) y seleccionando el carácter correspondiente al código ASCII resultante. En el código CJam, esto se logra mediante2b91%c .

Por ejemplo, los códigos de caracteres de ALGare 65 76 71. Desde (4 × 65 + 2 × 76 + 71) = 483, 483 % 91 + 12 = 40y 40 si el código de caracteres de( .

Esto proporciona la siguiente asignación:

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

Ahora, podemos codificar los partidos de la ronda de 16 de la siguiente manera:

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

Si suponemos que el primer equipo en orden alfabético siempre gana, los partidos de los cuartos de final son los siguientes:

(B2;4#8[

Tenga en cuenta que esta cadena se puede obtener del primero seleccionando cada segundo carácter, comenzando por el primero. En el código CJam, esto se logra mediante 2%.

Usando la misma idea, los partidos de las semifinales y el partido final son los siguientes:

(248
(4

El código

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

empuja la cadena que contiene las coincidencias de la ronda de 16, luego hace lo siguiente tres veces: duplica la cadena, extrae cada segundo carácter de la copia, concatena. El resultado es la cadena.

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

que contiene todas las coincidencias (algunas de ellas más de una vez).

Cómo funciona

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)