Введение:

Я видел, что сейчас был только один вызов, связанный с бадминтоном . Так как я сам играю в бадминтон (последние 13 лет), я решил добавить несколько проблем, связанных с бадминтоном. Вот первый:

Вызов:

Входные данные: два целых числа.
Выходные данные: один из трех отдельных и уникальных выходных данных по вашему выбору. Один указывает на то, что вход является действительным счетом бадминтона И набор закончился победителем; один указывает на то, что вход является действительным счетом бадминтона И набор все еще в игре; один указывает на то, что ввод не является действительным счетом бадминтона.

В бадминтоне оба (пары) игроков начинают с 0 очков, и вы останавливаетесь, когда один из двух (пар) игроков набрал 21 очко, с разницей как минимум в 2 очка, максимум до 30-29.

Таким образом, это все возможные входные пары (в любом порядке), указывающие на то, что это действительный счет в бадминтоне И набор закончен:

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

И это все возможные входные пары (в любом порядке), указывающие, что это действительный счет в бадминтоне, НО все еще в игре:

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

Любая другая пара целых чисел будет неверным счетом бадминтона.

Правила соревнований:

• Ввод / вывод является гибким, поэтому:
  • Вы можете принять входные данные в виде списка из двух чисел; два разделенных числа через STDIN или параметры функции; две строки; и т.п.
  • Выходными данными будут три различных уникальных значения по вашему выбору. Может быть целыми числами (например [0,1,2], [1,2,3], [-1,0,1]и т.д.); может быть логическим (т.е. [true,false,undefined/null/empty]); могут быть символами / строками (т.е. ["valid & ended","valid","invalid"]); и т.п.
  • Пожалуйста, укажите ввод / вывод, который вы использовали в своем ответе!
• Вам разрешено принимать входные целые числа, предварительно упорядоченные, от низшего к высшему или наоборот.
• Входные целые числа могут быть отрицательными, в этом случае они, конечно, недействительны.

Основные правила:

• Это код-гольф , поэтому выигрывает самый короткий ответ в байтах.
  Не позволяйте языкам кода-гольфа отговаривать вас от публикации ответов на языках, не относящихся к кодексу. Попробуйте придумать как можно более короткий ответ для «любого» языка программирования.
• Стандартные правила применяются к вашему ответу с правилами ввода / вывода по умолчанию , поэтому вы можете использовать STDIN / STDOUT, функции / метод с правильными параметрами и типом возврата, полные программы. Ваш звонок.
• По умолчанию лазейки запрещены.
• Если возможно, добавьте ссылку с тестом для вашего кода (например, TIO ).
• Кроме того, добавление объяснения для вашего ответа настоятельно рекомендуется.

Тестовые случаи:

Эти контрольные примеры действительны, и набор завершен:

0 21
12 21
21 23
28 30
29 30

Эти тесты допустимы, но набор все еще в игре:

0 0
0 20
12 12
21 21
21 22

Эти тестовые примеры недействительны:

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

Stax , 20 байт

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

Запустите и отладьте его

Он принимает данные в том же формате, что и примеры. 0значит, есть действительный победитель. 1означает, что игра в процессе. -1означает неверный счет.

В псевдокоде с упорядоченными входами xи yалгоритмом

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

• signозначает , числовой знак ( -1, 0или 1)
• clamp вводит свой первый аргумент в указанный полуоткрытый интервал

Python 2 , 97 95 75 72 71 70 69 64 55 54 52 51 50 48 байтов

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

Попробуйте онлайн!

Принимает ввод как предварительно заказанный a,b.

Возвращает -2, -1, 0для ended, in play, invalid.

_{-1 байт, спасибо Кевину Круйссену}

---

Левая часть ( b-61<~a<a>b/22*b-3) - это проверка достоверности, а правая часть ( 19<b-(b<30)>a) - проверка на окончание игры.

Python 2 , 47 байт

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

Попробуйте онлайн!

Выводит список двух логических значений. Спасибо TFeld за написание тестового набора в их ответе, который позволил легко проверить мое решение.

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

Ключевым моментом является то, что действительный счет заканчивает игру точно, если увеличение более высокого значения bделает счет недействительным. Итак, мы просто кодируем условие действительности и проверяем его (a,b+1)дополнительно, (a,b)чтобы увидеть, закончилась ли игра.

Срок действия проверяется через три условия, которые связаны друг с другом:

• b<3+max(19,a): Проверяет, что более высокий балл bне является прошлым победой, либо либо, b<=21либо b<=a+2(выигрыш на два)
• 60-a>b: Эквивалентно тому a+b<=59, чтобы оценка не была выше(29,30)
• 61>60-a: Эквивалентно тому a>=0, что нижний балл неотрицательный

---

Python 2 , 44 байта

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

Попробуйте онлайн!

Улучшенная проверка достоверности TFeld экономит 3 байта. Основная идея состоит в том, чтобы переходить на «сверхурочную работу», b>21с b/22*bкоторой эффективно устанавливает баллы ниже 21 до нуля, в то время как я бы a>19продолжил с более длинными max(19,a).

---

Python 2 , 43 байта

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

Попробуйте онлайн!

Выходы:

ended: 0
going: -1
invalid: 1

Предполагается, что входы не ниже .$-2^{99}$

JavaScript (ES6),  55 53  48 байт

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

Попробуйте онлайн!

C # (интерактивный компилятор Visual C #) , 53 52 байта

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

Называется как f(max)(min). Возвращает 3 для недействительных, 1 для завершенных, 2 для текущих.

Сохранено 1 байт благодаря Кевину Круййсену

Попробуйте онлайн!

Желе , 25 байт

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

Попробуйте онлайн!

Левый аргумент: минимум. Правильный аргумент: максимум.
Invalid: 0. Текущая: 1. Завершено 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]$$

Объяснение:

»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 байт

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

Эта функция берет оценки, упорядоченные в порядке возрастания, и возвращает пустой набор, если оценка недействительна, или набор, содержащий сведения о том, завершен ли набор (поэтому {true}, если набор завершен и действителен, и {false}, если набор неполный и действительный)

Полная программа для запуска может выглядеть так:

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

Объяснение:

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 байтов

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

Попробуйте онлайн!

Возвращает Object, который является Integer 0для недопустимых игр и Booleans trueи falseдля действительных текущих игр и для действительных завершенных игр соответственно. Принимает заказанный (и карри) счет, с более высоким счетом первым.

-2 bytesинвертируя проверку конца матча.
-11 bytesпутем каррирования, использования побитовых операторов и некоторых хитростей автобоксирования возвращаемого типа - благодаря @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 байтов ^SBCS

Инфиксная молчаливая функция, где завершено - 2, текущее - 1, недействительное - 0, оставлены меньшие и большие баллы.

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

Попробуйте онлайн!

Реализует математические формулы Эрика Аутгольфера, объединенные в

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

и переведен непосредственно в APL (который является строго правоассоциативным, поэтому мы избегаем некоторых скобок):

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

что является нашим решением; (,≡30 31|,)×(⊢<2+X)×1+⊢>X←29⌊20⌈1+⊣:

⊣ левый аргумент;  один плюс это;  максимум 20 и то;  минимум 29 и то;  присвоить это ;  правильный аргумент больше (0/1) ?;  добавить один; ...  умножить следующее этим;  два плюс ;  - правильный аргумент меньше этого (0/1); …  умножьте следующее на это;  объединить аргументы;  остатки при делении на эти числа; $x$1 + x max ( 20 , … ) min ( 29 , … ) X : = … [ y > … ] 1 + … ( … ) × … 2 + X [ y < … ] ( … ) × … ( x , y )
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 ) = … ]
 ,≡ конкатенированные аргументы идентичны (0/1) ?; $[(x,y)=…]$

Сборка x86, 42 байта

Принимает вход ECXи EDXрегистрирует. Обратите внимание, что ECXдолжно быть больше, чем EDX.
Выводит в EAX, где 0означает, что игра все еще включена, 1представляя, что игра окончена, и -1(aka FFFFFFFF), представляя неверный счет.

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

Или, более читаемый в 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

Интересный факт: эта функция почти соответствует правилам C Calling Convention, по которым сохраняются регистры, за исключением того, что мне пришлось прибегнуть EBXк сбору, чтобы сэкономить несколько байтов при использовании стека.

---

Необязательный (не входит в число байтов)

Добавив следующие 6 байтов непосредственно перед началом кода выше, вы можете передать ECXи EDXнеупорядоченный:

39 D1 7D 02 87 CA

Что является следующим в читаемом синтаксисе Intel:

CMP ECX, EDX
JGE check
XCHG ECX, EDX

Retina 0.8.2 , 92 байта

\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

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. Принимает ввод в порядке возрастания. Пояснение: Первый этап просто конвертируется из десятичного в одинарный, чтобы можно было правильно сравнить результаты. Второй этап содержит шесть альтернативных шаблонов, сгруппированных в три группы, так что можно вывести три различных значения: 10для выигрыша, 01для текущего и 00для недопустимого. Шаблоны:

• Против 0-19 счет 21 является победой
• Против 20-28 счет +2 является победой
• Против 29 счет 30 - победа
• Против любого (более низкого) балла продолжается оценка 0-20
• Для оценки до 28, оценка +1 продолжается
• Все остальное (включая отрицательные оценки) является незаконным

APL (Dyalog Unicode) , 33 32 байта ^SBCS

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

Попробуйте онлайн!

в: пара в порядке убывания

out: 2 = выполняется, 1 = завершено, 0 = недействительно

тесты, украденные из ответа Адама

Bash 4+, 97 89 91 88 байт

Предположим, что входы по возрастанию. Используемые концепции из VDM-SL отвечают. Попробуйте онлайн
z==0 - игра в процессе
z==1- игра завершена
z==2- недействительно

-8 очисткой скобки от (( & | ))условий
+2 исправление ошибки, благодаря Кевину Круйссену
-3 улучшения логики Кевином Круйссеном

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