Determina il vincitore di una partita di football australiano

13

Nel calcio australiano, gli obiettivi valgono 6 punti e quelli dietro valgono 1 punto. I punteggi possono includere il numero di goal e spalle, nonché il punteggio totale. Dato il numero di goal e di spalle di due squadre diverse, determinare quale squadra ha vinto la partita.

Prendi quattro numeri interi g1, b1, g2, b2come input e genera due valori distinti per la vittoria della prima squadra o della seconda squadra. Il formato di input è flessibile, ma l'ordine di input deve consentire che sia evidente quale squadra è la prima. Ad esempio, g1, g2, b1, b2sarebbe permesso, ma b1, g2, g1, b2non lo sarebbe.

Casi test

I casi di test verranno utilizzati trueper la prima squadra vincente e falseper la seconda squadra vincente. L'input è nel 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

Ad esempio, per input (10,8),(11,1), la squadra 1 ha segnato 10 goal e 8 di spalle, per un totale di punti, mentre la squadra 2 ha segnato punti, quindi la squadra 1 vince .10∗6+8∗1=6811∗6+1∗1=67

Nessun input sarà un sorteggio - il comportamento del tuo programma sull'input del sorteggio non ha importanza.

code-golf  decision-problem  integer  game 
— Stefano
fonte
Potremmo estendere il calcio gaelico e lanciarlo?
— TRiG,
@TRiG fai la tua domanda!
— Stephen,
Proverò a pensare a qualcosa che non è troppo vicino.
— TRiG,
2
@TRiG, ​​GAA sarebbe identico, usando solo base-3 anziché base-6.
— Shaggy,
Sì @Shaggy, motivo per cui non potevo semplicemente copiare questa domanda per crearne uno equivalente. Qualcosa di simile. Magari includendo il calcio delle regole internazionali.
— TRiG,

Risposte:

7

Gelatina , 3 byte

ḅ6M

Un collegamento monadico che accetta un elenco di elenchi di numeri interi [[g1,b1],[g2,b2]], che restituisce un elenco [1]o [2].
(I pareggi avrebbero ceduto [1,2])

... O una stampa del programma completo 1o 2.

Provalo online! Oppure vedi la suite di test .

Come?

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

Assemblaggio CP-1610 ( Intellivision ), 9 DECLE 1 ≈ 12 byte

Una routine che prende input in R0 ( g1 ), R1 ( B1 ), R2 ( g2 ) e R3 ( B2 ) e imposta il flag di segno se la 2a squadra vince, o lo cancella in altro modo.

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

Il CP-1610 non ha istruzioni di moltiplicazione e può cambiare solo di 1 o 2 posizioni alla volta, quindi calcoliamo invece la seguente espressione:

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

Codice di prova 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

Produzione

produzione

screenshot da jzIntv

1. Un codice operativo CP-1610 è codificato con un valore di 10 bit, noto come "DECLE". Questa routine è lunga 9 DECLE.

— Arnauld
fonte
4

Lingua esoterica fonetica internazionale , 12 byte (lingua WIP)

6ɪθɪt6ɪθɪtʈo

Output 1per vero e 0per falso.

Nessun interprete TIO ancora, ma è eseguibile clonando il repository sopra e chiamando python main.py "code here".

Il TL; DR della lingua è che è una lingua basata su stack in cui ogni istruzione è un carattere dell'alfabeto fonetico internazionale .

Accetta gli argomenti come 4 input da STDIN, nell'ordine g1, b1, g2, b2. Potrebbe essere golfato fino a meno di 12 byte una volta che i loop sono completamente implementati.

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
— bigyihsuan
fonte
6
kuːl ˈlæŋgwɪʤ, djuːd!
— roblogic,
aɪ əm nɑːt əˈmjuːzd baɪ ðə hʊd; bɪˈniːθ ɪt ɪz ˈsɪmpli dʒʌst əˈnʌðər stæk-beɪst ˈlæŋɡwɪdʒ. aɪ ˈstrɒŋli dɪsˈkɜːrɪdʒ ju tu ʌpvoʊt ðɪs ˈænsər.
3

Cascata , 16 byte

#6&
>
 |/
 +
* &

Provalo online!

Riutilizza la stessa 6*a+blogica per entrambe le squadre, quindi stampa se il primo punteggio è più alto dell'altro

— Jo King
fonte
3

33 , 22 byte

6OxcOasz6OxcOaclmzh1co

Provalo online!

Prende l'input come 4 numeri interi delimitati e restituisce 0 per la prima squadra vincente, 1 per la seconda.

Spiegazione:

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 se sono consentiti risultati non distinti:

6OxcOasz6OxcOaclmo

Produrrà la differenza di punteggio; risultati positivi indicano la vittoria della prima squadra, negativo significa la vittoria della seconda squadra.

— TheOnlyMrCat
fonte
3

brainfuck , 45 38 36 32 29 28 byte

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

Provalo online!

Grazie a @Jo King per -8 byte

L'input è b1, g1, b2, g2 (vengono scambiati goal e spalle) Stampa Prints, se la squadra 1 ha vinto. Stampa null, se la squadra 2 ha vinto.

codice:

[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
— Dorian
fonte
Non credo che funzioni con input superiori a 10, ma comunque un'ottima soluzione. (Lo annoterei ancora). Potrebbe provare a superarlo più tardi :)
— Roman Gräf,
1
Sì, gli input maggiori di 9 sono almeno un po 'complicati, perché il codice utilizza solo un carattere per input. È necessario utilizzare i caratteri ASCII successivi ( :;<=>?ecc.) Se si desidera inserire punteggi più alti.
— Dorian,
"Input come codice carattere tranne null" è un'opzione? Inoltre, entrambi i punteggi devono essere uguali, quando sono divisi in numeri interi per 256, almeno quando si utilizza tio.
— Dorian,
3

Scratch 3.0 17 16 blocchi, 160 143 byte

Il punteggio viene dal metodo di punteggio proposto qui

1 blocco / 17 byte salvati grazie a @A (o Uzer_A su zero) _

Programma in blocchi migliori

Provalo su Scratch

Come gratta e vinci :

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)

Cronologia delle risposte

Programma in blocchi

Praticamente una porta della mia risposta Keg.

Provalo su Scratch

L'input è in forma di g1, b1, g2, b2

Nella sintassi di 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)

Ora so cosa stai dicendo ... perché il golf in zero?!? Beh, è ​​divertente. Ecco perchè. Inoltre, Scratch è unico in quanto non è molto spesso descritto qui su CGCC.

— Lyxal
fonte
— attinat
2

Keg , 10 byte (SBCS)

(2|¿¿6*+)>

Provalo online!

Come australiano, approvo questa domanda.

Input preso come:

b1
g1
b2
g2

E 0 indica la squadra 2 e 1 indica la squadra 1

spiegato

(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
— Lyxal
fonte
2

05AB1E , 6 5 byte

6δβZk

Immettere come elenco nidificato [[g1,b1],[g2,b2]]. Uscita 0se la squadra 1 vince e 1se la squadra 2 vince.

-1 byte grazie a @Grimy per avermelo ricordato δ.

Provalo online o verifica tutti i casi di test .

Spiegazione:

La conversione di base apparentemente arbitraria su elenchi nidificati non funziona senza un prodotto esterno della mappa esplicita .

 δβ    # 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)
— Kevin Cruijssen
fonte
2

C (gcc) , 39 35 31 26 byte

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

0 è falso

1 è vero

L'ingresso alla funzione è (g1, b1, g2, b2)

Grazie a Doorknob per -5 byte

Provalo online!

— girobuz
fonte
3
Dopo puoi rimuovere lo spazio return, ma puoi anche abusare di un dettaglio dell'implementazione per 26 byte .
— Maniglia della porta
2

Brain-Flak , 62 byte

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

Produce 1se la prima squadra ha perso e 0se ha vinto (o pareggiato).

Provalo 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
— Riley
fonte
2

Poetico , 751 byte

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

Provalo online!

Ragazzo, questo è stato difficile da scrivere.

L'input è nel seguente formato:

g1
b1
g2
b2

Ciò fornisce il codice di errore di "IF / EIF non corrispondenti" se la prima squadra vince e "EOF imprevisto" se la seconda squadra vince. (Per inciso, un pareggio viene trattato come la seconda squadra vincente).

— JosiahRyanW
fonte
1

Retina 0.8.2 , 34 byte

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

Provalo online! Il link include casi di test. Emette 1se la seconda squadra non vince e 0se lo fa. Spiegazione:

\d+
$*

Converti l'input in unario.

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

In ogni coppia, moltiplica il primo numero per sei e aggiungi il secondo.

(1*);\1$

Controlla se il secondo numero è maggiore del primo. In alternativa, è possibile utilizzare ^(1*);\1quale output 0se la prima squadra vince e in 1caso contrario.

— Neil
fonte
1

ABC-assemblatore , 111 74 byte

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

Provalo online!

Non usa nulla al di sopra delle operazioni di base dello stack:

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]
— Οurous
fonte
1

Spazio bianco, 115 byte

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

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Stampa 0se la squadra 1 vince e 1(potrebbe anche essere -1per lo stesso conteggio byte) se la squadra 2 vince.

Provalo online (solo con spazi non elaborati, schede e nuove righe).

Spiegazione in pseudo-codice:

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)

≥00

— Kevin Cruijssen
fonte
1

SimpleTemplate , 84 byte

Solo il semplice approccio "moltiplica per 6, somma e confronta", tranne per il fatto che il supporto matematico è estremamente carente.

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

Output 0per falso e 01vero.

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

Tutto dovrebbe essere chiaro con i commenti ( {@// ... }) aggiunti.

— Ismael Miguel
fonte
1

Japt , 6 byte

Input come array 2D. Uscite 1per la squadra 1, 0per un pareggio o -1per la squadra 2.

mì6 rg

Provalo

mì6 rg     :Implicit input of array
m          :Map
 ì6        :  Convert from base-6 digit array
    r      :Reduce by
     g     :  Sign of difference
— ispido
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.