В австралийском футболе голы приносят 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 ударов, в сумме $10*6+8*1=68$ очков, а команда 2 набрала $11*6+1*1=67$ очков, поэтому команда 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

Сборка CP-1610 ( Intellivision ), 9 DECLEs ¹ ≈ 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 ДЕКЛЕОВ.}

Python 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

Выходы 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.

брейкфак , 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

Скретч 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)

История ответов

В значительной степени порт моего кег ответа.

Попробуй это на Scratch

Ввод в форме 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)

Теперь я знаю, что вы говорите ... почему гольф на пустом месте?!? Ну, это весело. Поэтому. Кроме того, 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)

Зш, 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 байт

Попробуйте онлайн!

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

В каждой паре умножьте первое число на шесть и добавьте второе.

(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

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 выигрывает, и 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истинных.

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

Все должно быть ясно с {@// ... }добавлением комментариев ( ).

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

Go , 44 байта

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

Попробуйте онлайн!