Entrada

Te dan un mapa 2D con bolas y tierra en él. Se parece a esto:

  1         5          2
                 3
     4


__________________________

Cada número es una bola y el _nivel del suelo. El _carácter de subrayado no está permitido en ninguna otra línea que no sea la línea a nivel del suelo. Solo se permiten espacios, líneas nuevas y dígitos 0-9sobre el nivel del suelo. No puede asumir que la última línea es el nivel del suelo: se permiten líneas vacías debajo del nivel del suelo. También puede agregar espacios, para llenar líneas vacías, si eso le ayuda.

Las bolas pueden tener números del 0al 9, pueden colocarse una encima de la otra, pero no debajo del suelo. Los números de la pelota serán únicos.

Suponga que cada personaje es un metro .

Obtener mapa de pastebin!
Caso de prueba 1 - debería mostrar algo como esto
Caso de prueba 2 - debería producir los mismos resultados que el primer mapa

Desafío

Su desafío es leer un mapa como ese de un archivo o de stdin - se le permite usar cat balls.txt | ./yourexecutable- y la velocidad de salida de cada bola cuando toca el suelo.

Aquí está la fórmula para la velocidad:

Suponga que esa hes la diferencia del número de línea entre el número de línea del suelo y el número de línea de la pelota, y eso ges igual10m/s^2 .

Salida

Debes sacar el número y la velocidad de cada bola m/sal nivel del suelo. Por ejemplo N - Vm/s, donde Nes el número de bola y Ves su velocidad. También puede generar una matriz si lo desea.

¡Feliz codificación! :)

MATL , 31 30 27 25 bytes

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

La entrada es una matriz de caracteres 2D con un ;separador de filas:

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

Pruébalo en línea! O incluya una inicial ten el código para mostrar el mapa para mayor claridad.

Aquí están los otros casos de prueba: primero , segundo .

Explicación

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));}

Compilar y ejecutar con gcc -w golf.c -lm && cat balls.txt | ./a.out.

C - 194 (-5) 150 137 bytes

Con un poco más de tiempo y pensando, jugué 44 bytes.
Gracias a orlp por ayudarme a ahorrar 13 bytes.

Comenzaré con mi 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));}

Y versión legible 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    
}

Compila y ejecuta así: gcc -o balls ballsgolf.c -lm && cat 1.txt | ./balls

Salida

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

Pruébalo en línea!

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

Muchos bytes guardados gracias a Luis Mendo

Formato de entrada:

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

Explicación:

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

Versión 6, 84 bytes: (¡Gracias a Leaky Nun!)

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

Versión 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()]

Versión 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()]

Versión 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()])

Versión 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

Las versiones anteriores toman una serie de cadenas como entrada.

Versión 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

Esto toma el directorio del archivo como entrada del usuario.

Python 3, 84 bytes

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

Una función anónima que acepta la entrada por argumento como una cadena de varias líneas con todas las líneas vacías llenas de espacios, y devuelve una matriz donde cada elemento tiene la forma [número de bola, velocidad].

Cómo 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]

Pruébalo en Ideone

JavaScript (ES6) 93

Editar 2 bytes guardados gracias a @Jacajack

Una función con una cadena multilínea como parámetro de entrada. La salida no está ordenada (ya que esto no se solicita)

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

Prueba

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>