Che Inning è?

15

Obbiettivo

Alla luce delle World Series dietro l'angolo, ho bisogno di un programma in grado di leggere i punteggi delle caselle e dirmi di cosa si tratta. Questo è leggermente complicato perché il baseball utilizza un metodo dispari per registrare il punteggio. Non annotano il punteggio della squadra at-bat per l'inning fino a quando non hanno segnato una scala (e stanno ancora andando) o non hanno finito il loro at-bat. Quindi uno 0 sul tabellone indica sempre un at-bat finito. Per esempio:

Example A:
Inning| 1| 2| 3| 4| 5| 6| 7| 8| 9|
  Them| 0| 0| 0| 0| 0| 2|  |  |  |
    Us| 0| 0| 2| 0| 0| 0|  |  |  |

Example B:
Inning| 1| 2| 3| 4| 5| 6| 7| 8| 9|
  Them| 0| 0| 0| 0| 0| 2|  |  |  |
    Us| 0| 0| 2| 0| 0| 1|  |  |  |

Example C:
Inning| 1| 2| 3| 4| 5| 6| 7| 8| 9|
  Them| 0| 0| 0| 0| 0| 2|  |  |  |
    Us| 0| 0| 2| 0| 0|  |  |  |  |

#Them is the Away Team, Us is the Home Team (who are the guys you root for)
  • Esempio A: Sappiamo di essere in cima alla settima perché Us ha uno 0 registrato nella parte inferiore della sesta e la parte superiore della settima è vuota.
  • Esempio B: può essere la parte inferiore del sesto o la parte superiore del settimo.
  • Esempio C: può essere la parte superiore o inferiore della sesta.

Il tuo compito è di restituire quale / i inning potrebbe essere.

Ingresso

Due elenchi di numeri interi non negativi. Le liste saranno considerate frastagliate con l'elenco della squadra in trasferta della stessa dimensione o di un elemento più grande rispetto alla squadra di casa. Puoi prendere i punteggi in entrambi gli ordini ma dichiarare nella risposta se non si utilizza il valore predefinito. Vale a dire, Squadra ospite quindi Squadra di casa (impostazione predefinita) o Squadra ospite quindi Squadra ospite (invertita). Possono anche essere riempiti con dati fittizi, se lo si desidera, indicare la risposta in tal caso.

Produzione

Una stringa o qualcosa di equivalente che identifica il numero inning e se è in alto o in basso. Ad esempio 7B 8T, B7 T8, ['7B','8T']sono tutti bene. Se ci sono due risposte, è necessario generare entrambe. Il formato è piuttosto flessibile però.

Regole

  • L'input sarà sempre valido
  • I giochi possono andare in inning extra indefiniti. Il tuo programma dovrebbe essere in grado di supportare fino a 255 inning.
  • Sono vietate le scappatoie standard
  • Questo è code-golf, quindi vince il codice più corto

Casi test

#Input:
[[], 
 []] 
#Output: 1T

#Input:
[[0], 
 []] 
#Output: 1B

#Input:
[[0,0,0,1], 
 [0,0,0,0]] 
#Output: 5T

#Input:
[[0,0,0,1], 
 [0,0,0,1]] 
#Output: 4B, 5T

#Input:
[[0,0,0,1,0,0,1,0,0,1],
 [0,0,0,0,1,0,0,1,0,1]] 
#Output: 10B, 11T

#Input:
[[0,0,0,1], 
 [0,0,0]] 
#Output: 4T, 4B

#Input:
[[0,0,0,0], 
 [0,0,0]] 
#Output: 4B
code-golf 
— Veskah
fonte
Possiamo prendere le due liste in ordine inverso? cioè in basso poi in alto?
— Jo King,
@JoKing Certo, purché sia ​​notato e la risposta corrisponda ancora correttamente.
— Veskah,
Il valore di ritorno intero positivo / negativo è accettabile?
@Rogem Lo sta spingendo un po 'ma leggendo il tuo articolo, va bene. Ho detto che l'output è abbastanza flessibile.
— Veskah,

Risposte:

4

C (gcc) , 50 byte

Accetta l'input come puntatore a un elenco interfogliato (ad es {them#1, us#1, them#2,...}.).

Restituisce un'opzione tramite modifica e l'altra tramite il valore restituito.

I valori negativi indicano la parte inferiore dell'inning, i valori positivi indicano la parte superiore dell'inning. Gli zeri sono "vuoti". Il valore assoluto dell'output è il numero dell'inning. Quindi, -4,5indica che le possibilità sono la parte superiore della quinta e la parte inferiore della quarta e 1,0indica che l'unica possibilità è la parte superiore della prima.

Il valore di ritorno della macro può essere utilizzato per determinare se ci sono uno o due inning possibili; il valore restituito è 0se non ci sono altri inning. Altrimenti, è il numero dell'inning.

Zero byte di codice sorgente. Utilizzare quanto segue come flag di preprocessore:

-Df(o,n,l)=({o=n%2?~n/2:n/2+1;l[n-1]?-o-~n%2:0;})

Provalo online!

Degolf

-Df(o,n,l)=({
// Define a function-like macro f(o,n,l)
// o is the output variable, n is the size of the list, 
// l is a pointer to the first element of the list.
o=n%2?~n/2:n/2+1;
// If there's an odd number of elements, first possible inning is -(n+1)/2. 
// Else, it is (n/2)+1.
l[n-1]?-o-~n%2:0})
// If the score from the last inning is non-zero, the other possible inning
// needs to be determined; flip the sign of first output value then deduct 
// 1 from it if the number of elements is even.
Inoltre, è possibile aggiungere altri 4 byte a questo campo se posso assumere che l'elenco sia in ordine inverso (dall'ultimo al primo) o che il puntatore indichi l'ultimo elemento dell'array. Non è andato per quello, dato che sembrava troppo ingannevole.
Mi piacerebbe sapere da @veskah se prendere input come hai fatto è ok, perché sembra abbastanza diverso (e utile) dalle specifiche originali.
— BLT,
2
@BLT Per convenzione, l'interlacciamento è il modo in cui gli elenchi di elenchi vengono eseguiti in C; il dereferenziamento multiplo è molto faticoso per le risorse. Un'altra opzione sarebbe quella di avere una lista dopo l'altra, ma sarebbe quindi poco pratico aggiungere nuovi elementi.
3

Perl 6 , 52 48 45 byte

-3 byte grazie a qualche ristrutturazione da nwellnhof!

->\a,\b{(+a,a==b if (b,a)[a>b].tail;b+1,a>b)}

Provalo online!

Blocco di codice anonimo che accetta input come due elenchi, in alto e in basso. L'output è un elenco di tuple, in cui il primo elemento è il numero inning e il secondo elemento è True o False, corrispondente a Bottom o Top.

Spiegazione:

       {                                    }  # Anonymous code block
->\a,\b   # That takes input lists a and b
        (                                  )   # Return a list of
                                    b+1,a>b    # A list of 
                                               #  The length of the second list plus 1
                                               #  And top/bottom
         +a,a==b     # And the length of the first list
                     # And the other of top/bottom
                 if  # Only if:
                    (b,a)[a>b]      # The current of top/bottom's
                              .tail # Last element exists and is not 0
— Jo King
fonte
3

R , 103 96 byte

function(a,b,l=sum(a|1),k=sum(b|1))I(l,I(l-k,I(a[l],c(l,-l),-l),I(b[l],c(-l,l+1),l+1)),1)
I=`if`

Provalo online!

@digEmAll ha salvato 7 byte!

Prende due elenchi di vettori come input e genera uno o due numeri interi che rappresentano i possibili inning. Gli interi positivi sono la parte superiore dell'inning e gli interi negativi sono la parte inferiore dell'inning.

In R, i numeri interi positivi sono veritieri, quindi posso usare la differenza di lunghezze come primo argomento if().

— BLT
fonte
Probabilmente avresti più fortuna con [[un ifsostituto dal momento che usi [nel tuo codice.
— Giuseppe,
@Giuseppe l'ho provato con <e ^. Penso che sia [stato quello usato nell'esempio che ricordo.
— BLT
Puoi anche dare un altro nome a 'if'(e rimuovere {}e spostarti f=all'esterno): 96 byte
— digEmAll
2

Gelatina , 11 byte

ZẎṖṠṪ$СẈd2

Provalo online!

Primo elemento: indice della colonna basato su 0.
Secondo elemento: 0per la parte superiore, 1per la parte inferiore.

L'output è un elenco di una o due coppie come specificato sopra (preimpostato per mostrarlo meglio). Gli innings di output sono in ordine inverso.

— Erik l'Outgolfer
fonte
2

Python 2 , 135 129 126 125 123 119 byte

a,b=input()
c=len(a)
e,f=`c+1`+"T",`c`+"B"
print((f+e,e)[b[-1]<1],(`c`+"T"+f,f)[a[-1]<1])[len(b)<c]if b else"1"+"TB"[c]

Provalo online!

-1 grazie a @ovs

-4 grazie ancora a @ovs

— ElPedro
fonte
if d else"11BT"[c<1::2]per -3
— ovs
if dRiesco a vedere (non avrei dovuto perdere quello!) Ma else"11BT"[c<1::2]non ne esce più corto a meno che non mi manchi qualcosa.
— ElPedro,
Non preoccuparti @ovs perché ho trovato un altro modo ispirato dal tuo if dcomunque.
— ElPedro,
Invece di if dte puoi fare if b, quindi non è necessario archiviare len(b)in variabili.
— Ovs
@ovs Ho guardato questo, ma anche bisogno ddi [d<c]. Non riesco a vedere un modo per aggirare quello. Qualche idea?
— ElPedro,
1

Python 2 , 65 byte

a,b=input()
exec"a,b=[0]+b,a;print[len(b)][a[-1]<len(a+b)%2:];"*2

Provalo online!

Stampa due righe, prima la possibilità di inning in basso e poi quella in alto, come elenco singleton. Se uno dei due non è possibile, tale elenco è vuoto.

— XNOR
fonte
1

Pulito , 84 75 byte

import StdEnv
$ =length
?v|last[0:v]>0= $v=0
@a b| $b< $a=(?a,$a)=($a+1,?b)

Provalo online!

Definisce la funzione @ :: [Int] [Int] -> (Int, Int)e alcuni helper.
Fornisce un output nel formato in (Top, Bottom)cui uno zero indica una possibilità nulla.

— Οurous
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.