Notwen vuole studiare la cinematica dei corpi lanciati da grandi altezze in un campo gravitazionale uniforme, ma sfortunatamente non ha la possibilità tecnica di andare in luoghi sufficientemente alti e osservare gli oggetti mentre cadono. Ma chi non vuole vedere i progressi della scienza quindi ... Aiutiamo Notwen a costruire un simulatore di gravità!

Background fisico

Un oggetto lasciato cadere da un'altezza ( senza velocità iniziale ) in un campo gravitazionale uniforme, trascurando gli effetti atmosferici come la resistenza o il vento aumenta la velocità e accelera verso il suolo con il tempo. Questo "tasso di variazione" della velocità in un'unità di tempo è chiamato accelerazione gravitazionale . Vicino alla superficie della Terra, è approssimativamente uguale a , ma ai fini di questa sfida useremo il valore , nel senso che in un solo secondo, un oggetto aumenta la sua velocità di circa . Valuta di avere un'altezza , che è un multiplo di $h$ $g\approx9.8\frac{m}{s^2}$ $10\frac{m}{s^2}$ $10 \frac{m}{s}$ $h$ $100m$ e immagina di dividere quell'altezza in intervalli uguali, ciascuno lungo metri. Notwen vuole misurare quanto tempo impiega l'oggetto a superare ciascuno di quegli intervalli, quindi è quello che intendiamo calcolare anche noi. La cinematica moderna - saltando i tecnicismi - ci dice che: dove per tutti i valori di nel nostro caso, è l'iniziale velocità all'inizio del nostro intervallo e è la durata dell'intervallo di tempo (per riferimento, l'indicizzazione inizia da 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$ ). Sappiamo anche che ha la seguente espressione: numericamente, otteniamo e inserendo la prima equazione e risolvendo per dà

Quindi l'oggetto percorre il primo intervallo (

) in

, il secondo intervallo (

) in

e così via ( pastebin con più valori).

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$

La sfida

Input: l'altezza da cui viene lanciato l'oggetto come: un numero intero positivo di , o il numero di intervalli (quindi o significherebbe che ) - quale dipende da te. $h$ $100$ $h$ $N=\frac{h}{100}$ $700$ $7$ $h=700m$

Output: un'animazione in arte ASCII di un oggetto che cade, lasciato cadere da un'altezza (dettagli sotto). $h$

La struttura di un frame di output deve essere la seguente:

$N$ newline che precedono il "terreno", rappresentato da almeno un carattere non bianco (es @.). Almeno uno dei personaggi del terreno deve trovarsi sulla verticale su cui cade l'oggetto.
Un altro personaggio non bianco che rappresenta l'oggetto (ad esempio X), diverso da quello che hai scelto per il terreno.

Opzionalmente , un carattere all'inizio di ogni linea che rappresenta l'asse verticale o il muro fatto su linee. Qualsiasi quantità di spazi iniziali e finali va bene purché siano coerenti tra i fotogrammi, nonché qualsiasi quantità di spazi tra il muro e l'oggetto. Esempi di frame validi includono ¹ (per o ):

N

$N$

h = 700 m

$h=700m$

N = 7

$N=7$

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

L'oggetto deve iniziare sulla prima riga del primo fotogramma, quindi dopo l'output deve essere e il programma deve visualizzare l'oggetto sulla stessa verticale ma sulla riga successiva nel secondo fotogramma; quindi dopo l'output deve essere nuovamente scaricato e il programma dovrebbe visualizzare l'oggetto sulla stessa verticale ma sulla riga successiva nel terzo frame e così via, fino a quando l'oggetto raggiunge la linea sopra il terreno. Esempio: $t_0\approx 4.47s$ $t_1\approx 1.85s$

Regole

L'output dovrebbe essere un testo scritto su una console interattiva (flushable), una GIF, un file separato per ogni frame o qualche altra ragionevole tecnica di output.
Ogni fotogramma dovrebbe sovrascrivere completamente l'ultimo fotogramma e trovarsi nella stessa posizione.
Si può presumere che il tempo richiesto dal compilatore / interprete per produrre il testo sia trascurabile e che la precisione minima consentita per il calcolo delle radici quadrate sia di 2 decimali.
Puoi prendere input e fornire output attraverso qualsiasi metodo standard , tenendo presente che queste scappatoie sono vietate per impostazione predefinita. Questo è code-golf , quindi prova a completare l'attività nel minor numero di byte che puoi gestire nella tua lingua preferita.

^{1: Sono indulgente su ciò che costituisce un frame valido perché voglio consentire ciò che si adatta meglio alla tua soluzione e non sto cercando di aggiungere elementi superflui alla sfida. Se qualcosa non è chiaro, chiedere nei commenti.}

— Mr. Xcoder
fonte

3

JavaScript (ES7) + CSS + HTML, 340 byte

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

Espandi frammento

Se ho le mie somme giuste, la durata dell'animazione è $\sqrt { 20 N }$ e poi il cubico-bezier CSS fa il resto.

— Neil
fonte

2

Carbone , 28 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Nota: spazio finale. Puoi osservare il ritardo su TIO ma non puoi guardare l'animazione, quindi dovrai immaginarlo dall'output. Accetta Ncome input. Spiegazione:

Ｎθ

Input N.

↓θ⁴

Stampa il muro e il terreno, in modo che la forma dell'output sia coerente.

Ｆθ«

Passa sopra ogni intervallo.

Ｊ²ιＰX

Posizionare un Xall'altezza appropriata.

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

Stampa il contenuto della tela corrente e attendi il tempo appropriato (troncato al millisecondo più vicino).

Sovrascrivi il Xcon uno spazio.

— Neil
fonte

2

Perl 6 , 81 byte

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

"Provalo online!", Ma TIO non è in grado di gestire l'animazione.

Spiegazione

Ho scelto un approccio un po 'diverso (e penso che sia in meglio, anche se non lo so per certo). Invece di dormire per i tempi indicati dalla formula nell'OP, ho solo disegnato la situazione appropriata "ogni 10 ms" (± errori indotti da 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

A causa del troncamento automatico, Fa solo la cosa giusta ™ e sposta la "o" solo dopo ogni 100 m di caduta.

— Ramillies
fonte

1

Haskell, 145 byte

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]

Deve essere eseguito in un terminale ANSI. L'ingresso è il numero di intervalli.

threadDelayIl parametro è in nanosecondi, quindi un valore letterale 4472135è più breve di 2*sqrt 5*10^6. Sfortunatamente 46**4 = 4477456non rientra nei limiti della precisione richiesta.

— Nome del modello
fonte

1

Python 2 , 117 120 123 123 byte

-3 byte Grazie a "Non essere un punto 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))

Provalo online!

— mdahmoune
fonte

1

+1 da parte mia, buona soluzione! L'uso del carattere non stampabile effettivo non salverebbe un paio di byte anziché chr(27)?

— Mr. Xcoder

@ Don'tbeax-tripledot E se non si ottiene il personaggio stesso, '\33'dovrebbe essere ancora più breve.

— Jonathan Frech,

Inoltre, lo 2*5**.5è 20**.5.

— Jonathan Frech,

Radice @JonathanFrech Square di 20 sostituita da 4.47

— mdahmoune

@mdahmoune Bene ... Se quell'accuratezza è abbastanza buona, allora sì.

— Jonathan Frech,

1

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

Necessita di utilizzare il sistema; per 13 byte aggiuntivi.

Stranamente, Console.Clear () non sembra funzionare per me su TIO. Tuttavia, questo funziona perfettamente in un'app console sotto VS2017.

EDIT: Grazie a Embodiment of Ignorance per abbreviare il loop, sottolineando la mia assegnazione variabile non necessaria e non necessaria utilizzando System.Threading; dichiarazione (rimanente dalla copia VS) e sottolineando che era necessario il terreno! Totale di 8 byte giocati a golf finora con l'aggiunta del terreno. Grazie grazie!

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')+"-");}}

Provalo online!

— Destroigo
fonte

Aiuta Notwen a simulare la gravità!

Background fisico

La sfida

Regole

JavaScript (ES7) + CSS + HTML, 340 byte

Carbone , 28 byte

Perl 6 , 81 byte

Spiegazione

Haskell, 145 byte

Python 2 , 117 120 123 123 byte

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