ऑस्ट्रेलियाई फुटबॉल के खेल के विजेता का निर्धारण करें

Question

ऑस्ट्रेलियाई फुटबॉल में, लक्ष्य 6 अंक के होते हैं और बेहंड 1 अंक के लायक होते हैं। स्कोर में लक्ष्य और बही की संख्या, साथ ही कुल स्कोर शामिल हो सकते हैं। दो अलग-अलग टीमों के लिए लक्ष्यों और behinds की संख्या को देखते हुए, यह निर्धारित करें कि किस टीम ने गेम जीता।

चार पूर्णांकों g1, b1, g2, b2को इनपुट के रूप में लें , और दो अलग मानों के लिए आउटपुट करें कि क्या पहली टीम या दूसरी टीम इनपुट जीत गई थी। इनपुट प्रारूप लचीला है, लेकिन इनपुट ऑर्डर में यह स्पष्ट होना चाहिए कि कौन सी टीम पहले है। उदाहरण के लिए, g1, g2, b1, b2अनुमति दी b1, g2, g1, b2जाएगी , लेकिन नहीं।

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

trueपहली टीम जीतने के falseलिए और दूसरी टीम जीतने के लिए टेस्ट मामलों का उपयोग करेगी । इनपुट प्रारूप में है (g1,b1),(g2,b2)।

(1,0),(0,1)        true
(2,0),(0,11)       true
(10,8),(11,1)      true
(0,0),(1,0)        false
(100,100),(117,0)  false
(7,7),(5,12)       true
(2,0),(0,13)       false

उदाहरण के लिए, निवेश के लिए (10,8),(11,1), टीम 1 10 गोल और 8 behinds, के लिए कुल रन बनाए $10*6+8*1=68$ अंक है, जबकि टीम 2 रन बनाए $11*6+1*1=67$ अंक है, तो टीम 1 जीत ।

कोई इनपुट ड्रॉ नहीं होगा - ड्रॉ इनपुट पर आपके प्रोग्राम का व्यवहार कोई मायने नहीं रखता।

Comments

क्या हम गेलिक फुटबॉल और बाधा दौड़ के लिए बढ़ सकते हैं?

— TRGG

@TRiG अपना सवाल खुद करें!

— स्टीफन

मैं कुछ ऐसा सोचने की कोशिश करूँगा जो बहुत करीब नहीं है।

— टीआरजी

@TRiG, ​​GAA समान होगा, बस बेस -6 के बजाय बेस -3 का उपयोग करना होगा।

— झबरा

हाँ @ शिग्गी, यही वजह है कि मैं इस सवाल को एक बराबर GAA बनाने के लिए कॉपी नहीं कर सका। कुछ समान। हो सकता है कि अंतर्राष्ट्रीय नियम फुटबॉल भी शामिल हो।

— TRGG

Answer 1

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

ḅ6M

एक मोनडिक लिंक पूर्णांक की सूची की एक सूची को स्वीकार करता है [[g1,b1],[g2,b2]], जो एक सूची [1]या पैदावार देता है [2]।
_{(ड्रॉ निकलेगा [1,2])}

... या एक पूर्ण कार्यक्रम मुद्रण 1या 2।

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।

कैसे?

ḅ6M - Link: list of lists of integers, X
 6  - literal six
ḅ   - convert (X) from base 6 (vectorises)
  M - maximal indices

Answer 2

CP-1610 असेंबली ( Intellivision ), 9 DECLEs ¹ tes 12 बाइट्स

आर 0 ( $g_1$ ), आर 1 ( $b_1$ ), आर 2 ( $g_2$ ) और आर 3 ( $b_2$ ) में इनपुट लेने और दूसरी टीम के जीतने पर साइन फ्लैग को सेट करने या अन्यथा उसे साफ़ करने के लिए एक रूटीन ।

275   PSHR  R5        ; push return address
110   SUBR  R2,   R0  ; R0 -= R2
082   MOVR  R0,   R2  ; R2 = R0
04C   SLL   R0,   2   ; R0 <<= 2
0D0   ADDR  R2,   R0  ; R0 += R2
0D0   ADDR  R2,   R0  ; R0 += R2
0C8   ADDR  R1,   R0  ; R0 += R1
118   SUBR  R3,   R0  ; R0 -= R3
2B7   PULR  R7        ; return

CP-1610 में कोई गुणन निर्देश नहीं है और यह एक बार में केवल 1 या 2 पदों पर ही स्थानांतरित हो सकता है, इसलिए हम निम्नलिखित अभिव्यक्ति की गणना करते हैं:

((R0 - R2) << 2) + (R0 - R2) + (R0 - R2) + R1 - R3

पूर्ण परीक्षण कोड

          ROMW    10              ; use 10-bit ROM width
          ORG     $4800           ; map this program at $4800

          ;; ------------------------------------------------------------- ;;
          ;;  test code                                                    ;;
          ;; ------------------------------------------------------------- ;;
main      PROC
          SDBD                    ; set up an interrupt service routine
          MVII    #isr,     R0    ; to do some minimal STIC initialization
          MVO     R0,       $100
          SWAP    R0
          MVO     R0,       $101

          EIS                     ; enable interrupts

          SDBD                    ; R4 = pointer to test cases
          MVII    #@@data,  R4
          MVII    #$200,    R5    ; R5 = backtab pointer

@@loop    PSHR    R5              ; save R5 on the stack
          MVI@    R4,       R0    ; load the next test case
          MVI@    R4,       R1    ; into R0 .. R3
          MVI@    R4,       R2
          MVI@    R4,       R3
          CALL    score           ; invoke our routine
          BMI     @@true

          MVII    #$80,     R0    ; set output to '0'
          B       @@output

@@true    MVII    #$88,     R0    ; set output to '1'

@@output  PULR    R5              ; restore R5
          MVO@    R0,       R5    ; draw the output

          SDBD                    ; was it the last test case?
          CMPI    #@@end,   R4
          BLT     @@loop          ; if not, jump to @@loop

          DECR    R7              ; loop forever

@@data    DECLE   1, 0, 0, 1      ; test cases
          DECLE   2, 0, 0, 11
          DECLE   10, 8, 11, 1
          DECLE   0, 0, 1, 0
          DECLE   100, 100, 117, 0
          DECLE   7, 7, 5, 12
          DECLE   2, 0, 0, 13
@@end     ENDP

          ;; ------------------------------------------------------------- ;;
          ;;  ISR                                                          ;;
          ;; ------------------------------------------------------------- ;;
isr       PROC
          MVO     R0,       $0020 ; enable display

          CLRR    R0
          MVO     R0,       $0030 ; no horizontal delay
          MVO     R0,       $0031 ; no vertical delay
          MVO     R0,       $0032 ; no border extension
          MVII    #$D,      R0
          MVO     R0,       $0028 ; light-blue background
          MVO     R0,       $002C ; light-blue border

          JR      R5              ; return from ISR
          ENDP

          ;; ------------------------------------------------------------- ;;
          ;;  routine                                                      ;;
          ;; ------------------------------------------------------------- ;;
score     PROC
          PSHR    R5              ; push the return address

          SUBR    R2,       R0    ; R0 -= R2
          MOVR    R0,       R2    ; R2 = R0
          SLL     R0,       2     ; R0 <<= 2
          ADDR    R2,       R0    ; R0 += R2
          ADDR    R2,       R0    ; R0 += R2
          ADDR    R1,       R0    ; R0 += R1
          SUBR    R3,       R0    ; R0 -= R3

          PULR    R7              ; return
          ENDP

उत्पादन

^{स्क्रीनशॉट jzIntv से}

---

_{1. एक सीपी -1610 ओपकोड को 10-बिट मान के साथ एन्कोड किया गया है, जिसे 'DECLE' के रूप में जाना जाता है। यह दिनचर्या 9 DECLE से लंबी है।}

Answer 3

पायथन 3 , 26 बाइट्स

lambda g,b,G,B:6*g+b>6*G+B

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

अविश्वसनीय रूप से दिलचस्प जवाब नहीं।

Answer 4

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

(a,b,c,d)=>a*6+b>c*6+d

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

Comments

जेएस में भी काम करता है।

— झबरा

या जावा बदलकर =>करने के लिए->

— केविन Cruijssen

Answer 5

अंतर्राष्ट्रीय ध्वन्यात्मक गूढ़ भाषा , 12 बाइट्स (WIP भाषा)

6ɪθɪt6ɪθɪtʈo

1सत्य के लिए और 0असत्य के लिए आउटपुट ।

अभी तक कोई TIO दुभाषिया नहीं है, लेकिन ऊपर के भंडार को क्लोन करके और कॉल करके चलाने योग्य है python main.py "code here"।

भाषा का TL; DR यह है कि यह एक स्टैक-आधारित भाषा है जहाँ हर निर्देश अंतर्राष्ट्रीय ध्वन्यात्मक वर्णमाला का एक चरित्र है ।

क्रम में STDIN से 4 इनपुट के रूप में तर्क देता है g1, b1, g2, b2। एक बार छोरों को पूरी तरह से लागू करने के बाद 12 बाइट्स से कम पर गोल्फ किया जा सकता है।

6ɪθɪt6ɪθɪtʈo
6            ; Push 6
 ɪ           ; Take number input, push
  θ          ; Pop 2, multiply, push
   ɪ         ; Take number input, push
    t        ; Pop 2, add, push
     6       ; Push 6
      ɪ      ; Take number input, push
       θ     ; Pop 2, multiply, push
        ɪ    ; Take number input, push
         t   ; Pop 2, add, push 
          ʈ  ; Pop 2, if a > b push 1, otherwise 0
           o ; Pop, print

Comments

ku kl ˈlæŋgwɪʤ, dju !d!

— लुटेरा

aɑː ːm nɑːt əˈmjudzd baðə ʊ h ;d; bniˈ ɪˈt ɪz ɪˈsplmpli dəˈst ʌðənʌðər stæk-beˈst ɪlæŋɡwɪdʒ। aɒŋ ɜːstrɪli dɪsˈkɪrʒd t जु तू ˈpvoʊt ˈæs .nsðɪr।

Answer 6

पर्ल 6 , 13 बाइट्स

*×6+*>*×6+*

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

4 पूर्णांकों के रूप में इनपुट लेता है, और मूल रूप से सिर्फ सवाल पूछता है

Answer 7

कैस्केड , 16 बाइट्स

#6&
>
 |/
 +
* &

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

6*a+bदोनों टीमों के लिए एक ही तर्क का पुन: उपयोग करता है और फिर प्रिंट करता है कि क्या पहला स्कोर दूसरे की तुलना में अधिक है

Answer 8

जे , 12 बाइट्स

>&(1#.6 1*])

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

Answer 9

33 , 22 बाइट्स

6OxcOasz6OxcOaclmzh1co

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

इनपुट को 4 सीमांकित पूर्णांक के रूप में लेता है, और पहली जीतने वाली टीम के लिए 0, दूसरे के लिए 1 रिटर्न देता है।

स्पष्टीकरण:

6Oxc                   | Multiplies the first number by 6
    Oa                 | Adds the second number
        6Oxc           | Multiplies the third number by 6
            Oa         | Adds the fourth number
      sz      clmz     | Subtract this from the first team's score
                  h1co | Print 0 if the first team's score is greater, 1 otherwise

-4 बाइट्स अगर nondistinct परिणाम की अनुमति है:

6OxcOasz6OxcOaclmo

स्कोर अंतर का उत्पादन करेगा; सकारात्मक परिणामों का अर्थ है पहली टीम की जीत, नकारात्मक का अर्थ है दूसरी टीम की जीत।

Answer 10

स्काला , 11 बाइट्स

_*6+_>_*6+_

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

के क्रम में 4 इंटेगर लेता है g1 b1 g2 b2।

Answer 11

ब्रेनफक , 45 38 36 32 29 28 बाइट्स

,[>,[<++++++>-],]-[[-<]>>]>.

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

@Jo King फॉर -8 बाइट्स के लिए धन्यवाद

इनपुट बी 1, जी 1, बी 2, जी 2 (लक्ष्य और बियांड का आदान-प्रदान होता है) प्रिंट्स þ, अगर टीम 1 जीती। प्रिंट्स शून्य, अगर टीम 2 जीती।

कोड:

[tape: p1, p2, print marker]

[Get input and calculate scores]
,               input behinds of team 1
[               while input
  >,                go to next cell and input goals of team
  [<++++++>-]       add it 6 times to behinds
,]              repeat this with the second pair of values

[Determine, which one is better]
-               set print marker
[               while score of both teams is greater than zero
  [-<]              decrement and go to previous cell (team 1 or empty cell/in the first run, it will decrement the print marker a second time)
  >>                return to team 2 (or two cells to the right of the first team that became 0)
]
>               go one cell right. If team 1 won, we are at the print marker now
                If team 2 won, we are one cell right of the print marker
.           Print that

Comments

मुझे नहीं लगता कि यह 10 से अधिक इनपुट के साथ काम करता है, लेकिन वैसे भी एक महान समाधान। (अभी भी इसे नोट करेंगे)। हो सकता है कि बाद में आउटगोल्फ को एक कोशिश दें :)

— रोमन ग्रैफ

हां, 9 से अधिक के इनपुट कम से कम थोड़े पेचीदा हैं, क्योंकि कोड केवल प्रति इनपुट एक वर्ण का उपयोग करता है। :;<=>?यदि आप उच्च स्कोर दर्ज करना चाहते हैं तो आपको अगले ASCII वर्ण ( आदि) का उपयोग करने की आवश्यकता है ।

— डोरियन

क्या "वर्ण को शून्य के अलावा वर्ण कोड के रूप में इनपुट" एक विकल्प है? साथ ही, दोनों स्कोर बराबर होने चाहिए, जब पूर्णांक 256 से विभाजित हो, तो कम से कम जब आप टियो का उपयोग करें।

— डोरियन

Answer 12

स्क्रैच 3.0 17 16 ब्लॉक, 160 143 बाइट्स

स्कोर यहाँ प्रस्तावित स्कोरिंग विधि से आता है

1 ब्लॉक / 17 बाइट्स ने @A (या खरोंच पर Uzer_A) के लिए धन्यवाद बचाया

इसे स्क्रैच पर आज़माएं

स्क्रैचब्लॉक के रूप में :

when gf clicked
repeat(2
ask[]and wait
set[m v]to((answer)*(6)
ask[]and wait
change[m v]by(answer
add(m)to[x v
end
say<(item(1) of [x v]) > (m)

उत्तर इतिहास

मेरे केग उत्तर का बहुत अधिक पोर्ट।

इसे स्क्रैच पर आज़माएं

इनपुट के रूप में है g1, b1, g2, b2

स्क्रैचब्लॉक सिंटैक्स में

when gf clicked
repeat(0
set[m v]to(0
ask[]and wait
change[m v]by((answer)*(6)
ask[]and wait
change[m v]by(answer
add(m)to[x v
end
say<(item(1) of [x v]) > (m)

अब मुझे पता है कि तुम क्या कह रहे हो ... क्यों खरोंच में गोल्फ? खैर, यह मजेदार है। इसीलिए। इसके अलावा, स्क्रैच इस मायने में विशिष्ट है कि यह बहुत बार यहां CGCC पर प्रदर्शित नहीं होता है।

Comments

51 बाइट्स?

— 7

Answer 13

साफ , 34 बाइट्स

import StdEnv
$a b c d=a*6+b>c*6+d

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

$ :: Int Int Int Int -> Boolजैसे तर्कों के साथ परिभाषित करता है$ g1 b1 g2 b2

Answer 14

Keg , 10 बाइट्स (SBCS)

(2|¿¿6*+)>

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

एक ऑस्ट्रेलियाई के रूप में, मैं इस सवाल का अनुमोदन करता हूं।

इनपुट के रूप में लिया गया:

b1
g1
b2
g2

और 0 का मतलब टीम 2 और 1 का मतलब टीम 1 है

व्याख्या की

(2| #twice
¿¿  #get input in the form of bn, gn where n is the team number
*6+ #multiply the goals by 6 and add the values
)>  #compare the two values to determine the winner

Answer 15

05AB1E , 6 5 बाइट्स

6δβZk

एक नेस्टेड सूची के रूप में इनपुट [[g1,b1],[g2,b2]] । आउटपुट 0अगर टीम 1 जीतती है और1 अगर टीम 2 जीतती है।

-1 बाइट @ ग्रीम को धन्यवादमेरे बारे में याद दिलाने केδ ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

नेस्टेड सूचियों पर स्पष्ट रूप से मनमाना आधार रूपांतरण एक स्पष्ट मानचित्र बाहरी उत्पाद के बिना काम नहीं करता है ।

 δβ    # Apply arbitrary base-conversion double-vectorized,
6      # using the (implicit) input-list of lists and 6 as base
       # (i.e. [a,b] becomes 6a+b (or to be more precise: 6¹a + 6⁰b))
   Z   # Get the maximum of this mapped list (without popping the list itself)
    k  # And get the 0-based index of this maximum in the mapped list
       # (after which the top of the stack is output implicitly as result)

Answer 16

Zsh, 19 बाइट्स

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

((6*$1+$2>6*$3+$4))

इनपुट आदेश है g1 b1 g2 b2। कोड से बाहर निकलें 0==trueऔर1==false

Answer 17

सी (gcc) , ३ ९ ३५ ३१ २६ बाइट्स

e(a,b,c,d){a=(a-c)*6>d-b;}

0 झूठा है

1 सच है

फंक्शन का इनपुट है (g1, b1, g2, b2)

-5 बाइट्स के लिए Doorknob को धन्यवाद

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

Comments

आप बाद में स्थान निकाल सकते हैं return, लेकिन आप 26 बाइट्स के लिए कार्यान्वयन विवरण का दुरुपयोग भी कर सकते हैं ।

— दरवाज़े

Answer 18

ब्रेन-फ्लैक , 62 बाइट्स

([((({})({}){}){}{}[(({})({}){}){}{}]<(())>)(<>)]){({}())<>}{}

आउटपुट 1अगर पहली टीम हार गई, और 0अगर वे जीत गए (या बंधे)।

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

# Input: G B g b

   (                                 <(())>)                   # Push 1 under...
    ({})({}){}){}{}                                            #   6G + B
                   [                ]                          #   Minus
                    (({})({}){}){}{}                           #   6g + b
                                             <>                # Switch stacks
([(                                         (  )])             # Push 0 under -(6G+B-6g+b)
                                                   ({}())<>    # Add 1 and switch stacks...
                                                  {        }   #   until one stack reaches 0
                                                            {} # Pop, leaving either 1 or 0

Answer 19

पॉवरशेल , 35 बाइट्स

param($g,$b,$h,$c)$g*6+$b-gt$h*6+$c

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

Comments

वैकल्पिक 35 बाइट्स

— Veskah

Answer 20

काव्य , 751 बाइट्स

the game:a game o soccer
for a moment of my fun,i kicked my leg
o,i hurt a player
o.m.gee,o no
suddenly i then apologized a little
o.m.gee,o no
but really,i loved a good soccer battle
a game i am doing,i love it
there is a game,a twenty-to-one unwinnable match(as we called it,i mean)a match we won
a wonder of an event i saw
i played,i go in again
i am happy in a match-up of teams,i am pumped
then o,a coach i saw played soccer
i know i do admire a game o soccer
o,a match was not a bummer,and also i am making in an extra score
i think i saw a split net,a hole i ripped out a net
i am ready to win a match
o,my people and i love a sport,a bit o soccer
i am going in a game,i score,i win
o really,i am doing a game o soccer
play ball
i am gonna wi-n

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

लड़का, यह लिखने के लिए एक कठिन था।

इनपुट निम्न प्रारूप में है:

g1
b1
g2
b2

यदि "पहली टीम जीतती है, और दूसरी टीम जीतती है तो" अप्रत्याशित EOF "" यह "बेमेल IF / EIF का त्रुटि कोड देता है। (संयोग से, एक टाई को दूसरी टीम के विजेता के रूप में माना जाता है)।

Answer 21

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

\d+
$*
(1*),
$1$1$1$1$1$1
(1*);\1$

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। 1दूसरी टीम नहीं जीतती है और 0अगर ऐसा होता है तो आउटपुट । स्पष्टीकरण:

\d+
$*

इनपुट को unary में बदलें।

(1*),
$1$1$1$1$1$1

प्रत्येक जोड़ी में, पहली संख्या को छह से गुणा करें और दूसरे को जोड़ें।

(1*);\1$

जांचें कि क्या दूसरी संख्या पहले से अधिक है। वैकल्पिक रूप से, आप उपयोग कर सकते हैं ^(1*);\1जो कि आउटपुट होगा 0यदि पहली टीम जीतती है और1 यदि यह नहीं होती है।

Answer 22

PHP (7.4), 32 बाइट्स

fn($g,$b,$G,$B)=>$g+$b/6>$G+$B/6

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

Answer 23

एबीसी-असेंबलर , 111 74 बाइट्स

.o 0 4 iiii
f
	subI
	pushI 6
	mulI
	addI
	subI
	pushI 0
	ltI
.d 0 1 b
	rtn

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

यह सबसे बुनियादी स्टैक संचालन के ऊपर कुछ भी उपयोग नहीं करता है:

subI    | B = [g1-g2,b1,b2]
pushI 6 | B = [6,g1-g2,b1,b2]
mulI    | B = [6*g1-6*g2,b1,b2]
addI    | B = [6*g1+b1-6*g2,b2]
subI    | B = [6*g1+b1-6*g2-b2]
pushI 0 | B = [0,6*g1+b1-6*g2-b2]
ltI     | B = [0<6*g1+b1-6*g2-b2]

Answer 24

पर्ल 5 , 18 बाइट्स

say<>*6+<>><>*6+<>

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

इनपुट लाइन अलग है:

g1
b1
g2
b2

Answer 25

वोल्फ्राम लैंग्वेज (मैथेमेटिका) , 13 बाइट्स

6#+#2>6#3+#4&

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

सीधा और उबाऊ

Answer 26

व्हॉट्सएप, 115 बाइट्स

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _STDIN_as_integer][T    T   T   _Retrieve_integer][S S S T  T   S N
_Push_6][T  S S N
_Multiply][S N
S _Duplicate][S N
S _Duplicate][T N
T   T   _STDIN_as_integer][T    T   T   _Retrieve_integer][T    S S S _Add][S N
S _Duplicate][S N
S _Duplicate][T N
T   T   _STDIN_as_integer][T    T   T   _Retrieve_input][S S S T    T   S N
_Push_6][T  S S N
_Multiply][S N
S _Duplicate][S N
S _Duplicate][T N
T   T   _STDIN_as_integer][T    T   T   _Retrieve_input][T  S S S _Add][T   S S T   _Subtract][N
T   T   N
_If_negative_jump_to_Label_NEGATIVE][S S S N
_Push_0][T  N
S T _Print_as_integer][N
N
N
_Exit_Program][N
S S N
_Label_NEGATIVE][S S S T    N
_Push_1][T  N
S T _Print_as_integer]

पत्र S(स्थान), T(टैब), और N(नई-पंक्ति) केवल हाइलाइटिंग के रूप में जोड़े गए।
[..._some_action]केवल स्पष्टीकरण के रूप में जोड़ा गया।

0अगर टीम 2 जीतती है तो प्रिंट 1 और 1( -1उसी बाइट-काउंट के लिए भी हो सकता है )।

इसे ऑनलाइन आज़माएँ (कच्चे स्थान, टैब और नई-नई लाइनों के साथ)।

छद्म कोड में स्पष्टीकरण:

Integer g1 = STDIN as integer
Integer t1 = g1*6
Integer b1 = STDIN as integer
t1 = t1 + b1
Integer g2 = STDIN as integer
Integer t2 = g2*6
Integer b2 = STDIN as integer
t2 = t2 + b2
If(t1 - t2 < 0):
  Goto NEGATIVE
Print 0
Exit program

Label NEGATIVE:
  Print 1
  (implicitly exit with an error)

एक मामूली नोट: चूंकि इनपुट होने की गारंटी है $\geq0$, मैं बाद के आदानों के लिए ढेर-पते के रूप में इनपुट का फिर से उपयोग करने के लिए अपने लाभ के लिए उपयोग कर रहा हूं। उन चुनौतियों के साथ, जिनके नकारात्मक इनपुट हो सकते हैं, मुझे 0ढेर-पते के रूप में फिर से धक्का देना होगा, क्योंकि ढेर-पते नकारात्मक नहीं हो सकते।

Answer 27

रूबी , 21 बाइट्स

->a,b,x,y{b-y>6*x-=a}

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

बोरिंग समाधान के आसपास काम किया, एक बाइट को बचाया और इसे एक दिन कहा।

Answer 28

SimpleTemplate , 84 बाइट्स

सिर्फ साधारण "6 से गुणा, योग और तुलना" aproach, सिवाय गणित के समर्थन के अतिवादी कमी है।

{@set*A argv.0,6}{@incbyargv.1 A}{@set*B argv.2,6}{@incbyargv.3 B}0{@ifB is lowerA}1

0असत्य के लिए और 01सत्य के लिए आउटपुट ।

---

Ungolfed:

{@// multiply the first argument by 6}
{@set* teamA argv.0, 6}

{@// add the 2nd argument to the previous result}
{@inc by argv.1 teamA}

{@// same as before, for argument 3 and 4}
{@set* teamB argv.2, 6}
{@inc by argv.3 teamB}

{@echo 0}
{@// alternative: teamA is greater than teamB}
{@if teamB is lower than teamA}
    {@echo 1}
{@/}

टिप्पणियों के साथ सब कुछ स्पष्ट होना चाहिए ( {@// ... }) जोड़ा गया।

Answer 29

जाप , 6 बाइट्स

2 डी-सरणी के रूप में इनपुट। 1टीम 1 के लिए आउटपुट , 0ड्रॉ के लिए या -1टीम 2 के लिए।

mì6 rg

कोशिश करो

mì6 rg     :Implicit input of array
m          :Map
 ì6        :  Convert from base-6 digit array
    r      :Reduce by
     g     :  Sign of difference

Answer 30

जाओ , ४४ बाइट्स

func f(a,b,x,y int)bool{return a*6+b>=x*6+y}

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