Вступление

ТЛ; др

Постоянно выводить текущее расстояние от Земли до Солнца.

Упрощенно, орбита Земли вокруг Солнца является эллипсом. Таким образом, фактическое расстояние между ними постоянно меняется. Это расстояние можно рассчитать для любого данного дня, используя эту формулу :

Уравнение можно разбить на следующие части ² :

• 1представляет 1 AU (астрономическая единица), равно149,597,870.691 km
• 0.01672это орбитальный эксцентриситет между Землей и Солнцем
• cosконечно функция косинуса, но с аргументом в градусах, а не в радианах
• 0.9856составляет 360 ° / 365,256363 дней , полный оборот за один год, где 365.256363длина сидерического года, в средних солнечные дни
• day это день года [1-365]
• 4представляет смещение перигелия , которое находится между 4 и 6 января

Формула занимает целый день, но для решения этой задачи - непрерывного вывода - вам нужно быть более точным; или ничего особенного не произойдет до следующего дня. Просто добавьте процент прошедшего времени к текущему дню, например ¹ :

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

Несколько примеров:

• 1 января 23:59:59 1.99998842592593
• 1 января, 18:00:00 1.75
• 1 января, 12:00:00 1.50
• 1 января, 06:00:00 1.25

вход

Этот вызов не имеет вклада.

Если ваш язык не может получить текущее время, вы можете получить его в качестве входных данных для вашей программы. Допустимые входные данные - это метки времени или полные строки даты и времени, которые лучше всего подходят для языка. Прохождение текущего дня в одиночку (например, 55 января или 5.25в тот же день в 6 часов) не допускается.

Выход

Выведите текущее расстояние от Земли до Солнца:

• Выведите значение в km.
• Обновите значение по крайней мере каждую секунду .

Пример вывода:

152098342

Если это не увеличивает количество байт, вы также можете распечатать результат:

152,098,342
152,098,342 km

Требования

• Вы можете написать программу или функцию. Если это анонимная функция, пожалуйста, включите пример того, как ее вызвать.
• Это код-гольф, поэтому выигрывает самый короткий ответ в байтах.
• Стандартные лазейки запрещены.

Пример реализации

Я подготовил пример реализации в JavaScript. Это ни соревнование, ни игра в гольф.

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

_{¹ Чтобы не чрезмерно увеличивать сложность, вам не нужно переводить местное время в UTC. Если вы используете UTC, пожалуйста, добавьте примечание к вашему ответу.}

_{² Более подробную информацию см. В разделе « Расстояние Земля-Солнце в определенный день года» в разделе « Физика».}

TI-BASIC, 38 байт

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

Для калькулятора серии TI-84 +. Назовите это prgmA. Обратите внимание, что это переполняет стек после нескольких тысяч итераций; используйте While 1:...:Endвместо этого, если это проблема, для двух дополнительных байтов.

При этом для справки используется перигелий 1 января 1997 года, 23:16 UTC, и с точностью до нескольких десятков километров (около 7 цифр точности) в течение следующих нескольких лет.

Ява - 185 180 байт

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

При этом используется тот факт, что в дне 86 400 секунд, и используется местное время, а не время по Гринвичу. Вывод происходит гораздо чаще, чем раз в секунду. Не уверен, что операторы импорта должны быть включены в число байтов.

Для включения задержки в 1 секунду добавляется около 26 байтов, например

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

Ява определенно не самый подходящий для игры язык. :)

Удалено несколько байтов благодаря @insertusernameherehere

Python, 101 байт

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

345600 = 4 * 24 * 3600 (четыре дня)

5022635,53 ≌ (365,256363 * 24 * 3600) / (2π) (секунды в году / 2π)

Bash / coreutils / bc, 101 байт

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

Это вычисляет смещение от 4 января в секундах, поэтому использует соответствующую константу для преобразования в радианы. Пол года превращается примерно в пи:

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

Остальная часть расчета прямо из вопроса.

F #, 178 байт

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

Это скрипт F #, который хорошо работает в F # Interactive. Для простоты требование «непрерывного вывода» перенесено на буквальный уровень, хотя я потерял байт, чтобы выводить вывод на новую строку каждую итерацию, чтобы он не был слишком плохим. = Р

Разгромил и объяснил:

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 байт

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

объяснение

{DateValue@"Year",1,5}представляет 5 января этого года, и ...~DateDifference~...дает временную дистанцию.

Dynamic[...,UpdateInterval->1] обновлять выражение один раз в секунду.

Pyth, 51 байт

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

Альтернативная формула

d / AU = 1 - 0,01672 cos (2π [время с перигелия] / [орбитальный период])
Эта формула, по сути, такая же, как формула OP, за исключением того, что она обобщена, чтобы иметь возможность использовать любой перигелий в качестве контрольной даты.

Формула OP имеет [время с перигелия] как (день - 4) и имеет (2π рад / [орбитальный период]), предварительно рассчитанный как 0,9856 градусов в день.

В моем решении я использую перигелий ближе всего к эпохе Unix, 2 - ^го января 1970 года.

Код

Собранный вручную в питонический псевдокод:

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

По сути, это просто превращение следующей формулы в код:
d = (1 - 0,01672 cos (2π (t - 86400) / 31558149)) * 149597870.691,
где t - время Unix.

Python 2,4 - 158 байт

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

Занимает местное время и выплевывает расстояние. time.localtime () возвращает кортеж и на него можно ссылаться здесь .

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