Trong bóng đá Úc, các bàn thắng có giá trị 6 điểm và phía sau có giá trị 1 điểm. Điểm số có thể bao gồm số lượng mục tiêu và phía sau, cũng như tổng số điểm. Cho số lượng bàn thắng và số điểm sau của hai đội khác nhau, hãy xác định đội nào thắng trận đấu.

Lấy bốn số nguyên g1, b1, g2, b2làm đầu vào và xuất hai giá trị riêng biệt cho dù đội thứ nhất hoặc nhóm thứ hai được nhập có thắng hay không. Định dạng đầu vào là linh hoạt, nhưng thứ tự đầu vào phải cho phép nó rõ ràng là đội nào trước. Ví dụ, g1, g2, b1, b2sẽ được cho phép, nhưng b1, g2, g1, b2sẽ không.

Các trường hợp thử nghiệm

Các trường hợp thử nghiệm sẽ sử dụng truecho đội thứ nhất chiến thắng và falsecho đội thứ hai chiến thắng. Đầu vào là ở định dạng (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

Như một ví dụ, đối với đầu vào (10,8),(11,1), đội 1 ghi được 10 bàn thắng và 8 behinds, với tổng số $10*6+8*1=68$ điểm, trong khi đội 2 ghi được $11*6+1*1=67$ điểm, do đó nhóm 1 chiến thắng .

Không có đầu vào sẽ là một trận hòa - hành vi của chương trình của bạn đối với đầu vào vẽ không thành vấn đề.

Thạch , 3 byte

ḅ6M

Liên kết đơn âm chấp nhận danh sách danh sách các số nguyên, [[g1,b1],[g2,b2]]mang lại danh sách [1]hoặc [2].
_{(Bốc thăm sẽ mang lại[1,2] )}

... Hoặc một chương trình in đầy đủ 1hoặc 2.

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm .

Làm sao?

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

Lắp ráp CP-1610 ( Intellivision ), 9 DECLE ¹ ≈ 12 byte

Một thói quen lấy đầu vào trong R0 ( $g_1$ ), R1 ( $b_1$ ), R2 ( $g_2$ ) và R3 ( $b_2$ ) và đặt cờ ký nếu đội thứ 2 thắng hoặc xóa nó đi.

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 không có hướng dẫn nhân và chỉ có thể thay đổi 1 hoặc 2 vị trí tại một thời điểm, vì vậy chúng tôi tính toán biểu thức sau:

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

Mã kiểm tra đầy đủ

          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

Đầu ra

^{ảnh chụp màn hình từ jzIntv}

_{1. Mã op CP-1610 được mã hóa với giá trị 10 bit, được gọi là 'DECLE'. Thủ tục này dài 9 tháng.}

Python 3 , 26 byte

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

Hãy thử trực tuyến!

Câu trả lời không thú vị lắm.

C # (Trình biên dịch tương tác Visual C #) , 22 byte

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

Hãy thử trực tuyến!

Ngôn ngữ bí truyền ngữ âm quốc tế , 12 byte (ngôn ngữ WIP)

6ɪθɪt6ɪθɪtʈo

Đầu ra 1cho đúng và 0sai.

Chưa có trình thông dịch TIO, nhưng có thể chạy được bằng cách sao chép kho lưu trữ ở trên và gọi python main.py "code here".

TL; DR của ngôn ngữ là ngôn ngữ dựa trên ngăn xếp trong đó mọi hướng dẫn là một ký tự từ Bảng chữ cái ngữ âm quốc tế .

Có các đối số là 4 đầu vào từ STDIN, theo thứ tự g1, b1, g2, b2. Có thể được đánh xuống dưới 12 byte sau khi các vòng lặp được thực hiện đầy đủ.

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

Perl 6 , 13 byte

*×6+*>*×6+*

Hãy thử trực tuyến!

Có đầu vào là 4 số nguyên và về cơ bản chỉ cần làm như câu hỏi

Xếp tầng , 16 byte

#6&
>
 |/
 +
* &

Hãy thử trực tuyến!

Sử dụng lại 6*a+blogic tương tự cho cả hai đội sau đó in xem điểm đầu tiên có cao hơn nhóm kia không

J , 12 byte

>&(1#.6 1*])

Hãy thử trực tuyến!

33 , 22 byte

6OxcOasz6OxcOaclmzh1co

Hãy thử trực tuyến!

Lấy đầu vào là 4 số nguyên được phân tách và trả về 0 cho đội thứ nhất chiến thắng, 1 cho số thứ hai.

Giải trình:

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 byte nếu cho phép kết quả không rõ ràng:

6OxcOasz6OxcOaclmo

Sẽ đầu ra chênh lệch điểm số; kết quả tích cực có nghĩa là đội thứ nhất chiến thắng, tiêu cực có nghĩa là đội thứ hai giành chiến thắng.

Scala , 11 byte

_*6+_>_*6+_

Hãy thử trực tuyến!

Có 4 số nguyên theo thứ tự g1 b1 g2 b2.

Brainfuck , 45 38 36 32 29 28 byte

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

Hãy thử trực tuyến!

Cảm ơn @Jo King vì -8 byte

Đầu vào là b1, g1, b2, g2 (mục tiêu và phía sau được trao đổi) In, nếu đội 1 giành chiến thắng. In null, nếu đội 2 thắng.

mã:

[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

Scratch 3.0 17 16 khối, 160 143 byte

Điểm đến từ phương pháp tính điểm được đề xuất ở đây

1 khối / 17 byte được lưu nhờ @A (hoặc Uzer_A trên đầu) _

Dùng thử trên Scratch

Như Scratchblocks :

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)

Trả lời lịch sử

Khá nhiều cổng câu trả lời Keg của tôi.

Dùng thử trên Scratch

Đầu vào ở dạng g1, b1, g2, b2

Trong cú pháp Scratchblocks

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)

Bây giờ tôi biết những gì bạn đang nói ... tại sao chơi golf trong đầu?!? Chà, thật vui. Đó là lý do tại sao. Ngoài ra, Scratch là duy nhất ở chỗ nó không thường xuất hiện ở đây trên CGCC.

Sạch , 34 byte

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

Hãy thử trực tuyến!

Xác định $ :: Int Int Int Int -> Boolvới các đối số được thực hiện như$ g1 b1 g2 b2

Keg , 10 byte (SBCS)

(2|¿¿6*+)>

Hãy thử trực tuyến!

Là một người Úc, tôi chấp nhận câu hỏi này.

Đầu vào được lấy là:

b1
g1
b2
g2

Và 0 có nghĩa là đội 2 và 1 có nghĩa là đội 1

Giải thích

(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

05AB1E , 6 5 byte

6δβZk

Đầu vào như một danh sách lồng nhau [[g1,b1],[g2,b2]]. Đầu ra 0nếu đội 1 thắng và 1nếu đội 2 thắng.

-1 byte cảm ơn @Grimy đã nhắc nhở tôi vềδ .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Rõ ràng chuyển đổi cơ sở tùy ý trên các danh sách lồng nhau không hoạt động mà không có sản phẩm bên ngoài bản đồ rõ ràng .

 δβ    # 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)

Zsh, 19 byte

thử trực tuyến !!

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

Thứ tự đầu vào là g1 b1 g2 b2. Mã thoát 0==truevà1==false

C (gcc) , 39 35 31 26 byte

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

0 là sai

1 là đúng

Đầu vào cho hàm là (g1, b1, g2, b2)

Cảm ơn Doorknob cho -5 byte

Hãy thử trực tuyến!

Brain-Flak , 62 byte

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

Đầu ra 1nếu đội thứ nhất thua, và0 nếu họ thắng (hoặc bị ràng buộc).

Hãy thử trực tuyến!

# 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

PowerShell , 35 byte

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

Hãy thử trực tuyến!

Thơ mộng , 751 byte

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

Hãy thử trực tuyến!

Boy, đây là một khó khăn để viết.

Đầu vào có định dạng sau:

g1
b1
g2
b2

Điều này đưa ra mã lỗi "IF / EIF không khớp" nếu đội thứ nhất thắng và "EOF bất ngờ" nếu đội thứ hai thắng. (Ngẫu nhiên, một chiếc cà vạt được coi là đội thứ hai chiến thắng).

Võng mạc 0.8.2 , 34 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Đầu ra 1nếu đội thứ hai không thắng và 0nếu có. Giải trình:

\d+
$*

Chuyển đổi đầu vào thành unary.

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

Trong mỗi cặp, nhân số thứ nhất với sáu và thêm số thứ hai.

(1*);\1$

Kiểm tra xem số thứ hai có lớn hơn số thứ nhất không. Ngoài ra, bạn có thể sử dụng ^(1*);\1sẽ xuất ra 0nếu đội đầu tiên thắng và 1nếu không.

PHP (7.4), 32 byte

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

Hãy thử trực tuyến!

Trình biên dịch ABC , 111 74 byte

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

Hãy thử trực tuyến!

Nó không sử dụng bất cứ điều gì trên các hoạt động ngăn xếp cơ bản nhất:

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]

Perl 5 , 18 byte

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

Hãy thử trực tuyến!

Đầu vào là dòng tách biệt:

g1
b1
g2
b2

Ngôn ngữ Wolfram (Mathicala) , 13 byte

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

Hãy thử trực tuyến!

thẳng thắn và nhàm chán

Khoảng trắng, 115 byte

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

Chữ cái S(dấu cách), T(tab) và N(dòng mới) được thêm vào dưới dạng chỉ tô sáng.
[..._some_action]chỉ thêm vào giải thích.

In 0nếu đội 1 thắng và 1(cũng có thể có -1cùng số byte) nếu đội 2 thắng.

Dùng thử trực tuyến (chỉ có không gian thô, tab và dòng mới).

Giải thích bằng mã giả:

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)

Một lưu ý nhỏ: vì các yếu tố đầu vào được đảm bảo $\geq0$, Tôi đang sử dụng điều đó cho lợi ích của mình để sử dụng lại các đầu vào làm địa chỉ heap cho các đầu vào tiếp theo. Với những thách thức có thể có đầu vào tiêu cực, tôi phải đẩy lại 0thành địa chỉ heap, vì địa chỉ heap không thể âm.

Ruby , 21 byte

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

Hãy thử trực tuyến!

Làm việc xung quanh giải pháp nhàm chán, lưu một byte và gọi nó là một ngày.

SimpleTemplate , 84 byte

Chỉ đơn giản là "nhân với 6, tổng và so sánh", ngoại trừ sự hỗ trợ toán học là cực kỳ thiếu.

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

Đầu ra 0cho sai và 01đúng.

Ung dung:

{@// 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}
{@/}

Mọi thứ nên rõ ràng với các ý kiến ​​( {@// ... }) được thêm vào.

Japt , 6 byte

Đầu vào dưới dạng mảng 2D. Đầu ra 1cho đội 1, 0cho một trận hòa hoặc -1cho đội 2.

mì6 rg

Thử nó

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

Đi , 44 byte

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

Hãy thử trực tuyến!