Introduction:

J'ai vu qu'il n'y avait qu'un seul autre défi lié au badminton en ce moment . Depuis que je joue au badminton moi-même (depuis 13 ans maintenant), je me suis dit que j'ajouterais des défis liés au badminton. Voici le premier:

Défi:

Entrée: Deux entiers
Sortie: L'une des trois sorties distinctes et uniques de votre choix. L'un indiquant que l'entrée est un score de badminton valide ET l'ensemble s'est terminé avec un gagnant; un indiquant que l'entrée est un score de badminton valide ET l'ensemble est toujours en jeu; celui indiquant que l'entrée n'est pas un score de badminton valide.

Avec le badminton, les deux (paires de) joueurs commencent avec 0 point, et vous vous arrêtez lorsque l'un des deux (paires de) joueurs a atteint un score de 21, avec au moins 2 points de différence, jusqu'à un maximum de 30-29.

Ce sont donc toutes les paires d'entrées possibles (dans l'un ou l'autre ordre) indiquant que c'est un score de badminton valide ET que l'ensemble est terminé:

[[0,21],[1,21],[2,21],[3,21],[4,21],[5,21],[6,21],[7,21],[8,21],[9,21],[10,21],[11,21],[12,21],[13,21],[14,21],[15,21],[16,21],[17,21],[18,21],[19,21],[20,22],[21,23],[22,24],[23,25],[24,26],[25,27],[26,28],[27,29],[28,30],[29,30]]

Et ce sont toutes les paires d'entrées possibles (dans l'un ou l'autre ordre) indiquant qu'il s'agit d'un score de badminton valide MAIS l'ensemble est toujours en jeu:

[[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[0,9],[0,10],[0,11],[0,12],[0,13],[0,14],[0,15],[0,16],[0,17],[0,18],[0,19],[0,20],[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7],[1,8],[1,9],[1,10],[1,11],[1,12],[1,13],[1,14],[1,15],[1,16],[1,17],[1,18],[1,19],[1,20],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],[2,8],[2,9],[2,10],[2,11],[2,12],[2,13],[2,14],[2,15],[2,16],[2,17],[2,18],[2,19],[2,20],[3,3],[3,4],[3,5],[3,6],[3,7],[3,8],[3,9],[3,10],[3,11],[3,12],[3,13],[3,14],[3,15],[3,16],[3,17],[3,18],[3,19],[3,20],[4,4],[4,5],[4,6],[4,7],[4,8],[4,9],[4,10],[4,11],[4,12],[4,13],[4,14],[4,15],[4,16],[4,17],[4,18],[4,19],[4,20],[5,5],[5,6],[5,7],[5,8],[5,9],[5,10],[5,11],[5,12],[5,13],[5,14],[5,15],[5,16],[5,17],[5,18],[5,19],[5,20],[6,6],[6,7],[6,8],[6,9],[6,10],[6,11],[6,12],[6,13],[6,14],[6,15],[6,16],[6,17],[6,18],[6,19],[6,20],[7,7],[7,8],[7,9],[7,10],[7,11],[7,12],[7,13],[7,14],[7,15],[7,16],[7,17],[7,18],[7,19],[7,20],[8,8],[8,9],[8,10],[8,11],[8,12],[8,13],[8,14],[8,15],[8,16],[8,17],[8,18],[8,19],[8,20],[9,9],[9,10],[9,11],[9,12],[9,13],[9,14],[9,15],[9,16],[9,17],[9,18],[9,19],[9,20],[10,10],[10,11],[10,12],[10,13],[10,14],[10,15],[10,16],[10,17],[10,18],[10,19],[10,20],[11,11],[11,12],[11,13],[11,14],[11,15],[11,16],[11,17],[11,18],[11,19],[11,20],[12,12],[12,13],[12,14],[12,15],[12,16],[12,17],[12,18],[12,19],[12,20],[13,13],[13,14],[13,15],[13,16],[13,17],[13,18],[13,19],[13,20],[14,14],[14,15],[14,16],[14,17],[14,18],[14,19],[14,20],[15,15],[15,16],[15,17],[15,18],[15,19],[15,20],[16,16],[16,17],[16,18],[16,19],[16,20],[17,17],[17,18],[17,19],[17,20],[18,18],[18,19],[18,20],[19,19],[19,20],[20,20],[20,21],[21,21],[21,22],[22,22],[22,23],[23,23],[23,24],[24,24],[24,25],[25,25],[25,26],[26,26],[26,27],[27,27],[27,28],[28,28],[28,29],[29,29]]

Toute autre paire d'entiers serait un score de badminton invalide.

Règles du défi:

• Les E / S sont flexibles, donc:
  • Vous pouvez prendre l'entrée comme une liste de deux nombres; deux nombres séparés via STDIN ou paramètres de fonction; deux cordes; etc.
  • La sortie sera trois valeurs distinctes et uniques de votre choix. Peut être des entiers (c. [0,1,2]-à [1,2,3]-d [-1,0,1].,, Etc.); peut être booléen (ie [true,false,undefined/null/empty]); peut être des caractères / chaînes (ie ["valid & ended","valid","invalid"]); etc.
  • Veuillez spécifier les E / S que vous avez utilisées dans votre réponse!
• Vous êtes autorisé à prendre les entiers d'entrée précommandés du plus bas au plus élevé ou vice-versa.
• Les entiers d'entrée peuvent être négatifs, auquel cas ils sont bien sûr invalides.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse avec des règles d'E / S par défaut , vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de test:

Ces cas de test sont valides et l'ensemble est terminé:

0 21
12 21
21 23
28 30
29 30

Ces cas de test sont valides, mais l'ensemble est toujours en jeu:

0 0
0 20
12 12
21 21
21 22

Ces cas de test ne sont pas valides:

-21 19
-19 21
-1 1
12 22
29 31
30 30
42 43
1021 1021

Stax , 20 octets

ÇåπßéD╩¬7▼ß▌ΣU¬í╡S┤╘

Exécuter et déboguer

Il prend l'entrée dans le même format que les exemples. 0signifie qu'il y a un gagnant valide. 1signifie que le jeu est en cours. -1signifie un score invalide.

En pseudo-code, avec des entrées ordonnées xet y, l'algorithme est

sign(clamp(x + 2, 21, 30) - y) | (x < 0 || x >= 30 ? 0 : -1)

• signdes moyens signe numérique ( -1, 0, ou 1)
• clamp force son premier argument dans l'intervalle semi-ouvert spécifié

Python 2 , 97 95 75 72 71 70 69 64 55 54 52 51 50 48 octets

lambda a,b:(b-61<~a<a>b/22*b-3)*~(19<b-(b<30)>a)

Essayez-le en ligne!

Prend l'entrée comme précommandé a,b.

Retours -2, -1, 0pour ended, in play, invalid.

_{-1 octet, merci à Kevin Cruijssen}

---

La partie gauche ( b-61<~a<a>b/22*b-3) est un contrôle de validité, et la partie droite ( 19<b-(b<30)>a) est un contrôle de fin de partie.

Python 2 , 47 octets

lambda a,b:[61>60-a>b<3+max(19,a)for b in-~b,b]

Essayez-le en ligne!

Affiche une liste de deux booléens. Merci à TFeld d' avoir écrit une suite de tests dans sa réponse qui m'a permis de vérifier facilement ma solution.

ended: [False, True]
going: [True, True]
invalid: [False, False]

L'idée clé est qu'un score valide termine le jeu exactement si l'augmentation de la valeur supérieure brend le score invalide. Donc, nous codons simplement la condition de validité et la vérifions (a,b+1)en plus (a,b)pour voir si le jeu est terminé.

La validité est vérifiée via trois conditions qui sont enchaînées:

• b<3+max(19,a): Vérifie que le score le plus élevé bn'est pas passé, avec ou b<=21ou b<=a+2(gagner par deux)
• 60-a>b: Équivaut à a+b<=59s'assurer que le score n'est pas supérieur à(29,30)
• 61>60-a: Équivalent à a>=0, garantit que le score le plus bas n'est pas négatif

---

Python 2 , 44 octets

lambda a,b:[b-61<~a<a>b/22*b-3for b in-~b,b]

Essayez-le en ligne!

Un contrôle de validité amélioré par TFeld économise 3 octets. L'idée principale est de branche sur « heures supplémentaires » b>21avec b/22*bqui fixe effectivement en dessous de 21 scores à zéro, alors que je l' avais bifurqué sur a>19le plus max(19,a).

---

Python 2 , 43 octets

lambda a,b:a>>99|cmp(2+max(19,a)%30-a/29,b)

Essayez-le en ligne!

Les sorties:

ended: 0
going: -1
invalid: 1

Suppose que les entrées ne sont pas inférieures à $-2^{99}$ .

JavaScript (ES6),  55 53  48 octets

^{$a\le b$}

(a)(b)$a\le b$$0$$1$$2$

a=>b=>a<0|a>29|b>30|b>21&b-a>2?2:b>20&b-a>1|b>29

Essayez-le en ligne!

C # (Visual C # Interactive Compiler) , 53 52 octets

a=>b=>b<0|a-b>2&a>21|b>29|a>30?3:a>20&a-b>1|a>29?1:2

Appelé comme f(max)(min). Renvoie 3 pour invalide, 1 pour terminé, 2 pour en cours.

1 octet enregistré grâce à Kevin Cruijjsen

Essayez-le en ligne!

Gelée , 25 octets

»19«28‘<‘×+2>ɗʋ⁹×,%Ƒ“œþ‘ɗ

Essayez-le en ligne!

Argument de gauche: minimum. Argument de droite: maximum.
Non valide: 0. En cours: 1. Terminé: 2.

$x$$y$

$$[a]=\cases{a\colon1\\\lnot a\colon0}\\\otimes(a,b)=(a\bmod30,b\bmod31)\\x,y\in\mathbb Z\\X:=\min(\max(x+1,20),29)\\p:=(x,y)\\([X<y]+1)[X+2>y][p=\otimes p]$$

Explication:

»19«28‘<‘×+2>ɗʋ⁹×,%Ƒ“œþ‘ɗ Left argument: x, Right argument: y
»19«28‘                   X := Bound x + 1 in [20, 29]:
»19                         X := max(x, 19).
   «28                      X := min(X, 28).
      ‘                     X := X + 1.
       <‘×+2>ɗʋ⁹          X := If X + 2 <= y, then 0, else if X < y, then 2, else 1:
       <                    t := If X < y, then 1, else 0.
        ‘                   t := t + 1.
          +2>ɗ              u := Check if X + 2 > y:
          +2                  u := X + 2.
            >                 u := If u > y, then 1, else 0.
         ×                  X := t * u.
                 ,%Ƒ“œþ‘ɗ z := If x mod 30 = x and y mod 31 = y, then 1, else 0:
                 ,          z := (x, y).
                  % “œþ‘    m := z mod (30, 31) = (x mod 30, y mod 31).
                   Ƒ        z := If z = m, then 1, else 0.
                ×         X * z.

VDM-SL , 80 octets

f(i,j)==if(j-i>2and j>21)or(i<0or i=30or j>30)then{}else{(j>20and j-i>1or j=30)} 

Cette fonction prend les scores ordonnés dans l'ordre croissant et renvoie l'ensemble vide si le score n'est pas valide ou l'ensemble contenant si l'ensemble est complet (donc {true} si l'ensemble est complet et valide et {false} si l'ensemble est incomplet et valide)

Un programme complet à exécuter pourrait ressembler à ceci:

functions
f:int*int+>set of bool
f(i,j)==if(j-i>2and j>21)or(i<0or i=30or j>30)then{}else{(j>20and j-i>1or j=30)}

Explication:

if(j-i>2 and j>21)             /*if scores are too far apart*/
or(i<0 or i=30 or j>30)        /*or scores not in a valid range*/
then {}                        /*return the empty set*/
else{                       }  /*else return the set containing...*/
     (j>20 and j-i>1 or j=30)  /*if the set is complete*/

Java (JDK) , 59 48 octets

a->b->b<0|b>29|a>b+2&a>21|a>30?0:a<21|a<30&a<b+2

Essayez-le en ligne!

Renvoie un Object, qui est respectivement Integer 0pour les jeux non valides et les Booleans trueet falsepour les jeux en cours valides et pour les jeux terminés valides. Prend le score ordonné (et curry), avec le score le plus élevé en premier.

-2 bytesen inversant le contrôle de fin de match.
-11 bytesen curry, en utilisant des opérateurs au niveau du bit, et quelques tromperies de type retour automatique - grâce à @KevinCruijssen

Non golfé

a->                      // Curried: Target type IntFunction<IntFunction<Object>>
    b->                  // Target type IntFunction<Object>
                         // Invalid if:
            b<0          //    Any score is negative
          | b > 29       //    Both scores above 29
          |   a > b + 2  //    Lead too big
            & a > 21     //        and leader has at least 21 points
          | a > 30       //    Anyone has 31 points
        ? 0              // If invalid, return 0 (autoboxed to Integer)
                         // If valid, return whether the game is ongoing (autoboxed to Boolean)
                         // Ongoing if:
        :   a < 21       //    Nobody has 21 points
          |   a < 30     //    Leader has fewer than 30 points
            & a < b + 2  //        and lead is small

APL (Dyalog Unicode) , 35 octets ^SBCS

Infixez la fonction tacite où la fin est 2, la valeur en cours est 1, la valeur invalide est 0, des scores plus petits et plus grands sont laissés.

(,≡30 31|,)×(⊢<2+X)×1+⊢>X←29⌊20⌈1+⊣

Essayez-le en ligne!

Implémente les formules mathématiques d'Erik l'Outgolfer combinées en

$$X:=\min(\max(x+1,20),29)\\\ ([X< y]+1)[X+2>y][(x,y)=(x\bmod30,y\bmod31)]$$

$$[(x,y)=(x,y)\bmod(30,31)]×[y<2+X]×(1+[y< (X:=\min(29,\max(20,1+x)))])$$

et traduit directement en APL (qui est strictement associatif à droite, donc nous évitons certaines parenthèses):

$$((x,y)≡30\ 31​|​x,y)×(y<2+X)×1+y>X←29​⌊​20​⌈​1 +x$$

$⊣$$x$$⊢$$y$

$$((⊣​,⊢)≡30\ 31​|⊣​,⊢)×(⊣​<2+X)×1​+⊢​>X←29​⌊​20​⌈​1​+⊣$$

$⊣⎕⊢$$⎕$$⎕$

$$(,​≡30\ 31​|​,)×(⊣​<2+X)×1​+⊢​>X←29​⌊​20​⌈​1​+⊣$$

qui est notre solution; (,≡30 31|,)×(⊢<2+X)×1+⊢>X←29⌊20⌈1+⊣:

⊣$x$
1+$1+x$
20⌈$\max(20,…)$
29⌊$\min(29,…)$
X←X$X:=…$
⊢>$[y>…]$
1+$1+…$
()×$(…)×…$
 2+XX$2+X$
 ⊢<$[y<…]$
()×$(…)×…$
 ,$(x,y)$
 30 31|$…\mod(30,31)$
 ,≡$[(x,y)=…]$

Assemblage x86, 42 octets

Prend entrée ECXet EDXregistres. Notez que cela ECXdoit être supérieur à EDX.
Sorties dans EAX, où 0signifie que le jeu est toujours activé, 1représentant la fin du jeu et -1(aka FFFFFFFF) représentant un score non valide.

31 C0 83 F9 1E 77 1F 83 FA 1D 77 1A 83 F9 15 7C 
18 83 F9 1E 74 12 89 CB 29 D3 83 FB 02 74 09 7C 
08 83 F9 15 74 02 48 C3 40 C3

Ou, plus lisible dans Intel Syntax:

check:
    XOR EAX, EAX
    CMP ECX, 30     ; check i_1 against 30
    JA .invalid     ; if >, invalid.
    CMP EDX, 29     ; check i_2 against 29
    JA .invalid     ; if >, invalid.
    CMP ECX, 21     ; check i_1 against 21
    JL .runi        ; if <, running.
    CMP ECX, 30     ; check i_1 against 30
    JE .over        ; if ==, over.
    MOV EBX, ECX
    SUB EBX, EDX    ; EBX = i_1 - i_2
    CMP EBX, 2      ; check EBX against 2
    JE .over        ; if ==, over.
    JL .runi        ; if <, running.
                    ; if >, keep executing!
    CMP ECX, 21     ; check i_1 against 21
    JE .over        ; if ==, over.
                    ; otherwise, it's invalid.
    ; fallthrough!
    .invalid:
        DEC EAX     ; EAX = -1
        RETN
    .over:
        INC EAX     ; EAX = 1
    ; fallthrough!
    .runi:
        RETN        ; EAX = 0 or 1

Fait amusant: cette fonction suit presque les règles de la convention d'appel C sur les registres à conserver, sauf que j'ai dû clobber EBXpour économiser quelques octets sur l'utilisation de la pile.

---

Facultatif (non inclus dans le nombre d'octets)

En ajoutant les 6 octets suivants directement avant le début du code ci-dessus, vous pouvez passer ECXet EDXnon ordonné:

39 D1 7D 02 87 CA

Qui est la syntaxe Intel lisible suivante:

CMP ECX, EDX
JGE check
XCHG ECX, EDX

Retina 0.8.2 , 92 octets

\d+
$*
^(1{0,19},1{21}|(1{20,28}),11\2|1{29},1{30})$|^(1*,1{0,20}|(1{0,28}),1?\4)$|.+
$#1$#3

Essayez-le en ligne! Le lien inclut des cas de test. Prend la saisie dans l'ordre croissant. Explication: La première étape passe simplement de la décimale à l'unaire afin que les scores puissent être correctement comparés. La deuxième étape contient six modèles alternatifs, regroupés en trois groupes afin que trois valeurs distinctes puissent être sorties, qui sont 10pour gagner, 01pour en cours et 00pour illégales. Les motifs sont les suivants:

• Contre 0-19, un score de 21 est une victoire
• Contre 20-28, un score de +2 est une victoire
• Contre 29, un score de 30 est une victoire
• Contre tout score (inférieur), un score de 0-20 est en cours
• Contre un score allant jusqu'à 28, un score de +1 est en cours
• Tout le reste (y compris les scores négatifs) est illégal

APL (Dyalog Unicode) , 33 32 octets ^SBCS

{h⍵+1 0}+h←(⊢≡31 30|⊢)×21 2∨.≥-\

Essayez-le en ligne!

dans: une paire en ordre décroissant

out: 2 = en cours, 1 = terminé, 0 = invalide

tests volés à la réponse d' Adám

Bash 4+, 97 89 91 88 octets

Supposons que les entrées augmentent. Concepts utilisés de VDM-SL réponse . Essayez-le en ligne
z==0 - jeu en cours
z==1- jeu terminé
z==2- invalide

-8 par nettoyage du support des (( & | ))conditions
+2 correction d'un bug, merci à Kevin Cruijssen
-3 améliorations logiques par Kevin Cruijssen

i=$1 j=$2 z=0
((j-i>2&j>21|i<0|i>29|j>30?z=2:0))
((z<1&(j>20&j-i>1|j>29)?z=1:0))
echo $z