Notwen veut étudier la cinématique des corps lancés de grandes hauteurs dans un champ gravitationnel uniforme mais malheureusement il n'a pas la possibilité technique d'aller à des endroits suffisamment hauts et d'observer les objets en tombant. Mais qui ne veut pas voir les progrès de la science alors ... Aidons Notwen à construire un simulateur de gravité!

Contexte physique

Un objet tombé d'une hauteur $h$ ( sans vitesse initiale ) dans un champ gravitationnel uniforme, négligeant les effets atmosphériques tels que la traînée ou le vent gagne en vitesse et accélère vers le sol avec le temps. Cette "vitesse de changement" de vitesse dans une unité de temps est appelée accélération gravitationnelle . Près de la surface de la Terre, il est approximativement égal à $g\approx9.8\frac{m}{s^2}$ , mais pour les besoins de ce défi, nous utiliserons la valeur $10\frac{m}{s^2}$ , ce qui signifie qu'en une seconde, un objet augmente sa vitesse d'environ $10 \frac{m}{s}$ . Envisagez d'avoir une hauteur $h$ , qui est un multiple de $100m$ et imaginez diviser cette hauteur en intervalles égaux, chacun de $100$ mètres de long. Notwen veut mesurer le temps qu'il faut à l'objet pour passer à travers chacun de ces intervalles, c'est donc ce que nous visons également à calculer. Lacinématiquemoderne- sauter les détails techniques - nous dit que:

Δ h_{k} = v_{k} t_{k} + \frac{1}{2} g t_{k}^{2}

$\Delta h_k=v_kt_k+\dfrac{1}{2}gt_k^2$ où

Δ h_{k} \equiv Δ h = 100 m

$\Delta h_k\equiv\Delta h=100m$ pour toutes les valeurs de

k

$k$ dans notre cas,

v_{k}

$v_k$ est la vitesse initiale au début de notre

k^{th}

$k^\text{th}$ intervalle et

t_{k}

$t_k$ est la durée du

k^{th}

$k^\text{th}$ intervalle de temps (pour référence, l'indexation commence à

0

$0$ avec

v_{0} = 0

$v_0=0$ ). On sait également que

v_{k}

$v_k$ a l'expression suivante:

v_{k} = \sqrt{2 g (Δ h_{0} + Δ h_{1} + \dots + Δ h_{k - 1})} = \sqrt{2 g k Δ h}

$v_k=\sqrt{2g(\Delta h_0+\Delta h_1+\cdots+\Delta h_{k-1})}=\sqrt{2gk\Delta h}$ Numériquement, on obtient

v_{k} = \sqrt{2000 k} \frac{m}{s}

$v_k=\sqrt{2000k}\frac{m}{s}$ et brancher dans la première équation et résoudre pour

t_{k}

$t_k$ donne

\begin{matrix} (*) & t_{k} = 2 \sqrt{5} (\sqrt{k + 1} - \sqrt{k}) s \end{matrix}

$\color{red}{\boxed{t_k=2\sqrt{5}\left(\sqrt{k+1}-\sqrt{k}\right)s}}\tag{*}$ Donc l'objet parcourt le premier intervalle (

k = 0

$k=0$ ) en

4.4721 s

$4.4721s$ , le deuxième intervalle (

k = 1

$k=1$ ) en

1.8524 s

$1.8524s$ et ainsi de suite (colleravec plus de valeurs).

Le défi

Entrée: La hauteur $h$ partir de laquelle l'objet est projeté comme: un multiple entier positif de $100$ , $h$ ou le nombre d'intervalles $N=\frac{h}{100}$ (donc $700$ ou $7$ signifierait que $h=700m$ ) - lequel dépend de vous.

Sortie: Une animation artistique ASCII d'un objet qui tombe, tombé d'une hauteur $h$ (détails ci-dessous).

La structure d'une trame de sortie doit être la suivante:

$N$ sauts de ligne précédant le "sol", représentés par au moins un caractère non blanc (par exemple@). Au moins un des caractères du sol doit se trouver sur la verticale sur laquelle tombe l'objet.
Un autre caractère non blanc représentant l'objet (par exemple X), autre que celui que vous avez choisi pour le sol.

Facultativement , un caractère au début de chaque ligne représentant l'axe vertical ou le mur fait sur

N

$N$ lignes. Toute quantité d'espaces de début et de fin est correcte tant qu'ils sont cohérents entre les cadres, ainsi que toute quantité d'espaces entre le mur et l'objet. Exemples de trames valides: ¹ (pour

h = 700 m

$h=700m$ ou

N = 7

$N=7$ ):

| X                                       >
|                             @           >   A
|                                         >
|        or            or           or    > 
|               O                         >
|                                         >
|                                         >
@@@             ^           -----            &&&

L'objet doit commencer sur la première ligne de la première image, puis après $t_0\approx 4.47s$ la sortie doit être vidée et votre programme doit afficher l'objet sur la même verticale mais sur la ligne suivante dans la deuxième image; puis après $t_1\approx 1.85s$ la sortie doit être à nouveau vidée et votre programme doit afficher l'objet sur la même verticale mais sur la ligne suivante dans le troisième cadre et ainsi de suite jusqu'à ce que l'objet atteigne la ligne juste au-dessus du sol. Exemple:

Règles

La sortie doit être du texte écrit sur une console interactive (jetable), un GIF, un fichier séparé pour chaque image ou une autre technique de sortie raisonnable.
Chaque image doit remplacer complètement la dernière image et être au même emplacement.
Vous pouvez supposer que le temps nécessaire au compilateur / interprète pour produire le texte est négligeable et que la précision minimale autorisée pour le calcul des racines carrées est de 2 décimales.
Vous pouvez prendre des entrées et fournir des sorties par n'importe quelle méthode standard , tout en prenant note que ces failles sont interdites par défaut. Il s'agit de code-golf , alors essayez de terminer la tâche dans le moins d'octets possible dans la langue de votre choix.

^{1: Je suis indulgent sur ce qui constitue un cadre valide parce que je veux autoriser ce qui convient le mieux à votre solution et je n'essaie pas d'ajouter des choses superflues au défi. Si quelque chose n'est pas clair, demandez dans les commentaires.}

— M. Xcoder
source

3

JavaScript (ES7) + CSS + HTML, 340 octets

f=n=>{o.style.height=n+'em';x.style.animationDuration=(n*20)**.5+'s';o.appendChild(x,x.remove())}

pre{position:relative;border:1px solid;height:5em;overflow:hidden}span{position:absolute;top:0;animation:x 10s cubic-bezier(0.33,0,0.67,0.33)both}@keyframes x{to{top:100%}}

<input type=number value=5 oninput=f(this.value)><pre id=o><span id=x>X

Développer l'extrait

$\sqrt { 20 N }$

— Neil
source

2

Fusain , 28 octets

Ｎθ↓θ⁴Ｆθ«Ｊ²ιＰXＲ⌊×φ×₂²⁰⁻₂⊕ι₂ι

Essayez-le en ligne! Le lien est vers la version détaillée du code. Remarque: espace de fin. Vous pouvez observer le retard sur TIO mais vous ne pouvez pas regarder l'animation, vous devrez donc l'imaginer à partir de la sortie. Prend Nen entrée. Explication:

Ｎθ

Entrée N.

↓θ⁴

Imprimez le mur et le sol afin que la forme de la sortie soit cohérente.

Ｆθ«

Boucle sur chaque intervalle.

Ｊ²ιＰX

Placez un Xà la hauteur appropriée.

Ｒ⌊×φ×₂²⁰⁻₂⊕ι₂ι

Générez le contenu du canevas actuel et attendez la durée appropriée (tronquée à la milliseconde près).

Remplacez le Xpar un espace.

— Neil
source

2

Perl 6 , 81 octets

{say "\e[s{"\n"x$_}-";map {say "\e[u{" \n"x 4.9e-6*$_²}o";sleep .01},^452*.sqrt}

"Essayez-le en ligne!", Mais TIO ne peut pas gérer l'animation.

Explication

J'ai choisi une approche un peu différente (et je pense que c'est pour le mieux, mais je n'en suis pas sûr). Au lieu de dormir pendant des durées données par la formule du PO, je dessine juste la situation appropriée "toutes les 10 ms" (± erreurs induites parsleep ).

$k$ $t=k/100$ $h = 100n$ $n$ $t$ $h = gt^2/2$

n = \frac{1}{100} \frac{1}{2} g t^{2} = \frac{1}{2} g \times {dix}^{- 6} k^{2} \approx 4,905 \times {dix}^{- 6} k^{2} .

$n = \frac{1}{100} \tfrac 1 2 g t^2 = \tfrac 1 2 g \times 10^{-6} k^2 \approx 4.905\times 10^{-6} k^2.$

k = \frac{\sqrt{n}}{\sqrt{4,905 \times {dix}^{- 6}}} \approx 452 \times \sqrt{n} .

$k = \frac{\sqrt n}{\sqrt{4.905\times 10^{-6}}} \approx 452 \times \sqrt n.$

$n$ say "\e[s{"\n"x$_}-" $n$ nouvelles lignes, et après cela, il imprime un tiret (le sol) et une nouvelle ligne. (Cela utilise la fonctionnalité intéressante des guillemets doubles dans Perl 6: vous pouvez incorporer le résultat de tout code directement dans la chaîne en écrivant ce code entre accolades.)

$452\sqrt n$ ^452*.sqrt $4.9\times 10^{-6} k^2$ o

En raison de la troncature automatique, il ne fait que la bonne chose ™ et déplace le "o" seulement après chaque 100 m de chute.

— Ramillies
source

1

Haskell, 145 octets

import Control.Concurrent
a!b=[a..b]>>"\n"
f h=mapM(\k->putStr("\27[2J"++1!k++'O':k!h++"-")>>threadDelay(round$4472135*(sqrt(k+1)-sqrt k)))[1..h]

Doit être exécuté dans un terminal ANSI. L'entrée est le nombre d'intervalles.

threadDelayLe paramètre de est en nanosecondes, donc un littéral 4472135est plus court que 2*sqrt 5*10^6. Malheureusement 46**4 = 4477456n'est pas dans la limite de la précision requise.

— nimi
source

1

Python 2 , 117 120 123 octets

-3 octets Merci à "Ne soyez pas un x-triple point" et "Jonathan Frech"

import time
h=input()
for k in range(h):print'\33[2J'+'\n'*k+'O'+'\n'*(h-k)+'^';time.sleep(2*5**.5*((k+1)**.5-k**.5))

Essayez-le en ligne!

— mdahmoune
source

1

+1 de moi, bonne solution! L'utilisation du caractère non imprimable ne permettrait-elle pas d'économiser quelques octets plutôt que chr(27)?

— M. Xcoder

@ Don'tbeax-tripledot Et si l'on n'obtient pas le personnage lui-même, '\33'devrait encore être plus court.

— Jonathan Frech

, Aussi 2*5**.5est 20**.5.

— Jonathan Frech

@JonathanFrech Racine carrée de 20 remplacée par 4.47

— mdahmoune

@mdahmoune Eh bien ... Si cette précision est suffisante, alors oui.

— Jonathan Frech

1

C # (.NET Core) , 201 , 180 + 13 = 193 octets

Besoin d'utiliser le système; pour 13 octets supplémentaires.

Étrangement, Console.Clear () ne semble pas fonctionner pour moi sur TIO. Cependant, cela fonctionne parfaitement dans une application console sous VS2017.

EDIT: Merci à Embodiment of Ignorance pour avoir raccourci la boucle, souligné mon assignation de variable inutile et inutile d'utiliser System.Threading; (restes de la copie VS), et soulignant que le terrain était nécessaire! Total de 8 octets golfés jusqu'à présent avec l'ajout du terrain. Ty Ty!

x=>{for(var j=x;j>0;System.Threading.Thread.Sleep((int)(4470*(Math.Sqrt(x-j+1)-Math.Sqrt(x-j--))))){Console.Clear();Console.Write("X".PadLeft(x-j+1,'\n').PadRight(x+1,'\n')+"-");}}

Essayez-le en ligne!

— Destroigo
source

Aidez Notwen à simuler la gravité!

Contexte physique

Le défi

Règles

JavaScript (ES7) + CSS + HTML, 340 octets

Fusain , 28 octets

Perl 6 , 81 octets

Explication

Haskell, 145 octets

Python 2 , 117 120 123 octets

C # (.NET Core) , 201 , 180 + 13 = 193 octets