创建世界杯猜谜程序

13

如您所知，世界杯小组赛阶段已经结束，从明天开始，最好的16支球队将开始淘汰赛阶段：

  • 巴西（BRA）
  • 墨西哥（MEX）
  • 荷兰（NED）
  • 智利（CHI）
  • 哥伦比亚（COL）
  • 希腊（GRE）
  • 哥斯达黎加（CRC）
  • 乌拉圭（URU）
  • 法国（FRA）
  • 瑞士（SUI）
  • 阿根廷（ARG）
  • 尼日利亚（NGA）
  • 德国（GER）
  • 美国（美国）
  • 比利时（BEL）
  • 阿尔及利亚（ALG）

在淘汰赛阶段，每场比赛的获胜者进入下一轮，失败者回家（没有平局）。单击此处查看有关淘汰赛阶段的更多信息。

您已被新的博彩网站golfbet.com录用，因为您擅长编程和体育博彩。您的任务是编写一个可以猜出比赛获胜者的程序或函数。当然，每个人都会做出不同的猜测，只要您的猜测是一致的，都没关系。

如果您不想猜测，可以使用以下猜测：

BRA
        BRA
CHI
                BRA
COL
        COL
URU
                        GER
FRA
        FRA
NGA
                GER
GER
        GER
ALG
                                        GER
NED
        NED
MEX
                NED
CRC
        CRC
GRE
                        ARG
ARG
        ARG
SUI
                ARG
BEL
        BEL
USA
  1. 程序必须输出相同的获胜者，而与团队的顺序无关（BRA-CHI比赛的获胜者必须与CHI-BRA比赛的获胜者相同）
  2. 如果一支球队输了，那就不能再参加比赛了。这意味着对于未进行的比赛，您必须指明。例如，如果您的程序猜测巴西将赢得BRA-CHI比赛，那么CHI-GER必须返回“无结果”，因为智利不会与德国对战。有关时间表，请参见上面的链接。

为了简单起见，您不必处理铜牌比赛（但是您当然可以）。

您的程序或函数将使用两个字符串作为输入：两个团队的3个字母的国家/地区代码，并返回获胜团队的国家/地区代码（您可以使用标准输入/输出或两个函数参数/返回值）。如果给定的两支球队不能按照您的猜测参加比赛，则您必须返回其他东西（这可以是国家代码以外的任何内容，例如空字符串，空值，错误消息）。您可以假定输入正确（列表中有两个不同的国家/地区代码）。

这主要是一个代码高尔夫球，因此以字节为单位的最短程序获胜。但是，好的和棘手的解决方案也很有价值。

示例（当然，您可以做出自己的猜测）：

输入：BRA CHI输出：BRA

输入：CHI BRA输出：BRA

输入：CHI GER输出：无结果

code-golf 
— 大卫·弗兰克
source
如果已经在[阴险]输出随机猜测，但总是让你最喜欢的球队获胜;）（如：输出随机猜测树）
— ɐɔıʇǝɥʇuʎs
@ɐɔıʇǝɥʇuʎscodegolf.stackexchange.com/ questions /32092 /…这与这很相似
— David Frank
4
@ɐɔıʇǝɥʇuʎs，这实际上更有趣。我们给了一个可能的程序空间，它大致对应于三元素集上的哈希函数，并且我们必须找到最小的程序，该程序等效于该空间中的任何程序。
— 彼得·泰勒
1
可以假设输入将是有效还是会BRA BRA和HAZ CHEEZBURGER必须得到妥善处理？
— 丹尼斯
@Dennis看到我的编辑-输入始终是有效的
— 大卫·弗兰克

Answers:

6

Python 2.x- 368 283

有趣的挑战。当然，我们需要从FIFA获得当前排名。巴西拥有所谓的“第十二个人”，因为他们有主场优势，因此权重为12/11。

a='BRA CHI COL URU FRA NGA ALG GER MEX NED CRC GRE ARG SUI BEL USA'.split()
d=[1242*12/11,1026,1137,1147,913,640,858,1300,882,981,762,1064,1175,1149,1074,1035]
m={}
for n in[16,8,4,2]:
 j=0
 for k in range(0,n,2):
  s=a[k] if d[k]>d[k+1] else a[k+1]
  m[a[k]+' '+a[k+1]]=s
  a[j]=s    
  j+=1
def f(s): 
 try: print m[s] 
 except: print 'no result'

欢迎缩短上述技巧：-)。

@TheRare和@MrLemon带来的改进

a='BRA CHI COL URU FRA NGA ALG GER MEX NED CRC GRE ARG SUI BEL USA'.split()
d=15,6,10,11,4,0,2,14,3,5,1,8,13,12,9,7
m={}
for n in 16,8,4,2:
 j=0
 for k in range(0,n,2):s=a[k]if d[k]>d[k+1]else a[k+1];m[a[k]+' '+a[k+1]]=s;a[j]=s;j+=1     
def f(s):print s in m and m[s]or'no result'

这导致以下结果： 

BRA CHI: BRA
COL URU: URU
FRA NGA: FRA
ALG GER: GER
MEX NED: NED
CRC GRE: GRE
ARG SUI: ARG
BEL USA: BEL
------------
BRA URU: BRA
FRA GER: GER
NED GRE: GRE
ARG BEL: ARG
------------
BRA GER: BRA
GRE ARG: ARG
------------
BRA ARG: BRA

示例调用： 

f('BRA MEX')
no result
f('BRA CHI')
BRA
— 威廉
source
1.您不使用j（它始终为零）。2. for k可以使用;定界符将其写成一行。3.如关键字后，您不需要的空间try或except4.您可以括号和关键字之间（删除空格a[k]if d[k]>d[k+1]else a[k+1]5是有效的）for n in 16,8,4,26def f(s):print s in m and m[s]or'no result'
— seequ
@TheRare他确实使用过j，但是。出现了轻微的格式错误j+=1。[15,6,10,11,4,0,2,14,3,5,1,8,13,12,9,7]当然，通过将FIFA数据重新编码为，您可以节省很多字符。
— MrLemon 2014年
@MrLemon啊，我自己没有尝试代码，只是看了一下。
— seequ 2014年
5

C，182178133（或126）

这里不是最短的程序，而是最容易更改预测的最短程序。现在所有半决赛选手都知道了，我正在更新。

代码也有一些更改。除了评论中丹尼斯的建议外，该程序已转换为函数（如在重新读取规则所允许的情况下），并且哈希得以缩短。

编号133

f(char*a,char*b){
  char*p,*t=" HIAEAIH N?=R=?N ;@4S4@; 5BDGDB5 B@?I?@B",h[3]={*a-a[1]%16,*b-b[1]%16};
  (p=strstr(t,h))&&puts(p-t&2?a:b);
}

怎么运行的

输入a，b并由表达式散列*a-a[1]%16为单个字符（*a是的缩写，等效于a[0]）。团队的哈希结果，a并b存储在中h。例如，BRA CHI变为@;。哈希值如下（已确认的准决赛者和我预测的冠军以标记*。）

GRE E   CRC A   *NED I   MEX H
USA R   BEL =   *ARG ?   SUI N
URU S   COL 4  **BRA @   CHI ;
NGA G   FRA D   *GER B   ALG 5

t[]存储我的预测。现在知道16和四分之一决赛的回合结果。每组4支球队的顺序是将第1和第4淘汰，第3则是准决赛。与半决赛选手类似，我预计第一和第四名将被淘汰，第三名半决赛选手将成为整体冠军。如果您不同意我的预测，只需重新排序表格即可。

预测存储在回文模块中，以适应用户以任何可能的顺序进入团队的可能性。该顺序将每组4个获胜的球队放在一起进行第三场比赛。因此，在第一组中，GRE E输给了CRC，MEX H输给了NED。这将CRC设置A为I在四分之一决赛中播放NED ，而无需重复键入。每组4个小组/ 7个字符之间用空格填充字符串，以帮助确保不会互相影响的小组没有输出。

每组8个字符中的每场可能的比赛的获胜者如下：invalid,b,a,a,b,b,a,invalid。因此，赢家的正确选择可采取的位置来进行h的t 和2。不幸的是，该strstr函数并不是最直接的函数，因为它返回一个指针p，因此我们必须p从中减去t以获得的实际位置。t.如果匹配无效（无法在中找到t），p则为零，并且no result会打印出短语。

一些可疑的改进，126

改进的哈希表达式可保存2个字符。不幸的是，这要求团队在功能下方的测试程序中显示（例如，Bra而不是BRA在上面的程序中使用）。我已经对自己感到满意，没有一个操作员可以做到这一点，所以2个运算符和一个单字符常量就可以了。还要注意，Uru映射到，space因此|需要一个备用字符来分隔团队代码组。

通过消除t预测字符串并将其视为文字，可以节省5个字符。这意味着不可能知道字符串存储的地址。但是，如果没有将其存储为零，我们只是感兴趣，p&2因此如果地址可被4整除，则代码将起作用（请注意，不允许p直接将指针视为整数，必须将其从另一个指针中减去）我使用了指针，a因此a也必须被4整除。）一个可以相当确信的32位或64位编译器/体系结构字符串将以这种方式存储。尽管我拒绝在Visual Studio / Windows上进行编译，但是这对我在GCC / cygwin上的效果很好。

g(char*a,char*b){
  char*p,h[3]={*a^a[1]+3,*b^b[1]+3};
  (p=strstr("|%&626&%|+4*#*4+|(71 17(|./3$3/.|/74&47/",h))&&puts(p-a&2?a:b);
}

main(){
  char team[16][4]={"Gre","Crc","Ned","Mex", "Usa","Bel","Arg","Sui", "Uru","Col","Bra","Chi", "Nga","Fra","Ger","Alg"}; 
  int i;
  for(i=1;i<16;i++){printf("%s %s \n",team[i-1],team[i]);g(team[i],team[i-1]);g(team[i-1],team[i]);}  
}
— Level River St
source
有趣的方法！您可以通过删除之间的空间节省几个字节char，并*p和更换a[0]，b[0]并h[0]用*a，B`和*h。此外，这个问题说，*如果给定的两支球队不会根据你的猜测玩，你必须返回别的东西（这可以是任何东西，但国家代码，比如空字符串，空，错误消息），所以在印刷没有结果是不需要，您可以替换puts(...)为(p=strstr(t,h))&&puts(p-t&2?a:b)。
— 丹尼斯2014年
特别感谢您的提示a[0]->*a！即将更新。只是想知道，有什么方法可以访问具有单个数字的多维数组？我编写了相同长度的命令行版本（可以用保存一个字节#define。）在这种情况和类似情况下最好避免使用双下标：char *p,h[2],*t="-LgRrRgL bA9j9Ab hp535ph OKYtYKO KpAgApK";main(int c,char**v){h[0]=v[1][1]*3-v[1][0]*2;h[1]=v[2][1]*3-v[2][0]*2;puts((p=strstr(t,h))?v[1+!(p-t&2)]:"no result");}
— Level River St
我发现了一个小错误。h应该以null终止，因此必须为h[3]。2.如果设置了p=v[1]，则可以访问v[i][j]为p[4*(i-1)+j]。它可以在我的机器上运行，但是我不知道它是否可移植... 3. h如果在内部声明，应该可以进行初始化main：main(int c,char**v){char*t="-LgRrRgL bA9j9Ab hp535ph OKYtYKO KpAgApK",*p=v[1],h[3]={p[1]*3-*p*2,p[5]*3-p[4]*2};(p=strstr(t,h))&&puts(v[1+!(p-t&2)]);}
— Dennis
@Dennis，您的代码在我的计算机上的GCC / cygwin和VS / Windows上均能正常工作。还for(int i=0;i<1000;i++)printf("%d %c ",i,i[*argv])回显了VS上命令行的evey可打印字符，但在GCC上，程序名称为0，第一个参数为40，第二个参数无处可见（我上升到1000。）很好。无论如何，除了更新了我的预测（我只是等待今晚的结果来确认它们，然后再发布）之外，我还是更改了规则中的功能。
— Level St
3

的JavaScript 215 206 120 116

有很大的改进空间：

ES5-215

a=prompt().split(' ');("BRACHI0COLURU0FRANGA0GERALG0NEDMEX0CRCGRE0ARGSUI0BELUSA0BRACOL0FRAGER0NEDCRC0ARGBEL0BRAGER0NEDARG0BRANED".split(0).filter(function(x){return x.match(a[0])&&x.match(a[1])})[0]||"").substr(0,3)


ES6-206

a=prompt().split(' ');("BRACHI0COLURU0FRANGA0GERALG0NEDMEX0CRCGRE0ARGSUI0BELUSA0BRACOL0FRAGER0NEDCRC0ARGBEL0BRAGER0NEDARG0BRANED".split(0).filter((x)=>{return x.match(a[0])&&x.match(a[1])})[0]||"").substr(0,3)

正则表达式方法-116

感谢ɐɔıʇǝɥʇuʎs发布了此链接，它帮助我制作了正则表达式 

a=prompt().split(' ').sort();a.join('').match(/LG(.R(A|G)|GE)|RG(S|BE|CR)|ELUS|AC(H|O)|OLUR|CGR|CM|FRANG|XNE/)&&a[0]
— 威廉·巴博萨
source
1
您可以通过转换split(' ')为split``和join('')来缩短解决方案join``。
— Arjun
2

蟒蛇（179 148 139 CQ太长了）

f=lambda *l:sorted(l)[0]if"".join(sorted(l))in"BRACHI COLURU FRANGA ALGGER MEXNED CRCGRE ARGSUI BELUSA BRACOL ALGFRA CRCMEX ARGBEL BRAFRA CRCMEX ARGBEL BRAFRA ARGCRC ARGBRA"else 0

大家都知道，以字母开头的国家/地区将获胜。（这个答案只是为了开始工作而存在）

由于这里的人的慈善，我可以将答案缩短一点：

import re;f=lambda *l:sorted(l)[0]if re.match('RGB|CM|RGS|CGR|L.F|XNE|EL.S|O.UR|RGCR|B.AF|L.GE|^BRACHI$|^FRANGA$|^BRACOL$',"".join(sorted(l)))else 0

这确实假设有有效的球队，但并不需要有效的阵容（f('BRA','NED')将返回0（无效比赛），但f('XNE')将返回'XNE'。）我从您的问题中并没有发现这是个问题。请随时重新滥用您认为合适的此正则表达式。

感谢@Ventero，我对正则表达式一无所知。

import re;f=lambda*l:sorted(l)[0]if re.match('RGB|CM|RGS|CGR|L.F|XNE|EL.S|O.UR|RGCR|B.AF|L.GE|BRACHI|FRANGA|BRACOL',"".join(sorted(l)))else 0
— ɐɔıʇǝɥʇuʎs
source
您可能需要re.search高尔夫版本，而不是re.match。另外，您应该能够放下^和$锚点。
— Ventero 2014年
2

斯卡拉（150）

type s=String;var m=Map[s,s]();def f(x:(s,s))={var a=x._1;var b=x._2;if(b<a){b=a;a=x._1};if(m.getOrElse(a,a)=="")m.getOrElse(b,b)else{m=m+(b->"");a}}

这是“ foo”和“ bar”之间可能的比赛，在第一轮中不会真正对抗的球队也会得到结果。（例如，以BRA，ARG开头）

它只是记录松动的团队。

type s=String //just aliasing for saving characters
var m=Map[s,s]() //map for storing loosing teams, a set would do too
def f(x:(s,s))={
  var a=x._1 var b=x._2
  if(b<a){b=a;a=x._1};//swap if b<a lexographically
  if(m.getOrElse(a,a)=="")//if a has loosed previously
     m.getOrElse(b,b)// return b if b was not in the map else return ""
  else{
    m=m+(b->"") //add b to the map, because a will definitly win this amazing match
    a //and return a
  }
}

致电：

f(("GER","BRA"))
— 蒂格
source
2

PowerShell（261221）

$a=Read-Host;$b=Read-Host;$x="CHIBRA","URUCOL","FRANGA","ALGGER","MEXNED","CRCGRE","SUIARG","BELUSA";0..($x.Length-2)|%{$x+=$x[2*$_].Substring(3)+$x[2*$_+1].Substring(3)};$x|?{"$a$b","$b$a"-eq$_}|%{$_.Substring(3);exit};0

作为一个相对较新的PowerShell用户，我发现管道绝对很棒。我认为下一步可能是尝试修改数组以希望消除所有这些子字符串调用。（我必须在最后添加一个电话，否则它将输出两个团队的数据）

新成员，首次尝试打高尔夫！

可以对四分之一决赛，半决赛和决赛进行硬编码以节省一些字符，但是>那样就不那么有趣了。

应该足够简单地进行破译，但它同时满足两个条件：无论输入的顺序如何，都给同一个获胜者>，并且仅对实际进行>比赛的获胜者返回！

任何改进的建议将不胜感激，谢谢！

原版的

$a=Read-Host;$b=Read-Host;$x=("CHIBRA","URUCOL","FRANGA","ALGGER","MEXNED","CRCGRE","SUIARG","BELUSA");for($c=0;$c-lt$x.length-1;$c+=2){$x+=$x[$c].Substring(3)+$x[$c+1].Substring(3)}foreach($i in $x){if($i-match$a-and$i-match$b){return $i.Substring(3)}}return 0
— Fuandon
source
1
有几件事（完全解决此问题将花费更多时间）：不要像使用C或C＃那样编写PowerShell。这意味着return在大多数情况下是不必要的。foreach而且大多数显式循环都被高估且无用。此类方法.Substring仅应在极端情况下使用（尽管人们可能会质疑足球的用途，但它不是一项极限运动）。通常，您希望尽可能多地使用管道。
— 2014年
1
不必for像编写冗长的循环那样for($c=0;$c-lt$x.length-1;$c+=2){$x+=$x[$c].Substring(3)+$x[$c+1].Substring(3)}使用带有范围和ForEach-Object（aliased %）：的管道0..($x.Length/2)|%{$x+=$x[2*$_].Substring(3)+$x[2*$_+1].Substring(3)}。通过仔细考虑数据的表示方式，您很有可能摆脱Substring呼叫。不需要在初始数组周围的括号。对于较大的数组，使用分隔符和使用也是有意义的-split（-split在分隔符为空格或制表符的情况下，这是唯一的）。
— 2014年
1
foreach例如，最后一个循环也可以写成管道（?is Where-Object）：$x|?{$_-match$a-and$_-match$b}|%{$_;exit};0本质上说»对其中的每个元素$x进行过滤以了解它们是否都匹配$a，$b然后输出第一个元素，然后退出。如果找不到，则输出0.«。因为您知道字符串的格式，所以也可以使用-match"$a$b|$b$a"。因为它们只需要以任意顺序出现在字符串中即可。这也意味着我们可以在这里使用一些技巧："$a$b","$b$a"-eq$_打高尔夫球。
— 2014年
2

CJam，64 58字节

lS/$_0=\:+4b256b1>:ca"oM-YtM-mM-^@}gM-^VM-^U8tM-=nM-^MfM-]oM-xgM-)tM-|m@gim{g_"2/&,*

由于代码包含不可打印的字符，因此上面使用了插入符号和M表示法。

以另外六个字节为代价，可以避免这些字符：

lS/$_0=\:+4b95b1>32f+:c"I8Vyv)2~N{VIEh1$IW32W)B82QBs2G"2/N*\#W>*

在线尝试。

测试运行

$ base64 -d > worldcup.cjam <<< \
> bFMvJF8wPVw6KzRiMjU2YjE+OmNhIm/ZdO2AfWeWlTh0vW6NZt1v+GepdPxtQGdpbXtnXyIyLyYsKg==
$ wc -c worldcup.cjam
58 worldcup.cjam
$ for A in ALG ARG BEL BRA CHI COL CRC FRA GER GRE MEX NED NGA SUI URU USA; do
> for B in ALG ARG BEL BRA CHI COL CRC FRA GER GRE MEX NED NGA SUI URU USA; do
> [[ $A < $B ]] && echo $A - $B : $(LANG=en_US cjam worldcup.cjam <<< "$A $B")
> done; done | grep ': .'
ALG - ARG : ALG
ALG - BRA : ALG
ALG - FRA : ALG
ALG - GER : ALG
ARG - BEL : ARG
ARG - CRC : ARG
ARG - SUI : ARG
BEL - USA : BEL
BRA - CHI : BRA
BRA - COL : BRA
COL - URU : COL
CRC - GRE : CRC
CRC - MEX : CRC
FRA - NGA : FRA
MEX - NED : MEX

怎么运行的

lS/$    " Read one line from STDIN, split at spaces and sort the resulting array.         ";
_0=\    " Extract the first element of a copy of the array and swap it with the array.    ";
:+      " Concatenate the strings.                                                        ";
4b      " Convert the resulting string into an integer by considering it a base 4 number. ";
256b    " Convert the integer into an array by considering it a base 256 number.          ";
1>:ca   " Drop the first element, convert into a string and create a singleton array.     ";
"…"     " Push a string of all matches encoded as explained above.                        ";
2/      " Split the string into an array of two-character strings.                        ";
&       " Intersect the two arrays. If the array is non-empty, the teams play.            ";
,*      " Multiply the string on the stack by the length of the array.                    ";
— 丹尼斯
source
应该公平地将bash脚本的大小添加到CJam程序的大小中。
— David Frank
1
@DavidFrank：我包含了Bash脚本，以证明我的程序仅提供15个匹配项的输出。它可以独立工作，不需要外部程序。
— 丹尼斯2014年
2

CJam，49个48字节

lS/$_0="^\16@&^^/+(^]^W^Y,>O?"{_2%+}3*@{2b91%c}%#1&!*

由于代码包含不可打印的字符，因此以上使用插入记号表示法。

以另外两个字节为代价，可以避免这些字符：

lS/$_0="(=BL2*;74)#%8J[K"{_2%+}3*@{2b91%C+c}%#1&!*

在线尝试。

测试运行

$ base64 -d > wc.cjam <<< bFMvJF8wPSIcMTZAJh4vKygdFxksPk8/IntfMiUrfTMqQHsyYjkxJWN9JSMxJiEq
$ wc -c wc.cjam
48 wc.cjam
$ for A in ALG ARG BEL BRA CHI COL CRC FRA GER GRE MEX NED NGA SUI URU USA; do
> for B in ALG ARG BEL BRA CHI COL CRC FRA GER GRE MEX NED NGA SUI URU USA; do
> [[ $A < $B ]] && echo $A - $B : $(cjam wc.cjam <<< "$A $B"); done; done | grep ': .'
ALG - ARG : ALG
ALG - BRA : ALG
ALG - FRA : ALG
ALG - GER : ALG
ARG - BEL : ARG
ARG - CRC : ARG
ARG - SUI : ARG
BEL - USA : BEL
BRA - CHI : BRA
BRA - COL : BRA
COL - URU : COL
CRC - GRE : CRC
CRC - MEX : CRC
FRA - NGA : FRA
MEX - NED : MEX

背景

我们首先给每个团队分配ASCII字符，方法是考虑其名称以2为底的数字，将得到的整数取模91，再加上12（以避免不可打印的字符），然后选择与得到的ASCII码相对应的字符。在CJam代码中，这是通过实现的2b91%c。

例如，字符代码ALG是65 76 71。自(4 × 65 + 2 × 76 + 71) = 483，483 % 91 + 12 = 40如果字符代码为，则为40 (。

这给出了以下映射：

ALG (    ARG 4    BEL #    BRA 2    CHI *    COL ;    CRC 8    FRA B
GER =    GRE J    MEX [    NED K    NGA L    SUI )    URU 7    USA %

现在，我们可以将第16轮的匹配编码如下：

(=BL2*;74)#%8J[K

如果我们假设第一支球队总是按字母顺序获胜，那么八强赛的比赛如下：

(B2;4#8[

请注意，可以通过从第一个字符开始选择每隔第二个字符来从第一个字符中获取此字符串。在CJam代码中，这是通过实现的2%。

使用相同的想法，半决赛和决赛的比赛如下：

(248
(4

代码 

"(=BL2*;74)#%8J[K"{_2%+}3*

推入包含16个回合匹配项的字符串，然后执行以下三次：复制字符串，提取副本的第二个字符，并进行连接。结果是字符串

(=BL2*;74)#%8J[K(B2;4#8[(B2;4#8[(248(B2;4#8[(248(248(4

其中包含所有匹配项（其中一些不止一次）。

怎么运行的

lS/$        " Read one line from STDIN, split at spaces and sort the resulting array.     ";
_0=         " Extract the first element of a copy of the array.                           ";
"…"         " Push the string containing the matches of the round of 16.                  ";
{_2%+}3*    " Push the remaining matches.                                                 ";
@           " Rotate the input array on top of the stack.                                 ";
{2b91%C+c}% " Perform the mapping for each team in the input array.                       ";
#           " Push the index of the match in the array of all matches (-1 for not found). ";
1&!         " Push 1 if the index is even (valid match) and 0 if it is odd.               ";
,*          " Repeat the string on the stack that many times.                             ";
— 丹尼斯
source
您对Cjam所做的一切真是太神奇了。每当我认为您可能会借用我的想法之一时，您就会想到更好的选择！您的预测代码"(=BL2*;74)#%8J[K"{_2%+}3*的长度与我的预测字符串的非回文形式的长度相同，"rRgL j9Ab 35ph tYKO gApK"但更容易处理。
— 水平河圣
0

JavaScript 271

t=prompt('Match?').split('-')
x=t[0],y=t[1],T='BRACHICOLURUFRANGAGERALGNEDMEXCRCGREARGSUIBELUSA'
v='\n',R='',W='No Game'
for(z=1;T!='USA';++z,T=n){R+=v+z+v,n='',r=/(...)(...)/g
while(m=r.exec(T))a=m[1],n+=b=m[2],R+=a+'-'+b+v,W=a==x&&b==y||a==y&&b==x?b:W
}
alert(W+'\n'+R)
— 狼锤
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.