에서는 축구 협회 (또한 축구로 알려진)와, 승부 차기는 넥타이 끝나지 수 매치에서 사용될 수있는 두 번째 타이 브레이커의 측정은, 별도의 시간 (예를 축구 협회 시간외) 후이다.

페널티 슛 아웃에서 주심은 슛 아웃의 목표를 결정하기 위해 동전을 던지고, 어떤 팀이 먼저 시작하는지 결정하기 위해 다른 동전을 던집니다. 그러나이 문제와 관련된 유일한 것은 아래에 설명 된 것입니다.

각 팀은 시작시 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, 문자열 또는 사용자 언어의 기본 목록 형식 에서 변환 된 정수로 표시 될 수 있습니다 . Bijective Base 2 형식을 선택하면 입력 규칙이 Bijective Base 2로 변환 된 숫자에 적용됩니다 (따라서 숫자 1및 2점수를 매기거나 점수를 매기 지 않거나 점수를 매기 지 않음). 일반 이진은 의도 된 이진 표현에서 선행 제로의 존재를 확인할 수 없으므로 허용되지 않습니다 .
• 이것은 code-golf 이므로 가장 짧은 솔루션이 승리합니다. 그러나 귀하의 언어가 "특화된 언어를 능가"할 수없는 것처럼 보이더라도 대답하지 마십시오.

테스트 사례

이 테스트 사례에서 0유언장은 무 목표 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]

자바 스크립트 (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

파이썬 2 , 176 169 171 169 바이트

@Kevin Cruijssen 덕분에 -2 바이트

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

그러나 유효한 점수 세트가 되려면 입력을 계속할 필요는 없지만 마지막 킥을하기 전에 계속할 수 있어야합니다. 이 조건은 1) 양 쪽이 같은 횟수로 마지막으로 걷어차 기 시작했을 때 지속 가능해야하고 2) 현재 연속 가능의 절반 지점 내에 있어야한다는 말과 동일합니다 h. h(a[:~-len(a+b)/2],b[:~-len(a+b)/2],6)테스트 조건 1) 및 h(a,b,7)( 7여백에 허용되는 추가 2 개의 절반을 나타내는) 테스트 조건 2)

각 팀이 최대 5 번 킥한 경우가 해결되었습니다. (다른 경우에 대한 설명은 계속됩니다.)

저수준 골프의 관점에서, 면도해야 할 것이 너무 많지는 않지만, 알고리즘 적으로는 훨씬 더 간단하게 수행 될 수 있습니다.

젤리 , 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의 바닥 글 코드는 여러 테스트 사례를 처리하고 입력에 대해 출력을 인쇄하는 것입니다.

8 바이트를 골라 낸 @EriktheOutgolfer 덕분에

펄 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}

온라인으로 사용해보십시오!

유효한 슛 아웃의 경우 거짓을, 유효하지 않은 슛 아웃의 경우 진실을 반환합니다.

설명

# 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