Neredeyse kütlesiz bir kedi, (x, y, z)hızda bir noktada uzaya düşüyor (bir uzay giysisi ve her şeyle endişelenmeyin) (vx, vy, vz). Noktada sabit, sonsuz yoğun bir gezegen (0 hacmi ile) vardır (0, 0, 0)ve nesneleri rivmeli olarak uzaktan çeker 1/r^2. Newton yer çekimine göre, nesne zaman sonra nereye gidiyor t?

Bu durumda neredeyse kütlesiz değeri çıktısını aldığınız anlamına gelir lim (mass --> 0) <position of cat>. Kütle gezegenin yer çekiminden etkilenir, ancak gezegen kedinin yerçekiminden etkilenmez. Başka bir deyişle, merkezi beden sabittir.

Bu Code Golf'e biraz benziyor : Uzay gemisinin kaderi nedir? [kayan noktalı sürüm] , ancak doğruluk ölçtüğü için bu farklı.

3 saniyeden daha kısa sürede çalışması gereken bir simülasyona dayalı bir çözüm uygulayabilirsiniz, VEYA tam bir değer veren bir program da uygulayabilirsiniz (ayrıca 3 saniyeden daha kısa sürede çalıştırılmalıdır). Aşağıdaki puanlama ayrıntılarına bakın. Bir simülasyon uygularsanız, kesin olması gerekmez, ancak yanlışlık nedeniyle puanınız daha düşük olacaktır.

Girdi : x y z vx vy vz tmutlaka x, y, z koordinatlarını, x, y ve z yönlerindeki hızı ve zamanı temsil eden tam sayılar olmak zorunda değildir. Kedinin hızının, o irtifadaki kaçış hızından kesinlikle daha düşük olduğu garanti edilir. Bir işleve parametreler dahil olmak üzere giriş her yerden alınabilir. Program dizüstü bilgisayarımda üç saniyeden daha kısa sürede çalışmalı t < 2^30, yani bir simülasyon çalıştırıyorsanız, zaman testinizi buna göre ayarlamanız gerekir. Her test durumu için 3 saniyelik sınıra ulaşmayı planlıyorsanız, bilgisayarımda üç saniye içinde çalışmasını sağlamak için hız kazançları için daha doğru / daha az doğru hale getirebilecek ayarlanabilir bir parametre olduğundan emin olun.

Çıktı :, x y zsüre sonra konum t.

İki cisim problemi mükemmel bir şekilde çözülebildiğinden teorik olarak mükemmel ve doğru bir cevap almak mümkündür.

Puanlama : Herhangi bir test durumunda, hata, çıktınız ile "doğru" çıktı arasındaki mesafe olarak tanımlanır. Gerçek çıktı, test senaryosu snippet'inin ürettiği çıktı olarak tanımlanır. Hata daha küçükse 10^(-8), hata sıfıra yuvarlanır. Puanınız 100 (veya daha fazla) rastgele test vakasındaki ortalama hatadır. Kusursuz bir cevap yazarsanız, 0 puan almalısınız; en düşük puan kazanır ve bağlar kod uzunluğuna göre kesilir.

Test senaryoları :

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

Bu durumda, yörünge periyot 2 * pi ile mükemmel daireseldir, bu nedenle 159154943 kez daire çizdikten sonra kedi yaklaşık olarak (0.83789, -0.54584) biter. Bu, kodunuzun test edileceği bir test durumu değildir; bununla birlikte, kusursuz bir cevap gönderirseniz, bu konuda test etmek isteyebilirsiniz.

Aşağıdaki pasaj rastgele ek test senaryoları oluşturur ve gönderimleri yargılamak için kullanılacaktır; bununla ilgili bir hata varsa bana bildirin:

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, tam, 186 bayt

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

Bu, Jesper Göranssonhis, “Kepler probleminin simetrileri”, 2015'e dayanan bir formül kullanarak kesin bir çözüm . Kapalı form çözümü olmayan Trans + B cos x + C sin x = D aşkın denklemini çözmek için ikili bir arama kullanır.

İşlev, NumPy dizileri olarak iletilecek konum ve hızın beklemesini bekler:

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

Bu sadece topun yuvarlanması içindir, çünkü kimse cevap göndermiyor gibi görünüyor. İşte çok geliştirilebilecek çok saf ve basit bir yol:

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

Test yapmak:

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

Hey, bu oldukça iyi. Yuvarlanması için yeterli olmayan yaklaşık 3.333 * 10 ^ (- 6) hatası var ... yakın.

Sadece eğlence için:

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

Oh iyi; bu yüzden en iyisi değil.

Ve jeneratörden rastgele bir test durumunda:

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]

Sadece yaklaşık 0.32305 hata ile!

Verlet entegrasyonu veya süslü algoritma gibi bir şey kullanarak bu çok geliştirilebilir. Aslında, bu algoritmalar simülasyonlara rağmen mükemmel puanlar bile alabilir.