Einführung

tl; dr

Kontinuierliche Ausgabe der aktuellen Entfernung von der Erde zur Sonne.

Vereinfacht ausgedrückt ist die Erdumlaufbahn um die Sonne eine Ellipse. Der tatsächliche Abstand zwischen beiden ändert sich also ständig. Diese Distanz kann für einen bestimmten Tag nach folgender Formel berechnet werden :

Die Gleichung kann in die folgenden Teile ^{2 aufgeteilt werden} :

• 1entspricht 1 AE (astronomische Einheit)149,597,870.691 km
• 0.01672ist die Exzentrizität der Umlaufbahn zwischen Erde und Sonne
• cosist natürlich die Kosinusfunktion, aber mit Argumenten in Grad und nicht im Bogenmaß
• 0.9856beträgt 360 ° / 365,256363 Tage , eine volle Umdrehung in einem Jahr, wobei 365.256363die Länge eines Sternjahres in mittleren Sonnentagen ist
• day ist der Tag des Jahres [1-365]
• 4stellt den Versatz zum Perihel dar , der zwischen dem 4. und 6. Januar liegt

Die Formel dauert einen ganzen Tag, aber für diese Herausforderung - eine kontinuierliche Ausgabe - müssen Sie genauer sein; oder bis zum nächsten Tag wird nicht viel passieren. Fügen Sie einfach den Prozentsatz der vergangenen Zeit zum aktuellen Tag hinzu, z. B. ¹ :

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

Einige Beispiele:

• 1. Januar, 23:59:59 1.99998842592593
• 1. Januar, 18:00:00 Uhr 1.75
• 1. Januar, 12:00:00 1.50
• 1. Januar, 06:00:00 1.25

Eingang

Diese Herausforderung hat keine Eingabe.

Wenn Ihre Sprache die aktuelle Zeit nicht abrufen kann, können Sie sie als Eingabe für Ihr Programm verwenden. Gültige Eingaben sind Zeitstempel oder vollständige Datums- / Uhrzeitzeichenfolgen , die der Sprache am besten entsprechen. Das Übergeben des aktuellen Tages allein (wie am 55. Januar oder 5.25am selben Tag um 6 Uhr) ist nicht erlaubt.

Ausgabe

Geben Sie die aktuelle Entfernung von der Erde zur Sonne aus:

• Den Wert in ausgeben km.
• Aktualisieren Sie den Wert mindestens jede Sekunde .

Beispielausgabe:

152098342

Wenn es Ihre Byteanzahl nicht erhöht, können Sie das Ergebnis auch hübsch ausdrucken:

152,098,342
152,098,342 km

Bedarf

• Sie können ein Programm oder eine Funktion schreiben. Wenn es sich um eine anonyme Funktion handelt, geben Sie bitte ein Beispiel für den Aufruf an.
• Dies ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes.
• Standardlücken sind nicht zulässig.

Beispielimplementierung

Ich habe eine Beispielimplementierung in JavaScript vorbereitet. Es ist weder wettbewerbsfähig noch golfen.

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

_{¹ Um die Komplexität nicht unangemessen zu erhöhen, müssen Sie Ihre Ortszeit nicht in UTC umrechnen. Wenn Sie UTC verwenden, fügen Sie Ihrer Antwort eine Notiz hinzu.}

_{² Weitere Informationen finden Sie unter " Erde-Sonne-Abstand an einem bestimmten Tag des Jahres " bei Physik}

TI-BASIC, 38 Bytes

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

Für einen Taschenrechner der Serie TI-84 +. Nennen Sie das prgmA. Beachten Sie, dass der Stapel nach einigen tausend Iterationen überläuft. Verwenden Sie While 1:...:Endstattdessen ein, wenn dies ein Problem ist, für zwei zusätzliche Bytes.

Dies verwendet das Perihel am 1. Januar 1997, 23:16 UTC als Referenz und ist in den nächsten Jahren auf einige Dutzend Kilometer genau (ungefähr 7 Stellen Genauigkeit).

Java - 185 180 Bytes

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

Dies nutzt die Tatsache, dass ein Tag 86.400 Sekunden hat und die Ortszeit verwendet, nicht GMT. Die Ausgabe erfolgt viel häufiger als einmal pro Sekunde. Nicht sicher, ob Importanweisungen in die Byteanzahl einbezogen werden sollen.

Um eine Verzögerung von 1 Sekunde einzuschließen, werden etwa 26 Bytes hinzugefügt, z

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 ist definitiv nicht die golferischste Sprache. :)

Einige Bytes dank @insertusernamehere entfernt

Python, 101 Bytes

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

345600 = 4 * 24 * 3600 (vier Tage)

5022635.53 ≌ (365.256363 * 24 * 3600) / (2π) (Sekunden im Jahr / 2π)

Bash / Coreutils / BC, 101 Bytes

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

Dies berechnet den Versatz vom 4. Januar in Sekunden und verwendet eine entsprechende Konstante, um in Bogenmaß umzurechnen. Ein halbes Jahr rechnet sich in ungefähr pi um:

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

Der Rest der Berechnung ergibt sich direkt aus der Frage.

F #, 178 Bytes

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

Dies ist ein F # -Skript, das in F # Interactive gut ausgeführt wird. Der Einfachheit halber wird die Anforderung der "kontinuierlichen Ausgabe" auf ein wörtliches Niveau gebracht, obwohl ich bei jeder Iteration ein Byte verloren habe, um die Ausgabe in einer neuen Zeile zu drucken, damit sie nicht zu schlecht ist. = P

Ungolfed und erklärte:

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 Bytes

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

Erläuterung

{DateValue@"Year",1,5}stellt den 5. Januar dieses Jahres dar und ...~DateDifference~...gibt die zeitliche Distanz an.

Dynamic[...,UpdateInterval->1] Aktualisieren Sie den Ausdruck einmal pro Sekunde.

Pyth, 51 Bytes

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

Alternative Formel

d / AU = 1 - 0,01672 cos (2π [Zeit seit Perihel] / [Umlaufzeit])
Diese Formel entspricht im Wesentlichen der OP-Formel, mit der Ausnahme, dass verallgemeinert wird, dass jedes Perihel als Bezugsdatum verwendet werden kann.

Die OP-Formel hat [Zeit seit Perihel] als (Tag - 4) und (2π rad / [Umlaufzeit]) als 0,9856 Grad / Tag vorberechnet.

In meiner Lösung verwende ich das Perihel am nächsten an die Unix - Epoche, 2 ^nd Januar 1970.

Der Code

Handkompilierter pythonischer Pseudocode:

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

Dies ist im Wesentlichen nur das
Umwandeln der folgenden Formel in Code: d = (1 - 0,01672 cos (2π (t - 86400) / 31558149)) * 149597870.691
wobei t die Unix-Zeit ist.

Python 2.4 - 158 Bytes

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

Nimmt die Ortszeit und spuckt die Entfernung aus. time.localtime () gibt ein Tupel zurück und kann hier referenziert werden .

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