Trong bóng đá liên kết (còn được gọi là bóng đá), đá luân lưu là biện pháp phá vỡ thứ hai có thể được sử dụng trong một trận đấu không thể kết thúc bằng hòa, sau hiệp phụ (tức là hiệp hội bóng đá ngoài giờ).

Trong loạt sút luân lưu, trọng tài chính ném một đồng xu để xác định mục tiêu nào là loạt sút luân lưu xảy ra, và sau đó ném một đồng xu khác để xác định đội nào bắt đầu trước. Tuy nhiên, điều duy nhất liên quan đến thử thách này là những gì xảy ra sau đó, được mô tả dưới đây.

Mỗi đội có 5 hình phạt có sẵn khi bắt đầu, và tỷ số hình phạt là 0-0. Nếu tại bất kỳ thời điểm nào, hình phạt còn lại của một đội không đủ để thay đổi đội chiến thắng hiện tại, thì loạt đá luân lưu dừng lại.

Nếu không có hình phạt nào còn lại, nhưng điểm của cả hai đội đều bằng nhau, một hình phạt bổ sung sẽ được cấp cho cả hai đội. Điều này được lặp lại cho đến khi các điểm không bằng nhau.

Sau loạt sút luân lưu, đội có số điểm phạt lớn nhất sẽ thắng trận đấu.

Thử thách

Thử thách của bạn là, đưa ra hai danh sách Avà Bthể hiện hình phạt nào mà đội A và đội B ghi được tương ứng, để xác định xem chúng có đại diện cho loạt sút luân lưu hợp lệ hay không. Một loạt đá luân lưu là hợp lệ nếu có thể đạt được trạng thái đại diện bởi đầu vào, bất kể đội chiến thắng có thể được xác định hay không. Lưu ý rằng bạn có thể phải kiểm tra cả hai kịch bản (bắt đầu Đội A, bắt đầu Đội B), vì, nếu trạng thái được mô tả trong đầu vào có thể truy cập được cho ít nhất một kịch bản, đầu vào là hợp lệ. Nếu độ dài của danh sách là khác nhau, nhóm được đại diện bởi nhóm dài hơn bắt đầu trước (nhóm chỉ có thể có nhiều yếu tố hơn nhóm khác và nhóm của danh sách ngắn hơn không thể bắt đầu, do đó nhóm của danh sách dài hơn sẽ bắn hai hình phạt liên tiếp, vì danh sách ngắn hơn sẽ bị cạn kiệt sớm).

Ví dụ chi tiết

Bạn có thể bỏ qua phần Quy tắc bên dưới, đây chỉ là để giúp giải quyết thử thách.

Giả sử bạn lấy cú sút này làm đầu vào, -có nghĩa là không có bàn thắng nào được ghi và Xcó nghĩa là bàn thắng được ghi (không hợp lệ):

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.

Ngược lại, đây là một ví dụ hợp lệ:

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.

Một ví dụ khác, lần này có thêm hình phạt:

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.

Đây là một đầu vào hợp lệ khi còn quá sớm để xác định người chiến thắng:

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.

Cuối cùng, đây là một đầu vào trong đó độ dài của danh sách khác nhau:

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.

Quy tắc

• Đội nào bắn trước có thể là A hoặc B, bạn không thể cho rằng một người sẽ luôn bắn trước.
• Các danh sách sẽ có cùng độ dài hoặc độ dài của chúng sẽ khác nhau.
• Bạn có thể chọn bất kỳ hai giá trị riêng biệt và nhất quán nào để thể hiện các hình phạt được ghi / không được bảo vệ.
• Các danh sách cũng có thể được biểu diễn dưới dạng số nguyên được chuyển đổi từ cơ sở 2, chuỗi hoặc định dạng danh sách gốc của ngôn ngữ của bạn. Nếu định dạng cơ sở 2 phỏng đoán được chọn, quy tắc đầu vào áp dụng cho các số được chuyển đổi thành cơ sở 2 tính toán (vì vậy các chữ số 1và 2có thể có nghĩa là được ghi và không được bảo vệ hoặc không được ghi điểm và được ghi tương ứng). Nhị phân thông thường không được phép , vì người ta không thể xác định sự hiện diện của các số 0 đứng đầu trong biểu diễn nhị phân dự định.
• Đây là môn đánh gôn , vì vậy giải pháp ngắn nhất sẽ thắng. Tuy nhiên, xin đừng nản lòng khi trả lời ngay cả khi có vẻ như ngôn ngữ của bạn không thể "đánh bại những người chuyên ngành".

Các trường hợp thử nghiệm

Trong các trường hợp thử nghiệm này, 0di chúc đại diện cho mục tiêu không có mục tiêu và 1ý chí đại diện cho mục tiêu.

Định dạng:

[Team A], [Team B]

Đầu vào hợp lệ:

[], []
[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]

Đầu vào không hợp lệ:

[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 byte

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

Hãy thử trực tuyến!

Đã bình luận

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 byte

-2 byte nhờ @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)

Hãy thử trực tuyến! (Bao gồm một số trường hợp thử nghiệm bổ sung không được liệt kê ở trên.)

Tạo một hàm fcó hai đối số (hai danh sách các hình phạt được ghi / không được kiểm soát) và trả về Truenếu điểm số có thể hợp lệ và Falsenếu không.

Giải thích một phần:

Trước hết, việc execxây dựng chỉ là một cách để tiết kiệm một vài byte bằng cách không phải lặp lại biểu thức len(a+b)nhiều lần. Đoạn mã trên tương đương với đoạn mã sau:

Cập nhật: câu trả lời mới và được cải thiện là cùng một số byte có hoặc không có execmánh khóe, vì vậy vì lợi ích của sự đơn giản, tôi đã loại bỏ nó.

Cập nhật 2: Phiên bản sửa lỗi mới bao gồm nén chuỗi nhiều hơn thông qua thay thế và exec. Có, tôi sử dụng %định dạng và một .replacechuỗi trên cùng một chuỗi. Mã ở trên tương đương với:

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

Tuy nhiên, để trở thành một bộ điểm số hợp lệ, một đầu vào không cần phải được tiếp tục một cách nghiêm ngặt, nhưng nó phải được tiếp tục trước khi cú đá cuối cùng được thực hiện. Điều kiện này tương đương với việc nói rằng nó phải 1) có thể tiếp tục được trong lần cuối cùng cả hai bên đã đá cùng một số lần và 2) hiện đang ở trong hai nửa điểm có thể tiếp tục - đó là nơi tranh luận cuối cùng hxuất hiện: h(a[:~-len(a+b)/2],b[:~-len(a+b)/2],6)kiểm tra điều kiện 1) và h(a,b,7)( 7đại diện cho thêm hai nửa điểm cho phép trong lề) kiểm tra điều kiện 2).

Trường hợp mỗi đội đã đá tối đa năm lần như vậy đã được giải quyết. (Giải thích để được tiếp tục cho trường hợp khác.)

Về mặt chơi golf ở cấp độ thấp, tôi nghi ngờ có quá nhiều thứ để cạo râu, nhưng về mặt thuật toán có lẽ nó có thể được thực hiện đơn giản hơn một chút.

Thạch , 62 54 49 byte

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

Hãy thử trực tuyến!

ṫ⁵Ṗ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Ç

Lưu ý mã chân trang tại tio chỉ để xử lý nhiều trường hợp thử nghiệm và in đầu ra so với đầu vào.

Cảm ơn @EriktheOutgolfer đã chơi golf 8 byte

Perl 6 , 123 byte

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

Hãy thử trực tuyến!

Trả lại falsey cho loạt đá luân lưu hợp lệ, trung thực cho những người không hợp lệ.

Giải trình

# 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