Sleep for 1000 years

Question

Some sleep commands implement a delay of an integer number of seconds. However, 2³² seconds is only about 100 years. Bug! What if you need a larger delay?

Make a program or a function which waits for 1000 years, with an error of less than ±10%. Because it's too time-consuming to test, please explain how/why your solution works! (unless it's somehow obvious)

You don't need to worry about wasting CPU power - it can be a busy-loop. Assume that nothing special happens while your program waits - no hardware errors or power failures, and the computer's clock magically continues running (even when it's on battery power).

What the solution should do after the sleep is finished:

• If it's a function: return to caller
• If it's a program: terminate (with or without error) or do something observable by user (e.g. display a message or play a sound)

Answer 1

MATL, 6 5 bytes

35WY.

This waits for 34359738368 seconds, which is a little more than 1089 years and a half.

Don't try it online!

Explanation

35     % Push 35
W      % 2 raised to that. Gives 34359738368
Y.     % Pause for that many seconds

Answer 2

C (gcc), 40 36 32 29 26 24 bytes

i;f(){--i&&f(sleep(7));}

Try it online!

-3 thanks to @gastropner.

-1 recursive approach thanks to @AZTECCO.

4294967295*7/86400/365.25 ~ 952.69

Answer 3

Python 3 (Excluding CPython on Windows), 28 bytes

import time
time.sleep(3e10)

Try it online! (Remember to put something in your will so future generations can check that it ended on time.)

time.sleep(seconds) takes either an int or a float.

1000*365.2422*24*60*60/3e10 == 1.051897536 which is an error of less than 10%.

Answer 4

bash, 26 bytes

I think part of the challenge here is to not have a signed 32 bit overflow, so:

ping -i86400 -c365243 t.co

The idea here is to make 1000 years of pings (365243), once per day (86400).

"t.co" is simply a four character internet hostname (in this case, a link shortener). If your local host table has a one character hostname, you can subtract 3 bytes.

Answer 5

Ruby, 10 bytes

sleep 3e10

Try it online!

There are approximately \$3*10^{10}\$ seconds in a thousand years.

Answer 6

PowerShell, 35 32 24 21 19 bytes

1..3e4|%{sleep 1mb}

Try it online!

Strangely, the maximum seconds value for Start-Sleep is 2147483. No, I don't know why it's such an odd value. That works out to a little over 2 megabytes (2097152). 1mb * 30000 / 86400 / 365.25 is 996.821051030497, so a little under 1000 years. I could get more exact using a different value than 3e4, but this is within the allowed margin and I'm lazy.

Saved 3 bytes thanks to ceilingcat.
Saved 8 bytes thanks to Jeff Zeitlin.
Saved 3 bytes thanks to Neil.
Saved 2 bytes thanks to Mark Henderson and Nahuel Fouilleul.

Answer 7

6502 Machine Code on an Apple II, 10 9 bytes

Code is actually platform-independent, other than it relies on the Apple's clock speed of 1.023 MHz for timing.

Code starts at address 0x0000:

0000: A2 CA F6 44 F0 FB D0 F8 F7

Saved an additional byte. Details are below original answer.

Original answer:

Code starts at address 0x0059:

0059: A2 08 F6 60 D0 FA CA D0 F9 F5

Disassembly:

loop1: 0059- A2 nn     LDX #$nn   ; 2 cyc
loop2: 005B- F6 60     INC $60,X  ; 6 cyc
       005D- D0 FA     BNE loop1  ; 2-3 cyc
       005F- CA        DEX        ; 2 cyc
       0060- D0 F9     BNE loop2  ; 2-3 cyc
       0062- pp        DB  $pp    ; data byte

This is a fairly simple routine that increments a multi-byte counter. When the counter rolls over, the last branch instruction gets modified so that it points to an RTS instruction, which provides the exit for the routine.

loop1 is taken for each increment of the counter and takes 11 cycles per iteration. loop2 is taken for each byte carried over and takes 13 cycles per iteration. So if we increment the counter N times, we spend approximately:

11*N + 13*(1/256 + 1/(256^2) + 1/(256^3) + ...)*N = 11.05*N cycles

1000 years is 365242*86400*1023000 = 32282717702400000 cycles

So we need N = 2921512914244345 +/- 10%

Or a range of 2629361622819911 - 3213664205668779
= 0x095763F583A447 - 0x0B6ACF816801AB

In the code above, set pp = 0xF5 and nn = 0x08.

This gives us a 7-byte counter in memory locations 0x62-0x68 (with MSB at lowest address, i.e. big endian). Only location 0x62 is initialized, so our starting counter value could be anywhere from 0xF5000000000000 to 0xF5FFFFFFFFFFFF.

We'll increment the counter until it rolls over to 0, which will cause the byte at 0x61 to increment by 1, which happens to be the branch target for loop2. On the first byte carry after rollover-- when the counter hits 0x100-- we'll hit the modified branch instruction for the first time. This will take us to address 0x5C (loop2+1). The 0x60 byte there is the opcode for "Return from Subroutine" (RTS) which provides our exit.

So our total loop count is between, 0x0A000000000101 and 0x0B000000000100, which is a subset of the range we calculated which gives us the necessary number of cycles +/- 10%.

Now that we have the exact starting and ending counter values, we could go back and calculate the exact cycle counts, but given how much margin there is, I'm willing to hand-wave that part.

You can actually test it out with smaller values of nn. For example nn of 4 will pause for several seconds.

9-byte answer:

0000- A2 CA     LDX #$CA   ; 2 cyc
0002- F6 44     INC $44,X  ; 6 cyc
0004- F0 FB     BEQ $0001  ; 2-3 cyc (rollover)
0006- D0 F8     BNE $0000  ; 2-3 cyc (non-rollover)
0008- F7        DB  $F7    ; data byte

Saved one byte by folding the DEX opcode into the argument for LDX.

Instead of 11.05 cycles, each counter increment is now 13 + 11*(1/256 + 1/(256^2) + ...) = 13.043 cycles.

Now we need 2475073064976549 +/- 10% iterations, or a range of 0x7E9F591BF7A2E - 0x9AC2C23EA071C.

So now we initialize the 7-byte counter to something between 0xF7000000000000 and 0xF7FFFFFFFFFFFF. This ends up giving between 0x08000000000001 and 0x09000000000000 loop iterations, which is within the +/-10% needed.

When the counter rolls over to 0, the last branch gets modified to jump to $0001, which leads to an increment of the BNE opcode itself (to a CMP instruction, which for our purpose is effectively a no-op). Code then falls through to $0008, which now contains a 0 (because of counter rollover). A 0 byte is a BRK instruction, which drops you back to the system monitor, ending the routine.

Answer 8

05AB1E, 6 bytes

27;°.W

Inspired by the other answer in 05AB1E.

Waits for 10^27/2 milliseconds, or about 1002 years.

Explanation:

27            push the number 27
  ;           divide by 2
   °          replace X by 10 to the power of X
    .W        wait that number of milliseconds

Try it online!

Answer 9

Jelly, 8 bytes

32œS$ȷ9¡

Try it online!

A niladic link which waits for 32 seconds 1 billion times. 32,000,000,000 is within 10% of 31,557,600,000 seconds which is 1,000 years (ignoring leap seconds and ignoring the fact that centuries indivisible by 400 are not leap years).

Answer 10

Charcoal, 7 bytes

Ｆ³³ＲＸφ⁴

Try it online! Link is to verbose version of code with a speed up factor of 1e9 (obtained by changing the ⁴ into a a ¹) so that it doesn't time on TIO. Explanation:

Ｆ³³

Repeat 33 times.

ＲＸφ⁴

Refresh the screen, but delay 1000⁴ milliseconds between refreshes.

Although there are 33 refreshes, there are only 32 intervals, so the total delay is 32000000000000 milliseconds or approximately 1015 years.

Answer 11

Java (JDK), 23 bytes

v->Thread.sleep(7L<<42)

Try it online!

It's hard to find a short way to write a number in Java. Thread.sleep only accepts a long number of milliseconds. So the standard answer 3e10 doesn't work because it's a double. Casting it to a long would be the appropriate action. But it would still be 1000 too small. So enter 3e13 which is closer. But fortunately, 7L<<42 is 30,786,325,577,728, which is close to the actual count of 1000 years, and is a long without cast, so 4 bytes shorter than (long)3e13.

Credits

• -4 bytes thanks to Neil by replacing (long)3e13 with 7L<<42.

Answer 12

Batch, 41 25 bytes

^{-8 bytes thanks to AdmBorkBork
-6 bytes thanks to ceilingcat
-2 bytes thanks to inspiration from Neil}

ping 1 -n 31556952000>nul

Using 31,556,952 seconds / year and a (default) 1 second delay between each ping, this will wait 1000 years before returning nothing.

Note that ping 1 results in failure but it'll fail 31 billion times so that still works.

Answer 13

APL (Dyalog Unicode), 9 8 bytes^SBCS

-1 thanks to Eric Towers.

Full program. This works by observing that $$\sum_{n=1}^{8^6}n=3.44×10^{10}\approx3.16×10^{10}$$which is the number of seconds in a thousand years.

⎕dl¨⍳8*6

Don't try it online!

8*6 \$8^6=262144\$

⍳ ɩntegers until that

⎕dl¨ delay each of those many seconds

Answer 14

Wolfram Language (Mathematica), 11 bytes

Pause[2^35]

2 to the 35th power is about 8.9% greater than 31,556,926,000.

Answer 15

T-SQL, 56 bytes

DECLARE @ INT=0a:WAITFOR TIME'9:0'SET @+=1IF @<4E5GOTO a

• The SQL WAITFOR command is limited to 24 hours, so it has to go in a loop.
• WAITFOR has two options: DELAY that waits a certain length of time, or TIME which waits until a certain time of day. Turns out WAITFOR TIME'9:0' (which will pause until 9am the following day) is a couple of bytes shorter than WAITFOR DELAY'24:0'.
• Using a GOTO loop is shorter than a WHILE loop.
• I'm looping 4E5 times (400,000), which is within 10% of the 10-year (365,242 day) goal.
• If I start it today, this would complete in February, 3115

Answer 16

Lua, 38 bytes

t=os.time;o=t()+2^35while t()<o do end

Try it online!

Being ANSI C compliant, Lua does not implement any sleep functions, so we have to make one ourselves. Oh, and make sure to keep the dust off that One Thousand Year Computer, we're busy waiting.

Lua, 38 bytes

t=os.time;o=t()+2^35repeat until o<t()

Try it online!

Same thing, different loop. Tried to see if I can save some bytes, but nope.

Answer 17

C# (Visual C# Interactive Compiler), 59 bytes

b=>{for(var d=DateTime.Now.AddYears(999);d>DateTime.Now;);}

Can be tested by replacing AddYears() with AddSeconds()

Try it online!

Answer 18

R, 24 bytes

sapply(1:25e4,Sys.sleep)

Try it online!

A solid starter, feels like there's optimisation to be had with a different function & number combo. This sleeps for 1s, then 2s, then 3s, then 4s... up to 250000s, at which point it's been running for about 990 years and outputs a list of 250k empty elements.

Answer 19

Pyth, 10 bytes

VT.dC"¼€

Try it online!

There are exactly 31,557,600 seconds in the Julian astronomical year., totalling 31,557,600,000 seconds in 1000 years. 2^32 is about a tenth of this, so we just wait for 3,155,760,000 seconds ten times. Note that € is a blank codepoint in the TIO, not sure why it translates to this on SE

Here you can see that C"¼€ is equal to 3,155,760,000

And here is an example that waits for only 22 seconds using a similar method

Pyth, 8 bytes

.dC"XúÃ

Try it online!

Alternatively, this one just uses C"XúÃ for 31,557,600,000. I thought it was more in line with the spirit of the challenge to have a 2^32 limit, though

---

The average length of a sidereal year, however, is 365.256363004 days or around 31,558,149.763 seconds, giving us a total of ~31,558,149,764 seconds in 1000 years. In this case, the more accurate solution would be

This: VT.dC"¼ê@

This:.dC"Y&ƒ(1 byte longer than Julian solution)

Answer 20

Perl 5, 18 bytes

sleep 1e9for 1..30

Try it online!

10 bytes (doesn't work)

sleep 3e10

Try it online!

Answer 21

PHP, 30 bytes

The time() function can be used instead of microtime(1), as when plused with 3e10, PHP converts the value into a float, even when the original value is an int and thereby save some more bytes.

time_sleep_until(time()+3e10);

See how php converts values


As stated by "manassehkatz-Reinstate Monica" a flag can be set to make it run without the tags in PHP, so a more clean version is here made. (36 bytes)

time_sleep_until(microtime(1)+3e10);

Google tells me that 1000 years = 3.1556926 × 10¹⁰ seconds (31,556,926,000)
The method cloud even be made recoverable in the event of power failures. (not done in this example)

<?php time_sleep_until(microtime(true)[phone])); ?>

The shorter but more imprecise version (45 bytes with the php tags)

<?php time_sleep_until(microtime(1)+3e10); ?>

With a correction from "Kaddath" this option below is dropped as the documentation state that it is a int not a float used in sleep()
It can be done like so:

<?php sleep(31556926000); ?>

Try it online!

Answer 22

Mumps (M): 7 Bytes

H 9**11

Mumps likes single-letter commands & big numbers... H(ang) sleeps for ## of seconds; 9 to the 11th power gives 31381059609 seconds, which is almost 0.6% low for 1000 years; well within the margin of error.

Keeping with the 7 byte code length, I tested "power of 9" sleep times on 2 different Mumps implementations; the largest power of 9 on YottaDB/GT.M I can find without numeric overflow would be:

H 9**49

which gives a sleep time of just over 1,814 decillion millennia. InterSystems' Cache doesn't overflow and can go to:

H 9**99

which gives 9.352x10⁸³ millennia. That's quite a nap in 7 bytes!

Answer 23

JavaScript (Node.js), 70, 67, 34 bytes

-3 thanks to Joost K, see their answer for why I used 8e6
-33 thanks to Benjamin Gruenbaum for pointing out callbacks are better, using the concept of his answer

I've found 2 ways of solving this problem. The first defines a globally:

(f=_=>a&&setTimeout(f,--a))(a=8e6)

the other method passes a through each time, using setTimeout's further args:

(f=a=>a&&setTimeout(f,--a,a))(8e6)

These solutions remain the same length when using IIFEs or just calling the function manually.

Answer 24

Applescript, 10

delay 3e10

Sleeps for 3 * 10¹⁰ seconds.

Answer 25

05AB1E, 7 6 bytes

35oF.Z

~8.879% too large

Also take a look at this excellent alternative 6-byter by @anatolyg.

Previous 7-byters:

žqþ¨¨.W     # ~0.449% too small
žG14∍.W     # ~3.837% too large
13°3*.W     # ~4.936% too small

For 100%^† precision (†: assuming a year is 365.25 days), use •Tε‚šä¦•.W (10 bytes) instead.

Explanations:

35          # Push 35
  o         # Pop and push 2 to the power 35: 34359738368
   F        # Loop that many times:
    .Z      #  And sleep for 1 second every iteration

žq          # Push PI with 15 decimal digits by default: 3.141592653589793
  þ         # Remove the dot by only leaving the digits: 3141592653589793
   ¨¨       # Remove the last two digits: 31415926535897
     .W     # Sleep that many ms

žG          # Push builtin integer 32768
  14∍       # Extend it to size 14: 32768327683276
     .W     # Sleep that many ms

13°         # Push 10 to the power 13: 10000000000000
   3*       # Multiply it by 3: 30000000000000
     .W     # Sleep that many ms

•Tε‚šä¦•    # Push compressed integer 31557600000000
        .W  # Sleep that many ms

See this 05AB1E tip of mine (section How to compress large integers?) to understand why •Tε‚šä¦• is 31557600000000.

05AB1E is built in Elixir, and its sleep builtin can even hold :infinity apparently, so I can assume the .W has no maximum.

Answer 26

05AB1E, 5 bytes

₆9e.W

Sleeps for about 1082 years.

Try it online!

₆         # push 36
 9        # push 9
  e       # nPr (number of 9-element permutations of a 36-element list)
   .W     # wait that many milliseconds

Answer 27

SAS, 38 bytes

data;do i=1to 3e10;a=sleep(1);end;run;

This loop seems to be the shortest option as both sleep and wakeup are capped at 46 days - slightly less than 2²² seconds. I wonder what the rationale for that was?

Answer 28

JavaScript (Node.js), 34 bytes

uses the 3e13 like most answers but in a for loop. The 1 at the end is to make it a valid for loop.

d=Date.now;for(i=d();i>d()-3e13;)1

Try it online!

Don't actually try it...

Answer 29

C# (Visual C# Interactive Compiler), 38 37 bytes

this waits 1 + 2 + 3.. +77e5-1 + 77e5ms.

I got this 77e5 magic number using the formula (x+1)/2*x=3e13 where x results in approximately 7.745.967 which I shortened to 77e5.

To check if it still falls in the allowed range I did 1000*365.25*24*3600*1000/((77e5+1)/2*77e5) which is 1.064 aka 6.45% of target

update : 8e6 results in 0.98 more precise and less bytes.

for(var i=0;i++<8e6;)Thread.Sleep(i);

Try it online!

Answer 30

Roblox, 11 bytes

wait(3e+10)

Waits 30,000,000,000 seconds, which is roughly equal to 950 years.

Answer 31

Red, 9 bytes

wait 3e10

Try it online!

Answer 32

Tcl, 23 bytes

after 30000000000000000

Try it online!

Answer 33

MSX-BASIC, 47 characters

1FORK=1TO31557600000:TIME=0
2IFTIME<50GOTO2
3NEXT

TIME is a MSX-BASIC system variable holding a 50Hz counter that can be initialized to any value at will. There are 31557600000 seconds in 1000 years (assuming one leap year every 4 years) so there you go.

Answer 34

Zsh/Bash/Sh, 23,19,14,10 bytes

sleep 8e6h

-4 bytes thanks to @Grimmy

Explanation

Linux sleep command can take a suffix of either s (seconds), m (minutes), h (hours), or d (days).

365250 days is equivalent to 1000 years

Answer 35

RPL, 8 bytes

3E10WAIT

shall wait 3e10 seconds on, say, your hp48sx. Good the OP excluded hardware issues, so we can ignore the reboot at the end of Dec. 31st, 2088 (the date is reinitialized to Jan. 1st, 1989.)

For RPL/2, add one byte as a space is needed before WAIT.

I am surprised such commands are accepted anyhow…

Btw a challenge about 2763 years would allow us to use the factorial as in 14!WAIT.

Answer 36

SmileBASIC, 19 bytes

@L
WAIT 12e7GOSUB@L

Waits 120 000 000 frames (around 21.2 days), and loops until the GOSUB stack overflows (after 16383 iterations)
This lasts 1038.32 years

Answer 37

MathGolf, 15 bytes

{tï╜Ä_⌐_¬Wó+<}▲

Just like my top 05AB1E answer, it's ~8.879% too large.

Try it online with debugging argument -d to see what's going on.

Explanation:

There were a few difficulties to tackle here:

1. Apparently there is no way in MathGolf to access a value outside of the scope of a while-loop. I therefore had to push the initial timestamp inside the loop, and by using some duplicates and stack-rotates access it to check against the current timestamp.
2. After that I initially had {t_⌐_¬Wó+<}▲ (12 bytes) to overcome the issue mentioned at point 1. Unfortunately there are some bugs in MathGolf, so this required a leading 1, otherwise the do-while didn't work: 1{t_⌐_¬Wó+<}▲.
3. MathGold is built in Python, and since Python's List size is limited to 536,870,912 items, I therefore had to remove unused garbage from the stack instead of letting it grow by one additional item every iteration. (Since it executes roughly 5-10 iterations per ms on TIO, the stack size grows way too fast to last even close to 1000 years.) I did this by adding an if-statement in front of that initial duplicate, so I only duplicate it in the very first iteration. For some reason I could now also remove that 1 which was used as a bug-workaround..

Putting it all together gave me the 15-byter you see here, with the following code explanation:

{            }▲  # Do-while true with pop:
 t               #  Push the current timestamp
  ï              #  Push the current 0-based loop-index
   ╜             #  If it's falsey (so it's the first iteration):
    Ä            #   Execute the following single command:
     _           #    Duplicate this initial timestamp
      ⌐          #  Rotate the stack, so the bottom item is at the top
       _         #  Duplicate it
        ¬        #  And rotate the stack back, so its both at the top and bottom now
         Wó      #  Push 35, and then pop and push 2**35: 34359738368
           +     #  Add it to the timestamp of the first iteration
            <    #  And check whether it's still lower than the current timestamp

Answer 38

Python 3, all platforms, 91 bytes

from datetime import *;z=datetime.now()+timedelta(days=365242)
while z>datetime.now(): pass

The rules say simple termination is fine, which happens after the while loop is done. I couldn't put it all on one line, because the while loop has to start on its own line for the interpreter to recognize it. I also didn't want to use sleep since the challenge specifically calls that out as the problem.

Answer 39

TI-BASIC, 17 bytes

For(I,0,2^32:rand(564:End

TI-BASIC doesn't have any wait commands/functions, so I just used one of the slowest functions available: generating random lists!

Generating a random list of 564 elements takes \$\approx7.95\$ seconds to make and the loop goes through \$2^{32}\$ iterations, so that results in \$7.95*2^{32}=34144990003.2\$ seconds or \$1082.01255\$ years.

Answer 40

JavaScript (V8), 35 26 bytes

setTimeout(alert(''),3e13)

Try it online!

Answer 41

at, 19 bytes

at now + 1000 years

Answer 42

Scratch (scratchblocks3 syntax), 30 bytes

It's the obvious solution but it's surprisingly short for a Scratch program. Sleeps for exactly 951.3 years + a few milliseconds.

when gf clicked
wait(3e10)secs

Answer 43

Bash and a fast spaceship, 7 bytes

sleep 1

Try it online!

This requires that the computer running the program (e.g. TIO) be

1. Accelerated away from Earth for 250 years from the point of view of observers on Earth at about \$3.4\times10^{10}\frac{m}{s^2}\$ (observers on the spacecraft, if suitably restrained, will experience the acceleration for 0.25 seconds)
2. Accelerated toward Earth for 500 years (observers on the spacecraft will experience the acceleration for 0.5 seconds) at about \$3.4\times10^{10}\frac{m}{s^2}\$
3. Accelerated away from Earth for the final 250 years (or 0.25 seconds in the spacecraft frame) at \$3.4\times10^{10}\frac{m}{s^2}\$.

The required acceleration was estimated by setting the integral of the relativistic proper time equation to be \$T_s\$ (quarter of the parameter you want to pass to sleep()) and setting \$T_e\$ to 250 years.

\$\displaystyle T_s=\int_0^{T_e} \sqrt{1-\left(\frac{v(t)}{c}\right)^2} \ \mathrm{d}t\$

where

\$v(t)=\frac{at}{\sqrt{1+\left(\frac{at}{c}\right)^2}}\$

It turns out that

\$\displaystyle \int_0^T \sqrt{1-\left(\frac{at}{c\sqrt{1+\left(\frac{at}{c}\right)^2}}\right)^2} \ \mathrm{d}t=\frac{c}{a}\sinh^{-1}\left(\frac{a T}{c}\right)\$

Solving for a for \$T_e\$=250 years and \$T_s\$=.25 seconds yields a~3.4e10. Viola!

Relativistic Twin Paradox

Hyperbolic Motion (Relativity)

Answer 44

[C#] A bit larger than 32 bytes

class Program
{
    static void Main(string[] args)
    {
        Sleep(1000);
    }

    public static void Sleep(int years)
    {
        BigInteger bigTemp = (BigInteger)years;
        BigInteger integ = bigTemp*365*24*60*60;
        int temp = 0;

        while (integ > int.MaxValue)
        {
            Thread.Sleep(int.MaxValue);
            integ -= int.MaxValue;
        }
        temp = (int)integ;
        Thread.Sleep(temp);
    }
}

I see no error there

Answer 45

JavaScript, 15 bytes

setTimeout(3e10)