Nel calcio associativo (noto anche come calcio), un tiro di rigore è la seconda misura del pareggio che può essere utilizzata in una partita che non può finire in parità, dopo i tempi supplementari (ad es. Il calcio straordinario dell'associazione).

In un tiro di rigore, l'arbitro principale lancia una moneta per determinare a quale goal avviene il tiro, quindi lancia un'altra moneta per determinare quale squadra inizia per prima. Tuttavia, l'unica cosa rilevante per questa sfida è ciò che accade allora, descritto di seguito.

Ogni squadra ha 5 penalità disponibili all'inizio e il punteggio della penalità è 0-0. Se, in qualsiasi momento, le penalità rimanenti di una squadra non sono sufficienti per cambiare la squadra attualmente vincente, lo sho-stop si interrompe.

Se non ci sono penalità rimanenti, ma i punti di entrambe le squadre sono uguali, viene accordata una penalità aggiuntiva per entrambe le squadre. Questo si ripete fino a quando i punti non sono uguali.

Dopo l'arresto del tiro, la squadra con il punteggio più alto vince la partita.

Sfida

La tua sfida è, dato due elenchi Ae Bche rappresentano rispettivamente i rigori segnati rispettivamente dalla squadra A e dalla squadra B, per determinare se rappresentano un rigore valido. Una sparatoria è valida se è possibile raggiungere lo stato rappresentato dall'input, indipendentemente dal fatto che la squadra vincente possa essere determinata. È possibile che sia necessario eseguire il test per entrambi gli scenari (avvio della squadra A, avvio della squadra B) poiché, se lo stato descritto nell'input è raggiungibile per almeno uno scenario, l'input è valido. Se le lunghezze delle liste sono diverse, la squadra rappresentata da quella più lunga inizia per prima (può avere solo un elemento in più rispetto all'altra e la squadra della lista più corta non può iniziare, da allora la squadra della lista più lunga tirerebbe due penalità di seguito, poiché l'elenco più breve verrà esaurito prematuramente).

Esempi dettagliati

Puoi saltare alla sezione Regole di seguito, solo per aiutare a risolvere la sfida.

Supponiamo di ottenere questo tiro fuori come input, dove -significa che nessun goal è stato segnato e Xsignifica che un goal è stato segnato (non è valido):

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.

Al contrario, ecco un esempio valido:

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.

Un altro esempio, questa volta con penalità extra:

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.

Ecco un input valido in cui è troppo presto per determinare il vincitore:

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.

Infine, ecco un input in cui le lunghezze delle liste differiscono:

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.

Regole

• La squadra che spara per prima può essere A o B, non puoi presumere che uno tiri sempre per primo.
• Gli elenchi avranno la stessa lunghezza o le loro lunghezze differiranno di una.
• Puoi scegliere due valori distinti e coerenti per rappresentare penalità segnate / non segnate.
• Gli elenchi possono anche essere rappresentati come numeri interi convertiti dalla base biiettiva 2, stringhe o dal formato elenco nativo della tua lingua. Se viene scelto un formato di base 2 biiettivo, le regole di input si applicano ai numeri convertiti in base biiettiva 2 (quindi cifre 1e 2possono significare rispettivamente punteggio e non segnato o non segnato e segnato). Il binario regolare non è consentito , poiché non è possibile determinare la presenza di zeri iniziali nella rappresentazione binaria prevista.
• Questo è code-golf , quindi vince la soluzione più breve. Tuttavia, ti preghiamo di non scoraggiarti dal rispondere anche se sembra che la tua lingua non possa "battere quelle specializzate".

Casi test

In questi casi di test, una 0volontà rappresenterà un non-obiettivo e una 1volontà rappresenterà un obiettivo.

Formato:

[Team A], [Team B]

Ingressi validi:

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

Ingressi non validi:

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

Provalo online!

Commentate

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 grazie a @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)

Provalo online! (Compresi alcuni casi di test extra non elencati sopra.)

Crea una funzione f che accetta due argomenti (i due elenchi delle penalità segnate / non segnate) e restituisce Truese i punteggi sono eventualmente validi e in caso Falsecontrario.

Spiegazione parziale:

Prima di tutto, la execcostruzione è solo un modo per salvare qualche byte non ripetendo l'espressionelen(a+b) più di una volta. Il codice sopra riportato è equivalente al seguente:

Aggiornamento: la risposta nuova e migliorata è lo stesso conteggio di byte con o senza exec inganno, quindi per motivi di semplicità l'ho rimosso.

Aggiornamento 2: La nuova versione corretta di bug include ancora più compressione delle stringhe tramite sostituzione e exec. Sì, utilizzo la %formattazione e una .replacesulla stessa stringa. Il codice sopra è equivalente a:

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

Tuttavia, per essere un insieme valido di punteggi, un input non deve essere strettamente continuativo, ma deve essere stato continuabile prima che sia stato effettuato l'ultimo calcio. Questa condizione equivale a dire che deve 1) essere stato continuativo l'ultima volta che entrambe le parti hanno calciato lo stesso numero di volte e 2) essere attualmente entro due punti e mezzo di essere continuabile - ed è qui che arriva l'argomento finale h: h(a[:~-len(a+b)/2],b[:~-len(a+b)/2],6)verifica la condizione 1) e h(a,b,7)(la 7rappresentazione di altri due mezze punte consentite a margine) verifica la condizione 2).

Il caso in cui ciascuna squadra abbia calciato un massimo di cinque volte è stato quindi risolto. (Spiegazione da continuare per l'altro caso.)

In termini di golf a basso livello, dubito che ci sia troppo da radere, ma algoritmicamente potrebbe probabilmente essere fatto un po 'più semplicemente.

Gelatina , 62 54 49 byte

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

Provalo 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Ç

Si noti che il codice piè di pagina di tio è solo per gestire più casi di test e stampare output su input.

Grazie a @EriktheOutgolfer per giocare a golf con 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}

Provalo online!

Restituisce falsey per sparatorie valide, sinceramente per sparatorie non valide.

Spiegazione

# 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