El campeonato de fútbol americano, Super Bowl 50 , se lleva a cabo hoy a las 11:30 pm UTC (y puedes verlo en vivo en línea ). Este desafío fue hecho para celebrarlo.

En un juego de fútbol americano, dos equipos compiten para obtener la mayor cantidad de puntos y hay seis formas de anotar estos puntos. Le daremos a cada uno una abreviatura:

• Gol de campo - FG: 3 puntos
• Touchdown - TD: 6 puntos
• Punto extra - XP: 1 punto - Sólo se puede conseguir directamente después de una toma de contacto.
• Conversión de dos puntos : XD(como un punto extra pero más feliz): 2 puntos: solo se puede puntuar directamente después de un touchdown.
• Seguridad - S: 2 puntos
• Feria saque de captura - FCK: 3 puntos (un juego muy raro)

Escriba un programa o función que tome una sola cadena de línea que contenga solo estas seis abreviaturas, tanto en mayúsculas como en minúsculas.

Esta cadena representa todos los eventos de puntuación en un juego (o parte de un juego) de fútbol, ​​con los términos en mayúsculas pertenecientes a un equipo y las minúsculas pertenecientes al otro.

Su trabajo es informar los puntajes finales del juego e indicar quién ganó con la salida del formulario

[score 1] [to] [score 2]

dónde:

• [score 1] es siempre el mayor de los dos puntajes (si no es igual), independientemente de si ganó mayúscula o minúscula.
• [score 2] es la menor de las dos puntuaciones (si no es igual).
• [to]es TOsi ganó el equipo en mayúsculas, tosi ganó el equipo en minúsculas y Tosi es un empate.

Ejemplo: todos los eventos de puntuación en el Super Bowl XLIX podrían resumirse por la cadena

TDXPtdxpTDXPtdxpfgtdxpTDXPTDXP

donde mayúsculas son los New England Patriots y minúsculas los Seattle Seahawks . Los Patriots anotaron 28 y los Hawks 24, por lo que el resultado sería:

28 TO 24

Notas

• Su programa / función debe admitir cualquier entrada arbitraria, incluida la cadena vacía.
• XPy XDsolo ocurrirá justo después TD. xpy xdsolo ocurrirá justo después td.
• No puede suponer que la cadena de entrada comienza o termina en un caso determinado.
• Opcionalmente se permite una nueva línea final tanto en la entrada como en la salida

Puntuación

El código más corto en bytes gana. Las respuestas que se publican antes del inicio (¡ demasiado tarde ahora! ) Del Super Bowl 50 pueden predecir el equipo ganador (ya sea Panthers o Broncos ), y si son correctas, ¡obtenga un bono de -10%!

(Comprobaré el historial de revisiones para asegurarme de que las predicciones no hayan cambiado y que realmente se hayan realizado antes del inicio).

Casos de prueba

[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

Pyth, 49 46 43 42 bytes (37.8 bytes con bonificación)

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

¡Gracias a @Maltysen por ayudarme a ahorrar 4 bytes!

Pruébalo en el compilador Pyth .

Me gusta cubrir todas las bases, así que apostaré por los Broncos.

Cómo 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 es una familia de funciones que funcionan en cadenas.

• Si la primera puntuación en J(correspondiente a mayúsculas zy minúsculas , es decir, las letras minúsculas originales) es inferior a la segunda puntuación, la función de signo volverá -1, (-1 + 1) ^ 2 == 2y r" to "2es swapcase, así que vuelve " TO ".

• Si el primer puntaje es más alto que el segundo, la función de signo regresará 1, (1 + 1) ^ 2 == 0y r" to "0es lowercase, entonces regresa " to ".

• Si los puntajes son iguales, la función de signo regresará 0, (0 + 1) ^ 2 == 3y r" to "3es title, entonces regresa " To ".

MATL , 51 * 0.9 = 45.9 54 57 58 63 bytes

¡Gracias a Dennis por eliminar 3 bytes!

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

Una cadena de entrada vacía se representa en el compilador en línea como un único carácter de nueva línea.

EDITAR (8 de junio de 2016): el siguiente enlace incluye una modificación según la versión 18.1.0 del idioma (mover primero 3 derecha antes Xc)

Pruébalo en línea!

Apuesto a los Broncos.

Explicación

Los puntajes se detectan usando una sola letra, ya sea mayúscula o minúscula (en mayúscula se muestra a continuación):

• P para XP (1 punto)
• D para XD (2 puntos)
• F para FG (3 puntos) y para FCK (3 puntos)
• T para TD (6 puntos)
• S para S (2 puntos)

Cada una de estas cinco letras corresponde únicamente a un evento de puntuación, excepto que

• Fse reutiliza para FGy FCK, que tienen la misma puntuación. ¡Gracias a @Dennis por esto !
• Ddetectará tanto TD como XD. Entonces Tse le asignarán 4 puntos en lugar de 6 para compensar.

El pedido PDFTS , ahorra unos cuantos bytes en la definición de la matriz número que especifica los puntos: [1,2,3,4,2].

Cada evento se detecta por la presencia de una de las letras anteriores en mayúsculas o minúsculas. La comparación se realiza en tres dimensiones: longitud de la cadena de entrada ( N ) × número de equipos (2) × número de eventos de puntuación detectados (5). Se hace un uso extensivo de la transmisión , que es la expansión automática de una matriz a lo largo de una dimensión singleton para que coincida con el tamaño de una matriz más grande.

'%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*

Pruébalo en línea!

No tengo idea de qué es un Bronco, así que apostaré por los Panthers.

Cómo 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 guardados aplicando la sugerencia 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

PRUEBA

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 guardados gracias a @ dev-null , 5 gracias a @Not que Charles y 2 gracias a @Neil !

Explicación

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

Requiere la -nbandera y -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

Editar: Olvidé apoyar to, Toy TO.

Lua, 231 200 bytes

Fue muy divertido, incluso si realmente no conozco las reglas del fútbol americano (Tenemos Rugby aquí :)). Tuve que probar muchas cosas para hacerlo lo más corto posible, no creo que haya muchas cosas que mejorar, tal vez no.

Editar: Soy un retardado total. La primera solución en la que trabajé giraba en torno al uso de la expansión de la matriz, luego la cambié y la matriz que contenía los puntajes para el equipo en minúsculas y mayúsculas ya no era útil. Eliminarlo y usar una variable simple hace que sea hermoso -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))

Sin golfos y explicaciones

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

El búho excelente ya pasó hace mucho tiempo, pero como todavía no hay una solución de 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 en Python 2 o 3.