美国足球锦标赛，超级碗50，今天晚上11:30发生UTC（你可以观看在线直播）。挑战是为了庆祝它。

在美式足球比赛中，两支球队竞争以获取最高分，并且有六种方法来得分。我们将给每个缩写：

• 射门得分 - FG：3分
• 触地得分 - TD：6分
• 加分 - XP：1分-只能在达阵后直接得分。
• 两点转换 - XD（就像加分，但更快乐）：2分-只能在触地得分后直接得分。
• 安全 - S：2分
• 公平接球 - FCK：3分（非常罕见的比赛）

编写一个仅包含大写和小写这六个缩写的单行字符串的程序或函数。

该字符串表示足球比赛（或比赛的一部分）中的所有得分事件，其中大写字母属于一个团队，小写字母属于另一个团队。

您的工作是报告游戏的最终成绩，并指出谁赢得了表格输出

[score 1] [to] [score 2]

哪里：

• [score 1] 始终是两个分数中较大的一个（如果不相等），无论大写还是小写获胜。
• [score 2] 是两个分数中较小的一个（如果不相等）。
• [to]是TO大写团队获胜，to小写团队获胜，还是To平局。

例如：将所有得分事件在第四十九届超级杯 可以用字符串来概括

TDXPtdxpTDXPtdxpfgtdxpTDXPTDXP

大写字母是新英格兰爱国者，小写字母是 Seattle Seahawks。爱国者队得分28，老鹰队得分24，因此输出为：

28 TO 24

笔记

• 您的程序/函数必须支持任意输入，包括空字符串。
• XP并且XD只会在之后发生TD。xp并且xd只会在之后发生td。
• 在某些情况下，您可能不会假设输入字符串开始或结束。
• 输入和输出中都可选地允许尾随换行符

计分

以字节为单位的最短代码获胜。在超级碗50 揭幕战之前发布的答案（为时已晚！）可以预测获胜的球队（豹队或野马队），如果正确，则可获得-10％字节的奖金！

（我将检查修订历史记录，以确保预测没有改变，并且确实是在启动之前做出的。）

测试用例

[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字节（37.8字节，带奖金）

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

感谢@Maltysen帮助我节省了4个字节！

在Pyth编译器中尝试一下。

我喜欢覆盖所有基地，所以我敢打赌野马队。

怎么运行的

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是对字符串进行操作的函数系列。

• 如果in中的第一个分数J（对应于交换的大小写z，即原始的小写字母）低于第二个分数，则sign函数将返回-1，(-1 + 1) ^ 2 == 2并且r" to "2为swapcase，因此返回" TO "。

• 如果第一个得分比第二得分越高，征函数将返回1，(1 + 1) ^ 2 == 0而r" to "0为lowercase，因此它返回" to "。

• 如果分数相等，符号函数将返回0，(0 + 1) ^ 2 == 3而r" to "3为title，因此它返回" To "。

MATL，51 * 0.9 = 45.9 54 57 58 63字节

感谢Dennis删除了3个字节！

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

空的输入字符串在联机编译器中表示为单个换行符。

编辑（2016年6月8日）：下面的链接包括修改按语言的版本18.1.0（第一移动他3右前Xc）

在线尝试！

我打赌野马队。

说明

使用单个字母（大写或小写）检测分数（大写如下所示）：

• P XP（1分）
• D XD（2分）
• F FG（3分）和FCK（3分）
• T 对于TD（6分）
• S 对于S（2分）

这五个字母中的每个字母都唯一对应于一个得分事件，除了

• F被重新用于FG和FCK，它们的得分相同。感谢@Dennis！
• D将同时检测TD和XD。因此T将分配4点而不是6点进行补偿。

PDFTS在定义指定点的数字数组时，排序节省了一些字节：[1,2,3,4,2]。

通过以上字母之一的大写或小写来检测每个事件。比较从三个维度进行：输入字符串长度（N）×团队数（2）×检测到的得分事件数（5）。广播已得到广泛使用，广播是沿单例维度自动扩展数组以匹配较大数组的大小。

'%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字节

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

在线尝试！

我不知道什么是野马，所以我押注黑豹。

怎么运行的

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字节

编辑使用@Neil的技巧保存的2个字节

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

测试

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字节

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

@ dev-null节省了9个字节，@ Not that Charles节省了 5 个字节，@ Neil节省了 2个字节！

说明

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，144140 + 2 = 142字节

%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标志和-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

编辑：忘记支持to，To并且TO。

Lua，231 200字节

即使我不太了解美式橄榄球的规则，这也很有趣（我们在这里有橄榄球）。我必须测试很多事情以使其尽可能短，我认为没有很多事情可以改进，也许没有。

编辑：我是一个总智障。我研究的第一个解决方案是使用数组扩展，然后我对其进行了更改，并且包含小写和大写团队得分的数组不再有用。删除它并使用简单变量将产生-31个字节。

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

脱节和解释

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个字节

出色的猫头鹰已经很久了，但是由于还没有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]

适用于Python 2或3。