Eine beinahe masselose Katze fällt in den Weltraum (keine Sorge, mit einem Raumanzug und allem) und zwar an der Stelle der (x, y, z)Geschwindigkeit (vx, vy, vz). Am Punkt befindet sich ein fester, unendlich dichter Planet (mit einem Volumen von 0), der entfernte (0, 0, 0)Objekte anziehtr mit einer Beschleunigung1/r^2 . Wohin geht das Objekt nach der Newtonschen Schwerkraft nach der Zeit t?

Nahezu masselos bedeutet in diesem Fall, dass Sie den Wert von ausgeben lim (mass --> 0) <position of cat> . Die Masse wird durch die Schwerkraft des Planeten beeinflusst, aber der Planet wird nicht durch die Schwerkraft der Katze beeinflusst. Mit anderen Worten ist der Zentralkörper fest.

Das ist etwas ähnlich zu Code Golf: Was ist das Schicksal des Raumschiffs? [Gleitkomma-Version] , aber das ist anders, weil es die Genauigkeit misst.

Sie können eine auf einer Simulation basierende Lösung implementieren, die in weniger als 3 Sekunden ausgeführt werden muss, ODER Sie können ein Programm implementieren, das einen genauen Wert angibt (muss auch in weniger als 3 Sekunden ausgeführt werden). Details zur Wertung finden Sie weiter unten. Wenn Sie eine Simulation implementieren, muss diese nicht exakt sein, aber Ihre Punktzahl wird aufgrund der Ungenauigkeit niedriger sein.

Eingabe : x y z vx vy vz tNicht unbedingt ganze Zahlen, die die x-, y-, z-Koordinaten, die Geschwindigkeit in x-, y- und z-Richtung bzw. die Zeit darstellen. Es ist garantiert, dass die Geschwindigkeit der Katze streng unter der Fluchtgeschwindigkeit in dieser Höhe liegt. Die Eingabe kann von überall erfolgen, einschließlich der Parameter für eine Funktion. Das Programm muss auf meinem Laptop in weniger als drei Sekunden ausgeführt werden. t < 2^30Wenn Sie also eine Simulation ausführen, müssen Sie Ihren Zeitschritt entsprechend anpassen. Wenn Sie vorhaben, die 3-Sekunden-Grenze für jeden Testfall zu überschreiten, stellen Sie sicher, dass es einen einstellbaren Parameter gibt, der die Genauigkeit / Ungenauigkeit für Geschwindigkeitszuwächse erhöht, sodass ich ihn auf meinem Computer in drei Sekunden ausführen kann.

Ausgabe : x y zDie Position nach der Zeit t.

Da das Zweikörperproblem perfekt gelöst werden kann, ist es theoretisch möglich, eine perfekte, korrekte Antwort zu erhalten.

Bewertung : Für jeden Testfall ist der Fehler der Abstand zwischen Ihrer Ausgabe und der "wahren" Ausgabe. Die wahre Ausgabe ist definiert als die Ausgabe, die das Testfall-Snippet generiert. Wenn der Fehler kleiner als ist 10^(-8), wird der Fehler auf Null abgerundet. Ihre Punktzahl ist der durchschnittliche Fehler bei 100 (oder mehr) zufälligen Testfällen. Wenn Sie eine absolut genaue Antwort schreiben, sollten Sie eine Punktzahl von 0 erhalten. Die niedrigste Punktzahl gewinnt, und das Unentschieden wird durch die Codelänge unterbrochen.

Testfälle :

1 0 0 0 -1 0 1000000000 --> 0.83789 -0.54584 0

In diesem Fall ist die Umlaufbahn mit der Periode 2 * pi perfekt kreisförmig, sodass die Katze nach 159154943-maligem Kreisen bei ungefähr (0,83789, -0,54584) landet. Dies ist kein Testfall, an dem Ihr Code getestet wird. Wenn Sie jedoch eine absolut genaue Antwort einreichen, können Sie diese testen.

Das folgende Snippet generiert zufällige zusätzliche Testfälle und wird zur Beurteilung von Einsendungen verwendet. Lass es mich wissen, wenn es einen Fehler gibt:

var generateTestCase = function() {
  var periapsis = Math.random() * 10 + 0.5;
  var circularVelocity = Math.sqrt(1 / periapsis);
  var escapeVelocity = Math.sqrt(2) * circularVelocity;
  var v = Math.random() * (escapeVelocity - circularVelocity) + circularVelocity;
  var a = 1 / (2 / periapsis - v * v);
  var ecc = (a - periapsis) * (2 / periapsis - v * v);
  var semiLatus = a * (1 - ecc * ecc);
  var angM = Math.sqrt(semiLatus);
  var period = 2 * Math.PI * a * Math.sqrt(a);
  var getCoordAfterTime = function(t) {
    var meanAnomaly = t / (a * Math.sqrt(a));

    function E(e, M, n) {
      var result = M;
      for (var k = 1; k <= n; ++k) result = M + e * Math.sin(result);
      return result;
    }
    var eAnomaly = E(ecc, meanAnomaly, 10000);
    var radius = a * (1 - ecc * Math.cos(eAnomaly));
    var theta = Math.acos((semiLatus / radius - 1) / ecc);
    if (t > period / 2) theta = -theta;
    return {
      r: radius,
      t: theta,
      x: radius * Math.cos(theta),
      y: radius * Math.sin(theta)
    };
  }
  var t1 = Math.random() * period;
  var p1 = getCoordAfterTime(t1);
  var v1 = Math.sqrt(2 / p1.r - 1 / a);
  var velocityAngle1 = Math.acos(angM / p1.r / v1);
  var horizontal = Math.atan(-p1.x / p1.y);
  if (t1 < period / 2) {
    velocityAngle1 *= -1;
    horizontal += Math.PI;
  }
  var vx = v1 * Math.cos(horizontal + velocityAngle1);
  var vy = v1 * Math.sin(horizontal + velocityAngle1);
  var t2 = Math.random() * period;
  var p2 = getCoordAfterTime(t2);
  var v2 = Math.sqrt(2 / p2.r - 1 / a);
  var dummyPeriods = Math.floor(Math.random() * 100) * period + period;
  var rotate = function(x, y, z, th1, th2, th3) {
    var x1 = x * Math.cos(th1) - y * Math.sin(th1);
    var y1 = x * Math.sin(th1) + y * Math.cos(th1);
    var z1 = z;
    var x2 = x1 * Math.cos(th2) + z1 * Math.sin(th2);
    var y2 = y1;
    var z2 = -x1 * Math.sin(th2) + z1 * Math.cos(th2);
    var x3 = x2;
    var y3 = y2 * Math.cos(th3) - z2 * Math.sin(th3);
    var z3 = y2 * Math.sin(th3) + z2 * Math.cos(th3);
    return [x3, y3, z3];
  }
  var th1 = Math.random() * Math.PI * 2,
    th2 = Math.random() * 2 * Math.PI,
    th3 = Math.random() * 2 * Math.PI;
  var input = rotate(p1.x, p1.y, 0, th1, th2, th3)
    .concat(rotate(vx, vy, 0, th1, th2, th3))
    .concat([t2 - t1 + dummyPeriods]);
  var output = rotate(p2.x, p2.y, 0, th1, th2, th3);
  return input.join(" ") + " --> " + output.join(" ");
}
var $ = function(x) {
  return document.querySelector(x);
}
$("#onetestcase").onclick = function() {
  $("#result1").innerHTML = generateTestCase();
}
$("#huntestcases").onclick = function() {
  var result = [];
  for (var i = 0; i < 100; ++i) result.push(generateTestCase());
  $("#result100").innerHTML = result.join("\n");
}

<div>
  <button id="onetestcase">Generate</button>
  <pre id="result1"></pre>
</div>
<div>
  <button id="huntestcases">Generate 100 test cases</button>
  <pre id="result100"></pre>
</div>

Python 3.5 + NumPy, genau, 186 Bytes

from math import*
def o(r,v,t):
 d=(r@r)**.5;W=2/d-v@v;U=W**1.5;b=[0,t*U+9]
 while 1:
  a=sum(b)/2;x=1-cos(a);y=sin(a)/U;k=r@v*x/W+d*y*W
  if a in b:return k*v-r*x/W/d+r
  b[k+a/U-y>t]=a

Dies ist eine exakte Lösung, bei der eine Formel I verwendet wird, die auf Jesper Göranssonhis, „Symmetrien des Kepler-Problems“, 2015, basiert . Es wird eine binäre Suche verwendet, um die transzendentale Gleichung Ax + B cos x + C sin x = D zu lösen, für die es keine Lösung in geschlossener Form gibt.

Die Funktion erwartet, dass Position und Geschwindigkeit als NumPy-Arrays übergeben werden:

>>> from numpy import array
>>> o(array([1,0,0]),array([0,-1,0]),1000000000)
array([ 0.83788718, -0.54584345,  0.        ])
>>> o(array([-1.1740058273269156,8.413493259550673,0.41996042044140003]),array([0.150014367067652,-0.09438816345868332,0.37294941703455975]),7999.348650387233)
array([-4.45269544,  6.93224929, -9.27292488])

Javascript

Dies ist nur, um den Ball ins Rollen zu bringen, da niemand Antworten zu posten scheint. Hier ist ein sehr naiver, einfacher Weg, der viel verbessert werden kann:

function simulate(x, y, z, vx, vy, vz, t) {
  var loops = 1884955; // tune this parameter
  var timestep = t / loops;
  for (var i = 0; i < t; i += timestep) {
    var distanceSq = x*x + y*y + z*z; // distance squared from origin
    var distance = Math.sqrt(distanceSq);
    var forceMag = 1/distanceSq; // get the force of gravity
    var forceX = -x / distance * forceMag;
    var forceY = -y / distance * forceMag;
    var forceZ = -z / distance * forceMag;
    vx += forceX * timestep;
    vy += forceY * timestep;
    vz += forceZ * timestep;
    x += vx * timestep;
    y += vy * timestep;
    z += vz * timestep;
  }
  return [x, y, z];
}

Testen:

simulate(1, 0, 0, 0, -1, 0, Math.PI*2) --> [0.9999999999889703, -0.0000033332840909716455, 0]

Hey, das ist ziemlich gut. Es hat einen Fehler von ca. 3.333 * 10 ^ (- 6), der nicht ausreicht, um abgerundet zu werden ... es ist knapp.

Nur zum Spaß:

console.log(simulate(1, 0, 0, 0, -1, 0, 1000000000))
--> [-530516643639.4616, -1000000000.0066016, 0]

Naja; es ist also nicht das beste.

Und an einem zufälligen Testfall vom Generator:

simulate(-1.1740058273269156,8.413493259550673,0.41996042044140003,0.150014367067652,-0.09438816345868332,0.37294941703455975,7999.348650387233)
-->    [-4.528366392498373, 6.780385554803544, -9.547824236472668]
Actual:[-4.452695438880813, 6.932249293597744, -9.272924876103785]

Mit einem Fehler von nur ca. 0,32305!

Dies kann durch Verlet-Integration oder einen ausgefallenen Algorithmus erheblich verbessert werden. Tatsächlich können diese Algorithmen sogar perfekte Ergebnisse erzielen, obwohl es sich um Simulationen handelt.