Почти безмассовый кот упал в космос (не волнуйтесь, с скафандром и всем остальным) в точке (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.

Поскольку проблема двух тел может быть полностью решена, теоретически можно получить идеальный, правильный ответ.

Оценка : для любого тестового случая ошибка определяется как расстояние между вашим выходом и «истинным» выходом. Истинный вывод определен как тот, который генерирует фрагмент теста. Если ошибка меньше чем 10^(-8), ошибка округляется до нуля. Ваша оценка - это средняя ошибка на 100 (или более) случайных тестовых случаях. Если вы напишите совершенно точный ответ, вы должны получить оценку 0; выигрывает наименьшее количество очков, и связи будут нарушены по длине кода.

Тестовые случаи :

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

В этом случае орбита идеально круглая с периодом 2 * пи, поэтому после оборота 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

Это точное решение с использованием формулы I, разработанной на основе Йеспера Йоранссониса, «Симметрии задачи Кеплера», 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])

Javascript

Это просто для того, чтобы начать работать, так как никто, кажется, не публикует ответы. Вот очень наивный, простой способ, который можно значительно улучшить:

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 или какой-нибудь необычный алгоритм. Фактически, эти алгоритмы могут даже получить отличные результаты, несмотря на то, что они являются симуляциями.