W futbolu australijskim bramki są warte 6 punktów, a gole za 1 punktem. Wyniki mogą obejmować liczbę bramek i opóźnień, a także całkowity wynik. Biorąc pod uwagę liczbę bramek i opóźnień dla dwóch różnych drużyn, określ, która drużyna wygrała mecz.

Weź cztery liczby całkowite g1, b1, g2, b2jako dane wejściowe i wyślij dwie różne wartości dla tego, czy wygrał pierwszy zespół, czy drugi zespół. Format wejściowy jest elastyczny, ale kolejność wprowadzania musi pozwalać na jasne określenie, który zespół jest pierwszy. Na przykład g1, g2, b1, b2byłoby dozwolone, ale b1, g2, g1, b2nie.

Przypadki testowe

Przypadki testowe zostaną wykorzystane truedo wygrania pierwszej drużyny i falsedrugiej drużyny. Dane wejściowe są w formacie (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

Na przykład (10,8),(11,1)drużyna 1 zdobyła 10 bramek i 8 goli, w sumie punktów, podczas gdy drużyna 2 zdobyła punktów, więc drużyna 1 wygrywa .$10*6+8*1=68$$11*6+1*1=67$

Brak danych wejściowych nie będzie losowaniem - zachowanie Twojego programu podczas wprowadzania danych losowych nie ma znaczenia.

Galaretka , 3 bajty

ḅ6M

Monadyczny link akceptujący listę list liczb całkowitych [[g1,b1],[g2,b2]], który daje listę [1]lub [2].
_{(Losowanie dałoby [1,2])}

... Lub wydruk pełnego programu 1lub 2.

Wypróbuj online! Lub zobacz pakiet testowy .

W jaki sposób?

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

Zespół CP-1610 ( Intellivision ), 9 DECLE ¹ ≈ 12 bajtów

Rutynowa procedura wprowadzania danych w R0 ( $g_1$ ), R1 ( $b_1$ ), R2 ( $g_2$ ) i R3 ( $b_2$ ) i ustawianie flagi znaku, jeśli wygra 2. drużyna, lub usuwanie jej w inny sposób.

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 nie ma instrukcji mnożenia i może przesuwać się tylko o 1 lub 2 pozycje na raz, dlatego zamiast tego obliczamy następujące wyrażenie:

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

Pełny kod testowy

          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

Wynik

^{zrzut ekranu z jzIntv}

_{1. Kod operacyjny CP-1610 jest kodowany z 10-bitową wartością, znaną jako „DECLE”. Ta procedura ma długość 9 DECLE.}

Python 3 , 26 bajtów

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

Wypróbuj online!

Niezbyt interesująca odpowiedź.

C # (interaktywny kompilator Visual C #) , 22 bajty

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

Wypróbuj online!

Międzynarodowy fonetyczny język ezoteryczny , 12 bajtów (język WIP)

6ɪθɪt6ɪθɪtʈo

Dane wyjściowe 1dla wartości true i 0false.

Nie ma jeszcze interpretera TIO, ale można go uruchomić poprzez klonowanie powyższego repozytorium i wywołanie python main.py "code here".

TL; DR tego języka polega na tym, że jest to język oparty na stosie, w którym każda instrukcja jest znakiem z międzynarodowego alfabetu fonetycznego .

Pobiera argumenty jako 4 dane wejściowe ze STDIN, w kolejności g1, b1, g2, b2. Może być golfowany do mniej niż 12 bajtów, gdy pętle zostaną w pełni zaimplementowane.

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 bajtów

*×6+*>*×6+*

Wypróbuj online!

Pobiera dane wejściowe jako 4 liczby całkowite i po prostu robi to, o co pyta pytanie

Kaskada , 16 bajtów

#6&
>
 |/
 +
* &

Wypróbuj online!

Ponownie wykorzystuje tę samą 6*a+blogikę dla obu drużyn, a następnie drukuje, czy pierwsze wyniki są wyższe od innych

J , 12 bajtów

>&(1#.6 1*])

Wypróbuj online!

33 , 22 bajtów

6OxcOasz6OxcOaclmzh1co

Wypróbuj online!

Pobiera dane wejściowe jako 4 liczby całkowite rozdzielone i zwraca 0 dla pierwszej drużyny wygrywającej, 1 dla drugiej.

Wyjaśnienie:

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 bajty, jeśli niedopuszczalne wyniki są dozwolone:

6OxcOasz6OxcOaclmo

Wyprowadzi różnicę punktów; pozytywne wyniki oznaczają zwycięstwo pierwszej drużyny, ujemne oznacza zwycięstwo drugiej drużyny.

Scala , 11 bajtów

_*6+_>_*6+_

Wypróbuj online!

Przyjmuje 4 liczby całkowite w kolejności g1 b1 g2 b2.

pieprzenie mózgu , 45 38 36 32 29 28 bajtów

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

Wypróbuj online!

Dzięki @Jo King za -8 bajtów

Dane wejściowe to b1, g1, b2, g2 (bramki i gole są wymieniane) Drukuje þ, jeśli drużyna 1 wygrała. Drukuje zero, jeśli drużyna 2 wygrała.

kod:

[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 bloków, 160 143 bajtów

Wynik pochodzi z proponowanej metody punktacji tutaj

1 blok / 17 bajtów zapisanych dzięki @A (lub Uzer_A od zera) _

Wypróbuj w Scratch

Jako 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)

Historia odpowiedzi

Prawie port mojej odpowiedzi Keg.

Wypróbuj w Scratch

Dane wejściowe mają postać g1, b1, g2, b2

W składni 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)

Teraz wiem, co mówisz ... dlaczego golf od zera?!? Cóż, jest fajnie. Dlatego. Ponadto Scratch jest wyjątkowy, ponieważ nie jest bardzo często prezentowany tutaj na CGCC.

Czysty , 34 bajty

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

Wypróbuj online!

Definiuje $ :: Int Int Int Int -> Bool z argumentami branymi jak$ g1 b1 g2 b2

Keg , 10 bajtów (SBCS)

(2|¿¿6*+)>

Wypróbuj online!

Jako Australijczyk pochwalam to pytanie.

Dane wejściowe przyjęte jako:

b1
g1
b2
g2

A 0 oznacza zespół 2, a 1 oznacza zespół 1

Wyjaśnione

(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 bajtów

6δβZk

Wprowadź jako listę zagnieżdżoną [[g1,b1],[g2,b2]]. Wydajność, 0jeśli drużyna 1 wygra, a 1drużyna 2 wygra.

-1 bajtu dzięki @Grimy za przypomnienie δ.

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

Najwyraźniej dowolna podstawowa konwersja na listach zagnieżdżonych nie działa bez wyraźnego produktu zewnętrznego mapy .

 δβ    # 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 bajtów

spróbuj online !!

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

Kolejność wprowadzania to g1 b1 g2 b2. Kody wyjścia 0==truei1==false

C (gcc) , 39 35 31 26 bajtów

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

0 jest fałszem

1 jest prawdą

Wejście do funkcji to (g1, b1, g2, b2)

Dzięki Doorknob za -5 bajtów

Wypróbuj online!

Brain-Flak , 62 bajty

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

Wysyła, 1jeśli pierwsza drużyna przegrała i 0jeśli wygrała (lub remisowała).

Wypróbuj online!

# 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 bajtów

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

Wypróbuj online!

Poetycki , 751 bajtów

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

Wypróbuj online!

To był trudny do napisania.

Dane wejściowe mają następujący format:

g1
b1
g2
b2

Daje to kod błędu „Niezgodny IF / EIF”, jeśli wygrywa pierwsza drużyna, i „Nieoczekiwany EOF”, jeśli wygrywa druga drużyna. (Nawiasem mówiąc, remis jest traktowany jako wygrana drugiej drużyny).

Retina 0.8.2 , 34 bajty

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

Wypróbuj online! Link zawiera przypadki testowe. Wywołuje, 1jeśli druga drużyna nie wygra, a 0jeśli tak. Wyjaśnienie:

\d+
$*

Przekształć dane wejściowe w jednoargumentowe.

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

W każdej parze pomnóż pierwszą liczbę przez sześć i dodaj drugą.

(1*);\1$

Sprawdź, czy druga liczba jest większa niż pierwsza. Alternatywnie, możesz użyć tego, ^(1*);\1co by wyszło, 0jeśli pierwsza drużyna wygra, a 1jeśli nie.

PHP (7.4), 32 bajty

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

Wypróbuj online!

ABC-asembler , 111 74 bajtów

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

Wypróbuj online!

Nie używa niczego powyżej najbardziej podstawowych operacji na stosie:

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 bajtów

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

Wypróbuj online!

Wejście jest oddzielone wierszem:

g1
b1
g2
b2

Wolfram Language (Mathematica) , 13 bajtów

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

Wypróbuj online!

proste i nudne

Biała spacja, 115 bajtów

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

Dodane litery S(spacja), T(tab) i N(nowa linia) tylko jako wyróżnienia.
[..._some_action]dodano tylko jako wyjaśnienie.

Drukuje, 0jeśli drużyna 1 wygra i 1(może być również -1dla tej samej liczby bajtów), jeśli drużyna 2 wygra.

Wypróbuj online (tylko z surowymi spacjami, tabulatorami i nowymi wierszami).

Objaśnienie w pseudo-kodzie:

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)

Jedna drobna uwaga: ponieważ gwarantowane są nakłady $\geq0$, Używam tego na swoją korzyść, aby ponownie użyć danych wejściowych jako adresów sterty dla kolejnych danych wejściowych. W przypadku wyzwań, które mogą mieć negatywne dane wejściowe, musiałbym ponownie 0przesłać jako adres sterty, ponieważ adresy sterty nie mogą być ujemne.

Ruby , 21 bajtów

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

Wypróbuj online!

Obejrzał nudne rozwiązanie, uratował bajt i nazwał go dniem.

SimpleTemplate , 84 bajtów

Wystarczy proste podejście „pomnóż przez 6, zsumuj i porównaj”, z wyjątkiem tego, że wyjątkowo brakuje wsparcia matematycznego.

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

Dane wyjściowe 0dla false i01 true.

Nie golfowany:

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

Wszystko powinno być jasne z {@// ... }dodanymi komentarzami ( ).

Japt , 6 bajtów

Dane wejściowe jako tablica 2D. Wyniki 1dla drużyny 1, 0remisu lub -1drużyny 2.

mì6 rg

Spróbuj

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

Idź , 44 bajty

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

Wypróbuj online!