一只几乎没有质量的猫在(x, y, z)速度点上坠落在太空中（不用担心，有了宇航服和所有东西）(vx, vy, vz)。在该点有一个固定的，无限密集的行星（体积为0），(0, 0, 0)它r以加速度吸引远处的物体1/r^2。根据牛顿引力，物体在时间之后会流向何处t？

在这种情况下，几乎无质量表示您正在输出的值lim (mass --> 0) <position of cat>。质量受行星重力的影响，但行星不受猫重力的影响。换句话说，中央主体是固定的。

这有点类似于Code Golf：太空船的命运是什么？[浮点版本]，但这有所不同，因为它测量的是精度。

您可以实施基于仿真的解决方案，该方案必须在3秒以内运行，或者您可以实施提供准确值的程序（也必须在3秒以内运行）。请参阅下面的评分详情。如果您执行模拟，则不一定要精确，但是由于不准确，您的分数会降低。

输入：x y z vx vy vz t，不一定是分别表示x，y，z坐标，分别在x，y和z方向上的速度和时间的整数。可以保证猫的速度严格小于该高度下的逃逸速度。输入可以从任何地方进行，包括函数的参数。对于，该程序必须在我的笔记本电脑上运行不到三秒钟t < 2^30，这意味着，如果您正在运行模拟，则必须相应地调整时间步长。如果您打算为每个测试用例都达到3秒的限制，请确保有一个可调整的参数，该参数可使速度提高更为准确/不太准确，以便我可以在计算机上运行三秒钟。

输出：x y z，时间后的位置t。

由于两体问题可以完美解决，因此从理论上讲有可能获得完美，正确的答案。

计分：对于任何测试用例，错误定义为输出与“ true”输出之间的距离。真正的输出定义为测试用例代码段生成的输出。如果误差小于10^(-8)，则将误差四舍五入为零。您的分数是100个（或更多）随机测试用例的平均错误。如果您写出的答案非常准确，您的分数应为0；否则，您的分数为0。得分最低的获胜者，并且按码长打破平局。

测试用例：

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

在这种情况下，轨道是周期为2 * pi的完美圆形，因此，在绕转159154943次后，猫的视线约为（0.83789，-0.54584）。这不是测试您的代码的测试用例；但是，如果您提交的答案非常准确，则可能需要对此进行测试。

下面的代码片段会随机生成其他测试用例，并将用于判断提交的内容；让我知道是否存在错误：

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，准确，186个字节

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

这是一个精确的解决方案，使用的是我根据JesperGöranssonhis设计的公式“开普勒问题的对称性”，2015年。它使用二进制搜索来求解先验方程Ax + B cos x + C sin x = D，该方程没有闭式解。

该函数期望位置和速度作为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])

Java脚本

这只是为了使事情顺利进行，因为似乎没有人发布答案。这是一种非常幼稚的简单方法，可以进行很多改进：

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

测试：

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

嘿，那很好。它具有大约3.333 * 10 ^（-6）的错误，不足以将其四舍五入...很接近。

只是为了好玩：

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

那好吧; 所以这不是最好的。

在生成器的随机测试案例中：

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]

仅具有大约0.32305的误差！

通过使用诸如Verlet集成或某些奇特的算法，可以大大改善这一点。实际上，尽管是模拟，但这些算法甚至可能获得满分。