Contribution

Vous obtenez une carte 2D avec des balles et du sol. Cela ressemble à ceci:

  1         5          2
                 3
     4


__________________________

Chaque numéro est une balle et le _niveau du sol. Le _caractère de soulignement n'est autorisé sur aucune autre ligne que la ligne au niveau du sol. Seuls les espaces, les nouvelles lignes et les chiffres sont 0-9autorisés au-dessus du niveau du sol. Vous ne pouvez pas supposer que la dernière ligne est le niveau du sol - les lignes vides en dessous du niveau du sol sont autorisées. Vous pouvez également ajouter des espaces, pour remplir les lignes vides, si cela vous aide.

Les balles peuvent avoir des numéros de 0à 9, peuvent être placées les unes au-dessus des autres, mais pas sous le sol. Les numéros du ballon seront uniques.

Supposons que chaque personnage mesure un mètre .

Obtenez la carte de pastebin!
Cas de test 1 - devrait produire quelque chose comme ceci
Cas de test 2 - devrait produire les mêmes résultats que la première carte

Défi

Votre défi est de lire une carte comme celle-ci à partir d'un fichier ou de stdin- vous êtes autorisé à utiliser cat balls.txt | ./yourexecutable- et de produire la vitesse de chaque balle lorsqu'elle touche le sol.

Voici la formule de la vitesse:

Supposons que hc'est la différence de numéro de ligne entre le numéro de ligne du sol et le numéro de ligne de la balle, et qui gest égal 10m/s^2.

Production

Vous devez afficher le nombre et la vitesse de chaque balle m/sau niveau du sol. Par exemple N - Vm/s, où Nest le nombre de billes et Vsa vitesse. Vous pouvez également sortir un tableau si vous le souhaitez.

Bon codage! :)

MATL , 31 30 27 25 octets

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

L'entrée est un tableau de caractères 2D avec ;comme séparateur de ligne:

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

Essayez-le en ligne! Ou incluez une initiale tdans le code pour afficher la carte pour plus de clarté.

Voici les autres cas de test: premier , deuxième .

Explication

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 octets

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

Compilez et exécutez avec gcc -w golf.c -lm && cat balls.txt | ./a.out.

C - 194 (-5) 150 137 octets

Avec un peu plus de temps et de réflexion, j'ai joué au golf 44 octets
Merci à orlp de m'avoir aidé à économiser 13 octets

Je vais commencer avec mon code 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));}

Et version lisible par l'homme:

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

Compilez et exécutez comme ça: gcc -o balls ballsgolf.c -lm && cat 1.txt | ./balls

Production

1 10.000000
2 10.000000
3 8.944272
4 7.745967
5 10.000000

Pyth, 27 26 25 24 octets

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

Essayez-le en ligne!

Matlab, 100 96 89 90 octets

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

Beaucoup d'octets enregistrés grâce à Luis Mendo

Format d'entrée:

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

Explication:

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 octets

Version 6, 84 octets: (Merci à Leaky Nun!)

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

Version 5, 91 octets:

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

Version 4, 92 octets:

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

Version 3, 99 octets:

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

Version 2, 102 octets:

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

Les versions ci-dessus prennent un tableau de chaînes en entrée.

Version 1, 140 octets:

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

Cela prend le répertoire du fichier comme entrée de l'utilisateur.

Python 3, 84 octets

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

Une fonction anonyme qui accepte l'entrée par argument comme une chaîne multi-lignes avec toutes les lignes vides remplies d'espaces, et retourne un tableau où chaque élément est de la forme [numéro de balle, vitesse].

Comment ça fonctionne

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]

Essayez-le sur Ideone

JavaScript (ES6) 93

Éditer 2 octets enregistrés thx @Jacajack

Une fonction avec une chaîne multiligne comme paramètre d'entrée. La sortie n'est pas triée (car cela n'est pas demandé)

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

Tester

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>