O campeonato de futebol americano, Super Bowl 50 , está acontecendo hoje às 23:30 UTC (e você pode assistir ao vivo online ). Este desafio foi feito para celebrá-lo.

Em um jogo de futebol americano, duas equipes competem para obter o maior número de pontos e há seis maneiras de marcar esses pontos. Daremos a cada uma abreviação:

• Objetivo de campo - FG: 3 pontos
• Touchdown - TD: 6 pontos
• Ponto extra - XP: 1 ponto - Só pode ser pontuado diretamente após um touchdown.
• Conversão de dois pontos - XD(como um ponto extra, mas mais feliz): 2 pontos - Só pode ser pontuado diretamente após um touchdown.
• Segurança - S: 2 pontos
• Fair catch kick - FCK: 3 pontos (uma jogada muito rara)

Escreva um programa ou função que utilize uma única linha contendo apenas essas seis abreviações, em maiúsculas e minúsculas.

Essa sequência representa todos os eventos de pontuação em um jogo (ou parte de um jogo) de futebol, com os termos em maiúsculas pertencentes a um time e os minúsculos em outro.

Seu trabalho é relatar as pontuações finais do jogo e indicar quem ganhou com a saída do formulário

[score 1] [to] [score 2]

Onde:

• [score 1] é sempre a maior das duas pontuações (se não for igual), independentemente de haver ganho em maiúsculas ou minúsculas.
• [score 2] é a menor das duas pontuações (se não for igual).
• [to]é TOse o time em maiúsculas venceu, tose o time em minúsculas venceu e Tose é um empate.

Exemplo: Todos os eventos de pontuação no Super Bowl XLIX podem ser resumidos pela sequência

TDXPtdxpTDXPtdxpfgtdxpTDXPTDXP

onde maiúsculas são os New England Patriots e minúsculas são os Seattle Seahawks . O Patriots marcou 28 e o Hawks 24, então a saída seria:

28 TO 24

Notas

• Seu programa / função deve suportar qualquer entrada arbitrária, incluindo a sequência vazia.
• XPe XDsó ocorrerá logo depois TD. xpe xdsó ocorrerá logo depois td.
• Você não pode assumir que a sequência de entrada começa ou termina em um determinado caso.
• Uma única nova linha à direita é opcionalmente permitida na entrada e na saída

Pontuação

O código mais curto em bytes vence. As respostas postadas antes do início do jogo ( muito tarde agora! ) Do Super Bowl 50 podem prever a equipe vencedora ( Panteras ou Broncos ) e, se estiverem corretas, recebam um bônus de -10% de bytes!

(Verificarei o histórico de revisões para garantir que as previsões não foram alteradas e realmente foram feitas antes do início.)

Casos de teste

[empty string] -> 0 To 0
TDXPtdxpTDXPtdxpfgtdxpTDXPTDXP -> 28 TO 24
FG -> 3 TO 0
fg -> 3 to 0
TD -> 6 TO 0
td -> 6 to 0
TDXP -> 7 TO 0
tdxp -> 7 to 0
TDXD -> 8 TO 0
tdxd -> 8 to 0
S -> 2 TO 0
s -> 2 to 0
FCK -> 3 TO 0
fck -> 3 to 0
TDTDXDSssFCKfgfckFGtd -> 22 TO 16
fcksFCKS -> 5 To 5
tdtdtdtdxp -> 25 to 0
SSSSSSSTD -> 20 TO 0
fgSfckFGfgtdxptdxdTDs -> 26 to 11
FGTDXPtdxdtdsStdxpfgTDfckTDXDFCK -> 29 To 29

Pitão, 49 46 43 42 bytes (37,8 bytes com bônus)

jr" to "xh._-FJmsmhx"PSFT"kXd\D\S,rz2z2_SJ

Obrigado a @ Maltysen por me ajudar a economizar 4 bytes!

Experimente no Compilador Pyth .

Eu gosto de cobrir todas as bases, por isso aposto no Broncos.

Como funciona

jr" to "xh._-FJmsmhx"PSFT"kXd\D\S,rz2z2_SJ Input: z

                                  rz2      Swap the case of z.
                                 ,   z     Pair the result with z.
               m                           Map; for each d in the pair:
                           Xd\D\S            Replace each D with an S.
                 m                           Map; for each character k:
                   x"PSFT"k                    Compute k's first index on "PSFT".
                  h                            Increment the index.
                s                            Compute the sum of the incr. indices.
                                               "FG"  -> [3, 0]     -> 3
                                               "TD"  -> [4, 2]     -> 6
                                               "XP"  -> [0, 1]     -> 1
                                               "XD"  -> [0, 2]     -> 2
                                               "S"   -> [2]        -> 2
                                               "FCK" -> [3, 0, 0]  -> 3
                                               (lowercase letters) -> 0
              J                            Save the resulting list of scores in J.
            -F                             Reduce J by subtraction.
          ._                               Compute the sign of the difference.
         h                                 Add 1.
        x                             2    XOR the result with 2.
 r" to "                                   Pick‡ a function and apply it to " to ".
                                       _SJ Sort and reverse the list of scores.
j                                          Join, separating by the modified string.

^‡ r é uma família de funções que operam em seqüências de caracteres.

• Se o primeiro marcador em J(correspondente ao caso trocado z, ou seja, as letras minúsculas originais) é menor do que a segunda contagem, a função sinal voltará -1, (-1 + 1) ^ 2 == 2e r" to "2é swapcase, por isso, retorna " TO ".

• Se a primeira pontuação é maior do que a segunda pontuação, a função sinal vai voltar 1, (1 + 1) ^ 2 == 0e r" to "0é lowercase, por isso, ele retorna " to ".

• Se as pontuações são iguais, a função sinal vai voltar 0, (0 + 1) ^ 2 == 3e r" to "3é title, por isso, ele retorna " To ".

MATL , 51 * 0,9 = 45,9 54 57 58 63 bytes

Agradecimentos a Dennis por remover 3 bytes!

'%i To %i'j0h!3'PDFTS'tkXc=s4:Hh*sSPYD3MdXK?kK0<?Xk

Uma cadeia de entrada vazia é representada no compilador online como um único caractere de nova linha.

EDIT (8 de junho de 2016): O link abaixo inclui uma modificação conforme o release 18.1.0 do idioma (mova ele primeiro 3logo antes Xc)

Experimente online!

Eu aposto no Broncos.

Explicação

As pontuações são detectadas usando uma única letra, maiúscula ou minúscula (maiúsculas são mostradas a seguir):

• P para XP (1 ponto)
• D para XD (2 pontos)
• F para FG (3 pontos) e para FCK (3 pontos)
• T para TD (6 pontos)
• S para S (2 pontos)

Cada uma dessas cinco letras corresponde exclusivamente a um evento de pontuação, exceto que

• Fé reutilizado para FGe FCKcom a mesma pontuação. Obrigado a @Dennis por isso !
• Ddetectará TD e XD. Então T, serão atribuídos 4 pontos em vez de 6 para compensar.

A ordenação PDFTS, poupa alguns bytes quando definindo a matriz número que especifica os pontos: [1,2,3,4,2].

Cada evento é detectado pela presença de uma das letras acima em maiúsculas ou minúsculas. A comparação é feita em três dimensões: comprimento da string de entrada ( N ) × número de equipes (2) × número de eventos de pontuação detectados (5). É feito uso extensivo da transmissão , que é a expansão automática de uma matriz ao longo de uma dimensão singleton para corresponder ao tamanho de uma matriz maior.

'%i To %i'  % string with format specifiers for two integers
j0h         % input string. Attach 0 so it's never empty. Gives string of length N>0
!           % transpose into char array of size N×1
3           % number literal
'PDFTS'     % characters to detect the five combined types of score
tk          % duplicate and convert to lowercase
Xc          % concatenate along the third dimension to produce a 1×5×2 array
=           % test for equality with broadcast. Gives N×5×2 array
s           % sum along 1st dim. Gives 1×5×2 array
4:Hh        % array [1,2,3,4,2] to compute the total score. Size 1×5(×1) 
*           % multiply with broadcast. Gives 1×5×2 array
s           % sum along 2nd dim. Gives 1×1×2 array with the two scores
SP          % sort in reverse order along 3rd dim
YD          % sprintf. Gives output string with "To"
3M          % push array with the two scores again
dXK         % difference along 3rd dim. Gives a number. Copy to clipboard K
?           % is it non-zero? If so we need to make either lowercase or uppercase
  k         %   make (tentatively) lowercase
  K0<       %   did the uppercase team win?
  ?         %   if so...
    Xk      %     make uppercase
            % implicitly end the two if's and display string

CJam, 57 55 54 53 50 49 bytes

q_32f^]{"PSFTD"f#:)5Yer1b}%_$(@:-g"ToTOto"2/=\]S*

Experimente online!

Não tenho ideia do que é um Bronco, então aposto no Panthers.

Como funciona

q                              Read all input from STDIN.
 _                             Push a copy.
  32f^                         XOR all characters with 32. This swaps case.
      ]                        Wrap both strings in an array.
       {                 }%    Map; push the string S, then:
        "PSFTD"                    Push that string (T).
               f#                  Compute the index of each character of S in T.
                 :)                Increment each index.
                   5Yer            Replace 5's with 2's.
                       1b          Add the resulting integers.
                                       "FG"  -> [3 0]      -> 3
                                       "TD"  -> [4 2]      -> 6
                                       "XP"  -> [0 1]      -> 1
                                       "XD"  -> [0 2]      -> 2
                                       "S"   -> [2]        -> 2
                                       "FCK" -> [3 0 0]    -> 3
                                       (lowercase letters) -> 0

                               We've now computed the scores of the first (input)
                               and second (swapped case) team.

_$                             Push a copy of the array of scores and sort it.
  (                            Shift out the first (lower) score.
   @                           Rotate the array of scores on top.
    :-                         Reduce it by subtraction.
      g                        Compute the sign (1, 0 or -1) of the difference.
       "ToTOto"2/              Push ["To" "TO" "to"].
                 =             Select the string that corresponds to the sign.
                  \            Swap it with the lower score.
                   ]           Wrap the entire stack in an array.
                    S*         Join the resulting array, separating by spaces.

JavaScript (ES6), 128 130 bytes

Edite 2 bytes salvos aplicando a dica de @ Neil

s=>(l=u=0,s.replace(/fck|s|../gi,x=>(z=+' 231  362'[parseInt(x,36)%10],x>'a'?l+=z:u+=z)),l>u?l+' to '+u:u+(u>l?' TO ':' To ')+l

TESTE

f=s=>(
  l=u=0,
  s.replace(/fck|s|../gi,x=>(
    z=+' 231  362'[parseInt(x,36)%10],
    x>'a'?l+=z:u+=z
  )),
  l>u?l+' to '+u:u+(u>l?' TO ':' To ')+l
)

//TEST
console.log=x=>O.textContent+=x+'\n'

;[
["","0 To 0"],
["TDXPtdxpTDXPtdxpfgtdxpTDXPTDXP", "28 TO 24"],
["FG", "3 TO 0"],
["fg", "3 to 0"],
["TD", "6 TO 0"],
["td", "6 to 0"],
["TDXP", "7 TO 0"],
["tdxp", "7 to 0"],
["TDXD", "8 TO 0"],
["tdxd", "8 to 0"],
["S", "2 TO 0"],
["s", "2 to 0"],
["FCK", "3 TO 0"],
["fck", "3 to 0"],
["TDTDXDSssFCKfgfckFGtd", "22 TO 16"],
["fcksFCKS", "5 To 5"],
["tdtdtdtdxp", "25 to 0"],
["SSSSSSSTD", "20 TO 0"],
["fgSfckFGfgtdxptdxdTDs", "26 to 11"],
["FGTDXPtdxdtdsStdxpfgTDfckTDXDFCK", "29 To 29"]
].forEach(t=>{
  var i=t[0],x=t[1],r=f(i)
  console.log(i+' -> '+r+(r==x?' OK':' FAIL expected '+x))
})

<pre id=O></pre>

JavaScript (ES6), 165 156 151 149 bytes

s=>(a=b=0,s.match(/S|FCK|../gi)||[]).map(m=>(u=m.toUpperCase(),p=u>"XO"?1:u=="TD"?6:u>"R"?2:3,u<m?a+=p:b+=p))&&a>b?a+" to "+b:b+(b>a?" TO ":" To ")+a

9 bytes salvos graças a @ dev-null , 5 graças a @Não Charles e 2 graças a @Neil !

Explicação

var solution =

s=>(
    a=b=0,                // scores for teams A and B
    s.match(/S|FCK|../gi) // get an array of each abbreviation
      ||[]                // if it returns null, default to an empty array
  ).map(m=>(              // for each abbreviation m
    u=m.toUpperCase(),    // u = abbreviation in upper-case
    p=                    // p = number of points for the abbreviation
      u>"XO"?1            // case "XP"
      :u=="TD"?6          // case "TD"
      :u>"R"?2            // case "XD" or "S"
      :3,                 // case "FG" or "FCK"
    u<m?a+=p:b+=p         // add the points to the appropriate team
  ))
  
  // Output the scores
  &&a>b?a+" to "+b
  :b+(b>a?" TO ":" To ")+a

<input type="text" id="input" value="FGTDXPtdxdtdsStdxpfgTDfckTDXDFCK" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

Perl, 144 140 + 2 = 142 bytes

%a=qw(fg 3 td 6 xp 1 xd 2 s 2 fck 3);@a=(0,0);$^=lc,$a[$^eq$_]+=$a{$^}for/fck|s|../gi;$,=$".(To,TO,to)[$a[1]-$a[0]<=>0].$";say sort{$b-$a}@a

Requer a -nbandeira e -E:

$ echo "
TDXPtdxpTDXPtdxpfgtdxpTDXPTDXP
FG
fg
SSSSSSSTD
FGTDXPtdxdtdsStdxpfgTDfckTDXDFCK" | \
perl -nE'%a=qw(fg 3 td 6 xp 1 xd 2 s 2 fck 3);@a=(0,0);$^=lc,$a[$^eq$_]+=$a{$^}for/fck|s|../gi;$,=$".(To,TO,to)[$a[1]-$a[0]<=>0].$";say sort{$b-$a}@a'
0 To 0
28 TO 24 
3 TO 0
3 to 0
20 TO 0
29 To 29

Edit: Esqueceu de apoiar to, Toe TO.

Lua, 231 200 Bytes

Foi muito divertido, mesmo que eu realmente não conheça as regras do futebol americano (temos o Rugby aqui :)). Eu tive que testar muitas coisas para torná-lo o mais curto possível, acho que não há muitas coisas para melhorar, talvez não.

Edit: Eu sou um retardado total. A primeira solução em que trabalhei girou em torno do uso da expansão da matriz, depois a alterei e a matriz que continha as pontuações para a equipe em minúsculas e em maiúsculas não era mais útil. Removê-lo e usar variável simples gera belos -31 bytes.

a={F=3,D=2,T=4,P=1,S=2}l,u=0,0 io.read():gsub(".",function(c)x=a[c:upper()]if a[c]then u=u+a[c]elseif x then l=l+x end end)w=l>u and" to "or l<u and" TO "or" To "print(math.max(l,u)..w..math.min(l,u))

Ungolfed e explicações

a={F=3,D=2,T=4,P=1,S=2}        -- define the table a with our scoring values
l,u=0,0                        -- scores for the upper and lowercase teams
io.read():gsub(".",function(c) -- iterate over each character in the input
  x=a[c:upper()]               -- x contains the score for a lowercase character
  if a[c]                      -- if a contains c (would evaluate to nil otherwise)
  then
    u=u+a[c]                   -- increment the score of the uppercase team
  elseif x                     -- if x isn't nil
  then                         -- same as "a contains c:upper()"
    l=l+x                      -- increment the score of the lowercase team
  end
end)                           -- exit the anonyme function
w=l>u and" to "               -- nested ternary, lower > upper, we will use "to"
    or l<u and" TO "       -- lower < uppercase, use "TO"
    or" To "                   -- else (draw), use "To"
print(math.max(l,u)        -- output the concatenated string using 
      ..b.w..math.min(l,u))-- min/max to put the winner in the first position

Python, 167 bytes

A excelente coruja já passou, mas como ainda não existe uma solução Python:

def f(s):g=lambda s:0if s==""else{68:1,70:3,83:2,84:5,88:1}.get(ord(s[0]),0)+g(s[1:]);a=g(s);b=g(s.upper())-a;return"%i %s %i"%((a,("To","TO")[a>b],b),(b,"to",a))[a<b]

Funciona em Python 2 ou 3.