Code Golf: Qual è il destino dell'astronave? [versione a virgola mobile]


12

Questa domanda è leggermente più difficile della versione di arte ASCII. Non c'è arte e ora puoi fare qualche aritmetica in virgola mobile!

La sfida

USS StackExchange stava viaggiando attraverso il campo di gravità del pianeta cg-00DLEF quando a bordo si è verificata un'esplosione astronomica. In qualità di responsabile della programmazione della nave, il tuo compito è simulare la traiettoria della tua nave al fine di prevedere se sarai costretto a schiantarti a terra nel sistema solare cg-00DELF. Durante l'esplosione, la tua nave è stata gravemente danneggiata. A causa del limitato DEEEPRAROM * gratuito dell'astronave, devi scrivere il tuo programma nel minor numero di caratteri possibile.

* Memoria di sola lettura ad accesso casuale programmabile cancellabile elettronicamente eseguibile elettronicamente

La simulazione

Un po 'come la versione di arte ASCII, ci sarà l'idea di passi temporali. Nell'altra versione, una fase temporale era una quantità di tempo relativamente grande: la nave poteva viaggiare molto oltre la gravità di un pianeta in una singola fase temporale. Qui, il passo temporale è un'unità di tempo molto più piccola a causa delle maggiori distanze coinvolte. Una grande differenza, tuttavia, è la non esistenza di cellule. La posizione e la velocità attuali dell'astronave saranno numeri in virgola mobile, insieme alle forze gravitazionali coinvolte. Un altro cambiamento è il fatto che i pianeti ora hanno dimensioni molto maggiori.

Ci saranno fino a tre pianeti nella simulazione. Tutti e tre avranno una posizione, un raggio e una gravità specifici. La gravità per ogni pianeta è un vettore che esercita una forza direttamente verso il centro del pianeta. La formula per trovare la forza di questo vettore è (Gravity)/(Distance**2), dove la distanza è la distanza esatta dalla nave al centro del pianeta. Ciò significa che non vi è alcun limite al punto in cui la gravità può raggiungere.

In qualsiasi momento specifico, l'astronave ha una velocità, che è la distanza e l'angolo che ha percorso dall'ultimo passo temporale ad ora. Anche la nave ha slancio. La distanza che percorrerà tra la fase temporale corrente e la successiva è la somma della sua velocità corrente aggiunta a tutti i vettori di gravità nella sua posizione. Questa diventa la nuova velocità dell'astronave.

Ogni simulazione ha un limite di tempo di 10.000 passi temporali. Se l'astronave viaggia all'interno di un pianeta (è più vicina al centro del pianeta rispetto al raggio del pianeta), allora si schianta contro quel pianeta. Se l'astronave non si schianta contro alcun pianeta entro la fine della simulazione, si presume che sia fuggito dalla gravità. È improbabile che la nave possa essere allineata in modo così perfetto da riuscire a rimanere in orbita per 10000 fasi temporali mentre si schianta sulla 10001a sequenza temporale.

Ingresso

L'ingresso sarà di quattro righe su STDIN. Ogni riga è composta da quattro numeri delimitati da virgole. Ecco il formato dei numeri:

ShipLocX,ShipLocY,ShipVelX,ShipVelY
Planet1LocX,Planet1LocY,Planet1Gravity,Planet1Radius
Planet2LocX,Planet2LocY,Planet2Gravity,Planet2Radius
Planet3LocX,Planet3LocY,Planet3Gravity,Planet3Radius

Se ci sono meno di tre pianeti, le linee rimanenti saranno riempite con zeri per tutti i valori. Ecco un esempio di input:

60,0,0,10
0,0,4000,50
100,100,4000,50
0,0,0,0

Ciò significa che l'astronave si trova in (60,0) e viaggia dritta "su / nord" ad una velocità di 10 unità / passo temporale. Ci sono due pianeti, uno situato in (0,0) e uno in (100,100). Entrambi hanno una gravità di 4000 e un raggio di 50. Anche se tutti questi sono numeri interi, non saranno sempre numeri interi.

Produzione

L'output sarà una sola parola per STDOUT per dire se l'astronave è atterrata o meno. Se la nave si schianta, stampa crash. Altrimenti, stampa escape. Ecco l'output previsto per l'input sopra:

crash

Forse ti starai chiedendo cosa è successo. Ecco un post di Pastebin che ha un registro di volo dettagliato per l'astronave. I numeri non sono molto bravi ad aiutare le persone a visualizzare l'evento, quindi ecco cosa è successo: l'astronave riesce a sfuggire alla gravità del primo pianeta (a ovest) con l'aiuto della gravità del secondo pianeta (a nord-est). Si sposta a nord e poi passa leggermente a ovest del secondo pianeta, mancando a malapena. Quindi curva attorno al lato settentrionale del pianeta e si schianta contro il lato orientale del secondo pianeta.

Alcuni altri casi per l'esame

60,0,10,-10
0,0,2000,50
100,100,1357.9,47.5
0,0,0,0

fuga (a causa della legge del quadrato inverso, 2000 non è molto gravitazionale se sei a 60 unità di distanza)

0,0,0,0
100,100,20000,140
-50,-50,50,50
-100,-100,50,50

incidente (il primo pianeta è estremamente massiccio ed estremamente vicino)

0,0,0,0
0,0,0,0
0,0,0,0
0,0,0,0

fuga (questo è un caso limite: non ci sono pianeti e una semplice interpretazione suggerirebbe che l'astronave si trova direttamente in cima ai pianeti)

Regole, restrizioni e note

Questo è il codice golf. Si applicano le regole standard per il golf. Il programma deve essere scritto solo con caratteri ASCII stampabili. Non è possibile accedere a nessun tipo di database esterno. Puoi scrivere voci in qualsiasi lingua (diversa da quella specializzata nella risoluzione di questa sfida).

Termina trasmissione


rofl DEEEPRAROM! - L'interazione gravitazionale dei pianeti non dovrebbe essere simulata? Ancora non esattamente numericamente allora, ma abbastanza giusto. - Suppongo che la simulazione di riferimento utilizzi l'integrazione standard del 4 ° ordine Runge-Kutta e il nostro programma deve creare risultati equivalenti?
cessò di girare in senso antiorario il

Non ho capito come interagire con più pianeti. Il problema è che tenderanno a schiantarsi l'uno contro l'altro immediatamente. Per risolvere questo problema è necessario aumentare incredibilmente la scala della simulazione.
PhiNotPi

Per quanto riguarda il metodo Runge-Kutta, onestamente non sono ancora così avanzato in matematica. :( Quello che ho fatto è stato calcolare la gravità nella posizione corrente della nave e aggiungerla alla velocità della nave, generando la nuova velocità della nave. L'ho fatto per ogni passaggio temporale. So che questo non è completamente accurato, ma ho scoperto che dividendo la velocità iniziale della nave e la gravità dei pianeti per 10 aumenta la precisione della simulazione.
PhiNotPi

Ah, quello sarebbe il metodo di Eulero. Per i passi abbastanza piccoli anche quello è preciso; tuttavia Runge-Kutta o qualcos'altro di più sofisticato sarebbe più interessante per implementare l'IMO. Forse dovrei escogitare la mia sfida, non riesco a sembrare facilmente soddisfacente ...
cessò di girare in senso antiorario il

@leftaroundabout Vai avanti. Puoi fare qualcosa del tipo "simula l'intero sistema solare usando equazioni differenziali" o qualcosa di simile o magari aggiungere nella terza dimensione.
PhiNotPi

Risposte:


6

Python, 178 170 caratteri

p=input
a,b,c,d=p()
x=a+b*1j
v=c+d*1j
P=(p(),p(),p())
R='escape'
for i in' '*10000:
 for a,b,g,r in P:
  d=a+b*1j-x;v+=g*d/abs(d)**3
  if abs(d)<r:R='crash'
 x+=v
print R

2
Sei di umore complesso oggi, vero?
cessò di girare in senso antiorario il

8
si, isono ....
Keith Randall,

Come posso competere con quello?
Neil,

@Neil: il codice o la battuta spiritosa?
Keith Randall,

Bene il codice. La battuta spiritosa con cui posso stare al passo.
Neil,

2

Golfrun / GolfScript ?, 243 232 caratteri

10000:M;n%(','%2/{{~}%}/{{M*}%}:_~:v;_:x;'escape':R;{[','%2/{{~M*}%}/]}%:P;
M,{;P{~\x{0\-}%{+~@+@@+[\]}:|~:d.[~0\-]{[+.2%~*\.-2%~*@\-\.3%~*\(;);~*+]}:&~);~sqrt:z
..**\~d@[`~0]\&@M.*/\{1$/}%v|:v;;z\<{'crash':R;}{}if}/x v|:x;}/R puts

Golfrun è una lingua a cui sto lavorando, nata come interprete di GolfScript C, ma presto si è allontanata in qualche modo; anche se ho scritto questo codice senza usare le funzioni Golfrun consapevolmente specifiche (tranne che per sqrt), il test con l'originale GolfScript non è riuscito (ho dovuto aggiungere la funzione sqrt al codice originale, non sono un guru di Ruby ma credo che il problema sia non il mio ritocco).

Il primo problema con questa soluzione è che Golfrun, come GolfScript, non ha matematica in virgola mobile. È "simulato" ingrandendo i numeri, si spera nel modo corretto (ma non sono sicuro al 100% di averlo fatto in modo coerente). Anche così, la soluzione non gestisce i numeri in virgola mobile come input, quindi ho dovuto ingrandirli a mano per avere solo numeri interi.

Cercando di implementare l'algoritmo nel codice Python, ho anche implementato bit di matematica complessa in un modo piuttosto "generale". Manipolare l'algoritmo per evitarlo e / o incorporare ogni volta che è possibile, ritardare le definizioni, potrebbe salvare altri caratteri ...

Come faccio a sapere se questo codice funziona? Anzi, non sono sicuro che lo faccia! Ma fornendo gli esempi come input (dopo aver "rimosso" i punti in cui compaiono), ha scritto i risultati previsti, ad eccezione del "caso d'angolo" (che solleva un'eccezione anche in Python) ...

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.