Ingresso

Ti viene data una mappa 2D con palle e terra al suo interno. Sembra così:

  1         5          2
                 3
     4


__________________________

Ogni numero è una palla, ed _è il livello del suolo. Il _carattere di sottolineatura non è consentito in nessuna riga diversa da quella del livello del suolo. Sono 0-9consentiti solo spazi, newline e cifre sopra il livello del suolo. Non si può presumere che l'ultima riga sia il livello del suolo: sono consentite righe vuote al di sotto del livello del suolo. Puoi anche aggiungere spazi, per riempire le righe vuote, se ciò ti aiuta.

Le palle possono avere numeri da 0a 9, possono essere posizionate una sopra l'altra, ma non sotto terra. I numeri della palla saranno unici.

Supponi che ogni personaggio sia di un metro .

Ottieni la mappa da pastebin!
Il test case 1 - dovrebbe produrre qualcosa come questo
Test case 2 - dovrebbe produrre gli stessi risultati della prima mappa

Sfida

La tua sfida è leggere una mappa come quella da un file o da stdin- ti è permesso usare cat balls.txt | ./yourexecutable- e la velocità di uscita di ogni palla quando colpisce il terreno.

Ecco la formula per la velocità:

Supponiamo che hsia la differenza del numero di linea tra il numero di linea del terreno e il numero di linea della palla e che sia guguale 10m/s^2.

Produzione

Dovresti produrre il numero e la velocità di ogni pallina m/sa livello del suolo. Ad esempio N - Vm/s, dove Nè il numero di palla ed Vè la sua velocità. Se lo desideri, puoi anche generare un array.

Buona programmazione! :)

MATL , 31 30 27 25 byte

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

L'input è un array di caratteri 2D con ;come separatore di riga:

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

Provalo online! Oppure includi un'iniziale tnel codice per visualizzare la mappa per maggiore chiarezza.

Ecco gli altri casi di test: primo , secondo .

Spiegazione

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 121 byte

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

Compila ed esegui con gcc -w golf.c -lm && cat balls.txt | ./a.out.

C - 194 (-5) 150 137 byte

Con un po 'più di tempo e di pensiero, ho scartato 44 byte
Grazie a orlp per avermi aiutato a salvare 13 byte

Inizierò con il mio codice 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 versione leggibile dall'uomo:

//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    
}

Compilare ed eseguire in questo modo: gcc -o balls ballsgolf.c -lm && cat 1.txt | ./balls

Produzione

1 10.000000
2 10.000000
3 8.944272
4 7.745967
5 10.000000

Pyth, 27 26 25 24 byte

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

Provalo online!

Matlab, 100 96 89 90 byte

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

Molti byte salvati grazie a Luis Mendo

Formato di input:

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

Spiegazione:

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 byte

Versione 6, 84 byte: (Grazie a Leaky Nun!)

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

Versione 5, 91 byte:

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

Versione 4, 92 byte:

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

Versione 3, 99 byte:

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()])

Versione 2, 102 byte:

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

Le versioni precedenti prendono una matrice di stringhe come input.

Versione 1, 140 byte:

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

Questo prende la directory del file come input dall'utente.

Python 3, 84 byte

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

Una funzione anonima che accetta l'input per argomento come una stringa a più righe con tutte le righe vuote piene di spazi e restituisce un array in cui ogni elemento ha la forma [numero palla, velocità].

Come funziona

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]

Provalo su Ideone

JavaScript (ES6) 93

Modifica 2 byte salvati grazie a @Jacajack

Una funzione con una stringa multilinea come parametro di input. L'output non è ordinato (poiché non è richiesto)

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

Test

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>