호주 축구에서 목표는 6 점, 뒤는 1 점입니다. 점수에는 총 점수뿐만 아니라 목표 및 배후 수가 포함될 수 있습니다. 서로 다른 두 팀의 목표와 배후 수를 고려하여 어느 팀이 게임에서 이겼는지 결정하십시오.

4 개의 정수 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

예를 들어, input의 경우 (10,8),(11,1), 팀 1은 총 점으로 10 골, 뒤에서 점을 기록한 반면, 2 팀은 점을 얻었으므로 1 팀이 승리합니다. .$10*6+8*1=68$$11*6+1*1=67$

무승부 입력은 없습니다-무승부 입력에 대한 프로그램의 동작은 중요하지 않습니다.

젤리 , 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

CP-1610 어셈블리 ( Intellivision ), 9 DECLE ¹ ≈ 12 바이트

루틴 촬영에 입력 R0 ( $g_1$ ), R1 ( $b_1$ ), R2 ( $g_2$ ) 및 R3 ( $b_2$ ) 및 제 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. CP-1610 opcode는 'DECLE'로 알려진 10 비트 값으로 인코딩됩니다. 이 루틴의 길이는 9 DECLE입니다.}

파이썬 3 , 26 바이트

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

온라인으로 사용해보십시오!

믿을 수 없을 정도로 흥미로운 대답은 아닙니다.

C # (Visual C # 대화식 컴파일러) , 22 바이트

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

온라인으로 사용해보십시오!

국제 음역 밀교 언어 , 12 바이트 (WIP 언어)

6ɪθɪt6ɪθɪtʈo

1true 및 0false에 대한 출력 .

아직 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

펄 6 , 13 바이트

*×6+*>*×6+*

온라인으로 사용해보십시오!

입력을 4 개의 정수로 취하고 기본적으로 질문에서 묻는대로 수행합니다.

캐스케이드 , 16 바이트

#6&
>
 |/
 +
* &

온라인으로 사용해보십시오!

6*a+b두 팀 모두 동일한 논리를 재사용 한 다음 첫 번째 점수가 다른 점수보다 높은지 인쇄

J , 12 바이트

>&(1#.6 1*])

온라인으로 사용해보십시오!

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 바이트 :

6OxcOasz6OxcOaclmo

점수 차이를 출력합니다. 긍정적 인 결과는 첫 번째 팀 승리를, 부정은 두 번째 팀 승리를 의미합니다.

스칼라 , 11 바이트

_*6+_>_*6+_

온라인으로 사용해보십시오!

순서대로 4 개의 정수를 취합니다 g1 b1 g2 b2.

brainfuck , 45 38 36 32 29 28 바이트

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

온라인으로 사용해보십시오!

-8 바이트를위한 @Jo King 덕분에

입력은 b1, g1, b2, g2입니다 (목표와이면이 교환됩니다). 팀 1이 이기면 þ을 인쇄합니다. 2 팀이 이기면 null을 인쇄합니다.

암호:

[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

스크래치 3.0 17 16 블록 160 143 바이트

점수는 제안 된 점수 매기기 방법에서 비롯 됩니다.

@A (또는 처음 에는 Uzer_A) 덕분에 1 블록 / 17 바이트가 절약되었습니다.

스크래치에서 사용해보십시오

스크래치 블록으로 :

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)

답변 내역

내 Keg 답변의 포트입니다.

스크래치에서 사용해보십시오

입력은 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에 자주 등장하지 않는다는 점에서 독특합니다.

클린 , 34 바이트

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

온라인으로 사용해보십시오!

다음 $ :: Int Int Int Int -> Bool과 같은 인수로 정의$ g1 b1 g2 b2

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

05AB1E , 6 5 바이트

6δβZk

중첩 된 목록으로 입력하십시오 [[g1,b1],[g2,b2]]. 0팀 1이 이기고 1팀 2가 이기면 출력 됩니다 .

나에게 상기시켜 준 @Grimy 덕분에 -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)

Zsh, 19 바이트

온라인으로 사용해보십시오!

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

입력 순서는 g1 b1 g2 b2입니다. 종료 코드 0==true및1==false

C (gcc) , 39 35 31 26 바이트

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

0은 거짓

1은 사실이다

기능 입력은 (g1, b1, g2, b2)

-5 바이트의 Doorknob 덕분에

온라인으로 사용해보십시오!

Brain-Flak , 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

PowerShell , 35 바이트

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

온라인으로 사용해보십시오!

시적 , 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

첫 번째 팀이 이기면 "일치하지 않은 IF / EIF", 두 번째 팀이 이기면 "예기치 않은 EOF"오류 코드가 표시됩니다. (우연히 넥타이는 두 번째 팀 우승으로 간주됩니다).

레티 나 0.8.2 , 34 바이트

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

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 1두 번째 팀이 이기지 못하면 출력 합니다 0. 설명:

\d+
$*

입력을 단항으로 변환하십시오.

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

각 쌍에서 첫 번째 숫자에 6을 곱하고 두 번째 숫자를 더하십시오.

(1*);\1$

두 번째 숫자가 첫 번째 숫자보다 큰지 확인하십시오. 또는 첫 번째 팀이 이기고 그렇지 않은 경우 ^(1*);\1어떤 출력을 사용할 수 있습니다 .01

PHP (7.4), 32 바이트

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

온라인으로 사용해보십시오!

ABC- 어셈블러 , 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]

펄 5 , 18 바이트

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

온라인으로 사용해보십시오!

입력은 라인으로 구분됩니다 :

g1
b1
g2
b2

Wolfram Language (Mathematica) , 13 바이트

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

온라인으로 사용해보십시오!

간단하고 지루한

공백, 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팀 1이 이기면 인쇄 하고 팀 2가 이기면 같은 바이트 수일 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

루비 , 21 바이트

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

온라인으로 사용해보십시오!

지루한 솔루션을 해결하고 바이트를 저장하고 하루에 호출했습니다.

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참에 대한 출력 .

언 골프 드 :

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

주석 ( {@// ... })을 추가 하면 모든 것이 명확 해집니다 .

Japt , 6 바이트

2D 배열로 입력하십시오. 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

이동 , 44 바이트

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

온라인으로 사용해보십시오!