Notwen quiere estudiar la cinemática de los cuerpos arrojados desde grandes alturas en un campo gravitacional uniforme, pero desafortunadamente no tiene la posibilidad técnica de ir a lugares suficientemente altos y observar los objetos mientras cae. Pero quién no quiere ver avances en la ciencia, así que ... ¡Ayudemos a Notwen a construir un simulador de gravedad!

Antecedentes fisicos

Un objeto caído desde una altura ( sin velocidad inicial ) en un campo gravitacional uniforme, descuidando los efectos atmosféricos como el arrastre o el viento gana velocidad y acelera hacia el suelo con el tiempo. Esta "tasa de cambio" de velocidad en una unidad de tiempo se llama aceleración gravitacional . Cerca de la superficie de la Tierra, es aproximadamente igual a , pero para los propósitos de este desafío usaremos el valor , lo que significa que en un solo segundo, un objeto aumenta su velocidad en aproximadamente . Considere tener una altura , que es un múltiplo de $h$ $g\approx9.8\frac{m}{s^2}$ $10\frac{m}{s^2}$ $10 \frac{m}{s}$ $h$ $100m$ e imagine dividir esa altura en intervalos iguales, cada uno de metros de largo. Notwen quiere medir cuánto tiempo tarda el objeto en atravesar cada uno de esos intervalos, así que eso es lo que pretendemos calcular también. La cinemática moderna , sin tecnicismos, nos dice que: donde para todos los valores de en nuestro caso, es la inicial velocidad al comienzo de nuestro intervalo y es la duración del intervalo de tiempo (para referencia, la indexación comienza en con $100$

Δ 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$

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

$\Delta h_k\equiv\Delta h=100m$

k

$k$

v_{k}

$v_k$

k^{th}

$k^\text{th}$

t_{k}

$t_k$

k^{th}

$k^\text{th}$

0

$0$

v_{0} = 0

$v_0=0$

) También sabemos que tiene la siguiente expresión: Numéricamente, obtenemos y al conectarse a la primera ecuación y resolver obtiene Entonces el objeto viaja el primer intervalo ( ) en , el segundo intervalo ( ) en y así sucesivamente ( pastebin con mas valores).

v_{k}

$v_k$

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

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

$v_k=\sqrt{2000k}\frac{m}{s}$

t_{k}

$t_k$

\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{*}$

k = 0

$k=0$

4.4721 s

$4.4721s$

k = 1

$k=1$

1.8524 s

$1.8524s$

El reto

Entrada: La altura de la que el objeto se tira ya sea como: un múltiplo entero positivo de , o el número de intervalos (de modo ya sea o significaría que ) - cuál depende de ti. $h$ $100$ $h$ $N=\frac{h}{100}$ $700$ $7$ $h=700m$

Salida: una animación artística ASCII de un objeto que cae, que se cae desde una altura (detalles a continuación). $h$

La estructura de un marco de salida debe ser la siguiente:

$N$ líneas nuevas que preceden al "terreno", representadas por al menos un carácter que no es un espacio en blanco (por ejemplo @). Al menos uno de los personajes del suelo debe estar en la vertical sobre la que cae el objeto.
Otro personaje que no sea un espacio en blanco que represente el objeto (por ejemplo X), que no sea el que eligió para el suelo.
Opcionalmente , un carácter al comienzo de cada línea que representa el eje vertical o el muro hecho en líneas. Cualquier cantidad de espacios iniciales y finales están bien siempre que sean consistentes entre los marcos, así como cualquier cantidad de espacios entre la pared y el objeto. Ejemplos de tramas válidas incluyen ¹ (para o ): $N$ $h=700m$ $N=7$
```
| X                                       >
|                             @           >   A
|                                         >
|        or            or           or    > 
|               O                         >
|                                         >
|                                         >
@@@             ^           -----            &&&
```

El objeto debe comenzar en la primera línea del primer fotograma, luego, después de la salida debe enjuagarse y su programa debe mostrar el objeto en la misma vertical pero en la siguiente línea en el segundo fotograma; luego, después de la salida debe volver a enjuagarse y su programa debe mostrar el objeto en la misma vertical pero en la siguiente línea en el tercer cuadro y así sucesivamente, hasta que el objeto alcance la línea justo por encima del suelo. Ejemplo: $t_0\approx 4.47s$ $t_1\approx 1.85s$

Reglas

La salida debe ser un texto escrito en una consola interactiva (descargable), un GIF, un archivo separado para cada cuadro o alguna otra técnica razonable de salida.
Cada cuadro debe sobrescribir completamente el último cuadro y estar en la misma ubicación.
Puede suponer que el tiempo requerido para que el compilador / intérprete muestre el texto es insignificante y que la precisión mínima permitida para calcular las raíces cuadradas es de 2 decimales.
Puede tomar entradas y proporcionar salidas a través de cualquier método estándar , mientras toma nota de que estas lagunas están prohibidas de forma predeterminada. Este es el código de golf , así que intente completar la tarea en la menor cantidad de bytes que pueda administrar en el idioma que elija.

^{1: Soy indulgente sobre lo que constituye un marco válido porque quiero permitir lo que mejor se adapte a su solución y no estoy tratando de agregar cosas superfluas al desafío. Si algo no está claro, pregunte en los comentarios.}

— Sr. Xcoder
fuente

3

JavaScript (ES7) + CSS + HTML, 340 bytes

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

Expandir fragmento

Si tengo mis sumas correctas, entonces la duración de la animación es y luego el CSS cubic-bezier hace el resto. $\sqrt { 20 N }$

— Neil
fuente

2

Carbón , 28 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Nota: espacio final. Puede observar el retraso en TIO pero no puede ver la animación, por lo que tendrá que imaginarlo desde la salida. Toma Ncomo entrada. Explicación:

Ｎθ

Entrada N.

↓θ⁴

Imprima la pared y el suelo, de modo que la forma de la salida sea coherente.

Ｆθ«

Recorre cada intervalo.

Ｊ²ιＰX

Coloque un Xa la altura adecuada.

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

Imprima el contenido del lienzo actual y espere el tiempo adecuado (truncado al milisegundo más cercano).

Sobrescribir el Xcon un espacio.

— Neil
fuente

2

Perl 6 , 81 bytes

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

"Pruébelo en línea", pero TIO no puede manejar la animación.

Explicación

Elegí un enfoque un poco diferente (y creo que es para mejor, aunque no estoy seguro). En lugar de dormir por los tiempos dados por la fórmula en el OP, simplemente dibujo la situación apropiada "cada 10 ms" (± errores inducidos por sleep).

Eso significa que hay 100 cuadros por segundo, así que si denotamos el número de cuadro por , debe ser . Y dado que dividimos la distancia vertical en bloques de 100 metros, podemos escribir la altura como , donde es el número de bloques (dado como entrada). La altura recorrida en el tiempo viene dada por , por lo que el número de bloques recorridos es Podemos invertirlo para obtener el número total de cuadros que necesitamos renderizar: $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 10^{- 6} k^{2} \approx 4.905 \times 10^{- 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 10^{- 6}}} \approx 452 \times \sqrt{n} .

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

Esto es suficiente para escribir la función. Se necesita un argumento, el número de bloques para renderizar, es decir, . Primero lo hacemos . Eso imprime una secuencia de escape ANSI llamada Save Cursor , luego imprime líneas nuevas, y después de eso, imprime un guión (el suelo) y una nueva línea. (Esto utiliza la característica genial de las comillas dobles en Perl 6: puede insertar el resultado de cualquier código directamente en la cadena escribiendo ese código dentro de llaves). $n$ say "\e[s{"\n"x$_}-" $n$

Después de eso, hacemos una secuencia de 0 a (truncada automáticamente a entero) con , y la mapeamos sobre ella. En cada iteración, imprimimos una secuencia ANSI de cursor de guardado (que coloca el cursor en la posición donde se guardó por última vez), escribimos cadenas "espacio + nueva línea" (automáticamente truncada una vez más ) y finalmente un que denota el objeto. Luego dormimos durante 10 ms, enjuagamos y repetimos. $452\sqrt n$ ^452*.sqrt $4.9\times 10^{-6} k^2$ o

Debido al truncamiento automático, simplemente hace lo correcto ™ y mueve la "o" solo después de cada 100 m completos de la caída.

— Ramillies
fuente

1

Haskell, 145 bytes

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]

Debe ejecutarse en un terminal ANSI. La entrada es el número de intervalos.

threadDelayEl parámetro está en nanosegundos, por lo que un literal 4472135es más corto que 2*sqrt 5*10^6. Lamentablemente 46**4 = 4477456no está dentro del límite de la precisión requerida.

— nimi
fuente

1

Python 2 , 117 120 123 bytes

-3 bytes Gracias a "No seas un punto triple x" y "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))

Pruébalo en línea!

— mdahmoune
fuente

1

+1 de mi parte, ¡buena solución! ¿El uso del carácter real no imprimible podría ahorrar un par de bytes en lugar de hacerlo chr(27)?

— Sr. Xcoder

@ Don'tbeax-tripledot Y si uno no logra conocer al personaje en sí, '\33'aún debe ser más corto.

— Jonathan Frech

Además, 2*5**.5es 20**.5.

— Jonathan Frech

@JonathanFrech Raíz cuadrada de 20 reemplazada por 4.47

— mdahmoune

@mdahmoune Bueno ... Si esa precisión es lo suficientemente buena, entonces sí.

— Jonathan Frech

1

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

Necesita usar el sistema; por 13 bytes adicionales.

Curiosamente, Console.Clear () no parece estar funcionando para mí en TIO. Sin embargo, esto funciona perfectamente en una aplicación de consola bajo VS2017.

EDITAR: Gracias a Encarnación de la ignorancia por acortar el ciclo, señalando mi asignación de variable innecesaria e innecesaria usando System.Threading; declaración (sobrante de la copia VS), y señalando que el terreno era necesario! Total de 8 bytes de golf hasta el momento con la adición de la tierra. 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')+"-");}}

Pruébalo en línea!

— Destroigo
fuente

¡Ayuda a Notwen a simular la gravedad!

Antecedentes fisicos

El reto

Reglas

JavaScript (ES7) + CSS + HTML, 340 bytes

Carbón , 28 bytes

Perl 6 , 81 bytes

Explicación

Haskell, 145 bytes

Python 2 , 117 120 123 bytes

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