परिचय:

मैंने देखा कि अभी केवल एक अन्य बैडमिंटन से संबंधित चुनौती थी । चूंकि मैं खुद (पिछले 13 साल से) बैडमिंटन खेलता हूं, इसलिए मुझे लगा कि मैं कुछ बैडमिंटन से जुड़ी चुनौतियां जोड़ूंगा। यहाँ पहले एक:

चुनौती:

इनपुट: दो पूर्णांक
आउटपुट: अपनी पसंद के तीन विशिष्ट और अद्वितीय आउटपुट में से एक। एक संकेत है कि इनपुट एक वैध बैडमिंटन स्कोर है और सेट एक विजेता के साथ समाप्त हो गया है; एक संकेत है कि इनपुट एक वैध बैडमिंटन स्कोर है और सेट अभी भी खेल में है; इनपुट का संकेत देने वाला एक वैध बैडमिंटन स्कोर नहीं है।

बैडमिंटन के साथ, दोनों (जोड़े) खिलाड़ी 0 अंकों के साथ शुरू होते हैं, और आप तब रुकते हैं जब दो (जोड़े) खिलाड़ियों में से एक कम से कम 2 अंकों के अंतर के साथ अधिकतम 21-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]]

पूर्णांक के किसी भी अन्य जोड़ी में एक अमान्य बैडमिंटन स्कोर होगा।

चुनौती नियम:

I / O लचीला है, इसलिए:
- आप इनपुट को दो नंबरों की सूची के रूप में ले सकते हैं; एसटीडीआईएन या फ़ंक्शन मापदंडों के माध्यम से दो अलग-अलग संख्या; दो तार; आदि।
- आउटपुट आपकी अपनी पसंद के तीन विशिष्ट और विशिष्ट मूल्य होंगे। पूर्णांकों (यानी हो सकता है [0,1,2], [1,2,3], [-1,0,1], आदि); बूलियन (यानी [true,false,undefined/null/empty]) हो सकता है ; अक्षर / तार (यानी ["valid & ended","valid","invalid"]) हो सकते हैं; आदि।
- कृपया अपने उत्तर में आपके द्वारा उपयोग किए गए I / O को निर्दिष्ट करें!
आपको इनपुट-पूर्णांकों को पहले से ऑर्डर किए गए निम्नतम से उच्चतम या इसके विपरीत ले जाने की अनुमति है।
इनपुट पूर्णांक नकारात्मक हो सकता है, जिस स्थिति में वे निश्चित रूप से अमान्य हैं।

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
डिफ़ॉल्ट I / O नियमों के साथ आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
डिफ़ॉल्ट ढीले निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

परीक्षण के मामलों:

ये परीक्षण मामले वैध हैं, और सेट समाप्त हो गया है:

ये परीक्षण मामले वैध हैं, लेकिन सेट अभी भी खेल में है:

ये परीक्षण मामले अमान्य हैं:

code-golf number integer

— केविन क्रूज़सेन
स्रोत

1

स्टैक्स , 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 निर्दिष्ट आधे-खुले अंतराल में अपना पहला तर्क देता है

— पुनरावर्ती
स्रोत

6

पायथन 2 , 97 95 75 72 71 70 69 64 55 54 54 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) खेल समाप्त होने के लिए एक जांच है।

— TFeld
स्रोत

6

पायथन 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, सुनिश्चित करता है कि कम अंक गैर-नकारात्मक है

पायथन 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)।

पायथन 2 , 43 बाइट्स

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

इसे ऑनलाइन आज़माएं!

आउटपुट:

ended: 0
going: -1
invalid: 1

मान लेता है कि इनपुट्स नीचे नहीं हैं । $-2^{99}$

— XNOR
स्रोत

1

मेरी नवीनतम वैधता-जांच ( b-61<~a<a>b/22*b-3) का उपयोग करके , आप 3 बाइट्स बचा सकते हैं।

— TFeld

1

+1 सभी इनपुट्स के लिए अपना दूसरा समाधान कार्य करने के लिए बाइट:lambda a,b:-(a<0)|cmp(2+max(19,a)%30-a/29,b)

— TFeld

4

जावास्क्रिप्ट (ईएस 6), 55 53 48 बाइट्स

^{@KevinCruijssen को यह ध्यान देने के लिए धन्यवाद कि मैं पूरी तरह से नहीं मान रहा था (5 बाइट्स बचा रहा था ) $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

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत

4

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 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 बाइट धन्यवाद दिया

इसे ऑनलाइन आज़माएं!

— अज्ञान का अवतार
स्रोत

4

जेली , 25 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बायाँ तर्क: न्यूनतम। सही तर्क: अधिकतम।
अमान्य: 0। चल रही: 1। समाप्त: 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]$

स्पष्टीकरण:

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

— आउटग्रॉफर को एरिक करें
स्रोत

3

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} यदि सेट अधूरा है और सेट गलत है और वैध)

चलाने के लिए एक पूर्ण कार्यक्रम इस तरह लग सकता है:

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

— समय सीमा समाप्त डेटा
स्रोत

3

जावा (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अंत के मैच की जाँच inverting द्वारा।
-11 bytesकरीने से, बिटवाइज़ ऑपरेटरों का उपयोग करके, और कुछ रिटर्न टाइप ऑटोबॉक्सींग प्रवंचना - थैंक्स टू @ केविनक्रूजस्सेन

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

— सारा जे
स्रोत

3

एपीएल (Dyalog यूनिकोड) , 35 बाइट्स ^SBCS

Infix tacit फ़ंक्शन जहां समाप्त हुआ 2 है, चल रहा है 1, अमान्य है 0, छोटे और बड़े स्कोर बचे हैं।

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

इसे ऑनलाइन आज़माएं!

औजार एरिक Outgolfer के गणितीय सूत्रों में संयुक्त

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

और सीधे एपीएल में अनुवादित (जो कड़ाई से सही-सहयोगी है, इसलिए हम कुछ कोष्ठकों से बचते हैं):

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

जो हमारा समाधान है; (,≡30 31|,)×(⊢<2+X)×1+⊢>X←29⌊20⌈1+⊣:

⊣ बाएं तर्क; वन प्लस; अधिकतम 20 और वह; न्यूनतम 29 और वह; असाइन करें ; सही तर्क अधिक है (0/1) ;; एक जोड़ें; ... गुणा कि द्वारा निम्नलिखित; दो प्लस ; सही तर्क उससे कम (0/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)$
,≡ उस (0/1) के समान समसामयिक तर्क हैं ;; $[(x,y)=…]$

— एडम
स्रोत

3

x86 असेंबली, 42 बाइट्स

ECXऔर EDXरजिस्टरों में इनपुट लेता है । ध्यान दें कि ECXसे अधिक होना चाहिए EDX।
आउटपुट में EAX, जहां 0खेल का अभी भी मतलब है, 1खेल को खत्म करने का प्रतिनिधित्व करता है और -1(उर्फ 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

या, इंटेल सिंटैक्स में अधिक पठनीय:

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

मजेदार तथ्य: यह फ़ंक्शन सी कॉलिंग कन्वेंशन के नियमों का लगभग पालन करता है, जिस पर संरक्षित करने के लिए रजिस्टर करता है, सिवाय इसके कि मुझे EBXस्टैक के उपयोग पर कुछ बाइट्स को बचाने के लिए क्लोबर करना पड़ा ।

वैकल्पिक (बाइट-गिनती में शामिल नहीं)

ऊपर दिए गए कोड को शुरू करने से पहले सीधे 6 बाइट्स जोड़कर, आप पास कर सकते हैं ECXऔर EDXअनियंत्रित हो सकते हैं :

39 D1 7D 02 87 CA

जो पठनीय इंटेल सिंटैक्स में निम्नलिखित है:

CMP ECX, EDX
JGE check
XCHG ECX, EDX

— Fayti1703
स्रोत

2

रेटिना 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 का स्कोर जारी है
कुछ भी (नकारात्मक स्कोर सहित) अवैध है

— नील
स्रोत

1

APL (Dyalog Unicode) , 33 32 बाइट्स ^SBCS

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

इसे ऑनलाइन आज़माएं!

में: अवरोही क्रम में एक जोड़ी

बाहर: 2 = चालू, 1 = समाप्त, 0 = अमान्य

Adám के जवाब से चुराए गए परीक्षण

— NGN
स्रोत

1

बैश 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

— roblogic
स्रोत

1

आपके 89 बाइट्स संस्करण के 1बजाय आउटपुट के 2लिए लगता है 0 30। आपका 97 बाइट्स संस्करण सही ढंग से काम कर रहा था, इसलिए यदि आप इसे ठीक करने में असमर्थ हैं, तो आप हमेशा रोलबैक कर सकते हैं। उस 97 संस्करण के लिए बनाया गया। :)

— केविन क्रूज़सेन

1

यह इसे ठीक करना चाहिए, और एक ही समय में एक बाइट गोल्फ। :)

— केविन क्रूज़सेन

1

मैंने इसे ठीक किया, लेकिन तुम्हारा बेहतर था! रखने के लिए मुश्किल: पी

— रोबर्टिक

बग पर 29 30:( इसे "पूर्ण" होना चाहिए

— रोबोलिक

1

आह उफ़ .. इसे ठीक करने के लिए दूसरी टर्नरी में i>29होना चाहिए j>29।

— केविन क्रूज़सेन

वैध बैडमिंटन स्कोर?

परिचय:

चुनौती:

चुनौती नियम:

सामान्य नियम:

परीक्षण के मामलों:

स्टैक्स , 20 बाइट्स

पायथन 2 , 97 95 75 72 71 70 69 64 55 54 54 51 50 48 बाइट्स

पायथन 2 , 47 बाइट्स

पायथन 2 , 44 बाइट्स

पायथन 2 , 43 बाइट्स

जावास्क्रिप्ट (ईएस 6), 55 53 48 बाइट्स

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 53 52 बाइट्स

जेली , 25 बाइट्स

VDM-SL , 80 बाइट्स

स्पष्टीकरण:

जावा (JDK) , 59 48 बाइट्स

Ungolfed

एपीएल (Dyalog यूनिकोड) , 35 बाइट्स SBCS

x86 असेंबली, 42 बाइट्स

वैकल्पिक (बाइट-गिनती में शामिल नहीं)

रेटिना 0.8.2 , 92 बाइट्स

APL (Dyalog Unicode) , 33 32 बाइट्स SBCS

बैश 4+, 97 89 91 88 बाइट्स

एपीएल (Dyalog यूनिकोड) , 35 बाइट्स ^SBCS

APL (Dyalog Unicode) , 33 32 बाइट्स ^SBCS