Objetivo

En vista de que la Serie Mundial está a la vuelta de la esquina, necesito un programa que pueda leer los puntajes del cuadro y decirme qué entrada es. Esto es un poco complicado porque el béisbol usa un método extraño para registrar el puntaje. No escriben el puntaje del equipo al turno para la entrada hasta que hayan anotado una carrera (y todavía estén en marcha) o hayan terminado su turno al bate. Por lo tanto, un 0 en el marcador siempre significa un final al bate. Por ejemplo:

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)

• Ejemplo A: Sabemos que estamos en la parte superior de la 7ª porque Us tiene un 0 registrado en la parte inferior de la 6ª y la parte superior de la 7ª está en blanco.
• Ejemplo B: Puede ser la parte inferior de la sexta o la parte superior de la séptima.
• Ejemplo C: Puede ser la parte superior o inferior de la 6ta.

Su tarea es devolver qué entrada (s) podría ser.

Entrada

Dos listas de enteros no negativos. Se supondrá que las listas son irregulares, ya que la lista del equipo visitante es del mismo tamaño o un elemento más grande en comparación con el equipo local. Puede tomar los puntajes en cualquier orden pero indicar su respuesta si no usa el valor predeterminado. Es decir, Equipo Visitante y luego Equipo Local (predeterminado), o Equipo Local y luego Equipo Visitante (invertido). También se pueden rellenar con datos ficticios si lo desea, indique su respuesta si lo hace.

Salida

Una cadena o algo equivalente que identifica el número de entrada y si es la parte superior o inferior. Por ejemplo 7B 8T, B7 T8, ['7B','8T']son todos muy bien. Si hay dos respuestas, debe generar ambas. Sin embargo, el formato es bastante flexible.

Reglas

• La entrada siempre será válida
• Los juegos pueden entrar en entradas extras indefinidas. Su programa debería ser capaz de soportar hasta 255 entradas.
• Las lagunas estándar están prohibidas
• Este es el código de golf, por lo que el código más corto gana

Casos de prueba

#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

C (gcc) , 50 bytes

Toma la entrada como un puntero a una lista intercalada (es decir {them#1, us#1, them#2,...}).

Devuelve una opción por modificación y la otra por valor de retorno.

Los valores negativos indican la parte inferior de la entrada, los valores positivos indican la parte superior de la entrada. Los ceros están "vacíos". El valor absoluto de la salida es el número de la entrada. Entonces, -4,5indica que las posibilidades son la parte superior de la quinta y la parte inferior de la cuarta, e 1,0indica que la única posibilidad es la parte superior de la primera.

El valor de retorno de la macro se puede usar para determinar si hay una o dos entradas posibles; El valor de retorno es 0si no hay otra entrada. De lo contrario, es el número de la entrada.

Cero bytes de código fuente. Use lo siguiente como indicador de preprocesador:

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

Pruébalo en línea!

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.

Perl 6 , 52 48 45 bytes

-3 bytes gracias a alguna reestructuración de nwellnhof!

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

Pruébalo en línea!

Bloque de código anónimo que toma la entrada como dos listas, arriba y abajo. La salida es una lista de tuplas, donde el primer elemento es el número de entrada y el segundo elemento es Verdadero o Falso, correspondiente a Inferior o Superior.

Explicación:

       {                                    }  # 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

R , 103 96 bytes

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`

Pruébalo en línea!

¡@digEmAll ahorró 7 bytes!

Toma dos vectores de listas como entrada y genera uno o dos enteros que representan las posibles entradas. Los enteros positivos son la parte superior de la entrada, y los enteros negativos son la parte inferior de la entrada.

En R, los enteros positivos son verdaderos, por lo que puedo usar la diferencia de longitudes como primer argumento if().

JavaScript (Node.js) , 75 bytes

f=(a,c=1,p=0,z=0)=>1/(t=a[p][c-1])?f(a,c+p,1-p,t):[c,p]+(z?[,c+p-1,1-p]:'')

Pruébalo en línea!

Jalea , 11 bytes

ZẎṖṠṪ$СẈd2

Pruébalo en línea!

Primer elemento: índice de columna basado en 0.
Segundo elemento: 0para arriba, 1para abajo.

La salida es una lista de uno o dos pares como se especifica anteriormente (prettified para mostrarlo mejor). Las entradas de salida están en orden inverso.

Python 2 , 135 129 126 125 123 119 bytes

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]

Pruébalo en línea!

-1 con agradecimiento a @ovs

-4 gracias de nuevo a @ovs

Python 2 , 65 bytes

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

Pruébalo en línea!

Imprime dos líneas, primero la posibilidad de entrada inferior y luego la superior, como una lista única. Si ninguno de los dos es posible, esa lista está vacía.

Limpio , 84 75 bytes

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

Pruébalo en línea!

Define la función @ :: [Int] [Int] -> (Int, Int)y algunos ayudantes.
Da salida en la forma (Top, Bottom)donde un cero significa una posibilidad nula.