Objetivo

Tendo em vista que a World Series está chegando, preciso de um programa que possa ler as pontuações da caixa e me dizer qual é a entrada. Isso é um pouco complicado, porque o beisebol usa um método ímpar para registrar a pontuação. Eles não anotam a pontuação da equipe do at-bat até a entrada até marcarem uma corrida (e ainda estão indo) ou terminarem o seu at-bat. Assim, um 0 no placar significa sempre um taco terminado. Por exemplo:

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)

• Exemplo A: Sabemos que estamos no topo do 7º porque Us tem um 0 gravado na parte inferior do 6º e o topo do 7º está em branco.
• Exemplo B: Pode ser a parte inferior do 6º ou o topo do 7º.
• Exemplo C: pode ser o topo ou o fundo do sexto.

Sua tarefa é retornar quais entradas poderiam ser.

Entrada

Duas listas de números inteiros não negativos. As listas serão consideradas irregulares, com a lista do time Ausente sendo do mesmo tamanho ou um elemento maior em comparação com o da equipe da Casa. Você pode obter as pontuações em qualquer ordem, mas indicar em sua resposta se você não usar o padrão. Ou seja, Equipe visitante, depois time local (o padrão), ou Equipe local e time visitante (invertido). Eles também podem ser preenchidos com dados fictícios, se você quiser, indique na sua resposta se você o fizer.

Resultado

Uma string ou algo equivalente que identifica o número de entrada e se é o topo ou o fundo. Por exemplo 7B 8T, B7 T8, ['7B','8T']são todos muito bem. Se houver duas respostas, você deverá produzir as duas. O formato é bastante flexível.

Regras

• A entrada sempre será válida
• Os jogos podem ter entradas extras indefinidas. Seu programa deve ser capaz de suportar até 255 entradas.
• As brechas padrão são proibidas
• Isso é código-golfe, então o código mais curto ganha

Casos de teste

#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

Leva a entrada como um ponteiro para uma lista intercalada (ou seja, {them#1, us#1, them#2,...} ).

Retorna uma opção via modificação e a outra via valor de retorno.

Valores negativos indicam parte inferior do turno, valores positivos indicam parte superior do turno. Os zeros estão "vazios". O valor absoluto da saída é o número do turno. Assim, -4,5indica as possibilidades sendo a parte superior da quinta e a parte inferior da quarta, e1,0 indica a única possibilidade sendo a parte superior da primeira.

O valor de retorno da macro pode ser usado para determinar se há uma ou duas entradas possíveis; o valor de retorno é 0se não houver outro turno. Caso contrário, é o número do turno.

Zero bytes de código fonte. Use o seguinte como um sinalizador de pré-processador:

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

Experimente 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.

Perl 6 , 52 48 45 bytes

-3 bytes graças a alguma reestruturação do nwellnhof!

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

Experimente online!

Bloco de código anônimo que recebe a entrada como duas listas, superior e inferior. Saída é uma lista de tuplas, em que o primeiro elemento é o número de entrada e o segundo elemento é Verdadeiro ou Falso, correspondendo a Inferior ou Superior.

Explicação:

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

Experimente online!

@digEmAll economizou 7 bytes!

Pega dois vetores de listas como entrada e gera um ou dois números inteiros representando as possíveis entradas. Inteiros positivos são a parte superior do turno e inteiros negativos são a parte inferior do turno.

Em R, números inteiros positivos são verdadeiros, então eu posso usar a diferença de comprimentos como o primeiro argumento para 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]:'')

Experimente online!

Geléia , 11 bytes

ZẎṖṠṪ$СẈd2

Experimente online!

Primeiro elemento: índice da coluna baseado em 0.
Segundo elemento: 0para cima, 1para baixo.

Saída é uma lista de um ou dois pares, conforme especificado acima (pretendido para mostrá-lo melhor). As entradas de saída estão na ordem inversa.

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]

Experimente online!

-1 com agradecimentos a @ovs

-4 obrigado novamente 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

Experimente online!

Imprime duas linhas, primeiro a possibilidade de entrada inferior e depois a de cima, como uma lista única. Se um deles não for possível, essa lista estará vazia.

Limpo , 84 75 bytes

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

Experimente online!

Define a função @ :: [Int] [Int] -> (Int, Int)e alguns auxiliares.
Dá saída na forma em (Top, Bottom)que um zero significa uma possibilidade nula.