在协会足球（也称为足球）中，点球大战是第二个打破常规的措施，可能会在加时赛（即协会足球加时赛）之后不能打成平局的比赛中使用。

在点球大战中，主裁判掷硬币确定射门发生在哪个目标，然后掷另一枚硬币确定哪个队先开始。但是，与此挑战相关的唯一事情就是随后发生的事情，如下所述。

每队在开始时有5罚则，罚分是0-0。如果在任何时候，一支球队的剩余罚款还不足以改变目前获胜的球队，那么枪战将停止。

如果没有剩余的罚分，但两支球队的得分相等，则两支球队将被另外判罚。重复该过程，直到点不相等为止。

枪战停止后，点球得分最高的球队获胜。

挑战

您的挑战是给定两个列表，A并B代表球队A和球队B分别得分的点球，以确定他们是否代表有效的点球大战。如果可以达到输入所代表的状态，则无论是否确定获胜队伍，枪战都是有效的。请注意，您可能必须测试两种情况（团队A启动，团队B启动），因为如果至少在一种情况下输入中描述的状态可达到，则输入有效。如果列表的长度不同，则由较长的列表代表的团队首先开始（它只能比另一列表的元素多，而较短列表的团队则无法开始，因为较长列表的团队将受到两次处罚）连续，因为较短的列表会过早耗尽）。

详细的例子

您可以跳到下面的“规则”部分，它们仅用于帮助解决挑战。

假设您将这个枪战作为输入，这-意味着没有进球，也没有进球X（无效）：

Team A: - X X X X
Team B: - - - - X

Assuming team A starts first:

Team A: - (0 - 0) (max possible score 4 - 5)
Team B: - (0 - 0) (max possible score 4 - 4)
Team A: X (1 - 0) (max possible score 4 - 4)
Team B: - (1 - 0) (max possible score 4 - 3)
Team A: X (2 - 0) (max possible score 4 - 3)
Team B: - (2 - 0) (max possible score 4 - 2)
Team A: X (3 - 0) (max possible score 4 - 2)
Team A already has a higher score than B could ever have, but the input hasn't
ended yet, so it's invalid if team A is first.

Assuming team B starts first:

Team B: - (0 - 0) (max possible score 5 - 4)
Team A: - (0 - 0) (max possible score 4 - 4)
Team B: - (0 - 0) (max possible score 4 - 3)
Team A: X (1 - 0) (max possible score 4 - 3)
Team B: - (1 - 0) (max possible score 4 - 2)
Team A: X (2 - 0) (max possible score 4 - 2)
Team B: - (2 - 0) (max possible score 4 - 1)
Team A already has a higher score than B could ever have, but the input hasn't
ended yet, so it's invalid if team B stars first.

The input is invalid no matter which team starts first, so it's considered
invalid.

相反，这是一个有效的示例：

Team A: X X X
Team B: - - -

Assuming team A starts first:

Team A: X (1 - 0) (max possible score 5 - 5)
Team B: - (1 - 0) (max possible score 5 - 4)
Team A: X (2 - 0) (max possible score 5 - 4)
Team B: - (2 - 0) (max possible score 5 - 3)
Team A: X (3 - 0) (max possible score 5 - 3)
Team B: - (3 - 0) (max possible score 5 - 2)
It can be determined that team A wins, however the input has ended, so it's
valid if team A starts first. Therefore, the input is valid.

另一个例子，这次有额外的罚款：

Team A: X - X - - - X -
Team B: - X X - - - X X

Assuming team A starts first:

Team A: X (1 - 0) (max possible score 5 - 5)
Team B: - (1 - 0) (max possible score 5 - 4)
Team A: - (1 - 0) (max possible score 4 - 4)
Team B: X (1 - 1) (max possible score 4 - 4)
Team A: X (2 - 1) (max possible score 4 - 4)
Team B: X (2 - 2) (max possible score 4 - 4)
Team A: - (2 - 2) (max possible score 3 - 4)
Team B: - (2 - 2) (max possible score 3 - 3)
Team A: - (2 - 2) (max possible score 2 - 3)
Team B: - (2 - 2) (max possible score 2 - 2)
First 5 penalties result in a tie, so we move on to extra penalties.
Team A: -, Team B: - (2 - 2)
Team A: X, Team B: X (3 - 3)
Team A: -, Team B: X (3 - 4)
It can be determined that team B wins, however the input has ended, so it's
valid if team A starts first. Therefore, the input is valid.

这是一个有效的输入，现在确定获胜者还为时过早：

Team A: X X - -
Team B: - X - X

Assuming team A starts first:

Team A: X (1 - 0) (max possible score 5 - 5)
Team B: - (1 - 0) (max possible score 5 - 4)
Team A: X (2 - 0) (max possible score 5 - 4)
Team B: X (2 - 1) (max possible score 5 - 4)
Team A: - (2 - 1) (max possible score 4 - 4)
Team B: - (2 - 1) (max possible score 4 - 3)
Team A: - (2 - 1) (max possible score 3 - 3)
Team B: X (2 - 2) (max possible score 3 - 3)
The input has ended before the winner can be determined, so it's valid if team A
starts first. Therefore, the input is valid.

最后，这是列表长度不同的输入：

Team A: - - -
Team B: X X - X

Since team B shot more penalties, it starts first:

Team B: X (0 - 1) (max possible score 5 - 5)
Team A: - (0 - 1) (max possible score 4 - 5)
Team B: X (0 - 2) (max possible score 4 - 5)
Team A: - (0 - 2) (max possible score 3 - 5)
Team B: - (0 - 2) (max possible score 3 - 4)
Team A: - (0 - 2) (max possible score 2 - 4)
Team B: X (0 - 3) (max possible score 2 - 4)
It can be determined that team B wins, however the input has ended, so it's
valid.

规则

• 首先开枪的球队可以是A或B，您不能假设一个人总是开枪。
• 列表的长度相同，或者长度相差一。
• 您可以选择任何两个不同且一致的值来表示得分/未得分罚分。
• 列表也可以表示为从双射基数 2，字符串或您语言的本机列表格式转换的整数。如果选择了双射基座2格式中，输入规则适用于数字转换为双射基座2（所以数字1和2可以分别是指刻痕，并且未刻痕或无刻痕和刻痕）。不允许使用常规二进制，因为无法确定预期的二进制表示形式中是否存在前导零。
• 这是代码高尔夫球，因此最短的解决方案是成功的。但是，即使您的语言似乎无法“击败专业人士”，也请不要灰心。

测试用例

在这些测试用例中，a 0表示无效，a 1表示目标。

格式：

[Team A], [Team B]

有效输入：

[], []
[0], [0]
[0], [1]
[1], [1]
[0], []
[1, 1, 1, 1], [0, 0, 1, 1]
[0, 1, 1, 1, 1], [0, 1, 1, 0]
[0, 0, 0, 0, 1], [0, 0, 0, 1, 0]
[0, 0, 0, 0, 1], [0, 0, 0, 1]
[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1]
[0, 1, 1, 1, 1], [0, 1, 1, 0, 1]
[1, 1, 1], [0, 0, 0]
[1, 1, 1, 1], [0, 0, 1]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

输入无效：

[0, 1, 1, 1, 1], [0, 1, 1, 0, 0]
[0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 1, 0]
[0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 1]
[1, 1, 1, 0], [0, 0, 0]
[1, 1, 1, 1], [0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
[1, 0, 1, 0, 1], [0, 1, 0, 1, 0, 1]
[0, 0, 0, 0, 1], [0, 1, 1, 1, 0]

的JavaScript（ES6）， 117个112  109字节

(a)(b)$1$$2$$0$$1$

a=>b=>!(g=(a,b,P=Q=i=5)=>(p=a[5-i])|(q=b[5-i])&&(--i<0?P-Q:P-Q>i|Q+q-P-p>i&p<2)|g(a,b,P+p,Q+=q))(a,b)|!g(b,a)

在线尝试！

已评论

a => b =>                   // given a[] and b[]
  !(g = (                   // g is a recursive function taking:
      a,                    //   the results a[] of the team that plays first
      b,                    //   the results b[] of the team that plays second
      P =                   //   the cumulated goals P of the 1st team (relative value)
      Q =                   //   the cumulated goals Q of the 2nd team (relative value)
      i = 5                 //   a counter i
    ) =>                    // and returning a truthy value if something goes wrong
      (p = a[5 - i]) |      // if either the first team
      (q = b[5 - i]) && (   // or the second team is playing this round:
        --i < 0 ?           //   decrement i; if we've played more than 5 penalties:
          P - Q             //     do we already have a goal difference?
        :                   //   else:
          P - Q > i |       //     was the 1st team already guaranteed to win?
          Q + q - P - p > i //     or is the 2nd team now guaranteed to win
          & p < 2           //     while the 1st team failed its last attempt?
      ) |                   //
      g(                    //   do a recursive call:
        a, b,               //     pass a[] and b[] unchanged
        P + p,              //     update P
        Q += q              //     update Q
      )                     //   end of recursive call
  )(a, b) |                 // try g(a, b)
  !g(b, a)                  // try g(b, a); return 1 if at least one of them is falsy

Python 2中，176个 169 171 169字节

-2个字节，感谢@Kevin Cruijssen

exec"h=lambda a,b,m:m-%s/2>abs(sum(a)-sum(b));f=lambda a,b:a[5#==b[5#and h(a[:5],b[:5],6)if %s>10else h(a,b,7)and h(a[#,b[#,6)".replace("#",":~-%s/2]")%(("len(a+b)",)*6)

在线尝试！（包括上面未列出的一些额外的测试用例。）

创建一个f接受两个参数（得分/未得分罚分的两个列表）的函数，并返回True得分是否有效以及是否得分的函数False。

部分说明：

首先，该exec构造只是一种不必重复len(a+b)多次表达式即可节省几个字节的方法。上面的代码等效于以下代码：

更新：新的和改进的答案是相同的字节数（带有或不带有exec欺骗性），因此为了简单起见，我将其删除。

更新2：新的错误修复版本通过替换和包括更多字符串压缩exec。是的，我在同一字符串上使用%格式和.replace。上面的代码等效于：

h=lambda a,b,m:m-len(a+b)/2>abs(sum(a)-sum(b))
f=lambda a,b:a[5:(len(a+b)-1)/2]==b[5:~-len(a+b)/2]and h(a[:5],b[:5],6)if len(a+b)>10else h(a,b,7)and h(a[:(~-len(a+b)/2],b[:(len(a+b)-1)/2],6)

这个答案的主要思想是用“半点”来表示问题：每个成功的踢是一个半点，每个失败的踢是一个负半点。对于一组长度的分数$<=5$为了保持连续性（not len(a+b)>10），剩下的踢球总数必须大于或等于两队之间的半点差。当一支球队踢了额外的时间时，由于各种原因，必须从边距中减去半点，因此可以通过将方程式的两边都除以2来简化这一点。这是h代码中的函数（参数m等于6）。

但是，要成为一组有效的分数，输入不一定要严格连续，而必须在进行最后一击之前就已经是连续的。此条件等同于说它必须：1）双方上次踢相同次数的次数是可延续的，并且2）当前在可延续性的两个半点之内—这是最后一个论点h出现的地方：h(a[:~-len(a+b)/2],b[:~-len(a+b)/2],6)测试条件1）和h(a,b,7)（7在余量中表示另外两个允许的半点）测试条件2）。

这样就解决了每支球队最多踢过五次的情况。（对于其他情况，将继续说明。）

对于低水平的高尔夫运动，我怀疑还有很多事情要做，但是从算法上讲，它可以做得更简单。

果冻，62 54 49字节

ṫ⁵Ṗm2¬Ạ
N§ỤḢƊ¦LÞṚZFĵ12R:2U_ṁḣ⁵ṫ-N<Ø.ẠaÇoL<3
ṚÇoÇ

在线尝试！

ṫ⁵Ṗm2¬Ạ # helper function to determine whether
        # even indices at or beyond 10 are zero
ṫ⁵      # tail - take every item from 10
  Ṗ     # remove last item
   m2   # take every second item
     ¬  # logical not, will return 1 for an empty list
      Ạ # all
# function to create cumulative score
# difference and check values
N§ỤḢƊ¦    # negate scores for team with lower score
          # (or one of them if both same score)
  LÞṚ     # sort by length, longest first
  ZF      # transpose lists and flatten
  Ä       # cumulative sum
  µ       # this cumulative score difference (CSD) 
          # now becomes left value
  12R:2U_ # subtract cumulative score difference from
          # 6,5,5,4,4,3,3,2,2,1
  ṁḣ⁵     # shorten to be no longer than 10 items
          # and no longer than CSD
  ṫ-N<Ø.Ạ # check last two values are greater than 0,-1
  aÇ      # check that helper function also TRUE
  oL<3    # handle very short scores
# main link that calls the above for scores in either order
ṚÇoÇ

请注意，在tio的页脚代码仅用于处理多个测试用例，并根据输入打印输出。

感谢@EriktheOutgolfer打高尔夫球8个字节

Perl 6 6、123字节

{all map {@^b>@^a||[R,](map {abs(($+=$_)-++$ %2/2)>(5-++$ /2 max++$ %2)},flat roundrobin @a,-<<@b).skip.any},@^a,@^b,@b,@a}

在线尝试！

对于有效的枪战，返回falsey；对于无效的枪战，返回true。

说明

# Check whether block returns true (invalid shoot-out) for arguments (a, b) and (b, a)
{all map {...},@^a,@^b,@b,@a}
# Return true (invalid) if array b is longer than a
@^b>@^a||
# Return true (invalid) if any except the last value is true (shoot-out stopped)
[R,](...).skip.any
# Map values from a and negated b, interleaved
map {...},flat roundrobin @a,-<<@b
# Shoot out stopped?
abs(($+=$_)-++$ %2/2)>(5-++$ /2 max++$ %2)
    #     # Accumulator
           #        # Subtract 0.5 for first team
                      #                  # Sequence 4.5 4 3.5 3 2.5 2 1.5 1 1 0 1 0 1 0