En football australien, les buts valent 6 points et les revers valent 1 point. Les scores peuvent inclure le nombre de buts et de revers, ainsi que le score total. Compte tenu du nombre de buts et de revers pour deux équipes différentes, déterminez quelle équipe a remporté le match.

Prenez quatre entiers g1, b1, g2, b2en entrée et sortez deux valeurs distinctes pour savoir si la première équipe ou la deuxième équipe saisie a gagné. Le format d'entrée est flexible, mais l'ordre d'entrée doit permettre de savoir quelle équipe est la première. Par exemple, g1, g2, b1, b2serait autorisé, mais b1, g2, g1, b2ne le serait pas.

Cas de test

Les cas de test seront utilisés truepour la première équipe gagnante et falsepour la deuxième équipe gagnante. L'entrée est au 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

Par exemple, pour la contribution (10,8),(11,1), l'équipe 1 a marqué 10 buts et 8 derrière, pour un total de points, tandis que l'équipe 2 a marqué points, donc l'équipe 1 gagne .$10*6+8*1=68$$11*6+1*1=67$

Aucune entrée ne sera un tirage - le comportement de votre programme sur l'entrée de tirage n'a pas d'importance.

Gelée , 3 octets

ḅ6M

Un lien monadique acceptant une liste de listes d'entiers [[g1,b1],[g2,b2]], ce qui donne une liste [1]ou [2].
_{(Les tirages donneraient [1,2])}

... Ou une impression de programme complet 1ou 2.

Essayez-le en ligne! Ou consultez la suite de tests .

Comment?

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

Assemblage CP-1610 ( Intellivision ), 9 DECLEs ¹ ≈ 12 octets

Une routine prenant une entrée dans R0 ( ), R1 ( ), R2 ( ) et R3 ( ) et définissant le drapeau de signe si la 2e équipe gagne, ou l'effaçant autrement.$g_1$b 1 g 2 b 2$b_1$$g_2$$b_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

Le CP-1610 n'a pas d'instruction de multiplication et ne peut décaler que de 1 ou 2 positions à la fois, nous calculons donc l'expression suivante à la place:

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

Code de test complet

          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

Production

^{capture d'écran de jzIntv}

_{1. Un opcode CP-1610 est codé avec une valeur de 10 bits, appelée «DECLE». Cette routine dure 9 DECLEs.}

Python 3 , 26 octets

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

Essayez-le en ligne!

Réponse pas incroyablement intéressante.

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

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

Essayez-le en ligne!

Langage ésotérique phonétique international , 12 octets (langage WIP)

6ɪθɪt6ɪθɪtʈo

Sorties 1pour vrai et 0pour faux.

Pas encore d'interprète TIO, mais est exécutable en clonant le référentiel ci-dessus et en appelant python main.py "code here".

Le TL; DR de la langue est qu'il s'agit d'une langue basée sur la pile où chaque instruction est un caractère de l' alphabet phonétique international .

Prend les arguments comme 4 entrées de STDIN, dans l'ordre g1, b1, g2, b2. Peut être joué à moins de 12 octets une fois que les boucles sont complètement implémentées.

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 octets

*×6+*>*×6+*

Essayez-le en ligne!

Prend l'entrée comme 4 entiers, et fait essentiellement ce que la question demande

Cascade , 16 octets

#6&
>
 |/
 +
* &

Essayez-le en ligne!

Réutilise la même 6*a+blogique pour les deux équipes puis imprime si le premier score est supérieur à l'autre

J , 12 octets

>&(1#.6 1*])

Essayez-le en ligne!

33 , 22 octets

6OxcOasz6OxcOaclmzh1co

Essayez-le en ligne!

Prend l'entrée comme 4 entiers délimités et renvoie 0 pour la première équipe gagnante, 1 pour la seconde.

Explication:

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 octets si des résultats non distincts sont autorisés:

6OxcOasz6OxcOaclmo

Sortira la différence de score; des résultats positifs signifient la première victoire d'équipe, négatif signifie la deuxième victoire d'équipe.

Scala , 11 octets

_*6+_>_*6+_

Essayez-le en ligne!

Prend 4 entiers dans l'ordre de g1 b1 g2 b2.

brainfuck , 45 38 36 32 29 28 octets

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

Essayez-le en ligne!

Merci à @Jo King pour -8 octets

L'entrée est b1, g1, b2, g2 (les buts et les revers sont échangés) Imprime þ, si l'équipe 1 a gagné. Imprime null, si l'équipe 2 a gagné.

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 blocs 160 143 octets

Le score provient de la méthode de notation proposée ici

1 bloc / 17 octets enregistrés grâce à @A (ou Uzer_A sur scratch) _

Essayez-le sur Scratch

En tant que 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)

Historique des réponses

À peu près un port de ma réponse Keg.

Essayez-le sur Scratch

L'entrée est sous la forme de g1, b1, g2, b2

Dans la syntaxe 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)

Maintenant je sais ce que vous dites ... pourquoi jouer au golf à zéro?!? Eh bien, c'est amusant. C'est pourquoi. De plus, Scratch est unique en ce qu'il n'est pas très souvent présenté ici sur CGCC.

Nettoyer , 34 octets

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

Essayez-le en ligne!

Définit $ :: Int Int Int Int -> Boolavec des arguments pris comme$ g1 b1 g2 b2

Keg , 10 octets (SBCS)

(2|¿¿6*+)>

Essayez-le en ligne!

En tant qu'Australien, j'approuve cette question.

Entrée prise comme:

b1
g1
b2
g2

Et 0 signifie équipe 2 et 1 signifie équipe 1

Expliqué

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

6δβZk

Saisie sous forme de liste imbriquée [[g1,b1],[g2,b2]]. Sortie 0si l'équipe 1 gagne et 1si l'équipe 2 gagne.

-1 octet merci à @Grimy de me l'avoir rappelé δ.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

Apparemment, la conversion de base arbitraire sur des listes imbriquées ne fonctionne pas sans un produit externe de carte explicite .

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

essayez-le en ligne !!

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

L'ordre d'entrée est g1 b1 g2 b2. Codes de sortie 0==trueet1==false

C (gcc) , 39 35 31 26 octets

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

0 est faux

1 est vrai

L'entrée de la fonction est (g1, b1, g2, b2)

Merci à Doorknob pour -5 octets

Essayez-le en ligne!

Brain-Flak , 62 octets

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

Sorties 1si la première équipe a perdu et 0si elle a gagné (ou à égalité).

Essayez-le en ligne!

# 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 octets

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

Essayez-le en ligne!

Poétique , 751 octets

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

Essayez-le en ligne!

C'était difficile à écrire.

L'entrée est au format suivant:

g1
b1
g2
b2

Cela donne le code d'erreur "IF / EIF non apparié" si la première équipe gagne et "EOF inattendu" si la deuxième équipe gagne. (Par ailleurs, une égalité est traitée comme la deuxième équipe gagnante).

Retina 0.8.2 , 34 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Sorties 1si la deuxième équipe ne gagne pas et 0si c'est le cas. Explication:

\d+
$*

Convertissez l'entrée en unaire.

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

Dans chaque paire, multipliez le premier nombre par six et ajoutez le second.

(1*);\1$

Vérifiez si le deuxième nombre est supérieur au premier. Alternativement, vous pouvez utiliser ^(1*);\1ce qui sortira 0si la première équipe gagne et 1si ce n'est pas le cas.

PHP (7.4), 32 octets

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

Essayez-le en ligne!

Assembleur ABC , 111 74 octets

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

Essayez-le en ligne!

Il n'utilise rien au-dessus des opérations de pile les plus élémentaires:

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 octets

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

Essayez-le en ligne!

L'entrée est séparée par ligne:

g1
b1
g2
b2

Wolfram Language (Mathematica) , 13 octets

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

Essayez-le en ligne!

simple et ennuyeux

Espace, 115 octets

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

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté à titre d'explication uniquement.

Imprime 0si l'équipe 1 gagne et 1(pourrait aussi être -1pour le même nombre d'octets) si l'équipe 2 gagne.

Essayez-le en ligne (avec des espaces bruts, des tabulations et des nouvelles lignes uniquement).

Explication en pseudo-code:

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

Rubis , 21 octets

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

Essayez-le en ligne!

Contourné la solution ennuyeuse, sauvé un octet et appelé un jour.

SimpleTemplate , 84 octets

Juste la simple approche "multiplier par 6, additionner et comparer", sauf que le support mathématique fait extrêmement défaut.

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

Sorties 0pour faux et 01pour vrai.

Non golfé:

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

Tout devrait être clair avec les commentaires ( {@// ... }) ajoutés.

Japt , 6 octets

Entrée sous forme de tableau 2D. Sorties 1pour l'équipe 1, 0pour un match nul ou -1pour l'équipe 2.

mì6 rg

Essayez-le

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

Aller , 44 octets

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

Essayez-le en ligne!