Im Vereinsfußball (auch als Fußball bezeichnet) ist ein Elfmeterschießen die zweite Maßnahme, die nach einer Verlängerung (z. B. Verlängerung des Vereinsfußballs) in einem Spiel durchgeführt werden kann, das nicht mit einem Unentschieden endet.

Bei einem Elfmeterschießen wirft der Hauptschiedsrichter eine Münze, um festzustellen, bei welchem ​​Tor das Schießen stattfindet, und wirft dann eine weitere Münze, um festzustellen, welches Team zuerst startet. Das einzige, was für diese Herausforderung relevant ist, ist das, was dann passiert, wie unten beschrieben.

Jedes Team hat zu Beginn 5 Strafen zur Verfügung und die Strafpunktzahl ist 0-0. Wenn zu irgendeinem Zeitpunkt die verbleibenden Strafen einer Mannschaft nicht ausreichen, um die derzeit siegreiche Mannschaft zu ändern, wird das Schießen eingestellt.

Wenn es keine verbleibenden Strafen gibt, die Punkte beider Teams jedoch gleich sind, erhalten beide Teams eine zusätzliche Strafe. Dies wird wiederholt, bis die Punkte nicht mehr gleich sind.

Nach dem Ende des Schießens gewinnt das Team mit der höchsten Strafpunktzahl das Spiel.

Herausforderung

Ihre Herausforderung ist, da zwei Listen Aund Bdarstellt , welche Strafen Team A und Team B erzielt bzw. zu bestimmen , ob sie eine gültige Elfmeterschießen aus darstellen. Ein Elfmeterschießen ist gültig, wenn der durch die Eingabe dargestellte Zustand erreicht werden kann, unabhängig davon, ob die Siegermannschaft ermittelt werden kann. Beachten Sie, dass Sie möglicherweise beide Szenarien testen müssen (Team A startet, Team B startet), da die Eingabe gültig ist, wenn der in der Eingabe beschriebene Status für mindestens ein Szenario erreichbar ist. Wenn die Längen der Listen unterschiedlich sind, startet das Team, das durch das längere Team dargestellt wird, zuerst (es kann nur ein Element mehr als das andere haben, und das Team der kürzeren Liste kann nicht starten, da das Team der längeren Liste dann zwei Strafen schießt hintereinander, da die kürzere Liste vorzeitig erschöpft wird).

Ausführliche Beispiele

Sie können zum folgenden Abschnitt mit den Regeln springen. Diese dienen nur dazu, die Herausforderung zu lösen.

Angenommen, Sie erhalten dieses Schießen als Eingabe, wobei -bedeutet, dass kein Tor erzielt wurde und Xein Tor erzielt wurde (es ist ungültig):

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.

Im Gegenteil, hier ist ein gültiges Beispiel:

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.

Ein weiteres Beispiel, diesmal mit zusätzlichen Strafen:

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.

Hier ist eine gültige Eingabe, bei der es zu früh ist, um den Gewinner zu bestimmen:

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.

Hier ist eine Eingabe, bei der sich die Listenlängen unterscheiden:

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.

Regeln

• Die Mannschaft, die zuerst schießt, kann entweder A oder B sein. Man kann nicht davon ausgehen, dass immer eine zuerst schießt.
• Die Listen haben entweder die gleiche Länge oder sie unterscheiden sich um eins.
• Sie können zwei unterschiedliche und konsistente Werte auswählen, um erzielte / nicht bewertete Strafen darzustellen.
• Die Listen können auch als Ganzzahlen dargestellt werden, die von der bijektiven Basis 2, Zeichenfolgen oder dem systemeigenen Listenformat Ihrer Sprache konvertiert wurden. Wenn ein bijektives Basis-2-Format ausgewählt wird, gelten die Eingaberegeln für die in bijektives Basis-2-Format umgewandelten Zahlen (also Ziffern 1und 2können entweder Punkte und Punkte ohne Punktzahl oder Punkte und Punkte ohne Punktzahl bedeuten). Reguläre Binärdarstellung ist nicht zulässig , da das Vorhandensein führender Nullen in der beabsichtigten Binärdarstellung nicht festgestellt werden kann.
• Das ist Code-Golf , also gewinnt die kürzeste Lösung. Bitte lassen Sie sich jedoch nicht von der Beantwortung entmutigen, auch wenn es so aussieht, als könne Ihre Sprache die Fachsprache nicht schlagen.

Testfälle

In diesen Testfällen steht a 0für ein Nichtziel und a 1für ein Ziel.

Format:

[Team A], [Team B]

Gültige Eingaben:

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

Ungültige Eingaben:

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

Probieren Sie es online!

Kommentiert

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 Bytes

-2 Bytes dank @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)

Probieren Sie es online! (Einschließlich einiger zusätzlicher Testfälle, die oben nicht aufgeführt sind.)

Erstellt eine Funktion f, die zwei Argumente akzeptiert (die zwei Listen mit bewerteten / nicht bewerteten Strafen) und zurückgibt, Trueob die Bewertungen möglicherweise gültig sind und Falsenicht.

Teilweise Erklärung:

Erstens ist die execKonstruktion nur ein Weg, um ein paar Bytes zu sparen, indem der Ausdruck nicht len(a+b)mehr als einmal wiederholt werden muss. Der obige Code entspricht dem Folgenden:

Update: Die neue und verbesserte Antwort ist die gleiche Anzahl von Bytes mit oder ohne execTrick. Aus Gründen der Einfachheit habe ich sie entfernt.

Update 2: Die neue Version mit Bugfixes beinhaltet noch mehr String-Komprimierung durch Substitution und exec. Ja, ich verwende die %Formatierung und a .replacein derselben Zeichenfolge. Der obige Code entspricht:

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)

Die Hauptidee dieser Antwort ist es, die Frage in Form von "halben Punkten" zu formulieren: Jeder erfolgreiche Tritt ist ein halber Punkt und jeder gescheiterte ist ein negativer halber Punkt. Für eine Reihe von Partituren mit Länge$<=5$um fortzufahren ( not len(a+b)>10), muss die Gesamtzahl der verbleibenden Tritte größer oder gleich dem halben Punkt Abstand zwischen den beiden Teams sein. Wenn eine Mannschaft eine Verlängerung getreten hat, muss aus verschiedenen Gründen ein halber Punkt vom Spielraum abgezogen werden. Dies kann vereinfacht werden, indem beide Seiten der Gleichung durch zwei geteilt werden. Dies ist die Funktion him Code (mit dem Argument m6).

Um jedoch eine gültige Punktzahl zu erhalten, muss eine Eingabe nicht unbedingt fortführbar sein, sondern muss vor dem letzten Tritt fortführbar gewesen sein. Diese Bedingung ist gleichbedeutend mit der Aussage, dass beide Seiten 1) das letzte Mal, als sie die gleiche Anzahl von Tritten ausgeführt haben, fortfahren mussten und 2) derzeit nicht mehr als zwei halbe Punkte von ihrer Fortführbarkeit entfernt sind - hier kommt das letzte Argument ins Spiel h: h(a[:~-len(a+b)/2],b[:~-len(a+b)/2],6)Testbedingung 1) und h(a,b,7)(die 7zwei zusätzliche zulässige halbe Punkte im Rand darstellen) Testbedingung 2).

Der Fall, dass jedes Team maximal fünf Mal gekickt hat, ist damit geklärt. (Erklärung wird für den anderen Fall fortgesetzt.)

Ich bezweifle, dass es in Bezug auf Golf auf niedrigem Niveau zu viel gibt, um sich zu rasieren, aber algorithmisch könnte es wahrscheinlich viel einfacher gemacht werden.

Jelly , 62 54 49 Bytes

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

Probieren Sie es 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Ç

Beachten Sie, dass der Fußzeilencode bei tio nur dazu dient, mehrere Testfälle zu verarbeiten und Ausgaben gegen Eingaben auszudrucken.

Vielen Dank an @EriktheOutgolfer für das Abschlagen von 8 Bytes

Perl 6 , 123 Bytes

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

Probieren Sie es online!

Gibt Falschgeld für gültige Schießereien zurück, Wahrheit für ungültige.

Erläuterung

# 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