介绍

tl; dr

连续输出当前从地球到太阳的距离。

简化地说，地球绕太阳的轨道是椭圆形的。因此两者之间的实际距离在不断变化。可以使用以下公式针对任何给定日期计算此距离：

该方程可被分成以下几部分²：

• 1代表1 AU（天文单位），等于149,597,870.691 km
• 0.01672是地球和太阳之间的 轨道偏心率
• cos当然是余弦函数，但是参数是度数而不是弧度
• 0.9856是360°/ 365.256363天，一年中的完整旋转，这365.256363是恒星年的长度，以平均太阳日为准
• day 是一年中的一天 [1-365]
• 4代表距近日点的偏移量，它在1月4日至6日之间

公式需要一整天，但要解决这一挑战（持续输出），您必须更加准确；否则直到第二天什么事情都不会发生。只需将过去时间的百分比添加到当天，例如¹：

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

几个例子：

• 1月1日，23：59：59 1.99998842592593
• 1月1日，18：00：00 1.75
• 1月1日，12：00：00 1.50
• 1月1日，06：00：00 1.25

输入值

这个挑战没有投入。

如果您的语言无法获取当前时间，则可以将其作为程序的输入。有效输入是最适合该语言的时间戳或完整的日期时间字符串。仅通过当天（例如51月5日或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如果有问题，请代替两个额外的字节。

它以1997年1月1日世界标准时间（UTC）的近日点为参考，并且在接下来的几年内精确到几十公里以内（大约7位数）。

Java- 185180字节

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秒，并且使用的是当地时间，而不是GMT。输出每秒发生一次以上。不知道在字节数中是否应包含导入语句。

要包括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){}}

Java绝对不是最适用的语言。:)

感谢@insertusernamehere，删除了几个字节

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

它以秒为单位计算从1月4日开始的偏移量，因此使用相应的常数转换为弧度。半年约等于pi：

$ 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＃Interactive中运行良好的F＃脚本。为简单起见，尽管我确实丢失了一个字节以使输出在每次迭代时都在新行上打印，但“连续输出”的要求被带到了文字水平，因此并不太可能不错。= P

脱节并解释：

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} 表示今年1月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的公式具有[自近日起的时间]为（day-4），并且具有（2πrad / [轨道周期]）的预先计算为0.9856deg / day。

在我的解决方案，我用最接近Unix纪元，2近日点^次 1970年1月。

代码

手工编译为pythonic伪代码：

#                        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（）返回一个元组，可以在这里引用。

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