Giriş

tl; Dr.

Dünyadan Güneş'e olan mevcut mesafeyi sürekli olarak verin.

Basitleştirilmiş, Dünya'nın Güneş çevresindeki yörüngesi bir elipstir. Yani ikisi arasındaki gerçek mesafe sürekli değişiyor. Bu mesafe, bu formül kullanılarak herhangi bir gün için hesaplanabilir :

Denklem aşağıdaki bölümlere ayrılabilir ² :

• 1temsil 1 AB (astronomik birim), eşittir149,597,870.691 km
• 0.01672olan yörünge basıklık Dünya ile Güneş arasındaki
• coselbette kosinüs işlevidir, ancak radyan yerine derece cinsinden argümanla
• 0.9856olan 360 ° / 365,256363 gün , bir yıl içinde tam bir rotasyon, 365.256363ortalama güneş günde bir yıldız yıl boyu,
• day yılın günü [1-365]
• 44 - 6 Ocak arasındaki perihelion ofsetini temsil eder

Formül bir gün sürer, ancak bu zorluğun amacı için - sürekli bir çıktı - daha doğru olmalısınız; ya da ertesi güne kadar çok şey olmayacak. Geçmiş zamanın yüzdesini geçerli güne ekleyin, örneğin ¹ :

day + (h * 3600 + m * 60 + s) / 864 / 100

Birkaç Örnek:

• 1 Ocak, 23:59:59 1.99998842592593
• 1 Ocak, 18:00:00 1.75
• 1 Ocak, 12:00:00 1.50
• 1 Ocak, 06:00:00 1.25

Giriş

Bu zorluğun girdisi yok.

Diliniz geçerli saati alamıyorsa, bunu programınıza girdi olarak alabilirsiniz. Geçerli girdiler, zaman damgaları veya dile en uygun tam tarih-saat dizeleridir . Geçerli günün tek başına geçmesine ( 55 Ocak veya 5.25aynı gün saat 6'da olduğu gibi) izin verilmez.

Çıktı

Dünya ile Güneş arasındaki geçerli mesafeyi çıktılayın:

• Değeri çıktı olarak girin km.
• Değeri en az saniyede bir güncelleyin .

Örnek çıktı:

152098342

Bayt sayınızı artırmazsa, sonucu da güzel yazdırabilirsiniz:

152,098,342
152,098,342 km

Gereksinimler

• Bir program veya işlev yazabilirsiniz. Anonim bir işlevse, lütfen onu nasıl çağıracağınıza ilişkin bir örnek ekleyin.
• Bu kod-golf çok kısa bayt kazanır cevap.
• Standart boşluklara izin verilmez.

Örnek uygulama

JavaScript'te örnek bir uygulama hazırladım. Ne rekabetçi ne de golf.

// dayOfYear from http://stackoverflow.com/a/8620357/1456376
Date.prototype.dayOfYear = function() {
    var j1= new Date(this);
    j1.setMonth(0, 0);
    return Math.round((this-j1)/8.64e7);
}

// vars
var e = document.getElementById('view'),
    au = 149597870.691,
    deg2rad = Math.PI/180,
    date = now = value = null;

// actual logic
function calculate() {
    date = new Date();
    now = date.dayOfYear() + (date.getHours() * 3600 + date.getMinutes() * 60 + date.getSeconds()) / 864 / 100;
    value = 1 - 0.01672 * Math.cos(deg2rad * 0.9856 * (now - 4));
    // supported in Firefox and Chrome, unfortunately not in Safari
    e.innerHTML = Math.round(value * au).toLocaleString('en-US') + ' km';

    setTimeout(calculate, 1000);
}

// let's do this
calculate();

<div id="view"></div>

_{¹ Karmaşıklığı makul olmayan bir şekilde arttırmamak için yerel saatinizi UTC'ye dönüştürmeniz gerekmez. UTC kullanıyorsanız lütfen cevabınıza bir not ekleyin.}

_{² Daha fazla ayrıntı için Physics'teki " yılın belirli bir gününde Dünya-Güneş mesafesi " konusuna bakın.}

TI-BASIC, 38 bayt

Disp 25018086(59.8086-cos(5022635.4⁻¹checkTmr(83761
prgmA

TI-84 + serisi hesap makinesi için. Bunu adlandırın prgmA. Bunun birkaç bin yinelemeden sonra yığını taştığını unutmayın; While 1:...:Endiki ek bayt için bu bir sorunsa bunun yerine bir kullanın.

Bu, referans için 1 Ocak 1997, 23:16 UTC'de perihelion kullanır ve önümüzdeki birkaç yıl için birkaç düzine kilometre (yaklaşık 7 basamak doğruluk) içinde doğrudur.

Java - 185180 bayt

static void d(){while(true){System.err.println(149597870.691*(1-.01672*Math.cos(Math.toRadians(.9856*(Calendar.getInstance().get(6)+LocalTime.now().toSecondOfDay()/8.64e4-4)))));}}

Bu, günde 86.400 saniye olduğu gerçeğini kullanır ve GMT yerine yerel saati kullanıyor. Çıktı saniyede bir kereden fazla olur. Alma ifadelerinin bayt sayısına dahil edilmesi gerekip gerekmediğinden emin değilim.

1 saniyelik bir gecikme eklemek için yaklaşık 26 bayt eklenir;

static void d(){try{while(true){System.err.println(149597870.691*((1-.01672*Math.cos(Math.toRadians(.9856*(Calendar.getInstance().get(6)+LocalTime.now().toSecondOfDay()/8.64e4-4)))));Thread.sleep(1000L);}}catch(Exception e){}}

Java kesinlikle en golf edilebilir dil değildir. :)

@İnsertusernamehere sayesinde birkaç bayt kaldırıldı

Python, 101 bayt

import time,math
a=149597870.691
while 1:print(a-a*.01672*math.cos((time.time()-345600)/5022635.53))

345600 = 4 * 24 * 3600 (dört gün)

5022635.53 ≌ (365.256363 * 24 * 3600) / (2π) (yıl / 2π saniye)

Bash / coreutils / bc, 101 bayt

#!/bin/bash
bc -l <<<"149597870.691*(1-.01672*c((`date +%s`-`date -d 4-Jan +%s`)/5022635.5296))"
sleep .5
exec $0

Bu, 4 Ocak'tan itibaren ofseti saniye cinsinden hesaplar, bu nedenle radyanlara dönüştürmek için karşılık gelen bir sabit kullanır. Yarım yıl kabaca pi'ye dönüşür:

$ bc -l <<<"(365.256363/2*86400)/5022635.5296"
3.14159265361957033371

Hesaplamanın geri kalanı doğrudan sorudan.

F #, 178 bayt

open System
Seq.initInfinite(fun _->
let n=DateTime.Now
(1.-0.01672*Math.Cos(0.0172*((n-DateTime.Today).TotalDays+float(n.DayOfYear-4))))*149597870.691)|>Seq.iter(printfn"%f")

Bu F # Interactive'de iyi çalışan bir F # betiğidir. Basitlik adına, "sürekli çıktı" gereksinimi gerçek seviyelere alınır, ancak her yinelemede yeni bir satıra çıktı yazdırmak için bir bayt kaybettim, böylece çok kötü . P =

Açık ve açık:

Seq.initInfinite (fun _ ->            // Create an infinite sequence, with each element being defined by the following function
    let n = DateTime.Now
    let dayOffset = n.DayOfYear - 4   // Day of year returns the day as a number between 1 and 366
    let today = n - DateTime.Today    // Extract the current day, so the hours, minutes and all
    let partialDay = today.TotalDays  // Get the value of 'today' as a floating point number of days
                                      // so between 0 and 1 in this case - exactly what I needed
    // And now, the formula - note that 0.9856 has been combined with the conversion from degrees to radians, giving 0.0172
    (1. - 0.01672 * Math.Cos (0.0172 * (partialDay + float dayOffset))) * 149597870.691
)
|> Seq.iter (fun i -> printfn "%f" i) // For each of the (infinity of) numbers, print it

Mathematica, 97 bayt

Dynamic[1496*^5-2501*^3Cos[.9856#&@@Now~DateDifference~{DateValue@"Year",1,4}],UpdateInterval->1]

açıklama

{DateValue@"Year",1,5} bu yıl 5 Ocak'ı temsil ediyor ve ...~DateDifference~... zamansal mesafeyi veriyor.

Dynamic[...,UpdateInterval->1] ifadeyi saniyede bir güncelleyin.

Pyth, 51 bayt

#*149597870.691-1*.01672.t*c-.dZ86400 31558149*2.nZ1

Alternatif formül

d / AU = 1 - 0.01672 cos (2π [perihelion'dan beri geçen süre] / [orbital dönem])
Bu formül, herhangi bir perihelionun referans tarih olarak kullanılabilmesi için genelleştirilmesi dışında, esas olarak OP'nin formülü ile aynıdır.

OP formülü [periheliondan beri geçen süre] (gün - 4) olarak ve önceden (2π rad / [orbital dönem]) 0.9856 derece / gün olarak hesaplanmıştır.

Benim çözümde ben Unix çağın, 2 yakın Güneş'e en yakın noktaya kullanıyorum ^nd Ocak 1970.

Kod

Pythonic sözde koduna elle derlendi:

#                        while 1:
  *149597870.691             print( 149597870.691 * (                 # implicit print
    -1                           1 - (
      *.01672                        0.1672 * (
        .t                               trigo(
          *                                  multiply(
            c                                    divide(
              -.dZ86400                              unixTime-86400,
              31558149                               31558149
                                                 ),
            *2.nZ                                2*pi
                                             ),
          1                                  1                        # 1 means cos
                             )))))

Bu aslında aşağıdaki formülü koda dönüştürüyor:
d = (1 - 0.01672 cos (2π (t - 86400) / 31558149)) * 149597870.691,
burada t Unix zamanıdır.

Python 2.4-158 bayt

import time,math
while 1:t=time.localtime();print(int(149597870.691*(1-.01672*math.cos(math.radians(.9856*(t[7]+(t[3]*3600+t[4]*60+t[5])/864.0/100.0-4))))))

Yerel saati alır ve mesafeyi tükürür. time.localtime () bir tuple döndürür ve buraya başvurulabilir .

C, 338

#include <stdio.h>
#include <time.h>
#include <math.h>
int main ()
{
  time_t rt;
  struct tm * ti;
  while(1) {
  time(&rt);
  ti = localtime(&rt);
  double d = 1.0 - .01672*cos(0.0174533 * .9856*((ti->tm_yday + (ti->tm_hour * 3600.0 + ti->tm_mday * 60.0 + ti->tm_sec) / 86400.0) - 4));
  printf ("%f\n", d * 149598000.0);}
}