Le championnat de football américain, Super Bowl 50 , se déroule aujourd'hui à 23h30 UTC (et vous pouvez le regarder en direct en ligne ). Ce défi a été fait pour le célébrer.

Dans un match de football américain, deux équipes s'affrontent pour obtenir le plus de points et il y a six façons de marquer ces points. Nous donnerons à chacun une abréviation:

• Objectif de terrain - FG: 3 points
• Touchdown - TD: 6 points
• Point supplémentaire - XP: 1 point - Ne peut être marqué directement qu'après un touché.
• Conversion en deux points - XD(comme un point supplémentaire mais plus heureux): 2 points - Ne peut être marqué directement qu'après un touché.
• Sécurité - S: 2 points
• Coup de pied arrêt de volée - FCK: 3 points (un jeu très rare)

Écrivez un programme ou une fonction qui accepte une chaîne d'une seule ligne contenant uniquement ces six abréviations, en majuscules et en minuscules.

Cette chaîne représente tous les événements de notation dans un match (ou une partie d'un match) de football, les termes en majuscules appartenant à une équipe et les minuscules à l'autre.

Votre travail consiste à rapporter les scores finaux du jeu et à indiquer qui a gagné avec la sortie du formulaire

[score 1] [to] [score 2]

où:

• [score 1] est toujours le plus élevé des deux scores (s'il n'est pas égal), que les majuscules ou les minuscules l'emportent.
• [score 2] est le plus petit des deux scores (s'il n'est pas égal).
• [to]c'est TOsi l'équipe en majuscules a gagné, tosi l'équipe en minuscules a gagné et Tosi c'est une égalité.

Exemple: tous les événements de notation dans le Super Bowl XLIX peuvent être résumés par la chaîne

TDXPtdxpTDXPtdxpfgtdxpTDXPTDXP

où les majuscules sont les New England Patriots et les minuscules les Seattle Seahawks . Les Patriots ont marqué 28 et les Hawks 24, donc la sortie serait:

28 TO 24

Remarques

• Votre programme / fonction doit prendre en charge toute entrée arbitraire, y compris la chaîne vide.
• XPet XDne se produira que juste après TD. xpet xdne se produira que juste après td.
• Vous ne pouvez pas supposer que la chaîne d'entrée commence ou se termine dans un certain cas.
• Une seule nouvelle ligne de fin est éventuellement autorisée à la fois en entrée et en sortie

Notation

Le code le plus court en octets gagne. Les réponses publiées avant le coup d'envoi ( trop tard maintenant! ) Du Super Bowl 50 peuvent prédire l'équipe gagnante ( Panthers ou Broncos ), et si elles sont correctes, obtenez un bonus de -10%!

(Je vérifierai l'historique des révisions pour m'assurer que les prédictions n'ont pas changé et ont vraiment été faites avant le coup d'envoi.)

Cas de 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 octets (37,8 octets avec bonus)

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

Merci à @Maltysen de m'avoir aidé à économiser 4 octets!

Essayez-le dans le compilateur Pyth .

J'aime couvrir toutes les bases, donc je parie sur les Broncos.

Comment ça fonctionne

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 est une famille de fonctions qui opèrent sur des chaînes.

• Si le premier score de J(correspondant au cas échangé z, c'est-à-dire les lettres minuscules d'origine) est inférieur au deuxième score, la fonction de signe reviendra -1, (-1 + 1) ^ 2 == 2et l' r" to "2est swapcase, donc elle revient " TO ".

• Si le premier score est supérieur au deuxième score, la fonction signe reviendra 1, (1 + 1) ^ 2 == 0et l' r" to "0est lowercase, donc elle revient " to ".

• Si les scores sont égaux, la fonction signe reviendra 0, (0 + 1) ^ 2 == 3et l' r" to "3est title, donc elle revient " To ".

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

Merci à Dennis d'avoir supprimé 3 octets!

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

Une chaîne d'entrée vide est représentée dans le compilateur en ligne comme un seul caractère de nouvelle ligne.

EDIT (8 juin 2016): Le lien ci-dessous inclut une modification selon la version 18.1.0 de la langue (déplacez-le d'abord à 3droite avant Xc)

Essayez-le en ligne!

Je parie sur les Broncos.

Explication

Les scores sont détectés à l'aide d'une seule lettre, en majuscule ou en minuscule (en majuscule est indiqué ci-dessous):

• P pour XP (1 point)
• D pour XD (2 points)
• F pour FG (3 points) et pour FCK (3 points)
• T pour TD (6 points)
• S pour S (2 points)

Chacune de ces cinq lettres correspond uniquement à un événement de partition, sauf que

• Fest réutilisé pour FGet FCKqui ont le même score. Merci à @Dennis pour cela !
• Ddétectera à la fois TD et XD. Ainsi Tseront attribués 4 points au lieu de 6 pour compenser.

La commande PDFTS, permet d' économiser quelques octets lors de la définition du tableau de nombres qui spécifie les points: [1,2,3,4,2].

Chaque événement est détecté par la présence d'une des lettres ci-dessus en majuscule ou en minuscule. La comparaison se fait en trois dimensions: longueur de chaîne d'entrée ( N ) × nombre d'équipes (2) × nombre d'événements de score détectés (5). La diffusion est largement utilisée , c'est-à-dire l'expansion automatique d'un tableau le long d'une dimension singleton pour correspondre à la taille d'un tableau plus grand.

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

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

Essayez-le en ligne!

Je n'ai aucune idée de ce qu'est un Bronco, alors je parie sur les Panthers.

Comment ça fonctionne

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 octets

Modifier 2 octets enregistrés en appliquant le conseil 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

TESTER

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 octets

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 octets économisés grâce à @ dev-null , 5 grâce à @Not that Charles et 2 grâce à @Neil !

Explication

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 octets

%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

Nécessite le -n drapeau et -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

Modifier: oublié de prendre en charge to, Toet TO.

Lua, 231 200 octets

C'était très amusant, même si je ne connais pas vraiment les règles du football américain (nous avons le rugby ici :)). J'ai dû tester beaucoup de choses pour que ce soit aussi court que possible, je ne pense pas qu'il y ait beaucoup de choses à améliorer, peut-être pas.

Edit: je suis un retard total. La première solution sur laquelle j'ai travaillé tournait autour de l'utilisation de l'extension de tableau, puis je l'ai modifiée et le tableau contenant les scores pour l'équipe en minuscules et en majuscules n'était plus utile. Le supprimer et utiliser une variable simple fait un beau -31 octets.

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

Non golfé et explications

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 octets

La superbe chouette est révolue depuis longtemps, mais puisqu'il n'y a pas encore de solution 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]

Fonctionne en Python 2 ou 3.