Como você sabe, a fase de grupos da Copa do Mundo terminou e a partir de amanhã as 16 melhores equipes começarão a fase eliminatória:

• Brasil (BRA)
• México (MEX)
• Holanda (NED)
• Chile (CHI)
• Colômbia (COL)
• Grécia (GRE)
• Costa Rica (CRC)
• Uruguai (URU)
• França (FRA)
• Suíça (SUI)
• Argentina (ARG)
• Nigéria (NGA)
• Alemanha (GER)
• Estados Unidos (EUA)
• Bélgica (BEL)
• Argélia (ALG)

Na fase eliminatória, após cada partida, o vencedor passa para a próxima rodada e o perdedor vai para casa (não há empates). Clique aqui para ver mais sobre a fase eliminatória.

Você foi contratado pelo golfbet.com, um novo site de apostas porque é conhecido por ser bom em programação e apostas esportivas. Sua tarefa é escrever um programa ou função que possa adivinhar o vencedor de uma partida. É claro que todo mundo faz suposições diferentes, não importa, desde que sejam consistentes.

Se você não quer adivinhar, pode usar as seguintes suposições:

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. O programa deve apresentar o mesmo vencedor, independentemente da ordem das equipes (o vencedor da partida BRA-CHI deve ser o mesmo da partida CHI-BRA)
2. Se um time perde, não pode jogar mais nenhuma partida. Isso significa que, para as partidas que não ocorrem, você deve indicar isso. Por exemplo, se seu programa adivinha o Brasil para vencer a partida BRA-CHI, então o CHI-GER precisa retornar "sem resultado", porque o Chile não joga contra a Alemanha. Veja o link acima para agendar.

Por uma questão de simplicidade, você não precisa lidar com a partida de bronze (mas é claro).

Seu programa ou função usa duas cadeias de caracteres como entrada: o código do país de três letras das duas equipes e retorna o código do país da equipe vencedora (você pode usar entrada / saída padrão ou dois parâmetros de função / valor de retorno). Se as duas equipes indicadas não jogarem de acordo com seus palpites, você deve retornar outra coisa (isso pode ser qualquer coisa, exceto os códigos do país, por exemplo, sequência vazia, nulo, mensagem de erro). Você pode assumir que a entrada está correta (dois códigos de países diferentes que estão na lista).

Este é basicamente um código de golfe, e o programa mais curto em bytes vence. No entanto, soluções agradáveis ​​e complicadas também são valiosas.

Exemplo (é claro, você pode fazer suas próprias suposições):

entrada: BRA CHI saída: BRA

entrada: CHI BRA saída: BRA

entrada: saída CHI GER: sem resultado

Python 2.x - 368 283

Desafio interessante. É claro que precisamos obter classificações atuais da FIFA . O Brasil tem o chamado "12º homem", pois eles têm vantagem em casa, portanto, o peso de 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'   

Dicas para encurtar o exposto acima são bem-vindas :-).

Melhorias graças 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'

Isso leva aos seguintes 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

Chamadas de exemplo:

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

C, 182 178 133 (ou 126)

Não é o programa mais curto aqui, mas é o mais curto no qual a previsão pode ser alterada facilmente. Agora que todos os semifinalistas são conhecidos, estou atualizando.

Também há algumas alterações no código. Além das sugestões de Dennis nos comentários, o programa foi convertido em uma função (pois a leitura é permitida pelas regras) e o hash foi reduzido.

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

Como funciona

as entradas ae bsão divididas em hash pela expressão *a-a[1]%16em um único caractere ( *aé um equivalente menor a[0]). Os resultados do hash para as equipes ae bsão armazenados h. Por exemplo, BRA CHI se torna @;. Os valores hash são os seguintes (os semifinalistas confirmados e meu campeão previsto estão marcados com *.)

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[]armazena minhas previsões. Os resultados das rodadas de 16 e dos quartos de final são agora conhecidos. Cada grupo de 4 equipes é ordenado de forma que o 1º e o 4º foram eliminados, e o 3º é o semifinalista. Da mesma forma que os semifinalistas, estou prevendo que o 1º e o 4º serão eliminados e o 3º semifinalista será o vencedor geral. Se você não concordar com minhas previsões, basta reordenar a tabela.

As previsões são armazenadas em blocos palíndricos para acomodar a possibilidade do usuário entrar nas equipes em qualquer ordem possível. A ordem coloca as equipes vencedoras de cada conjunto de 4 juntas para jogar uma terceira partida. Assim, no primeiro grupo, o GRE Eperdeu para o CRC e o MEX Hperdeu para o NED. Isso configura o CRC Apara jogar NED Inas quartas de final sem precisar repetir a digitação. A corda é preenchida com um espaço entre cada grupo de 4 equipes / 7 caracteres para ajudar a garantir que não haja saída para as equipes que não se tocarão.

O vencedor de cada correspondência possível em cada grupo de 8 caracteres é o seguinte: invalid,b,a,a,b,b,a,invalid. Assim, a escolha correta do vencedor pode ser feita assumindo a posição hem t AND 2 . Infelizmente, a strstrfunção não é a mais direta, pois retorna um ponteiro p; portanto, devemos subtrair pde tpara obter a posição atual em t.Se a correspondência for inválida (não pode ser encontrada em t), pé zero e a frase no resulté impressa.

Algumas melhorias duvidosas, 126

2 caracteres salvos por uma expressão de hash aprimorada. Infelizmente, isso exige que o caso das equipes seja como mostrado no programa de teste abaixo da função (por exemplo, em Bravez de BRAser usado no programa acima.) Fiquei satisfeito de que não há como fazer isso com um único operador, portanto, 2 operadores e uma constante de caractere único são os melhores possíveis. Observe também que o Urumapeamento para spaceum caractere alternativo |é necessário para separar os grupos de códigos de equipe.

5 caracteres salvos ao eliminar te tratar a sequência de previsão como um literal. Isso significa que é impossível saber o endereço onde a string está armazenada. No entanto, desde que não seja armazenado em zero, estamos interessados ​​apenas em p&2que o código funcione se o endereço for divisível por 4. (Observe que não é permitido tratar o ponteiro pdiretamente como um número inteiro, ele deve ser subtraído de outro ponteiro Eu uso o ponteiro, aportanto, atambém deve ser divisível por 4.) Pode-se ter certeza de que as seqüências de compilador / arquitetura de 32 ou 64 bits serão armazenadas dessa maneira. Isso tem funcionado bem para mim no GCC / cygwin, embora se recuse a compilar no 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

Muito espaço para melhorias:

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)

Abordagem Regex - 116

Graças a forıʇǝɥʇuʎs por postar este link , ele me ajudou a fazer a 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 tempo demais)

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

Todo mundo sabe que o país com o nome que aparece primeiro no alfabeto vai ganhar. (Esta resposta existe apenas para começar)

Graças à caridade do (s) cara (s) por aqui , eu poderia encurtar minha resposta um pouco:

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

Isso pressupõe equipes válidas, mas não precisa de uma formação válida ( f('BRA','NED')retornaria 0 (partida inválida), mas f('XNE')retornaria 'XNE'. Não recebo sua pergunta de que isso seja um problema. Sinta-se à vontade para reutilizar este regex como achar melhor.

Obrigado @Ventero, não sei nada sobre regexes.

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

Aqui estão as partidas entre "foo" e "bar" possíveis, também as equipes que não jogarem real entre si nas primeiras rodadas terão resultado (por exemplo, começando com BRA, ARG)

É apenas gravar equipes perdedoras.

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

Chamado com:

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

PowerShell ( 262222 )

$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 um usuário relativamente novo do PowerShell, acho o pipeline absolutamente incrível. Acho que em seguida pode ser tentar mexer com a matriz para eliminar todas as chamadas de substring. (Eu tive que adicionar uma chamada no final, ou ela gerou as duas equipes)

Novo membro, primeira tentativa de código de golfe!

Poderia ter codificado as quartas de final, as semi e as finais para salvar alguns personagens, mas isso não seria tão divertido.

Deve ser simples o suficiente para decifrar, mas atende a ambas as condições: fornece o mesmo vencedor> independentemente do pedido digitado e retorna apenas um vencedor para as partidas que realmente ocorrem>!

Qualquer conselho para melhoria seria muito apreciado, obrigado!

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/&,*

O exemplo acima usa circunflexo e notação M., pois o código contém caracteres não imprimíveis.

Ao custo de seis bytes adicionais, esses caracteres podem ser evitados:

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

Experimente online.

Execução de teste

$ 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

Como 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&!*

O exemplo acima usa notação de intercalação, pois o código contém caracteres não imprimíveis.

Ao custo de dois bytes adicionais, esses caracteres podem ser evitados:

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

Experimente online.

Execução de teste

$ 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

fundo

Começamos atribuindo um caractere ASCII a cada equipe, considerando seu nome como um número base 2, utilizando o módulo inteiro resultante 91, adicionando 12 (para evitar caracteres não imprimíveis) e selecionando o caractere correspondente ao código ASCII resultante. No código CJam, isso é alcançado por 2b91%c.

Por exemplo, os códigos de caracteres de ALGsão 65 76 71. Desde (4 × 65 + 2 × 76 + 71) = 483, 483 % 91 + 12 = 40e 40, se o código de caractere de( .

Isso fornece o seguinte mapeamento:

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

Agora, podemos codificar as partidas da rodada de 16 da seguinte maneira:

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

Se assumirmos que o primeiro time em ordem alfabética sempre vence, os jogos das quartas de final são os seguintes:

(B2;4#8[

Observe que essa sequência pode ser obtida desde o primeiro, selecionando cada segundo caractere, começando com o primeiro. No código CJam, isso é alcançado por 2%.

Usando a mesma idéia, as partidas das meias-finais e da partida final são as seguintes:

(248
(4

O código

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

empurra a sequência que contém as correspondências da rodada de 16 e faz o seguinte três vezes: duplica a sequência, extrai cada segundo caractere da cópia, concatena. O resultado é a sequência

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

que contém todas as correspondências (algumas delas mais de uma vez).

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