Est-ce un préfixe de fusillade valide?

14

Dans le football d'association (également connu sous le nom de football), une séance de tirs au but est la deuxième mesure de bris d'égalité qui peut être utilisée dans un match qui ne peut pas se terminer par une égalité, après une prolongation (c'est-à-dire des heures supplémentaires de football d'association).

Lors d'une séance de tirs au but, l'arbitre principal lance une pièce pour déterminer à quel but la fusillade a lieu, puis lance une autre pièce pour déterminer quelle équipe commence en premier. Cependant, la seule chose pertinente pour ce défi est ce qui se passe alors, décrit ci-dessous.

Chaque équipe dispose de 5 pénalités au départ et le score de pénalité est de 0-0. Si, à tout moment, les pénalités restantes d'une équipe ne suffisent pas à changer l'équipe actuellement gagnante, la fusillade s'arrête.

S'il n'y a plus de pénalité, mais que les points des deux équipes sont égaux, une pénalité supplémentaire est accordée aux deux équipes. Ceci est répété jusqu'à ce que les points ne soient pas égaux.

Après les tirs de barrage, l'équipe avec le score de pénalité le plus élevé remporte la partie.

Défi

Votre défi est, étant donné deux listes AetB représenter les pénalités que l'équipe A et l'équipe B ont respectivement marquées, à déterminer si elles représentent une fusillade valide. Une fusillade est valide si l'état représenté par l'entrée peut être atteint, que l'équipe gagnante puisse être déterminée ou non. Notez que vous devez éventuellement tester les deux scénarios (démarrage de l'équipe A, démarrage de l'équipe B), car si l'état décrit dans l'entrée est accessible pour au moins un scénario, l'entrée est valide. Si les longueurs des listes sont différentes, l'équipe représentée par la plus longue commence en premier (elle ne peut avoir qu'un élément de plus que l'autre, et l'équipe de la liste la plus courte ne peut pas commencer, car alors l'équipe de la liste la plus longue tirerait deux pénalités d'affilée, car la liste plus courte sera épuisée prématurément).

Exemples détaillés

Vous pouvez passer à la section Règles ci-dessous, ce n'est que pour aider à résoudre le défi.

Supposons que vous obtenez cette fusillade en entrée, où -signifie qu'aucun but n'a été marqué et Xsignifie qu'un but a été marqué (il n'est pas valide):

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.

Au contraire, voici un exemple valable:

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 autre exemple, cette fois avec des pénalités supplémentaires:

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.

Voici une entrée valide où il est trop tôt pour déterminer le gagnant:

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.

Enfin, voici une entrée où les longueurs des listes diffèrent:

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.

Règles

  • L'équipe qui tire en premier peut être A ou B, vous ne pouvez pas supposer que l'on tirera toujours en premier.
  • Les listes auront soit la même longueur, soit leur longueur différera d'une unité.
  • Vous pouvez choisir deux valeurs distinctes et cohérentes pour représenter les pénalités marquées / non marquées.
  • Les listes peuvent également être représentées sous forme d'entiers convertis à partir de la base bijective 2, de chaînes ou du format de liste natif de votre langue. Si un format de base bijective 2 est choisi, les règles d'entrée s'appliquent aux nombres convertis en base bijective 2 (donc les chiffres 1et 2peuvent signifier respectivement notés et non notés ou non notés et notés). Le binaire régulier n'est pas autorisé , car on ne peut pas déterminer la présence de zéros de tête dans la représentation binaire prévue.
  • C'est le code-golf , donc la solution la plus courte l'emporte. Cependant, ne vous découragez pas de répondre même s'il semble que votre langue ne peut pas «battre les langues spécialisées».

Cas de test

Dans ces cas de test, un 0testament représente un objectif nul et un 1testament représente un objectif.

Format:

[Team A], [Team B]

Entrées valides:

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

Entrées non valides:

[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]
code-golf  decision-problem 
— Erik le Outgolfer
source
Puis-je retourner 0 ou faux pour invalide et renvoyer vrai pour valide?
— Incarnation de l'ignorance
@EmbodimentofIgnorance "Vous pouvez choisir deux valeurs distinctes et cohérentes pour représenter les pénalités marquées / non marquées." Les valeurs exactes n'ont pas d'importance, mais il ne doit y avoir que deux valeurs.
— Erik the Outgolfer
Je suppose [[0,0],[1,1]](ou tout cas de test où l'une des deux listes internes contient 2 éléments) est vrai, car le jeu est toujours en cours (tout comme les cas de test avec [[0],[1]]ou [[0],[]]sont toujours en cours)?
— Kevin Cruijssen
@KevinCruijssen Oui, car personne ne peut déterminer qui va gagner, le résultat pourrait être 3-2. ;-)
— Erik l'Outgolfer

Réponses:

3

JavaScript (ES6),  117 112  109 octets

(a)(b)1201

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)

Essayez-le en ligne!

Commenté

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
— Arnauld
source
2

Python 2 , 176 169 171 171 169 octets

-2 octets grâce à @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)

Essayez-le en ligne!(Y compris certains cas de test supplémentaires non répertoriés ci-dessus.)

Crée une fonction fqui prend deux arguments (les deux listes de pénalités marquées / non marquées) et renvoie Truesi les scores sont éventuellement valides et Falsesinon.

Explication partielle:

Tout d'abord, la execconstruction n'est qu'un moyen d'économiser quelques octets en évitant de répéter l'expression len(a+b)plus d'une fois. Le morceau de code ci-dessus est équivalent à ce qui suit:

Mise à jour: la réponse nouvelle et améliorée est le même nombre d'octets avec ou sans execastuce, donc dans un souci de simplicité, je l'ai supprimé.

Mise à jour 2: La nouvelle version corrigée de bogues inclut encore plus de compression de chaînes via substitution et exec. Oui, j'utilise le %formatage et un .replacesur la même chaîne. Le code ci-dessus est équivalent à:

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)

L'idée principale de cette réponse est de formuler la question en termes de "demi-points": chaque coup réussi est un demi-point et chaque échec est un demi-point négatif. Pour un ensemble de partitions de longueur<=5pour être continuable ( not len(a+b)>10), le nombre total de coups de pied restants doit avoir été supérieur ou égal à la marge du demi-point entre les deux équipes. Lorsqu'une équipe a donné un coup de pied supplémentaire, un demi-point doit être soustrait de la marge pour diverses raisons, ce qui peut être simplifié en divisant par deux les deux côtés de l'équation. Il s'agit de la fonction hdans le code (avec l'argument mégal à 6).

Cependant, pour être un ensemble de scores valide, une entrée n'a pas besoin d'être strictement continue, mais elle doit avoir été continue avant le dernier coup de pied. Cette condition équivaut à dire qu'elle doit 1) avoir été continue la dernière fois que les deux parties ont donné le même nombre de coups de pied et 2) être actuellement à moins de deux demi-points d'être continuable - c'est là que l'argument final hintervient: h(a[:~-len(a+b)/2],b[:~-len(a+b)/2],6)teste la condition 1) et h(a,b,7)( 7représentant deux demi-points supplémentaires autorisés dans la marge) teste la condition 2).

Le cas où chaque équipe a botté un maximum de cinq fois a ainsi été réglé. (Explication à suivre pour l'autre cas.)

En termes de golf de bas niveau, je doute qu'il y ait trop de choses à raser, mais algorithmiquement, cela pourrait probablement être fait un peu plus simplement.

— Aidan F. Pierce
source
1
Vous pouvez jouer (%s-1)/2au golf ~-%s/2pour économiser 2 octets.
— Kevin Cruijssen
@KevinCruijssen Merci!
— Aidan F. Pierce
1

Gelée , 62 54 49 octets

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

Essayez-le en ligne!

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

Notez que le code de pied de page sur tio est juste pour gérer plusieurs cas de test et imprimer les sorties par rapport aux entrées.

Merci à @EriktheOutgolfer d'avoir joué au golf sur 8 octets

— Nick Kennedy
source
Bien essayé! Ce n'est pas un défi très trivial. Certains golfs.
— Erik the Outgolfer
0

Perl 6 , 123 octets

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

Essayez-le en ligne!

Renvoie falsey pour les tirs valides, véridique pour les tirs invalides.

Explication

# 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
— nwellnhof
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.