В австралійському футболі голи коштують 6 очок, а відставання - 1 бал. Оцінки можуть включати кількість голів і позаду, а також загальний бал. Враховуючи кількість голів та відставання двох різних команд, визначте, яка команда виграла гру.

Візьміть чотири цілі числа 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 позаду, в цілому балів, тоді як команда 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 кодується з 10-бітовим значенням, відомим як "DECLE". Ця рутина триває 9 DECLEs.}

Python 3 , 26 байт

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

Спробуйте в Інтернеті!

Не неймовірно цікава відповідь.

C # (Visual C # Interactive Compiler) , 22 байти

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

Спробуйте в Інтернеті!

Міжнародна фонетична езотерична мова , 12 байт (мова WIP)

6ɪθɪt6ɪθɪtʈo

Виходи 1для істинних і 0для помилкових.

Інтерпретатора TIO поки немає, але його можна запустити, клонуючи сховище вище та зателефонувавши python main.py "code here".

TL; DR мови полягає в тому, що це мова на основі стека, де кожна інструкція є символом з Міжнародного фонетичного алфавіту .

Вважається аргументами як 4 входи з STDIN, в порядку 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

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

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

Спробуйте в Інтернеті!

Завдяки @Jo King за -8 байт

Введення - b1, g1, b2, g2 (обміняються цілі та позаду) Друкується þ, якщо команда 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

Scratch 3.0 17 16 блоків, 160 143 байт

Оцінка базується на запропонованому тут методі скорингу

1 блок / 17 байт збережено завдяки @A (або Uzer_A на нулі) _

Спробуйте на Scratch

Як скретчблоки :

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.

Спробуйте на Scratch

Введення здійснюється у формі g1, b1, g2, b2

У синтаксисі 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)

Тепер я знаю, що ти кажеш ... навіщо гольф на нулі?!? Ну, це весело. Ось чому. Крім того, Scratch унікальний тим, що не дуже часто тут представлений на CGCC.

Чисто , 34 байти

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

Спробуйте в Інтернеті!

Визначається $ :: Int Int Int Int -> Boolз аргументами, прийнятими як$ g1 b1 g2 b2

Кег , 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.

-1 байт, дякую @Grimy за те, що він мені нагадав δ.

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

Очевидно, що довільне базове перетворення у вкладених списках не працює без явного зовнішнього продукту карти .

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

Завдяки Doorknob за -5 байт

Спробуйте в Інтернеті!

Мозок-Флак , 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

У кожній парі помножте перше число на шість і додайте друге.

(1*);\1$

Перевірте, чи більше друге число, ніж перше. Крім того, ви можете скористатись ^(1*);\1результатом, 0якщо виграє перша команда, а 1якщо ні.

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]

Perl 5 , 18 байт

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

Спробуйте в Інтернеті!

Введення розділено рядками:

g1
b1
g2
b2

Мова Вольфрама (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 виграє і 1(може також бути -1за однакову кількість байтів), якщо команда 2 переможе.

Спробуйте його в режимі он-лайн (лише із необробленими пробілами, вкладками та новими рядками).

Пояснення в псевдокоді:

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, підсумовувати та порівнювати", за винятком того, що математичної підтримки надзвичайно не вистачає.

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

Спробуйте в Інтернеті!