Wprowadzenie:

Widziałem, że teraz jest tylko jedno wyzwanie związane z badmintonem . Ponieważ sam gram w badmintona (od 13 lat), pomyślałem, że dodam kilka wyzwań związanych z badmintonem. Oto pierwszy:

Wyzwanie:

Dane wejściowe: dwie liczby całkowite Dane
wyjściowe: Jedno z trzech różnych i unikalnych danych wyjściowych według własnego wyboru. Jeden wskazujący, że dane wejściowe to prawidłowy wynik badmintona ORAZ zestaw zakończył się zwycięzcą; jeden wskazuje, że dane wejściowe są prawidłowym wynikiem w badmintona ORAZ zestaw jest nadal w grze; jeden wskazuje, że dane wejściowe nie są prawidłowym wynikiem w badmintona.

W badmintonie obaj (pary) graczy zaczynają od 0 punktów, a ty zatrzymujesz się, gdy jeden z dwóch (par) graczy osiągnie wynik 21, z różnicą co najmniej 2 punktów, maksymalnie do 30-29.

Są to więc wszystkie możliwe pary wejściowe (w dowolnej kolejności) wskazujące, że jest to poprawny wynik badmintona ORAZ zestaw się zakończył:

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

I to są wszystkie możliwe pary wejściowe (w dowolnej kolejności) wskazujące, że jest to poprawny wynik badmintona, ALE, że zestaw jest nadal w grze:

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

Każda inna para liczb całkowitych byłaby nieprawidłowym wynikiem badmintona.

Zasady konkursu:

• I / O jest elastyczny, więc:
  • Możesz wziąć dane wejściowe jako listę dwóch liczb; dwie oddzielne liczby poprzez STDIN lub parametry funkcji; dwa ciągi; itp.
  • Rezultatem będą trzy odrębne i unikalne wartości według własnego wyboru. Mogą być liczbami całkowitymi (czyli [0,1,2], [1,2,3], [-1,0,1], itd.); mogą być booleanami (tj. [true,false,undefined/null/empty]); mogą być znakami / łańcuchami (tj. ["valid & ended","valid","invalid"]); itp.
  • Podaj we / wy użyte w odpowiedzi!
• Dozwolone jest przyjmowanie liczb całkowitych zamówionych w przedsprzedaży od najniższej do najwyższej lub odwrotnie.
• Wejściowe liczby całkowite mogą być ujemne, w którym to przypadku są oczywiście nieprawidłowe.

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły z domyślnymi regułami We / Wy , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i typem zwracanych, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem kodu (tj. TIO ).
• Zalecane jest również dodanie wyjaśnienia do odpowiedzi.

Przypadki testowe:

Te przypadki testowe są prawidłowe, a zestaw się zakończył:

0 21
12 21
21 23
28 30
29 30

Te przypadki testowe są prawidłowe, ale zestaw jest nadal w grze:

0 0
0 20
12 12
21 21
21 22

Te przypadki testowe są nieprawidłowe:

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

Stax , 20 bajtów

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

Uruchom i debuguj

Pobiera dane wejściowe w tym samym formacie co przykłady. 0oznacza, że ​​jest ważny zwycięzca. 1oznacza, że ​​gra jest w toku. -1oznacza nieprawidłowy wynik.

W pseudokodzie z uporządkowanymi danymi wejściowymi xi yalgorytmem jest

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

• signoznacza znak numerycznej ( -1, 0, a 1)
• clamp zmusza swój pierwszy argument do określonego przedziału półotwartego

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

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

Wypróbuj online!

Pobiera dane wejściowe zgodnie z zamówieniem a,b.

Powroty -2, -1, 0na ended, in play, invalid.

_{-1 bajt, dzięki Kevin Cruijssen}

---

Lewa część ( b-61<~a<a>b/22*b-3) to sprawdzenie poprawności, a prawa część ( 19<b-(b<30)>a) to sprawdzenie zakończenia gry.

Python 2 , 47 bajtów

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

Wypróbuj online!

Tworzy listę dwóch booleanów. Dzięki TFeld za napisanie pakietu testowego w odpowiedzi, który ułatwił sprawdzenie mojego rozwiązania.

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

Kluczowym spostrzeżeniem jest to, że prawidłowy wynik kończy grę dokładnie wtedy, gdy zwiększenie wyższej wartości bpowoduje, że wynik jest nieważny. Więc po prostu kodujemy warunek ważności i sprawdzamy go (a,b+1)dodatkowo, (a,b)aby sprawdzić, czy gra się zakończyła.

Ważność jest sprawdzana za pomocą trzech połączonych ze sobą warunków:

• b<3+max(19,a): Sprawdza, czy wyższy wynik bnie jest wygraną z przeszłości, z jednym b<=21lub b<=a+2(wygrana o dwa)
• 60-a>b: Równoważnik a+b<=59, upewniając się, że wynik nie jest wyższy(29,30)
• 61>60-a: Równoważnik a>=0, zapewnia, że ​​niższy wynik nie jest ujemny

---

Python 2 , 44 bajty

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

Wypróbuj online!

Ulepszona kontrola ważności przez TFeld pozwala zaoszczędzić 3 bajty. Główną ideą jest rozgałęzienie się w „dogrywce”, b>21przy b/22*bktórej efektywnie ustawia wyniki poniżej-21 na zero, podczas gdy ja rozgrywałbym a>19z dłuższymi max(19,a).

---

Python 2 , 43 bajty

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

Wypróbuj online!

Wyjścia:

ended: 0
going: -1
invalid: 1

$-2^{99}$

JavaScript (ES6),  55 53  48 bajtów

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

Wypróbuj online!

C # (interaktywny kompilator Visual C #) , 53 52 bajty

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

Nazywany jako f(max)(min). Zwraca 3 za nieprawidłowe, 1 za ukończone, 2 za trwające.

Zaoszczędził 1 bajt dzięki Kevinowi Cruijjsenowi

Wypróbuj online!

Galaretka , 25 bajtów

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

Wypróbuj online!

Lewy argument: minimum. Właściwy argument: maksymalny.
Nieprawidłowy: 0. W toku: 1. Zakończona: 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]$$

Wyjaśnienie:

»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 bajtów

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

Ta funkcja przyjmuje wyniki uporządkowane w kolejności rosnącej i zwraca pusty zestaw, jeśli wynik jest nieprawidłowy lub zestaw zawierający informację, czy zestaw jest kompletny (więc {true}, jeśli zestaw jest kompletny i ważny, oraz {false}, jeśli zestaw jest niekompletny i ważny)

Pełny program do uruchomienia może wyglądać następująco:

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

Wyjaśnienie:

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 bajtów

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

Wypróbuj online!

Zwraca an Object, czyli odpowiednio Integer 0dla nieważnych gier i Booleans trueoraz falsedla ważnych trwających gier i dla prawidłowych ukończonych gier. Bierze wynik uporządkowany (i curry), najpierw wyższy wynik.

-2 bytesodwracając kontrolę na koniec meczu.
-11 bytescurry, operatory bitowe i pewne sztuczki z automatycznym przekierowaniem typu return - dzięki @KevinCruijssen

Nie golfił

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 bajtów ^SBCS

Infix milcząca funkcja, w której zakończono na 2, trwającą na 1, nieprawidłową na 0, pozostały mniejsze i większe wyniki.

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

Wypróbuj online!

Implementuje połączone matematyczne formuły Erika the Outgolfer

$$X:=\min(\max(x+1,20),29)\\\ ([X< y]+1)[X+2>y][(x,y)=(x\bmod30,y\bmod31)]$$ przestawiono (tak jakby tradycyjny zapis matematyczny miał wektoryzację i przypisania wbudowane), aby

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

i przetłumaczone bezpośrednio na APL (który jest ściśle asocjacyjny, więc unikamy nawiasów):

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

Można to przeprowadzić w ukrytej funkcji po zastępując dla i dla , symbolizuje w lewo i w prawo argumentów zamiast dwóch zmiennych$⊣$$x$$⊢$$y$

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

Teraz jest równoważne dla dowolnej funkcji , więc możemy to uprościć$⊣⎕⊢$$⎕$$⎕$

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

które jest naszym rozwiązaniem; (,≡30 31|,)×(⊢<2+X)×1+⊢>X←29⌊20⌈1+⊣:

⊣ lewy argument;  jeden plus to;  maksymalnie 20 i więcej;  minimum 29 i to;  przypisz to do ;  czy poprawny argument jest większy (0/1) ?;  dodaj jeden; ...  wielokrotnie brzmienie że;  dwa plus ;  jest właściwym argumentem mniejszym niż ten (0/1); …  pomnóż przez to następujące;  konkatenuje argumenty;  reszty po podzieleniu przez te liczby; $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)$
 ,≡ czy skonkatenowane argumenty są identyczne z tym (0/1) ?; $[(x,y)=…]$

Montaż x86, 42 bajtów

Pobiera dane wejściowe ECXi EDXrejestruje. Pamiętaj, że ECXmusi być większa niż EDX.
Dane wyjściowe do EAX, gdzie 0oznacza, że ​​gra jest nadal włączona, co 1oznacza zakończenie gry i -1(inaczej FFFFFFFF) nieprawidłowy wynik.

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

Lub bardziej czytelny w składni 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

Ciekawostka: ta funkcja prawie spełnia zasady konwencji wywołującej C dotyczące rejestrów, które należy zachować, z wyjątkiem tego, że musiałem spychać, EBXaby zaoszczędzić trochę bajtów na zużyciu stosu.

---

Opcjonalne (nieuwzględnione w liczbie bajtów)

Dodając następujące 6 bajtów bezpośrednio przed rozpoczęciem powyższego kodu, możesz przekazać ECXi EDXuporządkować:

39 D1 7D 02 87 CA

Które są następujące w czytelnej składni Intel:

CMP ECX, EDX
JGE check
XCHG ECX, EDX

Retina 0.8.2 , 92 bajty

\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

Wypróbuj online! Link zawiera przypadki testowe. Pobiera dane wejściowe w kolejności rosnącej. Objaśnienie: Pierwszy etap po prostu konwertuje z dziesiętnego na jednoargumentowy, aby można było poprawnie porównać wyniki. Drugi etap zawiera sześć alternatywnych wzorców, pogrupowanych w trzy grupy, dzięki czemu można wyprowadzić trzy różne wartości, które są 10wygrane, 01trwałe i 00nielegalne. Wzory to:

• Przeciwko 0-19 wynik 21 to wygrana
• Przeciw 20-28 wynik +2 to wygrana
• Przeciw 29, wynik 30 to wygrana
• Przeciwko dowolnemu (niższemu) wynikowi trwa 0–20
• Przy wyniku do 28 punktów wynik +1 jest w toku
• Wszystko inne (w tym wyniki negatywne) jest nielegalne

APL (Dyalog Unicode) , 33 32 bajty ^SBCS

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

Wypróbuj online!

w: para w kolejności malejącej

out: 2 = w toku, 1 = zakończony, 0 = nieprawidłowy

testy skradzione z odpowiedzi Adáma

Bash 4+, 97 89 91 88 bajtów

Załóżmy, że dane wejściowe rosną. Zastosowane koncepcje z odpowiedzi VDM-SL . Wypróbuj online
z==0 - gra w toku
z==1- gra zakończona
z==2- nieważna

-8 po oczyszczeniu wspornika z (( & | ))warunków
+2 naprawianie błędu, dzięki Kevin Cruijssen
-3 ulepszenia logiki 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