Einführung:

Ich habe gesehen, dass es im Moment nur eine weitere Herausforderung im Zusammenhang mit Badminton gibt . Da ich selbst Badminton spiele (seit 13 Jahren), habe ich mir gedacht, dass ich einige Herausforderungen im Zusammenhang mit Badminton hinzufügen würde. Hier der erste:

Herausforderung:

Eingabe: Zwei Ganzzahlen
Ausgabe: Eine von drei eindeutigen Ausgaben Ihrer Wahl. Eine, die angibt, dass die Eingabe eine gültige Badminton-Punktzahl ist UND der Satz mit einem Gewinner endet. eine, die angibt, dass die Eingabe eine gültige Badminton-Punktzahl ist UND der Satz noch im Spiel ist; Ein Wert, der die Eingabe angibt, ist keine gültige Badminton-Punktzahl.

Beim Badminton beginnen beide (Paar-) Spieler mit 0 Punkten, und Sie hören auf, wenn einer der beiden (Paar-) Spieler eine Punktzahl von 21 mit mindestens 2 Punkten Unterschied von maximal 30 bis 29 erreicht hat.

Das sind also alle möglichen Eingabepaare (in beliebiger Reihenfolge), die anzeigen, dass es sich um eine gültige Badminton-Punktzahl handelt UND der Satz beendet ist:

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

Und dies sind alle möglichen Eingabepaare (in beliebiger Reihenfolge), die anzeigen, dass es sich um eine gültige Badminton-Punktzahl handelt, ABER das Set ist noch im Spiel:

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

Jedes andere ganzzahlige Paar wäre ein ungültiger Badminton-Score.

Herausforderungsregeln:

• I / O ist flexibel, also:
  • Sie können die Eingabe als Liste mit zwei Zahlen annehmen. zwei durch STDIN oder Funktionsparameter getrennte Zahlen; zwei Saiten; etc.
  • Es werden drei unterschiedliche und eindeutige Werte Ihrer Wahl ausgegeben. Kann ganze Zahlen sein (dh [0,1,2], [1,2,3], [-1,0,1], etc.); kann boolesch sein (dh [true,false,undefined/null/empty]); kann Zeichen / Strings sein (zB ["valid & ended","valid","invalid"]); etc.
  • Bitte geben Sie die E / A an, die Sie in Ihrer Antwort verwendet haben!
• Sie können die vorbestellten Eingabe-Ganzzahlen vom niedrigsten zum höchsten Wert oder umgekehrt verwenden.
• Die Eingabe-Ganzzahlen können negativ sein. In diesem Fall sind sie natürlich ungültig.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

Diese Testfälle sind gültig und der Satz wurde beendet:

0 21
12 21
21 23
28 30
29 30

Diese Testfälle sind gültig, aber das Set ist noch im Spiel:

0 0
0 20
12 12
21 21
21 22

Diese Testfälle sind ungültig:

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

Stax , 20 Bytes

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

Führen Sie es aus und debuggen Sie es

Die Eingabe erfolgt im gleichen Format wie in den Beispielen. 0bedeutet, dass es einen gültigen Gewinner gibt. 1bedeutet, dass das Spiel läuft. -1bedeutet ungültige Punktzahl.

Im Pseudocode mit geordneten Eingaben xund ylautet der Algorithmus

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

• signbedeutet numerische Zeichen ( -1, 0oder 1)
• clamp erzwingt das erste Argument in das angegebene halboffene Intervall

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

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

Probieren Sie es online!

Übernimmt die Eingabe wie vorbestellt a,b.

Returns -2, -1, 0für ended, in play, invalid.

_{-1 Byte, danke an Kevin Cruijssen}

---

Der linke Teil ( b-61<~a<a>b/22*b-3) ist eine Gültigkeitsprüfung und der rechte Teil ( 19<b-(b<30)>a) ist eine Prüfung für das Spielende.

Python 2 , 47 Bytes

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

Probieren Sie es online!

Gibt eine Liste mit zwei Booleschen Werten aus. Vielen Dank an TFeld für das Schreiben einer Testsuite in ihrer Antwort , die es mir leicht gemacht hat, meine Lösung zu überprüfen.

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

Die wichtigste Erkenntnis ist, dass ein gültiger Spielstand das Spiel genau dann beendet, wenn ein höherer Wert bden Spielstand ungültig macht. Also codieren wir einfach die Gültigkeitsbedingung und überprüfen sie auf(a,b+1) zusätzlich zu , (a,b)um zu sehen , ob das Spiel beendet ist.

Die Gültigkeit wird über drei miteinander verkettete Bedingungen überprüft:

• b<3+max(19,a): Überprüft, ob die höhere Punktzahl bnicht nach dem Gewinn liegt, entweder mit b<=21oder b<=a+2(Gewinn um zwei).
• 60-a>b: Entspricht a+b<=59, um sicherzustellen, dass die Punktzahl nicht höher ist(29,30)
• 61>60-a: Entspricht a>=0, stellt sicher, dass die niedrigere Punktzahl nicht negativ ist

---

Python 2 , 44 Bytes

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

Probieren Sie es online!

Eine verbesserte Gültigkeitsprüfung durch TFeld spart 3 Bytes. Die Hauptidee ist, nach "Überstunden" b>21zu b/22*bverzweigen, bei a>19denen die Ergebnisse unter 21 effektiv auf Null gesetzt werden, während ich mit den längeren Ergebnissen verzweigt habe max(19,a).

---

Python 2 , 43 Bytes

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

Probieren Sie es online!

Ausgänge:

ended: 0
going: -1
invalid: 1

Nimmt an, dass die Eingänge nicht unter $-2^{99}$ .

JavaScript (ES6),  55 53  48 Byte

^{Vielen Dank an @KevinCruijssen für die Feststellung, dass ich nicht vollständig von $a\le b$ ausgegangen bin (5 Byte gespart)}

Nimmt Eingaben wie (a)(b)bei $a\le b$ . Gibt $0$ (gültig), $1$ (beendet) oder $2$ (ungültig) zurück.

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

Probieren Sie es online!

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

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

Genannt als f(max)(min) . Gibt 3 für ungültig, 1 für beendet und 2 für fortlaufend zurück.

Dank Kevin Cruijjsen 1 Byte gespeichert

Probieren Sie es online!

Gelee , 25 Bytes

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

Probieren Sie es online!

Linkes Argument: Minimum. Richtiges Argument: maximal.
Ungültig: 0. Andauernd: 1. Beendet:2 .

Mathematisch funktioniert dies wie folgt (das linke Argument ist $x$ , das rechte ist $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]$$

Erläuterung:

»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 Bytes

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

Diese Funktion nimmt die Bewertungen in aufsteigender Reihenfolge und gibt die leere Menge zurück, wenn die Bewertung ungültig ist oder die Menge enthält, ob die Menge vollständig ist (also {true}, wenn die Menge vollständig und gültig ist und {false}, wenn die Menge unvollständig ist und gültig)

Ein vollständiges Programm könnte so aussehen:

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

Erläuterung:

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 Bytes

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

Probieren Sie es online!

Gibt eine zurück Object, die Integer 0für ungültige Spiele und die Booleans trueund falsefür gültige laufende Spiele bzw. für gültige beendete Spiele gilt. Nimmt die bestellte Punktzahl (und die Curry-Punktzahl), wobei die höhere Punktzahl an erster Stelle steht.

-2 bytes durch Umkehren der Spielende-Prüfung.
-11 bytesdurch Currying, Verwendung von bitweisen Operatoren und einige Tricks beim Autoboxing von Rückgabetypen - danke an @KevinCruijssen

Ungolfed

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 Byte ^SBCS

Infix-implizite Funktion, bei der "ended" 2 ist, "running" 1 ist, "invalid" 0 ist und kleinere und größere Scores übrig bleiben.

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

Probieren Sie es online!

Implementiert Erik der Outgolfer mathematische Formeln kombiniert in

$$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)))])$$

und direkt in APL übersetzt (was streng rechtsassoziativ ist, daher vermeiden wir einige Klammern):

$$((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​+⊣$$

Welches ist unsere Lösung? (,≡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)=…]$

x86-Assembly, 42 Bytes

Nimmt Eingaben auf ECXund EDXregistriert sie. Beachten Sie, ECXdass größer als sein muss EDX.
Ausgabe in EAX, wobei 0bedeutet, dass das Spiel noch läuft, 1das Spiel als beendet und -1(aka FFFFFFFF) eine ungültige Punktzahl darstellt.

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

Oder besser lesbar in 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

Tolles Faktum: Diese Funktion folgt fast den Regeln der C Calling Convention, welche Register erhalten bleiben sollen, außer ich musste puffern EBX, um ein paar Bytes bei der Stapelverwendung zu sparen.

---

Optional (nicht in der Byteanzahl enthalten)

Indem Sie die folgenden 6 Bytes direkt vor dem Start des obigen Codes hinzufügen, können Sie übergeben ECXund EDXungeordnet:

39 D1 7D 02 87 CA

Welches ist das Folgende in lesbarer Intel-Syntax:

CMP ECX, EDX
JGE check
XCHG ECX, EDX

Retina 0,8,2 , 92 Bytes

\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

Probieren Sie es online! Link enthält Testfälle. Nimmt die Eingabe in aufsteigender Reihenfolge vor. Erläuterung: Die erste Stufe wird einfach von dezimal nach unär konvertiert, damit die Ergebnisse richtig verglichen werden können. Die zweite Stufe enthält sechs alternative Muster, die in drei Gruppen eingeteilt sind, so dass drei unterschiedliche Werte ausgegeben werden können, die 10für den Gewinn, 01für den Fortbestand und 00für den illegalen Gebrauch sind. Die Muster sind:

• Gegen 0-19 ist eine Punktzahl von 21 ein Sieg
• Gegen 20-28 ist eine Punktzahl von +2 ein Gewinn
• Gegen 29 ist eine Punktzahl von 30 ein Gewinn
• Gegen jede (niedrigere) Punktzahl läuft eine Punktzahl von 0-20
• Bei einer Punktzahl von bis zu 28 liegt eine Punktzahl von +1 vor
• Alles andere (einschließlich negativer Werte) ist illegal

APL (Dyalog Unicode) , 33 32 Byte ^SBCS

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

Probieren Sie es online!

in: ein Paar in absteigender Reihenfolge

out: 2 = läuft, 1 = beendet, 0 = ungültig

Tests gestohlen von Adáms Antwort

Bash 4+, 97 89 91 88 Bytes

Angenommen, die Eingaben sind aufsteigend. Verwendete Konzepte von VDM-SL antworten. Online ausprobieren
z==0 - Spiel läuft
z==1- Spiel beendet
z==2- ungültig

-8 durch Klammerbereinigung von (( & | ))Bedingungen
+2 Fehlerbehebung dank Kevin Cruijssen
-3 Logikverbesserungen von 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