Im australischen Fußball sind Tore 6 Punkte wert und Hintertreffer 1 Punkt. Punktzahlen können die Anzahl der Tore und die Anzahl der Rückstände sowie die Gesamtpunktzahl umfassen. Bestimmen Sie anhand der Anzahl der Tore und Rückstände für zwei verschiedene Teams, welches Team das Spiel gewonnen hat.

Nehmen Sie vier Ganzzahlen g1, b1, g2, b2als Eingabe und geben Sie zwei unterschiedliche Werte aus, unabhängig davon, ob das erste oder das zweite eingegebene Team gewonnen hat. Das Eingabeformat ist flexibel, aber die Eingabereihenfolge muss deutlich machen, welches Team zuerst an der Reihe ist. Zum Beispiel g1, g2, b1, b2wäre erlaubt, b1, g2, g1, b2würde aber nicht.

Testfälle

Testfälle werden truefür den ersten Mannschaftssieg und falsefür den zweiten Mannschaftssieg verwendet. Die Eingabe erfolgt im Format (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

Als Beispiel für die Eingabe (10,8),(11,1)erzielte Team 1 10 Tore und 8 Rückstande, was insgesamt $10*6+8*1=68$ Punkte ergibt, während Team 2 $11*6+1*1=67$ Punkte erzielte, sodass Team 1 gewinnt .

Keine Eingabe ist ein Unentschieden - das Verhalten Ihres Programms bei der Zeicheneingabe spielt keine Rolle.

Gelee , 3 Bytes

ḅ6M

Ein monadischer Link, der eine Liste mit ganzen Zahlen akzeptiert [[g1,b1],[g2,b2]], die eine Liste mit [1]oder ergibt [2].
_{(Unentschieden würden ergeben [1,2])}

... oder ein volles Programm drucken 1oder 2.

Probieren Sie es online! Oder sehen Sie sich die Testsuite an .

Wie?

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

CP-1610 Baugruppe ( Intellivision ), 9 DECLEs ^{1 -} 12 Byte

Eine Routine, die Eingaben in R0 ( $g_1$ ), R1 ( $b_1$ ), R2 ( $g_2$ ) und R3 ( b 2 ) vornimmt$b_2$ ) vornimmt und das Vorzeichen setzt, wenn die 2. Mannschaft gewinnt, oder es anderweitig löscht.

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

Der CP-1610 hat keine Multiplikationsanweisung und kann jeweils nur um 1 oder 2 Positionen verschoben werden. Daher berechnen wir stattdessen den folgenden Ausdruck:

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

Vollständiger Testcode

          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

Ausgabe

^{Screenshot von jzIntv}

_{1. Ein CP-1610-Opcode wird mit einem 10-Bit-Wert codiert, der als "DECLE" bezeichnet wird. Diese Routine ist 9 DECLE lang.}

Python 3 , 26 Bytes

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

Probieren Sie es online!

Keine unglaublich interessante Antwort.

C # (Visual C # Interactive Compiler) , 22 Byte

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

Probieren Sie es online!

Internationale phonetische esoterische Sprache , 12 Bytes (WIP-Sprache)

6ɪθɪt6ɪθɪtʈo

Ausgänge 1für wahr und 0falsch.

Noch kein TIO-Interpreter, kann aber ausgeführt werden, indem Sie das Repository oben klonen und aufrufen python main.py "code here".

Die TL; DR der Sprache ist, dass es sich um eine stapelbasierte Sprache handelt, in der jede Anweisung ein Zeichen aus dem Internationalen Phonetischen Alphabet ist .

Übernimmt Argumente als 4 Eingaben von STDIN in der Reihenfolge g1, b1, g2, b2. Könnte auf weniger als 12 Bytes reduziert werden, sobald die Schleifen vollständig implementiert sind.

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 Bytes

*×6+*>*×6+*

Probieren Sie es online!

Nimmt die Eingabe als 4 Ganzzahlen und macht im Grunde nur, was die Frage verlangt

Kaskade , 16 Bytes

#6&
>
 |/
 +
* &

Probieren Sie es online!

Verwendet dieselbe 6*a+bLogik für beide Teams und druckt dann, ob die erste Punktzahl höher ist als die andere

J , 12 Bytes

>&(1#.6 1*])

Probieren Sie es online!

33 , 22 Bytes

6OxcOasz6OxcOaclmzh1co

Probieren Sie es online!

Nimmt die Eingabe als 4 durch Trennzeichen getrennte Ganzzahlen und gibt 0 für das erste gewinnende Team und 1 für das zweite zurück.

Erläuterung:

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, wenn nicht eindeutige Ergebnisse zulässig sind:

6OxcOasz6OxcOaclmo

Gibt die Punktedifferenz aus. Positive Ergebnisse bedeuten den ersten Mannschaftssieg, negative den zweiten Mannschaftssieg.

Scala , 11 Bytes

_*6+_>_*6+_

Probieren Sie es online!

Nimmt 4 ganze Zahlen in der Reihenfolge von g1 b1 g2 b2.

Brainfuck , 45 38 36 32 29 28 Bytes

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

Probieren Sie es online!

Vielen Dank an @Jo King für -8 Bytes

Die Eingabe ist b1, g1, b2, g2 (Tore und Hintergründe werden ausgetauscht). Druckt Prints, wenn Team 1 gewonnen hat. Gibt null aus, wenn Team 2 gewonnen hat.

Code:

[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 Blöcke, 160 143 Bytes

Score stammt aus vorgeschlagen Scoring - Methode hier

1 Block / 17 Bytes gespeichert dank @A (oder Uzer_A bei Scratch) _

Probieren Sie es einfach aus

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

Antwortverlauf

Ziemlich genau ein Port meiner Keg-Antwort.

Probieren Sie es einfach aus

Die Eingabe erfolgt in Form von g1, b1, g2, b2

In Scratchblocks-Syntax

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)

Jetzt weiß ich, was du sagst ... warum Golf von Grund auf?!? Nun, es macht Spaß. Deshalb. Scratch ist auch insofern einzigartig, als es hier auf CGCC nicht sehr häufig vorkommt.

Sauber , 34 Bytes

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

Probieren Sie es online!

Definiert $ :: Int Int Int Int -> Boolmit Argumenten wie$ g1 b1 g2 b2

Fass , 10 Bytes (SBCS)

(2|¿¿6*+)>

Probieren Sie es online!

Als Australier bin ich mit dieser Frage einverstanden.

Eingabe erfolgt als:

b1
g1
b2
g2

Und 0 bedeutet Team 2 und 1 bedeutet Team 1

Erklärt

(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 Bytes

6δβZk

Eingabe als verschachtelte Liste [[g1,b1],[g2,b2]]. Ausgabe, 0wenn Team 1 gewinnt und1 wenn Team 2 gewinnt.

-1 Byte Danke an @Grimy für die Erinnerung δ.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

Eine scheinbar willkürliche Basiskonvertierung auf verschachtelten Listen funktioniert nicht ohne ein explizites Map- Outer-Produkt.

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

versuche es online !!

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

Eingabereihenfolge ist g1 b1 g2 b2. Ausgangscodes 0==trueund1==false

C (gcc) , 39 35 31 26 Bytes

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

0 ist falsch

1 ist wahr

Eingang zur Funktion ist (g1, b1, g2, b2)

Danke an Doorknob für -5 Bytes

Probieren Sie es online!

Brain-Flak , 62 Bytes

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

Ausgänge, 1wenn die erste Mannschaft verloren hat, und0 ob sie gewonnen (oder unentschieden) hat.

Probieren Sie es 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 Byte

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

Probieren Sie es online!

Poetisch , 751 Bytes

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

Probieren Sie es online!

Junge, das war schwer zu schreiben.

Die Eingabe erfolgt im folgenden Format:

g1
b1
g2
b2

Dies gibt den Fehlercode "Mismatched IF / EIF", wenn das erste Team gewinnt, und "Unexpected EOF", wenn das zweite Team gewinnt. (Ein Unentschieden gilt übrigens als zweiter Mannschaftssieg).

Retina 0.8.2 , 34 Bytes

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

Probieren Sie es online! Link enthält Testfälle. 1Wird ausgegeben, wenn die zweite Mannschaft nicht gewinnt und 0wenn ja. Erläuterung:

\d+
$*

Konvertieren Sie die Eingabe in Unary.

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

Multiplizieren Sie in jedem Paar die erste Zahl mit sechs und addieren Sie die zweite.

(1*);\1$

Überprüfen Sie, ob die zweite Zahl größer als die erste ist. Alternativ können Sie festlegen, ^(1*);\1welche Ausgabe erfolgen soll, 0wenn das erste Team gewinnt und 1welche nicht.

PHP (7.4), 32 Bytes

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

Probieren Sie es online!

ABC-Assembler , 111 74 Bytes

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

Probieren Sie es online!

Es wird nichts über den grundlegendsten Stapeloperationen verwendet:

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 Bytes

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

Probieren Sie es online!

Die Eingabe ist zeilengetrennt:

g1
b1
g2
b2

Wolfram Language (Mathematica) , 13 Byte

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

Probieren Sie es online!

geradlinig und langweilig

Leerzeichen, 115 Bytes

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

Buchstaben S(Leerzeichen), T(Tabulator) und (Zeilenvorschub) werden Nnur als Hervorhebungen hinzugefügt.
[..._some_action]nur als Erklärung hinzugefügt.

Druck , 0wenn Team 1 gewinnt und 1(auch sein könnte -1für den gleichen Byte-count) , wenn Team 2 Siege.

Probieren Sie es online aus (nur mit Leerzeichen, Tabulatoren und Zeilenumbrüchen).

Erklärung im Pseudocode:

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)

Eine kleine Anmerkung: da sind die Eingänge garantiert $\geq0$Ich nutze das zu meinem Vorteil, um die Eingaben als Heap-Adressen für die nachfolgenden Eingaben wiederzuverwenden. Bei Herausforderungen, die negative Eingaben haben können, müsste ich erneut 0als Heap-Adresse pushen , da Heap-Adressen nicht negativ sein können.

Ruby , 21 Bytes

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

Probieren Sie es online!

Hat die langweilige Lösung umgangen, ein Byte gespeichert und es einen Tag genannt.

SimpleTemplate , 84 Byte

Nur der einfache Ansatz "Multiplizieren mit 6, Summieren und Vergleichen", außer dass die mathematische Unterstützung extrem fehlt.

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

Ausgaben 0für false und 01für true.

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

Alles sollte klar sein mit den Kommentaren ( {@// ... }) hinzugefügt.

Japt , 6 Bytes

Eingabe als 2D-Array. Ausgänge 1für Team 1, 0für ein Unentschieden oder -1für Team 2.

mì6 rg

Versuch es

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

Los , 44 Bytes

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

Probieren Sie es online!