Un gato casi sin masa se deja caer en el espacio (no te preocupes, con un traje espacial y todo) en el punto (x, y, z)con velocidad (vx, vy, vz). Hay un planeta fijo, infinitamente denso (con un volumen de 0) en el punto (0, 0, 0)y atrae objetos a distancia rcon aceleración 1/r^2. Según la gravedad newtoniana, ¿a dónde va el objeto después del tiempo t?

Casi sin masa en este caso significa que está emitiendo el valor de lim (mass --> 0) <position of cat>. La masa se ve afectada por la gravedad del planeta, pero el planeta no se ve afectado por la gravedad del gato. En otras palabras, el cuerpo central está fijo.

Esto es algo similar a Code Golf: ¿Cuál es el destino de la nave espacial? [versión de punto flotante] , pero esto es diferente porque mide la precisión.

Puede implementar una solución basada en una simulación, que debe ejecutarse en menos de 3 segundos, O puede implementar un programa que proporcione un valor exacto (también debe ejecutarse en menos de 3 segundos). Ver detalles de puntuación a continuación. Si implementa una simulación, no tiene que ser exacta, pero su puntaje será menor debido a la inexactitud.

Entrada : x y z vx vy vz tno necesariamente números enteros que representan las coordenadas x, y, z, la velocidad en las direcciones x, y y z y el tiempo, respectivamente. Se garantiza que la velocidad del gato es estrictamente menor que la velocidad de escape a esa altitud. La entrada puede tomarse desde cualquier lugar, incluidos los parámetros de una función. El programa debe ejecutarse en menos de tres segundos en mi computadora portátil t < 2^30, lo que significa que, si está ejecutando una simulación, debe ajustar su paso de tiempo en consecuencia. Si está planeando alcanzar el límite de 3 segundos para cada caso de prueba, asegúrese de que haya un parámetro sintonizable que pueda hacerlo más preciso / menos preciso para las ganancias de velocidad, de modo que pueda hacerlo funcionar en tres segundos en mi computadora.

Salida :, x y zla posición después del tiempo t.

Dado que el problema de dos cuerpos se puede resolver perfectamente, en teoría es posible obtener una respuesta correcta y perfecta.

Puntuación : Para cualquier caso de prueba, el error se define como la distancia entre su salida y la salida "verdadera". La salida verdadera se define como la que genera el fragmento de caso de prueba. Si el error es menor que 10^(-8), el error se redondea a cero. Su puntaje es el error promedio en 100 (o más) casos de prueba aleatorios. Si escribe una respuesta perfectamente precisa, debería obtener una puntuación de 0; gana la puntuación más baja, y los lazos se romperán por la longitud del código.

Casos de prueba :

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

En este caso, la órbita es perfectamente circular con el período 2 * pi, por lo que después de dar vueltas 159154943 veces, el gato termina en aproximadamente (0.83789, -0.54584). Este no es un caso de prueba en el que se probará su código; Sin embargo, si envía una respuesta perfectamente precisa, es posible que desee probarla.

El fragmento a continuación genera casos de prueba adicionales aleatorios y se utilizará para juzgar los envíos; avíseme si hay un error con esto:

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, exacto, 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

Esta es una solución exacta, utilizando una fórmula que diseñé basada en Jesper Göranssonhis, "Symmetries of the Kepler problem", 2015 . Utiliza una búsqueda binaria para resolver la ecuación trascendental Ax + B cos x + C sen x = D, que no tiene una solución de forma cerrada.

La función espera que la posición y la velocidad se pasen como matrices NumPy:

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

Esto es solo para que la pelota ruede, ya que nadie parece estar publicando respuestas. Aquí hay una manera muy ingenua y simple que se puede mejorar mucho:

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];
}

Pruebas:

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

Oye, eso está bastante bien. Tiene un error de aproximadamente 3.333 * 10 ^ (- 6) que no es suficiente para que se redondee hacia abajo ... está cerca.

Solo por diversión:

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

Oh bien; entonces no es el mejor.

Y en un caso de prueba aleatorio del generador:

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]

¡Con un error de solo aproximadamente 0.32305!

Esto se puede mejorar mucho usando algo como la integración de Verlet o algún algoritmo sofisticado. De hecho, esos algoritmos pueden incluso obtener puntajes perfectos, a pesar de ser simulaciones.