Mistrzostwa futbolu amerykańskiego, Super Bowl 50 , odbywają się dziś o 23:30 UTC (i można je obejrzeć na żywo w Internecie ). To wyzwanie podjęto, aby je uczcić.

W meczu futbolu amerykańskiego dwie drużyny rywalizują o najwyższą liczbę punktów. Istnieje sześć sposobów na zdobycie tych punktów. Damy każdemu skrót:

• Bramka do gry - FG: 3 punkty
• Przyłożenie - TD: 6 punktów
• Dodatkowy punkt - XP: 1 punkt - Można zdobyć tylko bezpośrednio po przyziemieniu.
• Konwersja dwupunktowa - XD(jak dodatkowy punkt, ale szczęśliwszy): 2 punkty - Można zdobyć tylko bezpośrednio po przyziemieniu.
• Bezpieczeństwo - S: 2 punkty
• Rzut wolny - FCK3 punkty (bardzo rzadka gra)

Napisz program lub funkcję, która pobiera pojedynczy ciąg wiersza zawierający tylko te sześć skrótów, zarówno dużymi, jak i małymi.

Ciąg ten reprezentuje wszystkie zdarzenia punktacji w meczu (lub części meczu) piłki nożnej, przy czym wielkie litery należą do jednej drużyny, a małe litery należą do drugiej.

Twoim zadaniem jest raportowanie końcowych wyników gry i wskazanie, kto wygrał z wydrukiem formularza

[score 1] [to] [score 2]

gdzie:

• [score 1] jest zawsze większy z dwóch wyników (jeśli nie jest równy), niezależnie od tego, czy wygrane zostały wielkie czy małe litery.
• [score 2] jest mniejszym z dwóch wyników (jeśli nie jest równy).
• [to]jest to, TOczy drużyna z wielkimi literami wygrała, toczy drużyna z małymi literami wygrała i Toczy jest remis.

Przykład: Wszystkie zdarzenia punktacji w Super Bowl XLIX można podsumować według ciągu

TDXPtdxpTDXPtdxpfgtdxpTDXPTDXP

gdzie wielkie litery to New England Patriots, a małe litery to Seattle Seahawks . Patrioci zdobyli 28, a Hawks 24, więc wynik byłby następujący:

28 TO 24

Notatki

• Twój program / funkcja musi obsługiwać dowolne dane wejściowe, w tym pusty ciąg znaków.
• XPi XDnastąpi dopiero po TD. xpi xdnastąpi dopiero po td.
• Nie można zakładać, że łańcuch wejściowy zaczyna się lub kończy w określonym przypadku.
• Pojedynczy znak nowej linii jest opcjonalnie dozwolony zarówno na wejściu, jak i na wyjściu

Punktacja

Najkrótszy kod w bajtach wygrywa. Odpowiedzi zamieszczone przed rozpoczęciem ( za późno! ) Super Bowl 50 mogą przewidzieć zwycięską drużynę ( Panthers lub Broncos ), a jeśli są poprawne, uzyskaj premię -10% bajtów!

(Sprawdzę historię zmian, aby upewnić się, że prognozy się nie zmieniły i naprawdę zostały dokonane przed rozpoczęciem).

Przypadki testowe

[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 bajtów (37,8 bajtów z premią)

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

Dzięki @Maltysen za pomoc w oszczędzaniu 4 bajtów!

Wypróbuj w kompilatorze Pyth .

Lubię obejmować wszystkie bazy, więc postawię na Broncos.

Jak to działa

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 to rodzina funkcji działających na łańcuchach.

• Jeśli pierwszy wynik w J(odpowiadające zamienione przypadku z, czyli oryginalne małe litery) jest niższy niż drugi wynik, funkcja znak powróci -1, (-1 + 1) ^ 2 == 2i r" to "2to swapcasetak, że wraca " TO ".

• Jeśli pierwszy wynik jest wyższy niż drugi wynik, funkcja znaku wróci 1, (1 + 1) ^ 2 == 0i tak r" to "0jest lowercase, więc zwraca " to ".

• Jeśli wyniki są równe, funkcja znak wróci 0, (0 + 1) ^ 2 == 3i r" to "3jest title, więc zwraca " To ".

MATL , 51 * 0,9 = 45,9 54 57 58 63 bajtów

Dzięki Dennis za usunięcie 3 bajtów!

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

Pusty ciąg wejściowy jest reprezentowany w kompilatorze online jako pojedynczy znak nowej linii.

EDYCJA (8 czerwca 2016 r.): Poniższy link zawiera modyfikację zgodnie z wersją 18.1.0 języka (najpierw przenieś go 3tuż przed Xc)

Wypróbuj online!

Stawiam na Broncos.

Wyjaśnienie

Wyniki są wykrywane za pomocą pojedynczej litery, wielkiej lub małej (duże litery pokazano poniżej):

• P za XP (1 punkt)
• D dla XD (2 punkty)
• F dla FG (3 punkty) i dla FCK (3 punkty)
• T dla TD (6 punktów)
• S dla S (2 punkty)

Każda z tych pięciu liter odpowiada jednoznacznie zdarzeniu punktowemu, z wyjątkiem tego

• Fjest ponownie używane dla FGi FCK, które mają ten sam wynik. Dzięki @Dennis za to !
• Dwykryje zarówno TD, jak i XD. TZostaną więc przypisane 4 punkty zamiast 6, aby to zrekompensować.

Porządkowanie PDFTSpozwala zaoszczędzić kilka bajtów podczas definiowania tablicy liczb określającej punkty:[1,2,3,4,2] .

Każde zdarzenie jest wykrywane przez obecność jednej z powyższych liter wielkimi lub małymi literami. Porównanie odbywa się w trzech wymiarach: długość ciągu wejściowego ( N ) × liczba drużyn (2) × liczba wykrytych zdarzeń wynikowych (5). Szeroko wykorzystuje się rozgłaszanie , które jest automatycznym rozszerzaniem tablicy wzdłuż wymiaru singletonu, aby dopasować ją do wielkości większej tablicy.

'%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 bajtów

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

Wypróbuj online!

Nie mam pojęcia, czym jest Bronco, więc postawię na Pantery.

Jak to działa

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 bajtów

Edytuj 2 bajty zapisane, stosując wskazówkę @ Neila

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 bajtów

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 bajtów zapisanych dzięki @ dev-null , 5 dzięki @Nie że Charles i 2 dzięki @Neil !

Wyjaśnienie

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 bajty

%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

Wymaga -n flagi i -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: Zapomniałem wsparcie to, Toa TO.

Lua, 231 200 bajtów

To była świetna zabawa, nawet jeśli tak naprawdę nie znam zasad futbolu amerykańskiego (mamy tutaj Rugby :)). Musiałem przetestować wiele rzeczy, aby były tak krótkie, jak to możliwe, nie sądzę, że jest wiele rzeczy do poprawy, może nie jest.

Edycja: Jestem całkowicie opóźniony. Pierwsze rozwiązanie, nad którym pracowałem, dotyczyło rozszerzenia tablicy, a następnie zmieniłem je, a tablica zawierająca wyniki zarówno dla małych, jak i wielkich zespołów nie była już użyteczna. Usunięcie go i użycie zwykłej zmiennej tworzy piękne -31 bajtów.

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

Bez golfa i wyjaśnienia

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 bajtów

Wspaniała sowa już dawno minęła, ale ponieważ nie ma jeszcze rozwiązania w języku 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]

Działa w Python 2 lub 3.