Introduzione:

Ho visto che c'era solo un'altra sfida legata al badminton in questo momento . Da quando gioco a badminton da solo (negli ultimi 13 anni), ho pensato di aggiungere alcune sfide legate al badminton. Ecco il primo:

Sfida:

Input: due numeri interi
Output: uno dei tre output distinti e unici di propria scelta. Uno che indica che l'ingresso è un punteggio di badminton valido E che il set è terminato con un vincitore; uno che indica che l'ingresso è un punteggio di badminton valido E che il set è ancora in gioco; uno che indica l'ingresso non è un punteggio di badminton valido.

Con il badminton, entrambi (coppie di) giocatori iniziano con 0 punti e ti fermi quando uno dei due (coppie di) giocatori ha raggiunto un punteggio di 21, con almeno 2 punti di differenza, fino ad un massimo di 30-29.

Quindi queste sono tutte possibili coppie di input (in entrambi gli ordini) che indicano che è un punteggio di badminton valido E che il set è finito:

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

E queste sono tutte possibili coppie di input (in entrambi gli ordini) che indicano che è un punteggio di badminton valido MA il set è ancora in gioco:

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

Qualsiasi altra coppia di numeri interi sarebbe un punteggio di badminton non valido.

Regole della sfida:

L'I / O è flessibile, quindi:
- Puoi prendere l'input come un elenco di due numeri; due numeri separati tramite STDIN o parametri di funzione; due corde; eccetera.
- L'output sarà tre valori distinti e unici di tua scelta. Può essere numeri interi (ad esempio [0,1,2], [1,2,3], [-1,0,1], etc.); può essere booleano (cioè [true,false,undefined/null/empty]); possono essere caratteri / stringhe (es. ["valid & ended","valid","invalid"]); eccetera.
- Per favore specifica l'I / O che hai usato nella tua risposta!
Puoi prendere gli interi di input preordinati dal più basso al più alto o viceversa.
Gli interi di input possono essere negativi, nel qual caso ovviamente non sono validi.

Regole generali:

Questo è code-golf , quindi vince la risposta più breve in byte.
Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
Per la tua risposta valgono regole standard con regole I / O predefinite , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
Sono vietate le scappatoie predefinite .
Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi test:

Questi casi di test sono validi e il set è terminato:

Questi casi di test sono validi, ma il set è ancora in gioco:

Questi casi di test non sono validi:

code-golf number integer

— Kevin Cruijssen
fonte

1

Stax , 20 byte

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

Esegui ed esegui il debug

Prende input nello stesso formato degli esempi. 0significa che c'è un vincitore valido. 1significa che il gioco è in corso. -1significa punteggio non valido.

In pseudo-codice, con input ordinati xe y, l'algoritmo è

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

signsignifica segno numerico ( -1, 0o 1)
clamp forza il suo primo argomento nell'intervallo di metà aperto specificato

— ricorsivo
fonte

6

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

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

Provalo online!

Accetta input come preordinato a,b.

I ritorni -2, -1, 0per ended, in play, invalid.

_{-1 byte, grazie a Kevin Cruijssen}

La parte sinistra ( b-61<~a<a>b/22*b-3) è un controllo di validità e la parte destra ( 19<b-(b<30)>a) è un controllo per la fine del gioco.

— TFeld
fonte

6

Python 2 , 47 byte

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

Provalo online!

Emette un elenco di due booleani. Grazie a TFeld per aver scritto una suite di test nella loro risposta che ha reso facile controllare la mia soluzione.

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

L'intuizione chiave è che un punteggio valido termina il gioco esattamente se aumentare il valore più alto brende il punteggio non valido. Quindi, codifichiamo semplicemente la condizione di validità e la controlliamo (a,b+1)oltre (a,b)a vedere se il gioco è terminato.

La validità viene verificata tramite tre condizioni che sono concatenate:

b<3+max(19,a): Verifica che il punteggio più alto bnon sia la vincita passata, con uno b<=21o b<=a+2(vittoria per due)
60-a>b: Equivalente a a+b<=59, assicurando che il punteggio non sia superiore(29,30)
61>60-a: Equivalente a a>=0, assicura che il punteggio più basso non sia negativo

Python 2 , 44 byte

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

Provalo online!

Un controllo di validità migliorato di TFeld consente di risparmiare 3 byte. L'idea principale è quella di diramare "straordinari" b>21con b/22*bcui azzerare effettivamente i punteggi inferiori a 21, mentre io avrei ramificato a>19con il più lungo max(19,a).

Python 2 , 43 byte

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

Provalo online!

Uscite:

ended: 0
going: -1
invalid: 1

$-2^{99}$

— XNOR
fonte

1

Utilizzando il mio ultimo controllo di validità ( b-61<~a<a>b/22*b-3), è possibile salvare 3 byte.

— TFeld,

1

+1 byte per far funzionare la tua seconda soluzione per tutti gli input:lambda a,b:-(a<0)|cmp(2+max(19,a)%30-a/29,b)

— TFeld

4

JavaScript (ES6), 55 53 48 byte

^{$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

Provalo online!

— Arnauld
fonte

4

C # (compilatore interattivo Visual C #) , 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

Chiamato come f(max)(min). Restituisce 3 per non valido, 1 per finito, 2 per in corso.

Salvato 1 byte grazie a Kevin Cruijjsen

Provalo online!

— Incarnazione dell'ignoranza
fonte

4

Gelatina , 25 byte

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

Provalo online!

Argomento sinistro: minimo. Argomento giusto: massimo.
Non valido: 0. In corso: 1. Ended: 2.

$x$ $y$

[a] = {\begin{cases} a : 1 \\ \neg a : 0 \end{cases} \otimes (a, b) = (a mod 30, b mod 31) x, y \in Z X := min (max (x + 1, 20), 29) p := (x, y) ([X < y] + 1) [X + 2 > y] [p = \otimes p]

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

Spiegazione:

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

— Erik the Outgolfer
fonte

3

VDM-SL , 80 byte

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

Questa funzione prende i punteggi ordinati in ordine crescente e restituisce il set vuoto se il punteggio non è valido o il set contiene se il set è completo (quindi {true} se il set è completo e valido e {false} se il set è incompleto e valido)

Un programma completo da eseguire potrebbe apparire così:

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

Spiegazione:

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*/

— Dati scaduti
fonte

3

Java (JDK) , 59 48 byte

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

Provalo online!

Restituisce una Object, che è il Integer 0per i giochi non valide e le Booleans truee falseper i giochi in corso in vigore e per i giochi finiti validi rispettivamente. Prende il punteggio ordinato (e curry), con il punteggio più alto per primo.

-2 bytesinvertendo il controllo di fine partita.
-11 bytesdal curry, usando operatori bit per bit e qualche trucco di autoboxing del tipo restituito - grazie a @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

— Sara J
fonte

3

APL (Dyalog Unicode) , 35 byte ^SBCS

Aggiunge la funzione tacita dove finisce è 2, in corso è 1, non valido è 0, rimangono punteggi più piccoli e più grandi.

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

Provalo online!

Implementa le formule matematiche di Erik the Outgolfer combinate in

X := min (max (x + 1, 20), 29) ([X < y] + 1) [X + 2 > y] [(x, y) = (x mod 30, y mod 31)]

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

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

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

e tradotto direttamente in APL (che è strettamente associativo a destra, quindi evitiamo alcune parentesi):

((x, y) \equiv 30 31 ​ | ​ x, y) \times (y < 2 + X) \times 1 + y > X \leftarrow 29 ​ ⌊ ​ 20 ​ ⌈ ​ 1 + x

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

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

((⊣ ​, ⊢) \equiv 30 31 ​ | ⊣ ​, ⊢) \times (⊣ ​ < 2 + X) \times 1 ​ + ⊢ ​ > X \leftarrow 29 ​ ⌊ ​ 20 ​ ⌈ ​ 1 ​ + ⊣

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

$⊣⎕⊢$ $⎕$ $⎕$

(, ​ \equiv 30 31 ​ | ​,) \times (⊣ ​ < 2 + X) \times 1 ​ + ⊢ ​ > X \leftarrow 29 ​ ⌊ ​ 20 ​ ⌈ ​ 1 ​ + ⊣

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

qual è la nostra soluzione; (,≡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)=…]$

— Adamo
fonte

3

x86 Assembly, 42 byte

Riceve input ECXe EDXregistra. Nota che ECXdeve essere maggiore di EDX.
Emette in EAX, dove 0significa che il gioco è ancora attivo, che 1rappresenta la fine del gioco e -1(aka FFFFFFFF) che rappresenta un punteggio non valido.

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

Oppure, più leggibile in Sintassi Intel:

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

Curiosità: questa funzione segue quasi le regole della C Calling Convention su quali registri conservare, tranne che ho dovuto bloccare EBXper salvare alcuni byte sull'uso dello stack.

Opzionale (non incluso nel conteggio byte)

Aggiungendo i seguenti 6 byte direttamente prima dell'inizio del codice sopra, è possibile passare ECXe EDXnon ordinati:

39 D1 7D 02 87 CA

Che è la seguente sintassi Intel leggibile:

CMP ECX, EDX
JGE check
XCHG ECX, EDX

— Fayti1703
fonte

2

Retina 0.8.2 , 92 byte

\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

Provalo online! Il link include casi di test. Accetta l'input in ordine crescente. Spiegazione: Il primo stadio converte semplicemente da decimale a unario in modo che i punteggi possano essere confrontati correttamente. La seconda fase contiene sei schemi alternativi, raggruppati in tre gruppi in modo che possano essere emessi tre valori distinti, che sono 10per la vittoria, 01per la continuazione e 00per la illegalità. I modelli sono:

Contro 0-19, un punteggio di 21 è una vittoria
Contro 20-28, un punteggio di +2 è una vittoria
Contro 29, un punteggio di 30 è una vittoria
Contro qualsiasi punteggio (inferiore), è in corso un punteggio di 0-20
Contro un punteggio fino a 28, è in corso un punteggio di +1
Qualsiasi altra cosa (compresi i punteggi negativi) è illegale

— Neil
fonte

1

APL (Dyalog Unicode) , 33 32 byte ^SBCS

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

Provalo online!

in: una coppia in ordine decrescente

out: 2 = in corso, 1 = terminato, 0 = non valido

test rubati dalla risposta di Adám

— NGN
fonte

1

Bash 4+, 97 89 91 88 byte

Supponiamo che gli input stiano ascendendo. Concetti usati dalla risposta VDM-SL . Provalo online
z==0 - gioco in corso
z==1- gioco completato
z==2- non valido

-8 dalla pulizia della parentesi dalle (( & | ))condizioni
+2 correzione di un bug, grazie a Kevin Cruijssen
-3 miglioramenti logici di 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

— roblogic
fonte

1

La tua versione di 89 byte sembra in uscita 1invece che 2per 0 30. La versione di 97 byte funzionava correttamente, quindi se non riesci a risolverlo, puoi sempre eseguire il rollback. Eseguito l'upgrade per quella versione 97. :)

— Kevin Cruijssen il

1

Questo dovrebbe risolverlo e golf un byte allo stesso tempo. :)

— Kevin Cruijssen il

1

L'ho risolto, ma il tuo era migliore! Difficile da mantenere: P

— roblogic

Bug a 29 30:( dovrebbe essere "completato"

— roblogic

1

Ah oops .. i>29dovrebbe essere j>29nel secondo ternario per ripararlo.

— Kevin Cruijssen,

Punteggio di badminton valido?

Introduzione:

Sfida:

Regole della sfida:

Regole generali:

Casi test:

Stax , 20 byte

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

Python 2 , 47 byte

Python 2 , 44 byte

Python 2 , 43 byte

JavaScript (ES6), 55 53 48 byte

C # (compilatore interattivo Visual C #) , 53 52 byte

Gelatina , 25 byte

VDM-SL , 80 byte

Spiegazione:

Java (JDK) , 59 48 byte

Ungolfed

APL (Dyalog Unicode) , 35 byte SBCS

x86 Assembly, 42 byte

Opzionale (non incluso nel conteggio byte)

Retina 0.8.2 , 92 byte

APL (Dyalog Unicode) , 33 32 byte SBCS

Bash 4+, 97 89 91 88 byte

APL (Dyalog Unicode) , 35 byte ^SBCS

APL (Dyalog Unicode) , 33 32 byte ^SBCS