Entrada

Você recebe um mapa 2D com bolas e chão nele. Se parece com isso:

  1         5          2
                 3
     4


__________________________

Cada número é uma bola e o _nível do solo. O _caractere sublinhado não é permitido em nenhuma outra linha que não seja a linha do nível do solo. Só são 0-9permitidos espaços, novas linhas e dígitos acima do nível do solo. Você não pode assumir que a última linha é o nível do solo - linhas vazias abaixo do nível do solo são permitidas. Você também pode adicionar espaços, para preencher linhas vazias, se isso ajudar.

As bolas podem ter números de 0até 9, podem ser colocadas uma acima da outra, mas não embaixo da terra. Os números da bola serão únicos.

Suponha que cada personagem tenha um metro .

Obter mapa da pastebin!
O caso de teste 1 - deve produzir algo como este
Caso de teste 2 - deve produzir os mesmos resultados que o primeiro mapa

Desafio

Seu desafio é ler um mapa como esse de um arquivo ou de stdin- você tem permissão para usar cat balls.txt | ./yourexecutable- e a velocidade de saída de cada bola quando ela atingir o chão.

Aqui está a fórmula para a velocidade:

Suponha que hseja a diferença do número da linha entre o número da linha do solo e o número da linha da bola e que gseja igual 10m/s^2.

Resultado

Você deve imprimir cada número e velocidade de bolas m/sno nível do solo. Por exemplo N - Vm/s, onde Né o número da bola e Vsua velocidade. Você também pode gerar uma matriz, se desejar.

Feliz codificação! :)

MATL , 31 30 27 25 bytes

95\16\5B#fG&X>1)b- 20*X^h

Input é uma matriz de caracteres 2D com ;como separador de linhas:

['  1         5          2  ';'                 3        ';'     4                    ';'                          ';'                          ';'__________________________']

Experimente online! Ou inclua uma inicial tno código para exibir o mapa para maior clareza.

Aqui estão os outros casos de teste: primeiro , segundo .

Explicação

95\      % Take input implicitly. Modulo 95: convert to numbers and map '_' into 0
16\      % Modulo 16: map space into 0 and digit chars into corresponding numbers
5B#f     % Find row indices and values of nonzero entries
G        % Push input again
&X>      % Index of maximum of each column. This finds character '_'
1)       % Get first value (they are all equal)
b        % Bubble row indices of numbers up in the stack
-        % Subtract to get distance from each number to the ground
20*X^    % Multiply by 20, take sqrt. This gives the velocity values
h        % Horizontally concat numbers and velocities. Display implicitly

C, 125 122 121 bytes

b[99]={};main(l,c){for(;(c=getchar())<95u;)b[c]=(l+=c==10);for(c=47;++c<58;)b[c]&&printf("%c,%f\n",c,sqrt((l-b[c])*20));}

Compile e execute com gcc -w golf.c -lm && cat balls.txt | ./a.out.

C - 194 (-5) 150 137 bytes

Com um pouco mais de tempo e pensamento, consegui 44 bytes.
Graças ao orlp por me ajudar a economizar 13 bytes

Vou começar com o meu código C:

b[256]={},n,i=47;main(l,c){for(;~(c=getchar());n=c==95?l:n)b[c]=(l+=c==10);for(;++i<58;)b[i]&&printf("%d %f\n",i-48,sqrt((n-b[i])*20));}

E versão legível por humanos:

//Throws many warnings, but lack of libraries is tolerated

/*
    c - current character
    l - line number (starts at 1)
    n - ground level
    i - iterator
    b - balls array
*/

b[256] = {}, n, i = 47; //That actually works, as long as you are using ASCII

main( l, c )
{
    for ( ;~( c = getchar( ) ); n = c == 95 ? l : n ) //Read stdin and search for ground
        b[c] = ( l += c == 10 ); //Increment lines counter on newlines, and save line numbers

    for ( ; ++i < 58; ) //Iterate through balls
        b[i] && printf( "%d %f\n", i - 48, sqrt( ( n - b[i] ) * 20 ) ); //Print out data    
}

Compile e execute assim: gcc -o balls ballsgolf.c -lm && cat 1.txt | ./balls

Resultado

1 10.000000
2 10.000000
3 8.944272
4 7.745967
5 10.000000

Pyth, 27 26 25 24 bytes

smf-hT "_". e, b @ * 20-xd \ _k2dC 
smf @ hT`M; .e, b @ * 20-xd \ _k2dC
 smf @ T`M; .e, b @ * 20-xd \ _k2dC
sm @ # `M; .e, b @ * 20-xd \ _k2dC

Experimente online!

Matlab, 100 96 89 90 bytes

s=input('');X=find(s==95);for i=0:9
[x y]=find(s==48+i);if(x)[i sqrt(20*(X(1)-x))]
end
end

Muitos bytes salvos graças a Luis Mendo

Formato de entrada:

['  1         9          2  ';'                 3        ';'     4                    ';'                          ';'                          ';'__________________________']

Explicação:

X=find(s==95)         -- finds '_', we'll need X(1) to determine max height
for i=0:9             -- loops through balls' numbers
[x y]=find(s==48+i)   -- finds the ball
if(x)                 -- if it is present
[i sqrt(20*(X(1)-x))] -- output its number and velocity

Python 3, 84 bytes

Versão 6, 84 bytes: (Obrigado à Leaky Nun!)

lambda a:[(c,(~-(len(a)-i)*20)**.5)for i,s in enumerate(a)for c in s if c.isdigit()]

Versão 5, 91 bytes:

lambda a:[c+":"+str((~-(len(a)-i)*20)**.5)for i,s in enumerate(a)for c in s if c.isdigit()]

Versão 4, 92 bytes:

lambda i:[c+":"+str((~-(len(i)-n)*20)**.5)for n in range(len(i))for c in i[n]if c.isdigit()]

Versão 3, 99 bytes:

def r(i):x=len(i);print([c+":"+str((~-(x-n)*20)**.5)for n in range(x)for c in i[n] if c.isdigit()])

Versão 2, 102 bytes:

def r(i):
 n=len(i)
 for l in i:
  for c in l:
   if c.isdigit():print(c+":"+str((~-n*20)**.5))
  n-=1

As versões acima usam uma matriz de seqüências de caracteres como entrada.

Versão 1, 140 bytes:

with open(input(),"r")as i:
 n=sum(1for l in i);i.seek(0)
 for l in i:
  for c in l:
   if c.isdigit():print(c+":"+str((~-n*20)**.5))
  n-=1

Isso leva o diretório do arquivo como entrada do usuário.

Python 3, 84 bytes

lambda x:[[i,(20*x[x.find(i):x.find('_')].count('\n'))**.5]for i in x if i.isdigit()]

Uma função anônima que aceita entrada por argumento como uma sequência de linhas múltiplas com todas as linhas vazias preenchidas com espaços e retorna uma matriz em que cada elemento está no formato [número da bola, velocidade].

Como funciona

lambda x                      Function with input x
...for i in x if i.isdigit()  Loop through all characters i in x for which i is a digit,
                              and hence one of the balls
x[x.find(i):x.find('_')]      Slice x to give the substring between the ball and the ground
....count('\n')               Count the number of newlines in the substring to give the
                              height of the ball
(20*...)**.5                  Calculate the speed of the ball as it hits the ground
[i,...]                       Package the ball number and speed into a list
:[...]                        Return all ball-speed pairs as a list with elements [ball
                              number, speed]

Experimente no Ideone

JavaScript (ES6) 93

Editar 2 bytes salvos thx @Jacajack

Uma função com uma sequência multilinha como parâmetro de entrada. A saída não é classificada (pois isso não é solicitado)

a=>[...a].reverse().map(c=>c>'Z'?b=i:c<' '?++i:c>' '&&console.log(c,Math.sqrt((i-b)*20)),i=0)

Teste

F=
a=>[...a].reverse().map(c=>c>'Z'?b=i:c<' '?++i:c>' '&&console.log(c,Math.sqrt((i-b)*20)),i=0)

function test()
{
  F(I.value);
}

test()

#I { height: 12em; width: 30em}

<textarea id=I>
    
 
  1         5          2
                 3
     4


__________________________




</textarea>
<button onclick="test()"></button>