ในสมาคมฟุตบอล (หรือเรียกอีกอย่างว่าฟุตบอล) การยิงจุดโทษเป็นมาตรการที่สองที่ใช้ในการแข่งขันซึ่งไม่สามารถจบลงด้วยการเสมอกันหลังจากช่วงต่อเวลาพิเศษ (เช่นสมาคมฟุตบอลล่วงเวลา)

ในการยิงจุดโทษผู้ตัดสินหลักโยนเหรียญเพื่อตัดสินว่าเกิดการยิงประตูครั้งใดจากนั้นโยนเหรียญอีกครั้งเพื่อพิจารณาว่าทีมใดเริ่มต้นก่อน อย่างไรก็ตามสิ่งเดียวที่เกี่ยวข้องกับความท้าทายนี้คือสิ่งที่เกิดขึ้นแล้วอธิบายไว้ด้านล่าง

แต่ละทีมมีการลงโทษ 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 คุณไม่สามารถสันนิษฐานได้ว่าจะยิงก่อนเสมอ
• รายการจะมีความยาวเท่ากันหรือความยาวจะแตกต่างกันไปหนึ่งรายการ
• คุณสามารถเลือกสองค่าที่แตกต่างและสอดคล้องกันเพื่อแสดงถึงการลงโทษที่ได้คะแนน / ไม่ได้คะแนน
• รายการยังสามารถแสดงเป็นจำนวนเต็มที่แปลงจากbijective base 2, สตริงหรือรูปแบบรายการดั้งเดิมของภาษาของคุณ หากเลือกรูปแบบฐาน bijective 2 กฎอินพุตจะนำไปใช้กับตัวเลขที่แปลงเป็นฐาน bijective 2 (ดังนั้นตัวเลข1และ2อาจหมายถึงคะแนนและไม่ได้คะแนนหรือไม่ได้คะแนนและไม่ได้คะแนนตามลำดับ) ไม่อนุญาตให้ใช้ไบนารีปกติเนื่องจากไม่สามารถระบุว่ามีเลขศูนย์นำหน้าในการแทนค่าไบนารี่ที่ต้องการ
• นี่คือรหัสกอล์ฟดังนั้นทางออกที่สั้นที่สุดชนะ อย่างไรก็ตามโปรดอย่าท้อแท้จากการตอบแม้ว่าดูเหมือนว่าภาษาของคุณจะไม่สามารถ "เอาชนะคนพิเศษ" ได้

กรณีทดสอบ

ในกรณีทดสอบเหล่านี้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]

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รุ่นใหม่รวมถึงการแก้ปัญหาการบีบอัดสตริงมากยิ่งขึ้นผ่านการทดแทนและ ใช่ฉันใช้%การจัดรูปแบบและ a .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)

กรณีที่แต่ละทีมมีการเตะมากที่สุดห้าครั้งจึงมีการตัดสิน (คำอธิบายจะดำเนินการต่อในกรณีอื่น)

ในแง่ของการเล่นกอล์ฟระดับต่ำฉันสงสัยว่ามีมากเกินกว่าที่จะโกนออกได้ แต่อัลกอริทึมมันอาจจะทำได้ง่ายขึ้นอีกเล็กน้อย

เยลลี่ , 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 , 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 สำหรับการยิงที่ถูกต้องจริงสำหรับคนที่ไม่ถูกต้อง

คำอธิบาย

# 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