Entrada:

Uma lista de números inteiros (que nunca conterão zero)

Resultado:

Uma lista do mesmo tamanho com contagens baseadas no seguinte:

• Se o item atual for negativo: verifique todos os itens anteriores a esse item e conte quantas vezes os dígitos ocorreram nesses outros números
• Se o item atual for positivo: verifique todos os itens após esse item e conte quantas vezes o dígito ocorreu nesses outros números

Há uma reviravolta: se o tamanho da lista for uniforme, contamos todos os números apenas uma vez (mesmo que corresponda a vários dígitos) e, se o tamanho for ímpar, contamos todos os dígitos dos números de cada dígito do item atual (duplicado dígitos são contados várias vezes).

Vamos dar alguns exemplos para esclarecer um pouco isso:

Exemplo com lista par:

Input:  [4, 10, 42, -10, -942, 8374, 728, -200]
Output: [3, 2,  4,  1,   2,    1,    1,   5   ]

O tamanho da lista é par ; portanto, contamos apenas cada número uma vez.

• 4: É positivo, então estamos ansiosos. Existem três números dígitos contendo o 4( 42, -942, 8374). Então começamos com a 3.
• 10: É positivo, então estamos ansiosos. Existem dois números que contêm o dígito 1e / ou 0( -10, -200). Então a segunda saída é 2.
• 42: Mais uma vez positivo, tão para a frente. Existem quatro números contendo quer o dígito 4e / ou 2( -942, 8374, 728, -200). Então a terceira saída é 4.
• -10: Desta vez é negativo, então olhamos para trás. Existe apenas um número que contém o dígito 1e / ou 0(ignoramos o sinal de menos) ( 10). Então a quarta saída é 1.
• etc.

Exemplo com lista ímpar:

Input:  [382, -82, -8, 381, 228, 28, 100, -28, -2]
Output: [13,  2,   2,  4,   8,   3,  0,   11,  6 ]

O tamanho da lista é ímpar , por isso contamos todos os dígitos.

• 382: É positivo, então estamos ansiosos. Há um 3nos outros números ( 381), seis 8nos outros números ( -82, -8, 381, 228, 28, -28) e seis 2nos outros números ( -82, 228, 28, -28, 2). Então começamos com a 13.
• -82: É negativo, então para trás. Há um 3no outro número ( 382) e um 8no outro número ( 382). Então a segunda saída é 2.
• ...
• 228: É positivo, tão para a frente. Existem três 2's nos outros números ( 28, -28, -2), e outras três 2' s, e duas 8's nos outros números ( 28, -28). Então essa saída é 8.
• etc.

Regras do desafio:

• Você pode assumir que a entrada nunca conterá 0como item, pois não é positiva nem negativa.
• Você pode assumir que a lista de entrada sempre conterá pelo menos dois itens.
• A E / S é flexível. A entrada / saída pode ser uma matriz / lista de números inteiros, sequência delimitada, matriz de dígitos / caracteres, etc.
• Se o primeiro número da lista for um número negativo ou o último número da lista for um número positivo, será 0 na lista resultante.
• Com listas ímpares, os números que contêm o mesmo dígito várias vezes são contados várias vezes, como 228no exemplo ímpar acima, resultando em 8(3 + 3 + 2) em vez de 5(3 + 2).

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

Casos de teste:

Input:  [4, 10, 42, -10, -942, 8374, 728, -200]
Output: [3, 2,  4,  1,   2,    1,    1,   5   ]

Input:  [382, -82, -8, 381, 228, 28, 100, -28, -2]
Output: [13,  2,   2,  4,   8,   3,  0,   11,  6 ]

Input:  [10, -11, 12, -13, 14, -15, 16, -17, 18, -19]
Output: [9,  1,   7,  3,   5,  5,   3,  7,   1,  9  ]

Input:  [10, -11, 12, -13, 14, -15, 16, -17, 18, -19, 20]
Output: [11, 2,   8,  4,   5,  6,   3,  8,   1,  10,  0 ]

Input:  [88, 492, -938, 2747, 828, 84710, -29, -90, -37791]
Output: [8,  9,   3,    9,    3,   4,     5,   4,   12    ]

Input:  [-1, 11, 11, 1]
Output: [0,  2,  1,  0]

Input:  [1, 11, 11, -1]
Output: [3, 2,  1,  3 ]

Input:  [-1, 11, 1]
Output: [0,  2,  0]

Input:  [1, 11, -1]
Output: [3, 2,  3 ]

05AB1E , 30 bytes

vy0›iNƒ¦}ëN£}€Sþyδ¢IgÈiĀ€Ù}OOˆ

Experimente online!

Python 2 , 149 148 121 116 111 107 bytes

lambda l:[sum([any,sum][len(l)%2](map(`n`.count,`abs(v)`))for n in l[:i:2*(v<0)-1])for i,v in enumerate(l)]

Experimente online!

Java (JDK 10) , 204 bytes

a->{int l=a.length,r[]=new int[l],i=0,j,x,y,b,s,t=10;for(;i<l;i++)for(j=i+(s=a[i]>0?1:-1);0<=j&j<l;j+=s)for(b=0,x=a[i];x!=0;x/=t)for(y=a[j];b<1&y!=0;y/=t)if(x%t==-y%t|x%t==y%t){r[i]++;b+=1-l%2;}return r;}

Experimente online!

Créditos

• -6 bytes graças a Kevin Cruijssen
• -1 byte graças a Java Gonzar

Perl 6 , 100 85 bytes

{.kv.map:{sum map (?*,+*)[$_%2],.[grep (*-$^i)*$^v>0,^$_].map:{.comb⊍$v.abs.comb}}}

Experimente online!

Usa o operador de multiplicação baggy ⊍.

Perl 5 -n , 92 bytes

($t=$&>0?$':$`)&say$q=y/ //%2?@a=$t=~/\b\d*[$&]+\d*\b/g:map$t=~/$_/g,$&=~/\d/g while/-?\d+/g

Experimente online!

JavaScript (Node.js) , 164.158.140 139 bytes

a=>a.map((x,i)=>a.slice(x<0?0:i+1,x<0?i:l).map(b=>c+=[...b+""].map(X=>s+=X>=0&&(x+"").split(X).length-1,s=0)&&l%2?s:+!!s,c=0)|c,l=a.length)

Experimente online!

Ruby , 126 bytes

->l{k=l.map{|i|i.abs.digits};c=-1;k.map{|n|x=k[l[c+=1]<0?0...c:c+1..-1];x.sum{|j|x=n.sum{|d|j.count d};l.size%2<1?x<1?0:1:x}}}

Experimente online!

Geléia , 43 42 bytes

>0ị"ḊÐƤżṖƤƊAṾ€€FċЀ¥e€€³LḂ©¤?"AṾ$€SṀ€S$®?€

Experimente online!