Notwen quer estudar a cinemática de corpos lançados de grandes alturas em um campo gravitacional uniforme, mas infelizmente ele não tem a possibilidade técnica de ir a lugares suficientemente altos e observar os objetos enquanto cai. Mas quem não quer ver avanços na ciência, então ... Vamos ajudar a Notwen a construir um simulador de gravidade!

Contexto físico

Um objeto caiu de uma altura $h$ ( sem velocidade inicial ) em um campo gravitacional uniforme, negligenciando efeitos atmosféricos, como arrasto ou vento, ganha velocidade e acelera em direção ao solo com o tempo. Essa "taxa de mudança" de velocidade em uma unidade de tempo é chamada aceleração gravitacional . Perto da superfície da Terra, é aproximadamente igual a $g\approx9.8\frac{m}{s^2}$ , mas, para os propósitos deste desafio, usaremos o valor $10\frac{m}{s^2}$ , o que significa que em um único segundo, um objeto aumenta sua velocidade em cerca de $10 \frac{m}{s}$ . Considere ter uma altura $h$ , que é um múltiplo de $100m$ e imagine dividir essa altura em intervalos iguais, cada um com $100$ metros de comprimento. Notwen quer medir quanto tempo leva para que o objeto caia em cada um desses intervalos, então é isso que pretendemos calcular também. Acinemáticamoderna- ignorando os aspectos técnicos - nos diz 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$ onde

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

$\Delta h_k\equiv\Delta h=100m$ para todos os valores de

k

$k$ , no nosso caso,

v_{k}

$v_k$ representa a velocidade inicial no início do nosso

k^{th}

$k^\text{th}$ intervalo e

t_{k}

$t_k$ é a duração do

k^{th}

$k^\text{th}$ intervalo de tempo (para referência, a indexação começa em

0

$0$ com

v_{0} = 0

$v_0=0$ ). Também sabemos que

v_{k}

$v_k$ tem a seguinte expressão:

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}$ Numericamente, obtemos

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

$v_k=\sqrt{2000k}\frac{m}{s}$ e ligar na primeira equação e resolvendo para

t_{k}

$t_k$ dá

\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{*}$ Assim, o objeto percorre o primeiro intervalo (

k = 0

$k=0$ ) em

4.4721 s

$4.4721s$ , o segundo intervalo (

k = 1

$k=1$ ) em

1.8524 s

$1.8524s$ e assim por diante (pastacom mais valores).

O desafio

Entrada: a altura $h$ da qual o objeto é lançado como: um múltiplo inteiro positivo de $100$ , $h$ ou o número de intervalos $N=\frac{h}{100}$ (então $700$ ou $7$ significaria que $h=700m$ ) - qual deles depende de você.

Saída: uma animação artística ASCII de um objeto em queda, que caiu da altura $h$ (detalhes abaixo).

A estrutura de um quadro de saída deve ser a seguinte:

$N$ novas linhas anteriores ao "solo", representadas por pelo menos um caractere que não é um espaço em branco (por exemplo@). Pelo menos um dos caracteres do solo deve estar na vertical em que o objeto cai.
Outro caractere que não é um espaço em branco que representa o objeto (por exemplo X), diferente daquele que você escolheu para o chão.

N

$N$

h = 700 m

$h=700m$

N = 7

$N=7$

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

$t_0\approx 4.47s$ $t_1\approx 1.85s$

Regras

A saída deve ser algum texto gravado em um console interativo (lavável), um GIF, um arquivo separado para cada quadro ou alguma outra técnica razoável de saída.
Cada quadro deve substituir completamente o último quadro e estar no mesmo local.
Você pode supor que o tempo necessário para que o compilador / intérprete produza o texto seja insignificante e a precisão mínima permitida para calcular as raízes quadradas seja de 2 casas decimais.
Você pode obter entrada e fornecer saída através de qualquer método padrão , observando que essas brechas são proibidas por padrão. Isso é código-golfe , então tente concluir a tarefa no mínimo de bytes que você puder gerenciar no seu idioma preferido.

^{1: Sou indulgente quanto ao que constitui um quadro válido, porque quero permitir o que melhor se adequa à sua solução e não estou tentando adicionar coisas supérfluas ao desafio. Se algo não estiver claro, pergunte nos comentários.}

— Mr. Xcoder
fonte

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 snippet

$\sqrt { 20 N }$

— Neil
fonte

2

Carvão , 28 bytes

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

Experimente online! Link é a versão detalhada do código. Nota: espaço à direita. Você pode observar o atraso no TIO, mas não pode assistir à animação, portanto terá que imaginar isso a partir da saída. Toma Ncomo entrada. Explicação:

Ｎθ

Entrada N.

↓θ⁴

Imprima a parede e o chão, para que a forma da saída seja consistente.

Ｆθ«

Loop em cada intervalo.

Ｊ²ιＰX

Coloque um Xna altura apropriada.

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

Envie o conteúdo atual da tela e aguarde a quantidade de tempo apropriada (truncada no milissegundo mais próximo).

Sobrescreva o Xespaço.

— Neil
fonte

2

Perl 6 , 81 bytes

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

"Experimente online!", Mas o TIO não pode lidar com a animação.

Explicação

Eu escolhi uma abordagem um pouco diferente (e acho que é para melhor, embora não tenha certeza). Em vez de adormecer pelos horários indicados pela fórmula no OP, apenas traço a situação apropriada "a cada 10 ms" (± erros induzidos por sleep).

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

$n$ say "\e[s{"\n"x$_}-" $n$

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

Devido ao truncamento automático, ele apenas faz a coisa certa ™ e move o "o" somente após cada 100 m de queda.

— Ramillies
fonte

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]

Precisa ser executado em um terminal ANSI. A entrada é o número de intervalos.

threadDelayO parâmetro está em nanossegundos, portanto, um literal 4472135é menor que 2*sqrt 5*10^6. Infelizmente, 46**4 = 4477456não está dentro do limite da precisão necessária.

— nimi
fonte

1

Python 2 , 117 120 123 bytes

-3 bytes Graças a "Não seja um ponto x triplo" e "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))

Experimente online!

— mdahmoune
fonte

11

+1 de mim, boa solução! Usar o caractere não imprimível real não salvaria alguns bytes em vez de chr(27)?

— Mr. Xcoder

@ Don'tbeax-tripledot E se alguém não se apega ao próprio personagem, '\33'deve ser ainda mais curto.

— Jonathan Frech

Além disso, 2*5**.5é 20**.5.

— Jonathan Frech

@JonathanFrech Raiz quadrada de 20 substituída por 4,47

— mdahmoune

@mdahmoune Bem ... Se essa precisão é boa o suficiente, então sim.

— Jonathan Frech

1

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

Precisa usar o sistema; por 13 bytes adicionais.

Estranhamente, o Console.Clear () não parece estar funcionando para mim no TIO. No entanto, isso funciona perfeitamente em um aplicativo de console no VS2017.

EDIT: Obrigado à Modalidade de Ignorância por encurtar o loop, apontando minha atribuição desnecessária de variáveis e uso desnecessário de System.Threading; (sobra da cópia do VS) e apontando que o terreno era necessário! Total de 8 bytes jogados até o momento com a adição do solo. 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')+"-");}}

Experimente online!

— Destroigo
fonte

Ajude Notwen a simular a gravidade!

Contexto físico

O desafio

Regras

JavaScript (ES7) + CSS + HTML, 340 bytes

Carvão , 28 bytes

Perl 6 , 81 bytes

Explicação

Haskell, 145 bytes

Python 2 , 117 120 123 bytes

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