En el fútbol australiano, los goles valen 6 puntos y los traseros valen 1 punto. Los puntajes pueden incluir el número de goles y goles, así como el puntaje total. Dada la cantidad de goles y detrás de dos equipos diferentes, determine qué equipo ganó el juego.

Tome cuatro enteros g1, b1, g2, b2como entrada y obtenga dos valores distintos para saber si el primer equipo o el segundo equipo ingresaron ganaron. El formato de entrada es flexible, pero el orden de entrada debe permitir que sea obvio qué equipo es el primero. Por ejemplo, g1, g2, b1, b2estaría permitido, pero b1, g2, g1, b2no lo estaría.

Casos de prueba

Los casos de prueba se utilizarán truepara el primer equipo ganador y falsepara el segundo equipo ganador. La entrada está en el formato (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

Como ejemplo, para el aporte (10,8),(11,1), el equipo 1 anotó 10 goles y 8 detrás, para un total de puntos, mientras que el equipo 2 anotó puntos, por lo que el equipo 1 gana .$10*6+8*1=68$$11*6+1*1=67$

Ninguna entrada será un sorteo: el comportamiento de su programa en la entrada de sorteo no importa.

Jalea , 3 bytes

ḅ6M

Un enlace monádico que acepta una lista de listas de enteros [[g1,b1],[g2,b2]], lo que produce una lista [1]o [2].
_{(Los sorteos rendirían [1,2])}

... O un programa completo de impresión 1o 2.

Pruébalo en línea! O vea el conjunto de pruebas .

¿Cómo?

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

Conjunto CP-1610 ( Intellivision ), 9 DECLEs ¹ ≈ 12 bytes

Una rutina que toma datos en R0 ( $g_1$ ), R1 ( $b_1$ ), R2 ( $g_2$ ) y R3 ( $b_2$ ) y establece el indicador de signo si el segundo equipo gana, o lo borra de lo contrario.

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

El CP-1610 no tiene instrucciones de multiplicación y solo puede cambiar por 1 o 2 posiciones a la vez, por lo que calculamos la siguiente expresión:

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

Código de prueba completo

          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

Salida

^{captura de pantalla de jzIntv}

_{1. Un código de operación CP-1610 está codificado con un valor de 10 bits, conocido como 'DECLE'. Esta rutina es de 9 DECLEs de largo.}

Python 3 , 26 bytes

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

Pruébalo en línea!

No es una respuesta increíblemente interesante.

C # (compilador interactivo de Visual C #) , 22 bytes

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

Pruébalo en línea!

Lenguaje Esotérico Fonético Internacional , 12 bytes (lenguaje WIP)

6ɪθɪt6ɪθɪtʈo

Salidas 1para verdadero y 0para falso.

Todavía no hay intérprete de TIO, pero se puede ejecutar clonando el repositorio anterior y llamando python main.py "code here".

El TL; DR del lenguaje es que es un lenguaje basado en pila donde cada instrucción es un carácter del Alfabeto Fonético Internacional .

Toma argumentos como 4 entradas de STDIN, en el orden g1, b1, g2, b2. Puede reducirse a menos de 12 bytes una vez que los bucles estén completamente implementados.

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+*

Pruébalo en línea!

Toma la entrada como 4 enteros, y básicamente hace lo que la pregunta hace

Cascada , 16 bytes.

#6&
>
 |/
 +
* &

Pruébalo en línea!

Reutiliza la misma 6*a+blógica para ambos equipos y luego imprime si el primer puntaje es más alto que el otro

J , 12 bytes

>&(1#.6 1*])

Pruébalo en línea!

33 , 22 bytes

6OxcOasz6OxcOaclmzh1co

Pruébalo en línea!

Toma la entrada como 4 enteros delimitados y devuelve 0 para el primer equipo ganador, 1 para el segundo.

Explicación:

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 bytes si se permiten resultados no distintivos:

6OxcOasz6OxcOaclmo

Producirá la diferencia de puntaje; Los resultados positivos significan que el primer equipo gana, negativo significa que el segundo equipo gana.

Scala , 11 bytes

_*6+_>_*6+_

Pruébalo en línea!

Toma 4 enteros en el orden de g1 b1 g2 b2.

brainfuck , 45 38 36 32 29 28 bytes

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

Pruébalo en línea!

Gracias a @Jo King por -8 bytes

La entrada es b1, g1, b2, g2 (se intercambian goles y detrás) Imprime þ, si el equipo 1 ganó. Imprime nulo, si el equipo 2 ganó.

código:

[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

Raspe 3.0 17 16 bloques, 160 143 bytes

La puntuación proviene del método de puntuación propuesto aquí

1 bloque / 17 bytes guardados gracias a @A (o Uzer_A en scratch) _

Pruébalo en Scratch

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

Historial de respuestas

Más o menos un puerto de mi respuesta Keg.

Pruébalo en Scratch

La entrada es en forma de g1, b1, g2, b2

En la sintaxis de 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)

Ahora sé lo que estás diciendo ... ¿por qué jugar golf en scratch? Bueno, es divertido Es por eso. Además, Scratch es único en el sentido de que no se presenta muy a menudo aquí en CGCC.

Limpio , 34 bytes

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

Pruébalo en línea!

Define $ :: Int Int Int Int -> Boolcon argumentos tomados como$ g1 b1 g2 b2

Barril , 10 bytes (SBCS)

(2|¿¿6*+)>

Pruébalo en línea!

Como australiano, apruebo esta pregunta.

Entrada tomada como:

b1
g1
b2
g2

Y 0 significa equipo 2 y 1 significa equipo 1

Explicado

(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

Ingrese como una lista anidada [[g1,b1],[g2,b2]]. Salida 0si el equipo 1 gana y 1si el equipo 2 gana.

-1 byte gracias a @Grimy por recordarme δ.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

Aparentemente, la conversión de base arbitraria en listas anidadas no funciona sin un producto externo de mapa explícito .

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

Pruébalo en línea !!

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

El orden de entrada es g1 b1 g2 b2. Códigos de salida 0==truey1==false

C (gcc) , 39 35 31 26 bytes

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

0 es falso

1 es verdad

La entrada a la función es (g1, b1, g2, b2)

Gracias a Doorknob por -5 bytes

Pruébalo en línea!

Brain-Flak , 62 bytes

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

Salidas 1si el primer equipo perdió y 0si ganaron (o empataron).

Pruébalo en línea!

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

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

Pruébalo en línea!

Poético , 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

Pruébalo en línea!

Chico, fue difícil de escribir.

La entrada tiene el siguiente formato:

g1
b1
g2
b2

Esto proporciona el código de error de "IF / EIF no coincidente" si el primer equipo gana, y "EOF inesperado" si gana el segundo equipo. (Por cierto, un empate se trata como el segundo equipo ganador).

Retina 0.8.2 , 34 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Salidas 1si el segundo equipo no gana y 0si lo hace. Explicación:

\d+
$*

Convierta la entrada a unario.

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

En cada par, multiplique el primer número por seis y agregue el segundo.

(1*);\1$

Verifique si el segundo número es mayor que el primero. Alternativamente, puede usar ^(1*);\1cuál saldría 0si el primer equipo gana y 1si no gana .

PHP (7.4), 32 bytes

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

Pruébalo en línea!

Ensamblador ABC , 111 74 bytes

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

Pruébalo en línea!

No usa nada por encima de las operaciones de pila más básicas:

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+<>

Pruébalo en línea!

La entrada está separada por línea:

g1
b1
g2
b2

Wolfram Language (Mathematica) , 13 bytes

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

Pruébalo en línea!

sencillo y aburrido

Espacio en blanco, 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]

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Imprime 0si el equipo 1 gana y 1(también podría ser -1para el mismo número de bytes) si el equipo 2 gana.

Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).

Explicación en pseudocódigo:

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

Ruby , 21 bytes

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

Pruébalo en línea!

Trabajé alrededor de la solución aburrida, ahorré un byte y lo llamé un día.

SimpleTemplate , 84 bytes

Simplemente el enfoque simple de "multiplicar por 6, sumar y comparar", excepto que el soporte matemático es extremadamente deficiente.

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

Salidas 0para falso y 01para verdadero.

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

Todo debe quedar claro con los comentarios ( {@// ... }) agregados.

Japt , 6 bytes

Entrada como una matriz 2D. Salidas 1para el equipo 1, 0para un empate o -1para el equipo 2.

mì6 rg

Intentalo

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 bytes

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

Pruébalo en línea!