Introducción:

Vi que solo había otro desafío relacionado con el bádminton en este momento . Como yo mismo juego al bádminton (durante los últimos 13 años), pensé que agregaría algunos desafíos relacionados con el bádminton. Aquí el primero:

Reto:

Entrada: Dos enteros
Salida: Una de las tres salidas distintas y únicas de su elección. Uno que indica que la entrada es una puntuación válida de bádminton Y el conjunto ha terminado con un ganador; uno que indica que la entrada es un puntaje de bádminton válido Y el conjunto aún está en juego; uno que indica que la entrada no es una puntuación válida de bádminton.

Con el bádminton, ambos (pares de) jugadores comienzan con 0 puntos, y usted se detiene cuando uno de los dos (pares de) jugadores ha alcanzado un puntaje de 21, con al menos 2 puntos de diferencia, hasta un máximo de 30-29.

Entonces, estos son todos los pares de entrada posibles (en cualquier orden) que indican que es una puntuación de bádminton válida Y el conjunto ha terminado:

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

Y estos son todos los pares de entrada posibles (en cualquier orden) que indican que es un puntaje de bádminton válido PERO el conjunto todavía está en juego:

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

Cualquier otro par de enteros sería una puntuación de bádminton no válida.

Reglas de desafío:

• I / O es flexible, entonces:
  • Puede tomar la entrada como una lista de dos números; dos números separados a través de STDIN o parámetros de función; dos cuerdas etc.
  • La salida será tres valores distintos y únicos de su propia elección. Puede ser números enteros (es decir [0,1,2], [1,2,3], [-1,0,1], etc.); pueden ser booleanos (es decir [true,false,undefined/null/empty]); pueden ser caracteres / cadenas (es decir ["valid & ended","valid","invalid"]); etc.
  • ¡Especifique la E / S que utilizó en su respuesta!
• Se le permite tomar los enteros de entrada ordenados de menor a mayor o viceversa.
• Los enteros de entrada pueden ser negativos, en cuyo caso, por supuesto, no son válidos.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

Estos casos de prueba son válidos y el conjunto ha finalizado:

0 21
12 21
21 23
28 30
29 30

Estos casos de prueba son válidos, pero el conjunto aún está en juego:

0 0
0 20
12 12
21 21
21 22

Estos casos de prueba no son válidos:

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

Stax , 20 bytes

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

Ejecutar y depurarlo

Toma entrada en el mismo formato que los ejemplos. 0significa que hay un ganador válido. 1significa que el juego está en progreso. -1significa puntuación inválida.

En pseudocódigo, con entradas ordenadas xy y, el algoritmo es

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

• signsignifica signo numérico ( -1, 0o 1)
• clamp fuerza su primer argumento en el intervalo medio abierto especificado

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)

Pruébalo en línea!

Toma entrada como pre-ordenado a,b.

Retornos -2, -1, 0para ended, in play, invalid.

_{-1 byte, gracias a Kevin Cruijssen}

---

La parte izquierda ( b-61<~a<a>b/22*b-3) es una verificación de validez, y la parte derecha ( 19<b-(b<30)>a) es una verificación para el juego terminado.

Python 2 , 47 bytes

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

Pruébalo en línea!

Emite una lista de dos booleanos. Gracias a TFeld por escribir un conjunto de pruebas en su respuesta que facilitó la verificación de mi solución.

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

La idea clave es que un puntaje válido finaliza el juego exactamente si aumentar el valor más balto invalida el puntaje. Entonces, simplemente codificamos la condición de validez y la verificamos (a,b+1)además (a,b)para ver si el juego ha terminado.

La validez se verifica a través de tres condiciones que están encadenadas:

• b<3+max(19,a): Comprueba que el puntaje más alto bno haya sido ganado anteriormente, ya sea con b<=21o b<=a+2(gana por dos)
• 60-a>b: Equivalente a a+b<=59, asegurando que el puntaje no esté por encima(29,30)
• 61>60-a: Equivalente a a>=0, asegura que el puntaje más bajo no sea negativo

---

Python 2 , 44 bytes

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

Pruébalo en línea!

Una verificación de validez mejorada por TFeld ahorra 3 bytes. La idea principal es ramificarse en el "tiempo extra" b>21con el b/22*bque efectivamente establece puntajes inferiores a 21 a cero, mientras que yo me ramifiqué a>19con el más largo max(19,a).

---

Python 2 , 43 bytes

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

Pruébalo en línea!

Salidas:

ended: 0
going: -1
invalid: 1

$-2^{99}$

JavaScript (ES6),  55 53  48 bytes

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

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 53 52 bytes

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

Llamado como f(max)(min). Devuelve 3 para inválido, 1 para terminado, 2 para en curso.

Guardado 1 byte gracias a Kevin Cruijjsen

Pruébalo en línea!

Jalea , 25 bytes

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

Pruébalo en línea!

Argumento a la izquierda: mínimo. Argumento correcto: máximo.
No válido: 0. En curso: 1. Terminado: 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]$$

Explicación:

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

Esta función toma los puntajes ordenados en orden ascendente y devuelve el conjunto vacío si el puntaje no es válido o el conjunto que contiene si el conjunto está completo (entonces {verdadero} si el conjunto está completo y es válido y {falso} si el conjunto está incompleto y válido)

Un programa completo para ejecutar podría verse así:

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

Explicación:

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

Pruébalo en línea!

Devuelve una Object, que es el Integer 0de los juegos no válidas y las Booleans truey falsepara los juegos actuales y válidos para los juegos terminados válidos respectivamente. Toma el puntaje ordenado (y curry), con el puntaje más alto primero.

-2 bytesinvirtiendo el cheque de fin de partido.
-11 bytescurry, utilizando operadores bit a bit y algunos trucos de autoboxing de tipo de retorno, gracias a @KevinCruijssen

Sin 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) , ^{SBCS de} 35 bytes

Función infija tácita donde finalizó es 2, en curso es 1, inválido es 0, quedan puntuaciones más pequeñas y más grandes.

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

Pruébalo en línea!

Implementa las fórmulas matemáticas de Erik the Outgolfer combinadas 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)))])$$

y traducido directamente a APL (que es estrictamente asociativo a la derecha, por lo que evitamos algunos paréntesis):

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

Ahora es equivalente a para cualquier función infija , por lo que podemos simplificar$⊣⎕⊢$$⎕$$⎕$

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

cual es nuestra solución; (,≡30 31|,)×(⊢<2+X)×1+⊢>X←29⌊20⌈1+⊣:

⊣ el argumento de la izquierda;  uno más eso;  máximo de 20 y eso;  mínimo de 29 y eso;  asignar eso a ;  es el argumento correcto mayor (0/1) ?;  agrega uno; ...  multiplica lo siguiente por eso;  dos más ;  es el argumento correcto menor que eso (0/1); ...  multiplica lo siguiente por eso;  concatenar los argumentos;  restos cuando se dividen entre estos números; $x$1 + x max ( 20 , … ) min ( 29 , … ) X : = … [ y > … ] 1 + … ( … ) × …
1+$1+x$
20⌈$\max(20,…)$
29⌊$\min(29,…)$
X←X$X:=…$
⊢>$[y>…]$
1+$1+…$
()×$(…)×…$
 2+XX$2+X$[ y < … ]
 ⊢<$[y<…]$
()×$(…)×…$( x , y )
 ,$(x,y)$
 30 31|$…\mod(30,31)$[ ( x , y ) = … ]
 ,≡ ¿son los argumentos concatenados idénticos a eso (0/1) ?; $[(x,y)=…]$

Asamblea x86, 42 bytes

Toma entrada ECXy se EDXregistra. Tenga en cuenta que ECXdebe ser mayor que EDX.
Salidas a EAX, donde 0significa que el juego aún está encendido, 1representando que el juego terminó y -1(también conocido como FFFFFFFF) que representa un puntaje no válido.

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

O, más legible en 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

Dato curioso: esta función casi sigue las reglas de la Convención de llamada C sobre qué registros conservar, excepto que tuve que bloquear EBXpara guardar algunos bytes en el uso de la pila.

---

Opcional (no incluido en el conteo de bytes)

Al agregar los siguientes 6 bytes directamente antes del inicio del código anterior, puede pasar ECXy EDXordenar:

39 D1 7D 02 87 CA

Que es lo siguiente en Intel Syntax legible:

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

Pruébalo en línea! El enlace incluye casos de prueba. Toma entrada en orden ascendente. Explicación: La primera etapa simplemente convierte de decimal a unario para que los puntajes se puedan comparar correctamente. La segunda etapa contiene seis patrones alternativos, agrupados en tres grupos para que se puedan generar tres valores distintos, que son 10para ganar, 01para continuo y 00para ilegal. Los patrones son:

• Contra 0-19, un puntaje de 21 es una victoria
• Contra 20-28, un puntaje de +2 es una victoria
• Contra 29, una puntuación de 30 es una victoria
• Contra cualquier puntaje (más bajo), un puntaje de 0-20 está en curso
• Contra un puntaje de hasta 28, un puntaje de +1 está en curso
• Cualquier otra cosa (incluidas las puntuaciones negativas) es ilegal

APL (Dyalog Unicode) , 33 32 bytes ^SBCS

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

Pruébalo en línea!

en: un par en orden descendente

fuera: 2 = en curso, 1 = finalizado, 0 = inválido

pruebas robadas de la respuesta de Adám

Bash 4+, 97 89 91 88 bytes

Suponga que las entradas son ascendentes. Conceptos usados ​​de la respuesta VDM-SL . Pruébelo en línea
z==0 - juego en progreso
z==1- juego completado
z==2- no válido

-8 por la limpieza del soporte de las (( & | ))condiciones
+2 arreglando un error, gracias a Kevin Cruijssen
-3 mejoras lógicas por 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