Dalam sepak bola asosiasi (juga dikenal sebagai sepak bola), adu penalti adalah tindakan kedua yang bisa digunakan dalam pertandingan yang tidak bisa berakhir dengan seri, setelah perpanjangan waktu (yaitu sepak bola asosiasi lembur).

Dalam adu penalti, wasit utama melempar koin untuk menentukan di mana gol adu penalti terjadi, dan kemudian melemparkan koin lain untuk menentukan tim mana yang mulai lebih dulu. Namun, satu-satunya hal yang relevan dengan tantangan ini adalah apa yang terjadi kemudian, dijelaskan di bawah ini.

Setiap tim memiliki 5 penalti yang tersedia di awal, dan skor penalti adalah 0-0. Jika, pada suatu titik, penalti tim yang tersisa tidak cukup untuk mengubah tim yang saat ini menang, adu penalti berhenti.

Jika tidak ada penalti yang tersisa, tetapi poin kedua tim sama, penalti tambahan diberikan untuk kedua tim. Ini diulangi sampai poin tidak sama.

Setelah tembak-menembak berhenti, tim dengan skor penalti terbesar memenangkan permainan.

Tantangan

Tantangan Anda adalah, diberi dua daftar Adan Bmewakili tim penalti A dan tim B mana yang mencetak skor masing-masing, untuk menentukan apakah mereka mewakili adu penalti yang sah. Adu tembak adalah valid jika keadaan yang diwakili oleh input dapat dicapai, terlepas dari apakah tim pemenang dapat ditentukan. Perhatikan bahwa Anda mungkin harus menguji kedua skenario (awal Tim A, awal Tim B), karena, jika keadaan yang dijelaskan dalam input dapat dijangkau untuk setidaknya satu skenario, input tersebut valid. Jika panjang daftar berbeda, tim yang diwakili oleh yang lebih panjang mulai lebih dulu (hanya dapat memiliki satu elemen lebih banyak dari yang lain, dan tim daftar yang lebih pendek tidak dapat memulai, karena kemudian tim daftar yang lebih panjang akan menembakkan dua penalti berturut-turut, karena daftar yang lebih pendek akan habis sebelum waktunya).

Contoh terperinci

Anda dapat melompat ke bagian Aturan di bawah ini, ini hanya untuk membantu menyelesaikan tantangan.

Misalkan Anda mendapatkan shoot-out ini sebagai input, di mana -berarti tidak ada gol yang dicetak dan Xberarti gol dicetak (itu tidak valid):

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.

Sebaliknya, ini adalah contoh yang valid:

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.

Contoh lain, kali ini dengan penalti ekstra:

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.

Berikut adalah input yang valid untuk menentukan pemenang:

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.

Akhirnya, inilah input di mana panjang daftar berbeda:

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.

Aturan

• Tim yang menembak pertama kali bisa A atau B, Anda tidak dapat menganggap satu akan selalu menembak terlebih dahulu.
• Daftar tersebut akan memiliki panjang yang sama, atau panjangnya akan berbeda satu.
• Anda dapat memilih dua nilai berbeda dan konsisten untuk mewakili hukuman yang dicetak / tidak dicetak.
• Daftar juga dapat direpresentasikan sebagai bilangan bulat yang dikonversi dari basis 2 kata sifat , string atau format daftar asli bahasa Anda. Jika format bijective base 2 dipilih, aturan input berlaku untuk angka-angka yang dikonversi ke bijective base 2 (jadi digit 1dan 2dapat berarti masing-masing mencetak gol dan tanpa skor atau tanpa skor dan skor masing-masing). Biner reguler tidak diperbolehkan , karena seseorang tidak dapat menentukan keberadaan nol terkemuka di representasi biner yang dimaksud.
• Ini adalah kode-golf , sehingga solusi terpendek menang. Namun, tolong jangan berkecil hati untuk menjawab bahkan jika sepertinya bahasa Anda tidak dapat "mengalahkan yang khusus".

Uji kasus

Dalam kasus-kasus uji ini, a 0akan mewakili tanpa tujuan, dan 1akan mewakili suatu tujuan.

Format:

[Team A], [Team B]

Input yang valid:

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

Input tidak valid:

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

Cobalah online!

Berkomentar

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 terima kasih kepada @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)

Cobalah online! (Termasuk beberapa test case tambahan yang tidak tercantum di atas.)

Menciptakan fungsi fyang mengambil dua argumen (dua daftar penalti yang dicetak / tidak dihukum) dan kembali Truejika skor mungkin valid dan Falsesebaliknya.

Penjelasan sebagian:

Pertama-tama, execkonstruksi hanyalah cara untuk menghemat beberapa byte dengan tidak harus mengulangi ekspresi len(a+b)lebih dari sekali. Sepotong kode di atas setara dengan yang berikut:

Pembaruan: jawaban yang baru dan lebih baik adalah jumlah byte yang sama dengan atau tanpa exectipu daya, jadi demi kesederhanaan saya telah menghapusnya.

Pembaruan 2: Versi bugfixed baru termasuk lebih banyak kompresi string melalui substitusi dan exec. Ya, saya menggunakan %pemformatan dan .replacepada string yang sama. Kode di atas setara dengan:

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

Namun, untuk menjadi set skor yang valid, input tidak harus benar-benar berkelanjutan, tetapi itu harus telah berkelanjutan sebelum tendangan terakhir dilakukan. Kondisi ini setara dengan mengatakan bahwa itu harus 1) telah berkelanjutan saat terakhir kali kedua belah pihak menendang jumlah yang sama kali dan 2) saat ini berada dalam dua setengah poin menjadi berkelanjutan - yang merupakan alasan argumen terakhir h: h(a[:~-len(a+b)/2],b[:~-len(a+b)/2],6)menguji kondisi 1) dan h(a,b,7)(yang 7mewakili dua poin tambahan yang diijinkan dalam margin) menguji kondisi 2).

Kasus di mana masing-masing tim telah menendang maksimal lima kali telah diselesaikan. (Penjelasan dilanjutkan untuk kasus lainnya.)

Dalam hal bermain golf tingkat rendah, saya ragu ada terlalu banyak untuk dicukur, tetapi secara algoritmik mungkin bisa dilakukan sedikit lebih sederhana.

Jelly , 62 54 49 byte

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

Cobalah online!

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

Perhatikan kode footer di tio hanya untuk menangani beberapa test case dan mencetak output terhadap input.

Terima kasih kepada @EriktheOutgolfer untuk bermain 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}

Cobalah online!

Mengembalikan falsey untuk tembak-menembak yang valid, jujur ​​untuk yang tidak valid.

Penjelasan

# 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