Die amerikanische Fußballmeisterschaft Super Bowl 50 findet heute um 23:30 Uhr UTC statt (und Sie können sie live online verfolgen ). Diese Herausforderung wurde gemacht, um sie zu feiern.

In einem American-Football-Spiel kämpfen zwei Teams um die meisten Punkte, und es gibt sechs Möglichkeiten, diese Punkte zu erzielen . Wir geben jedem eine Abkürzung:

• Field Goal - FG: 3 Punkte
• Touchdown - TD: 6 Punkte
• Extra Punkt - XP: 1 Punkt - Kann nur direkt nach einem Touchdown erzielt werden.
• Zwei-Punkte-Umwandlung - XD(wie ein zusätzlicher Punkt, aber glücklicher): 2 Punkte - Kann nur direkt nach einem Aufsetzen erzielt werden.
• Sicherheit - S: 2 Punkte
• Fair Catch Kick - FCK: 3 Punkte (ein sehr seltenes Spiel)

Schreiben Sie ein Programm oder eine Funktion, die eine einzelne Zeichenfolge mit nur diesen sechs Abkürzungen in Groß- und Kleinbuchstaben enthält.

Diese Zeichenfolge repräsentiert alle Bewertungsereignisse in einem Spiel (oder einem Teil eines Spiels) des Fußballs, wobei die Großbuchstaben einer Mannschaft und die Kleinbuchstaben der anderen Mannschaft zugeordnet sind.

Ihre Aufgabe ist es, die Endergebnisse des Spiels zu melden und anzugeben, wer mit der Ausgabe des Formulars gewonnen hat

[score 1] [to] [score 2]

wo:

• [score 1] ist immer die größere der beiden Punktzahlen (falls nicht gleich), unabhängig davon, ob Groß- oder Kleinschreibung gewonnen wurde.
• [score 2] ist der kleinere der beiden Werte (falls nicht gleich).
• [to]Es ist, TOwenn das Großbuchstaben-Team gewonnen hat, towenn das Kleinbuchstaben-Team gewonnen hat und Towenn es ein Unentschieden ist.

Beispiel: Alle Bewertungsereignisse in Super Bowl XLIX können durch die Zeichenfolge zusammengefasst werden

TDXPtdxpTDXPtdxpfgtdxpTDXPTDXP

Großbuchstaben sind die New England Patriots und Kleinbuchstaben sind die Seattle Seahawks . Die Patrioten erzielten 28 und die Hawks 24 Punkte, die Ausgabe wäre also:

28 TO 24

Anmerkungen

• Ihr Programm / Ihre Funktion muss beliebige Eingaben unterstützen, einschließlich der leeren Zeichenfolge.
• XPund XDwird erst unmittelbar danach auftreten TD. xpund xdwird erst unmittelbar danach auftreten td.
• Sie können nicht davon ausgehen, dass die Eingabezeichenfolge in einem bestimmten Fall beginnt oder endet.
• Optional ist sowohl in der Eingabe als auch in der Ausgabe eine einzelne nachgestellte Zeile zulässig

Wertung

Der kürzeste Code in Bytes gewinnt. Antworten, die vor dem Anpfiff ( jetzt zu spät! ) Des Super Bowl 50 veröffentlicht werden, können das Gewinnerteam (entweder Panthers oder Broncos) vorhersagen ) Wenn sie korrekt sind, erhalten Sie einen 10% -Byte-Bonus!

(Ich werde den Revisionsverlauf überprüfen, um sicherzustellen, dass sich die Vorhersagen nicht geändert haben und wirklich vor dem Anpfiff gemacht wurden.)

Testfälle

[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 mit Bonus)

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

Vielen Dank an @Maltysen, der mir geholfen hat, 4 Bytes zu sparen!

Probieren Sie es im Pyth-Compiler aus .

Ich mag es, alle Basen abzudecken, also wette ich auf die Broncos.

Wie es funktioniert

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 ist eine Familie von Funktionen, die mit Strings arbeiten.

• Wenn die erste Kerbe in J(zu vertauscht Fall entspricht z, das heißt, die ursprünglichen Kleinbuchstaben) niedriger ist als die zweite Kerbe, wird die Vorzeichenfunktion zurück -1, (-1 + 1) ^ 2 == 2und r" to "2istswapcase , so dass er zurückkehrt " TO ".

• Wenn die erste Punktzahl höher als die zweite Punktzahl ist, wird das Zeichen Funktion zurückkehren 1, (1 + 1) ^ 2 == 0und r" to "0ist lowercase, so gibt es " to ".

• Wenn die Punktzahlen gleich sind, wird die Vorzeichenfunktion zurückgegeben 0, (0 + 1) ^ 2 == 3und r" to "3ist titledies auch " To ".

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

Danke an Dennis für das Entfernen von 3 Bytes!

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

Eine leere Eingabezeichenfolge wird im Online-Compiler als einzelnes Zeilenumbruchzeichen dargestellt.

BEARBEITEN (8. Juni 2016): Der unten stehende Link enthält eine Änderung gemäß Release 18.1.0 der Sprache (zuerst 3rechts vor verschieben Xc).

Probieren Sie es online!

Ich wette auf die Broncos.

Erläuterung

Die Ergebnisse werden anhand eines einzelnen Buchstabens in Groß- oder Kleinbuchstaben ermittelt (Großbuchstaben werden im Folgenden angezeigt):

• P für XP (1 Punkt)
• D für XD (2 Punkte)
• F für FG (3 Punkte) und für FCK (3 Punkte)
• T für TD (6 Punkte)
• S für S (2 Punkte)

Jeder dieser fünf Buchstaben entspricht in einzigartiger Weise einem Bewertungsereignis

• Fwird für FGund wiederverwendet FCK, die die gleiche Punktzahl haben. Vielen Dank an @Dennis dafür !
• Derkennt sowohl TD als auch XD. So Twerden zum Ausgleich 4 statt 6 Punkte vergeben.

Die Reihenfolge PDFTSspart ein paar Bytes bei der Definition des Zahlenarrays, das die Punkte angibt:[1,2,3,4,2] .

Jedes Ereignis wird durch das Vorhandensein eines der obigen Buchstaben in Groß- oder Kleinbuchstaben erkannt. Der Vergleich erfolgt in drei Dimensionen: Länge der eingegebenen Zeichenfolge ( N ) × Anzahl der Teams (2) × Anzahl der erkannten Punkteereignisse (5). Broadcasting wird in großem Umfang verwendet. Dabei handelt es sich um die automatische Erweiterung eines Arrays entlang einer Singleton-Dimension, um der Größe eines größeren Arrays zu entsprechen.

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

Probieren Sie es online!

Ich habe keine Ahnung, was ein Bronco ist, also wette ich auf die Panther.

Wie es funktioniert

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

Bearbeiten Sie 2 Bytes, die mit @ Neils Tipp gespeichert wurden

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

PRÜFUNG

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 Bytes gespart dank @ dev-null , 5 dank @Not that Charles und 2 dank @Neil !

Erläuterung

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

Benötigt die -nFlagge und -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

Bearbeiten: Support vergessen to, Tound TO.

Lua, 231 200 Bytes

Es hat sehr viel Spaß gemacht, auch wenn ich die Regeln des American Football nicht wirklich kenne (wir haben Rugby hier :)). Ich musste viele Dinge testen, um es so kurz wie möglich zu halten. Ich glaube nicht, dass es viele Dinge gibt, die verbessert werden müssen. Vielleicht gibt es keine.

Edit: Ich bin total zurückgeblieben. Die erste Lösung, an der ich gearbeitet habe, drehte sich um die Verwendung der Array-Erweiterung. Dann habe ich sie geändert und das Array mit den Punktzahlen für das Klein- und das Großschreibungsteam war nicht mehr nützlich. Das Entfernen und Verwenden einer einfachen Variablen ergibt schöne -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 und Erklärungen

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

Die großartige Eule ist lange vorbei, aber da es noch keine Python-Lösung gibt:

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]

Funktioniert in Python 2 oder 3.