Il campionato di football americano, Super Bowl 50 , si svolge oggi alle 23:30 UTC (e puoi vederlo dal vivo online ). Questa sfida è stata fatta per celebrarla.

In una partita di football americano, due squadre competono per ottenere il maggior numero di punti e ci sono sei modi per segnare questi punti. Daremo a ciascuno un'abbreviazione:

• Field goal - FG: 3 punti
• Touchdown - TD: 6 punti
• Punto extra - XP: 1 punto - Può essere segnato solo dopo un touchdown.
• Conversione in due punti - XD(come un punto in più ma più felice): 2 punti - Può essere segnato solo dopo un touchdown.
• Sicurezza - S: 2 punti
• Fair catch calcio - FCK: 3 punti (un gioco molto raro)

Scrivi un programma o una funzione che accetta una stringa a riga singola contenente solo queste sei abbreviazioni, sia in maiuscolo che in minuscolo.

Questa stringa rappresenta tutti gli eventi di punteggio in una partita (o parte di una partita) del calcio, con i termini maiuscoli appartenenti a una squadra e quelli minuscoli appartenenti all'altra.

Il tuo compito è quello di riportare i punteggi finali del gioco e indicare chi ha vinto con l'output del modulo

[score 1] [to] [score 2]

dove:

• [score 1] è sempre il più grande dei due punteggi (se non uguale), indipendentemente dal fatto che sia maiuscolo o minuscolo vinto.
• [score 2] è il più piccolo dei due punteggi (se non uguale).
• [to]è TOse la squadra maiuscola ha vinto, tose la squadra minuscola ha vinto e Tose è un pareggio.

Esempio: tutti gli eventi di punteggio in Super Bowl XLIX potrebbero essere riassunti dalla stringa

TDXPtdxpTDXPtdxpfgtdxpTDXPTDXP

dove i caratteri maiuscoli sono i New England Patriots e i caratteri minuscoli sono i Seattle Seahawks . I Patriots hanno segnato 28 e gli Hawks 24, quindi l'output sarebbe:

28 TO 24

Appunti

• Il tuo programma / funzione deve supportare qualsiasi input arbitrario, inclusa la stringa vuota.
• XPe XDsi verificherà solo dopo TD. xpe xdsi verificherà solo dopo td.
• Non si può presumere che la stringa di input inizi o termini in un determinato caso.
• Una sola nuova riga finale è facoltativamente consentita sia in input che in output

punteggio

Vince il codice più breve in byte. Le risposte postate prima del calcio d'inizio ( troppo tardi ora! ) Del Super Bowl 50 possono prevedere la squadra vincente ( Panthers o Broncos ) e, se sono corrette, ottenere un bonus di byte del -10%!

(Verificherò la cronologia delle revisioni per assicurarmi che le previsioni non siano cambiate e siano state realmente fatte prima del calcio d'inizio.)

Casi test

[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 byte (37,8 byte con bonus)

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

Grazie a @Maltysen per avermi aiutato a salvare 4 byte!

Provalo nel compilatore Pyth .

Mi piace coprire tutte le basi, quindi scommetto sui Broncos.

Come funziona

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 è una famiglia di funzioni che operano su stringhe.

• Se il primo punteggio in J(corrispondente al caso scambiato z, ovvero le lettere minuscole originali) è inferiore al secondo punteggio, la funzione segno tornerà -1, (-1 + 1) ^ 2 == 2ed r" to "2è swapcase, quindi ritorna " TO ".

• Se il primo punteggio è superiore al secondo, la funzione del segno tornerà 1, (1 + 1) ^ 2 == 0ed r" to "0è lowercase, quindi ritorna " to ".

• Se i punteggi sono uguali, la funzione del segno tornerà 0, (0 + 1) ^ 2 == 3ed r" to "3è title, quindi ritorna " To ".

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

Grazie a Dennis per aver rimosso 3 byte!

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

Una stringa di input vuota è rappresentata nel compilatore online come un singolo carattere di nuova riga.

MODIFICA (8 giugno 2016): il link seguente include una modifica come da versione 18.1.0 della lingua (spostati prima 3prima Xc)

Provalo online!

Scommetto sui Broncos.

Spiegazione

I punteggi vengono rilevati utilizzando una singola lettera, maiuscola o minuscola (le lettere maiuscole sono mostrate di seguito):

• P per XP (1 punto)
• D per XD (2 punti)
• F per FG (3 punti) e per FCK (3 punti)
• T per TD (6 punti)
• S per S (2 punti)

Ognuna di queste cinque lettere corrisponde in modo univoco a un evento punteggio tranne quello

• Fviene riutilizzato per FGe FCK, che hanno lo stesso punteggio. Grazie a @Dennis per questo !
• Drileverà sia TD che XD. Quindi Tverranno assegnati 4 punti invece di 6 per compensare.

L'ordinamento PDFTS, salva alcuni byte nella definizione della matrice numero che specifica i punti: [1,2,3,4,2].

Ogni evento viene rilevato dalla presenza di una delle lettere sopra in maiuscolo o minuscolo. Il confronto viene effettuato in tre dimensioni: lunghezza stringa di input ( N ) × numero di team (2) × numero di eventi di punteggio rilevati (5). Viene ampiamente utilizzato il broadcasting , che è l'espansione automatica di un array lungo una dimensione singleton per adattarsi alla dimensione di un array più 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 byte

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

Provalo online!

Non ho idea di cosa sia un Bronco, quindi scommetterò sulle Pantere.

Come funziona

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 byte

Modifica 2 byte salvati applicando il suggerimento di @ 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

TEST

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 byte

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 byte salvati grazie a @ dev-null , 5 grazie a @Non che Charles e 2 grazie a @Neil !

Spiegazione

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 byte

%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

Richiede la -nbandiera 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: Ho dimenticato di supporto to, Toe TO.

Lua, 231 200 byte

È stato molto divertente, anche se non conosco davvero le regole del football americano (qui abbiamo il rugby :)). Ho dovuto testare molte cose per renderlo il più breve possibile, non credo che ci siano molte cose da migliorare, forse no.

Modifica: sono un ritardo totale. La prima soluzione su cui ho lavorato ruotava attorno all'espansione dell'array, quindi l'ho cambiata e l'array contenente i punteggi sia per la squadra minuscola che per quella maiuscola non era più utile. Rimuovendolo e usando la semplice variabile si ottiene un bellissimo -31 byte.

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 spiegazioni

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 byte

Il superbo gufo è passato molto tempo, ma poiché non esiste ancora una soluzione 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]

Funziona in Python 2 o 3.