Gelen ilişki futbol (aynı zamanda futbol olarak da bilinir), bir penaltı-out bir bağ içinde sona bir maç kullanılabilen ikinci bağlantı kesici ölçüsü, ekstra zaman (yani, futbol mesai) sonradır.

Penaltı atışlarında, ana hakem atış atışının hangi hedefe ulaştığını belirlemek için bir jeton fırlatır ve ardından hangi takımın ilk başladığını belirlemek için başka bir jeton fırlatır. Bununla birlikte, bu sorunla ilgili tek şey, aşağıda açıklanan şeydir.

Her takımın başlangıçta 5 penaltısı vardır ve penaltı puanı 0-0'dır. Herhangi bir noktada, bir takımın kalan cezaları şu anda kazanan takımı değiştirmek için yeterli değilse, atıcı durur.

Kalan ceza yoksa, ancak her iki takımın puanı eşitse, her iki takıma da ek bir ceza verilir. Puanlar eşit oluncaya kadar bu tekrarlanır.

Atış durdurulduktan sonra, en yüksek penaltı puanına sahip takım oyunu kazanır.

Meydan okuma

İki liste verildiğinde Ave BA takımının ve B takımının hangi penaltıları attığını, geçerli bir penaltı atışını temsil edip etmediklerini belirlemek için mücadeleniz. Atış ile temsil edilen duruma ulaşılabiliyorsa, kazanan takımın belirlenip belirlenemeyeceğine bir şut geçerlidir. Girişte açıklanan duruma en az bir senaryo için ulaşılabiliyorsa, giriş geçerli olduğundan, her iki senaryo için de (Takım A başlangıcı, Takım B başlangıcı) test etmeniz gerektiğini unutmayın. Listelerin uzunlukları farklıysa, daha uzun olan tarafından temsil edilen takım önce başlar (diğerinden daha fazla bir öğeye sahip olabilir ve daha kısa listenin ekibi başlayamaz, çünkü daha uzun listenin ekibi iki ceza atar daha kısa liste zamanından önce biteceği için üst üste).

Ayrıntılı örnekler

Aşağıdaki Kurallar bölümüne atlayabilirsiniz , bunlar yalnızca zorluğun çözülmesine yardımcı olmak içindir.

Bu atıcıyı girdi olarak aldığınızı varsayalım, burada -hiçbir gol atılmaz ve Xbir gol atılır (geçersiz):

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.

Aksine, geçerli bir örnek:

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.

Başka bir örnek, bu kez ekstra cezalarla:

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.

İşte kazananı belirlemek için çok erken olduğu geçerli bir giriş:

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.

Son olarak, listelerin uzunluklarının farklı olduğu bir girdi:

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.

kurallar

• İlk atış yapan takım A veya B olabilir, her zaman ilk atış yapacağınızı varsayamazsınız.
• Listeler aynı uzunlukta olacaktır veya uzunlukları bir farklı olacaktır.
• Puanlı / puansız cezaları temsil etmek için iki farklı ve tutarlı değer seçebilirsiniz.
• Listeler ayrıca iki temel tabandan , dizelerden veya dilinizin yerel liste biçiminden dönüştürülen tamsayılar olarak da temsil edilebilir . Bir örten tabanı 2 biçimi seçildiğinde, giriş kuralları numaraları için de geçerlidir örten taban 2'ye dönüştürülen (basamak çok 1ve 2herhangi birinde ayrı ayrı puan ve çizilmemiş veya çizilmemiş ve çizilmiş anlamına gelebilir). Düzenli ikili dosyaya izin verilmez , çünkü amaçlanan ikili gösterimde baştaki sıfırların varlığını belirleyemez.
• Bu kod golf , bu yüzden en kısa çözüm kazanır. Ancak, diliniz "uzman olanları yenemez" gibi görünse bile yanıt vermekten vazgeçmeyin.

Test senaryoları

Bu test örneklerinde, bir 0irade bir hedefi olmayanı ve bir 1irade bir hedefi temsil eder.

Biçim:

[Team A], [Team B]

Geçerli girişler:

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

Geçersiz girişler:

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

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

Çevrimiçi deneyin!

Yorumlananlar

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

Piton 2 , 176 169 171 169 bayt

@Kevin Cruijssen sayesinde -2 bayt

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)

Çevrimiçi deneyin! (Yukarıda listelenmeyen bazı ekstra test durumları dahil.)

fİki argüman alan bir fonksiyon oluşturur (skorlu / skorsuz cezaların iki listesi) ve Trueskorlar muhtemelen geçerli ve Falseaksi takdirde geri döner .

Kısmi açıklama:

Her şeyden önce, execinşaat, ifadeyi bir len(a+b)kereden fazla tekrarlamak zorunda kalmadan birkaç bayt kurtarmanın bir yoludur . Yukarıdaki kod parçası aşağıdakine eşittir:

Güncelleme: yeni ve geliştirilmiş cevap, exechile ile veya hile olmadan aynı bayt sayımıdır, bu nedenle basitliğin çıkarları için kaldırdım.

Güncelleme 2: Yeni düzeltilen sürüm, ikame ve aracılığıyla daha fazla dize sıkıştırması içerir exec. Evet, aynı dizede %biçimlendirme ve a kullanıyorum .replace. Yukarıdaki kod şuna eşdeğerdir:

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

Bununla birlikte, geçerli bir skor seti olmak için, bir girdinin kesinlikle sürdürülebilir olması gerekmez, ancak son vuruşun yapılmasından önce de devam ettirilmesi gerekir. Bu durum, 1) her iki tarafın da aynı sayıda kez son kez devam etmesi ve 2) şu anda sürdürebilir olmanın iki yarım noktası içinde olması gerektiğini söylemekle eşdeğerdir - bu, nihai argümanın hgeldiği yerdir : h(a[:~-len(a+b)/2],b[:~-len(a+b)/2],6)test koşulu 1) ve h(a,b,7)( 7marjda izin verilen ekstra iki yarı noktayı temsil eden) test koşulu 2).

Böylece her takımın en fazla beş kez tekme attığı durum karara bağlanmıştır. (Diğer dava için açıklama devam edecektir.)

Düşük seviyeli golf açısından, tıraş olmak için çok fazla şey olduğundan şüpheliyim, ancak algoritmik olarak muhtemelen biraz daha basit bir şekilde yapılabilir.

Jöle , 62 54 49 bayt

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

Çevrimiçi deneyin!

ṫ⁵Ṗ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'daki altbilgi kodunun yalnızca birden çok test senaryosunu ve çıktıları girdilere karşı işlemek için olduğunu unutmayın.

8 baytlık golf için @EriktheOutgolfer'a teşekkürler

Perl 6 , 123 bayt

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

Çevrimiçi deneyin!

Geçerli atışlar için falsey, geçersiz olanlar için doğruluk verir.

açıklama

# 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