这是一个挑战，其中有两个人1和2正在竞选办公室。人们在1和2的世界中以确定的方式进行投票，这可以使候选人在选举前弄清楚结果。

注意：这并不表示任何外部选举或其他政治事件。

两个人正在竞选办公室。我们将这些人称为1和2。因为他们俩都想知道他们是否会赢得选举，所以他们决定使用他们对人的知识以及一些代码来确定结果。由于要尽量减少政府支出，因此代码必须尽可能短。

您的任务：根据一连串的投票方式，输出赢得选举的人。

在1和2的有趣和令人兴奋的世界中，共有五类人：

• A：肯定会投1票的人。
• B：肯定会投赞成票2的人。
• X：将投票支持的人，无论左边的人投票支持谁。如果他们的左边没有人，则他们投票给右边的人投票的人。如果不清楚其右边的人在为谁投票，则他们不会投票。
• Y：人们会投票反对他们左边的那个人。如果他们的左边没有人，那么他们将投票反对右边的人。如果不清楚其右边的人在为谁投票，则他们不会投票。
• N：不投票的人。

这是从左到右评估的。

例：

为了清楚起见，任何被“评估”的人都是小写字母。

Input: `XXAYAN`
        xX      Votes for whoever their friend is voting for. Their friend has not decided yet, so it is unclear, so they do not vote.
        Xx      Person to left is voting "none" so votes "none."
          a     Votes for 1
          Ay    Since person on left is voting for 1, votes for 2.
            a   Votes for 1
             n  Does not vote

最终民意调查：

• 2人投票赞成1

• 1人投票赞成2

• 3人未投票

1票最高，所以1胜！

测试用例：

您可以使用其他字符或值作为输入和输出，只要它们是不同的即可。（例如：数字而不是字母，不同的字母，小写字母，真/假或正/负（用于输出）等）

Input -> Output

"AAAA" -> 1
"BBBB" -> 2
"BBAXY" -> 2
"BAXYBNXBAYXBN" -> 2
"XXAYAN" -> 1
"AAAABXXXX" -> 2
"AXNXXXXAYB" -> 1
"NANNY" -> 1
"XA" -> 1
"YAB" -> 2
"XY" -> anything (do not need to handle test cases with no victor)
"AB" -> anything (do not need to handle test cases with no victor)

Perl 5，56 80 72 65 53字节

+26字节用于在第一个位置处理X或Y，在第二个位置处理A或B。输出是1如果1赢得空（perl中的false值），否则。

s/^X(.)/$1$1/,s/A\KX|B\KY|^Y(?=B)/A/|s/B\KX|A\KY|^Y(?=A)/B/&&redo;$_=y/A//>y/B//

蒂奥

使用P和S替代X，并Y允许使用的字符XOR运算，将节省更多的字节

s/(?|^(P|S)(?=(A|B))|(A|B)\K(P|S))/P^$1^$2/e&&redo;$_=y/A//>y/B//

使用分支重置组(?|.. |.. )，以便引用分支$1 $2中的相应组。使用\0和\3代替X和Y

$_=s/^\W(?=(\w))|(\w)\K\W/$1.$2^$&/e?redo:y/A//>y/B//

72字节

65字节

53个字节

爪哇8，153个 141 135 131 129字节

a->{int l=a.length,t,r=0,i=-1;for(;++i<l;r+=(t=a[i]=a[i]>4?t<3?t^3:3:a[i]>3?t:a[i])>2?0:3-t*2)t=a[i>0?i-1:i<l-1?i+1:i];return r;}

使用整数数组作为输入，如果A获胜，则A=1, B=2, N=3, X=4, Y=5输出一个正整数（>= 1），<= -1如果B获胜，或者0如果是平局，则输出一个负整数（）。

-18个字节，感谢@OlivierGrégoire。

在线尝试。

说明：

a->{                      // Method with int-array parameter and boolean return-type
  int l=a.length,         //  Length of the input-array
      t,                  //  Temp integer, uninitialized
      r=0,                //  Result-integer, starting at 0
  i=-1;for(;++i<l         //  Loop `i` in the range [0, l):
           ;              //    After every iteration:
            r+=           //     Increase the result by:
             (t=a[i]=     //       Change `i`'th item in the array to:
                 a[i]>4?  //        If the `i`'th item is a 5:
                  t<3?    //         If `t` is 1 or 2:
                   t^3    //          Use `t` Bitwise-XOR 3 to invert it
                          //          (1 becomes 2; 2 becomes 1)
                  :       //         Else (`t` is 3, 4, or 5 instead):
                   3      //          Set it to 3
                 :a[i]>3? //        Else-if the `i`'th item is a 4:
                  t       //         Set it to `t`
                 :        //        Else (the `i`'th item is a 1, 2 or 3):
                  a[i])   //         Leave it unchanged
             )>2?         //      And if this new `i`'th value is 3, 4, or 5:
              0           //       Leave the result the same by increasing it with 0
             :            //      Else (it's 1 or 2 instead):
              3-t*2;      //       Increase it by 3 minus two times the `i`'th value
                          //       (which is 1 for 1; and -1 for 2)
         t=               //   Set `t` to:
           a[i>0?         //    If `i` is not the first item:
              i-1         //     Set `t` to the previous (`i-1`'th) value
             :i<l-1?      //    Else-if `i` is not the last item:
              i+1         //     Set `t` to the next (`i+1`'th) value
             :            //    Else (`i` is the first or last item):
              i];         //     Set `t` to the current item itself
  return r;}              //  Return the result
                          //  (positive if A wins; negative if B wins; 0 if it's draw)

Haskell，60 50 48 59字节

l#(v:o)|v<2=v+v#o|n<-(3-v)*l=n+n#o
_#_=0
f x=rem(x!!1)2#x>0

用途1为A，-1对B，0对N，2对X，并4为Y。True如果成功则返回A，否则返回False。

在线尝试！

在递归的方式下来，我们添加的输入列表中1的每个投票A，-1每一个投票B，并0为“无票”。l是最后一票，v下一票。如果为v=1，-1或0（或v<2），则将其添加到总和中。如果v是“票相同”（X在挑战中，2对于我的解决方案），我们保留并添加l（(3-2)*l= l）。如果v“反对”（Y在挑战中，4对于我的解决方案），我们首先取反l（(3-4)*l= -l），然后将其添加。基本情况是空列表，以开头的总和0。递归开始l设置到rem s 2哪里s是输入列表（x!!1）的第二个元素。rem s 2地图1和-1到自身，所有其他值0。固定表决l无论如何都会忽略[*]，X或者Y如果是固定表决，则得到正确的邻居。如果总和为正，则A获胜。

[*]这使单例列表具有像[1]工作一样的固定投票，因为由于Haskell的懒惰，从不评估对第二个元素的访问。诸如[2]错误之类的输入会失败，但不必考虑。

JavaScript（ES6）， 78 75  73字节

将输入作为整数数组，其中包括： = N， = A， = B， = Y， =X。$0$$1$$2$$4$$8$

返回如果第一候选胜或如果第二的候选人获胜。$false$$true$

a=>a.reduce((v,x,i)=>v+~~[,1,-1][p=x?x&3||~-x%7^(p&3||a[i+1]&3):0],p=0)<0

在线尝试！

05AB1E，34 33 32 30 字节

gFÐNè©2@iNx1.S-èDÄ2‹*D(‚®èNǝ]O

使用整数数组作为输入，如果A获胜，则A=-1, B=1, N=0, X=2, Y=3输出一个负整数（<= -1），>= 1如果B获胜，或者0如果是平局，则输出一个正整数（）。

在线尝试或验证所有测试用例。

说明：

g             # Take the length of the (implicit) input-list
              #  i.e. [3,1,3,3,2,0,1] → 7
 F            # Loop `N` in the range [0, length):
  Ð           #  Triplicate the list at the top of the stack
              #  (which is the implicit input-list in the first iteration)
   Nè         #  Get the `N`'th item of the list
              #   i.e. [3,1,3,3,2,0,1] and `N`=0 → 3
              #   i.e. [-1,1,-1,3,2,0,1] and `N`=3 → 3
     ©        #  Store it in the register (without popping)
   2@i        #  If it's larger than or equal to 2 (so either 2 or 3):
      Nx      #   Push `N` and `N` doubled both to the stack
              #    i.e. `N`=0 → 0 and 0
              #    i.e. `N`=3 → 3 and 6
        1.S   #   Compare the double integer with 1 (-1 if N*2<1; 0 if N*2==1; 1 if N*2>1)
              #   (So this will be -1 in the first iteration, otherwise it will be 1)
              #    i.e. 0 → -1
              #    i.e. 6 → 1
           -è #   Subtract that from the index, and index it into the list
              #    i.e. `N`=0 and -1 → 1 (first item, so get the next index)
              #     → [3,1,3,3,2,0,1] and 1 → 1
              #    i.e. `N`=3 and 1 → 2 (fourth item, so get the previous index)
              #     → [-1,1,-1,3,2,0,1] and 2 → -1
      D       #   Duplicate that value
       Ä2‹    #   Check if that value is -1, 0, or 1 (abs(i) < 2) (truthy=1; falsey=0)
          *   #   And multiply that with the value
              #   (remains the same if truthy; or becomes 0 if falsey)
      D(‚     #   Pair it with its negative (-1 becomes [-1,1]; 1 becomes [1,-1])
         ®è   #   And index the `N`'th value (from the register) into it (with wraparound)
              #   (if it was a 2, it uses the unchanged (first) value of the pair;
              #    if it was a 3, it uses the negative (second) value of the pair)
              #     i.e. [1,-1] and 3 → -1
              #     i.e. [-1,1] and 3 → 1
      Nǝ      #   And replace the `N`'th value with this
              #    i.e. [3,1,3,3,2,0,1], `N`=0 and -1 → [-1,1,3,3,2,0,1]
              #    i.e. [-1,1,-1,3,2,0,1], `N`=3 and 1 → [-1,1,-1,1,2,0,1]
 ]            # Close both the if-statement and loop
  O           # Sum the modified list (which now only contains -1, 0, or 1)
              #  i.e. [-1,1,-1,1,1,0,1] → 2

视网膜0.8.2，70字节

AY
AB
BY
BA
}`(A|B)X
$1$1
^X(A|B)|^Y[AB]
$1$1
+`N|X|Y|AB|BA

.+|(?<=B)

在线尝试！链接包括测试用例。并列输出0。说明：

AY
AB
BY
BA

办理Y选民的人决定的投票权。

}`(A|B)X
$1$1

手柄X选民的人决定投票权，然后回送，直到所有可能Y和X选票可以决定。

^X(A|B)|^Y[AB]
$1$1

X在已决定的选票旁边处理初始选民，在已决定的选票旁边处理初始选民Y。由于该投票者的投票将与决定的投票相反，因此在这种情况下，我们只需删除两个投票即可。

+`N|X|Y|AB|BA

删除任何剩余的无表决权或未定表决权，并取消所有成对的反对票。重复直到所有可能的投票都被取消。如果是平局，则什么都不会剩下，否则剩余的选票将是同一类型。

.+|(?<=B)

1如果有任何表决结果，但2如果有B表决结果，则输出。

JavaScript（Node.js），42字节

s=>s.map(c=>x+=l=c%2|l*c/2,l=s[x=1]%2)|x>1

在线尝试！

节省1个字节，这要感谢Shaggy。

• 输入为整数数组，其中N = 0，A = -1，B = 1，X = 2，Y = -2;
• 输出1 =虚假，2 =真实

蟒蛇 3 2， 125 121 117字节

（感谢乔纳森·弗雷希）

def f(x):
    for i,v in enumerate(x):n=x[i-(i>0)];x[i]=(v>3)*n+abs(n-1)*(v<0)+x[i]*(0<v<4)
    print x.count(1)>x.count(0)

使用制表符缩进

输入：的列表，int其中“ A” = 1，“ B” = 0，“ X” = 4，“ N” = 3，“ Y” =-1，因此“ AAAA”为[1, 1, 1, 1]，“ XXAYAN”为[4, 4, 1, -1, 1, 3]。

[{'A': 1, 'B': 0, 'X': 4, 'N': 3, 'Y': -1}[c] for c in s] 将字符串转换为所需的输入格式。

您可以在线尝试！（感谢乔纳森·弗雷希的建议）

Perl 5，54个字节

s/^\W(?=(\w))|(\w)\K\W/$1^$2^$&/e&&redo;$_=y/A//>y/B//

在线尝试！

用途A为A，B对B，N对N，\0对X，并\3为Y（最后两个是文本控制字符）。诀窍是A按位异或\3等于B，反之亦然。

Javascript（ES6）-133字节

a=>(i=($=_=>'AB'.search(_)+1)(a[1],o=0),[...a].map(v=>(r=['NAB','NBA']['XY'.search(x)],p=r?r[i]:v,i=$(p),o+='NA'.search(p))),o>0?1:2)

接收OP中给定格式的字符串，如果候选人1获胜，则返回1，否则返回2（我承认，我有偏见）。

Python 2中，95 73个字节

lambda(v):sum([l for l in[2*int(v[1]/2)]for i in v for l in[i*l**(i%2)]])

在线尝试！

• 输入为整数数组，其中N = 0，A = -2，B = 2，X = 1，Y = -1;
• 输出负= A，0 =绘制，正= B
• 如果第一个输入是X或Y，则2 * int（v [1] / 2）将第二个映射到其自身或0

需要进行错误修复，从而增加了额外的字节，但是由于@Stephen而将其转换为lambda，将其还原为95