I'm too cold, turn up the temperature

Question

This is my first golf contest.

What you need to do

Build me, in the shortest amount of bytes possible, my AC remote control system. My room is too cold right now, and I'm missing my remote.

Now, I don't want you literally building it or anything, just golf this:

A slow increment of temperature, starting at 40 degrees, and ending at exactly 72. The increment time must always be 500 millis per increment. It can wait another 500ms at the end. I would prefer it to stop however. The increment itself must go up by two each time, like my remote.

You should not clear the screen. You should have newlines.

What should happen

Example output (everything in parentheses shouldn't be outputted).

40
(wait 500 millis)
42
(wait 500 millis)
44
(..repeat until 72..)
72
(stop or wait 500ms)

Keep in mind This is my first golf, so I apologize if this is too hard to golf. :(

Best of luck, golfers!

Answer 1

Excel VBA (32-Bit Only), 123 Bytes

Declares the windows Kernel32 Sleep(ByVal dwMilliseconds as Long) function and uses a recursive helper function. Outputs to the VBE immediate window.

Declare Sub Sleep Lib"kernel32"(ByVal t&)
Sub a(i)
Debug.?i
If i<72Then Sleep 500:DoEvents:a i+2
End Sub
Sub b:a 40:End Sub    

Usage and Ouput

as seen from an b subroutine call from the VBE immediate window

b        ''  <- Subroutine Call
 40      ''  <- Output
 42 
 44     
 46     
 48     
 50     
 52     
 54     
 56     
 58     
 60     
 62     
 64     
 66     
 68     
 70     
 72   

Answer 2

Common Lisp, 57 52

(loop for b from 40 while(<(print b)72)do(sleep .5))

• Print returns its input parameter.
• The program exits immediately after reaching 72.

Ungolfed:

(loop
  for b from 40
  do (print b)
  while (< b 72)
  do (sleep .5))

Answer 3

Browser Javascript, 52 51 chars

eval(s="s=alert(x=setTimeout(s,500)*2+38)|x<69&&s")

Test with console.log instead of alert:

eval(s="s=console.log(x=setTimeout(s,500)*2+38)|x<69&&s")

Answer 4

PowerShell, 32 31 bytes

40..72|%{$_[$_%2];sleep -m 250}

Try it online!

Sleeps regardless if it's odd or even for half the time but will only output when the value is even due to out-of-bounds indexing returning nothing. Lost several bytes due to sleep defaulting to seconds and only taking ints.

Answer 5

*><>, 20 bytes

"H&"v
?;5S>2+:n:{:}=

Try it here!

This outputs the 40 and adds two every 500ms, outputting the new number. At 72 the program does not wait and exits immediately. Wasn't sure if we needed any sort of deliminator in-between the temperatures so there isn't one included.

Explanation

Setup:

"J("   push 72 and 38 (temp) to the stack
    v  enter main loop at ">"

Main loop:

>               move the IP right
 2+             add two to temp
   :n           copy and output temp
     :{:}       copy temp and 72
         =?;    if temp == 72, exit
            5S  sleep 500ms

Answer 6

Factor, 36 bytes

20 36 [a,b] [ 2 * . 5e8 sleep ] each

Pretty simple.

Answer 7

Python 3, 61 bytes

Not a winner, but a horrible, horrible abuse of a list comprehension: two side-effects and the result isn't even used.

import time
[print(2*x+40)==time.sleep(.5)for x in range(17)]

Similar:

[time.sleep(.5)for x in map(print,range(40,74,2))]

Answer 8

GNU sed, 87 + 1 = 88 bytes

+1 byte for -u flag (prevents sed from waiting until the end to flush all of the output).

Assumes it's running in an environment where the shell command sleep .5 works.

s/.*/40/
:
p
esleep .5
/72/Q
/8/bz
h
y/0246/2468/
s/.//
H
x
s/.\n//
b
:z
y/4568/5670/
b

Try it online! (Using Dennis' handy bash wrapper to timestamp each output line.)

Answer 9

Python 2, 54 bytes

Thanks @xnor for cutting 2 bytes off!

import time;x=40
exec'print x;x+=2;time.sleep(.5);'*17

55 bytes

This one uses a dfferent counting approach, can probably still be golfed:

import time;x=34
while x:print 74-x;x-=2;time.sleep(.5)

Answer 10

RBX.Lua, 36 bytes

Uses UTF-8 encoding. Golfed:

for i=40,72,2 do wait(.5)print(i)end

Should be pretty obvious to people with Lua knowledge. Here's an explanation:

for i=40,72,2 do --For-loop, counting from 40 to 72 in steps of 2.
wait(.5) --RBX.Lua builtin. Waits 0.5 seconds.
print(i) --Prints current temperature.
end --End of for loop.

Answer 11

Java, 93 bytes

a->{for(a=38;(a+=2)<73;){System.out.println(a);try{Thread.sleep(500);}catch(Exception e){}}};

This is a java.util.function.Consumer<Integer> that makes me want to take a new NullPointerException() and use it to slap whoever who made Thread.sleep() throw a checked exception.

Identical-in-length snippet that does the exact same thing with an "everyday" method:

void a(int A)throws Exception{for(A=38;(A+=2)<73;){System.out.println(a);Thread.sleep(500);}}

Answer 12

postgresql9.6, 162 bytes

do language plpgsql $$ declare n smallint;begin foreach n in array array(select generate_series(40,72,2))loop raise info'%',n;perform pg_sleep(.5);end loop;end;$$

formatted sql is here:

do language plpgsql $$
declare n smallint;
begin
foreach n in array array(select generate_series(40, 72, 2)) loop
    raise info '%', n;
    perform pg_sleep(.5);
end loop;
end;
$$

Answer 13

ForceLang, 71 bytes

For some unknown reason, does not quite work if you run the interpreter using Eclipse, but still functions properly if you run the interpreter using your terminal directly. ¯\_(ツ)_/¯

set s 38
label 1
io.writeln set s s+2
datetime.wait 500
if -72+s
goto 1

Answer 14

SAS, 60 bytes

Something different :)

data _null_;do i=40 to 72; put i;s=sleep(.5,1);end;run;

Answer 15

Swift, 208 bytes

import Foundation
import PlaygroundSupport
PlaygroundPage.current.needsIndefiniteExecution = true
func n(){if t<72{DispatchQueue.main.asyncAfter(deadline:.now()+0.5){t+=2;print(t);n()}}}
var t=40;print(t);n()

sleep() takes a UInt32 in Swift, so won't work for the 500 millisecond delay. If it was 1 second however:

import Foundation;(20...36).map{$0*2}.forEach{print($0);sleep(1)}

…65 bytes (with a delay at the end)

Answer 16

Python 2, 57 bytes

import time as t
x=40
while x<73:print x;t.sleep(.5);x+=2

This does require an 'extra' newline to actually run, so arguably response is 58 bytes (please feel free to edit/comment if this is what the figure above should be).

Edit: Remove unecessary whitespace between : and print

Edit2: changed 0.5 to .5, saving one byte.

Edit3: failed to add/count the sleep import, which raises the score to 60 bytes.

Edit4: Saved 3 bytes by adding extra line

Answer 17

101, 98 78 bytes

00001 101000 001 11 00001 01001000 00001 0001 000010 1111 00001 1001 000101 111

EDIT: The language has beed updated to support equals etc. So i managed to narrow it down a little. Note: i did not update the explaination.

developed a programming language in python over the course of the 2 last days. Its fairly simple, but is a pain to program in, as it consists only of 1's and 0's, and can only hold binary numbers with up to 6 numbers.

Explenation:

00001 101000 # declares variable 00001 to 40
00010 100010 # declares variable 00010 to 34

001 00010 # start of loop, checks if variable 00010 is over 0
00010 0011 000010 # 0011 is the function for decrementing, and i decrement by 2 (decimal)
1111 00001 # 1111 is the function for printing
00001 0001 000010 # same as above, only addition
1001 000101 # 1001 is timer, takes a whole number and divide by 10 to allow milliseconds
111 # same as end symbol in ruby

EDIT: Link to the language https://github.com/hrrs01/101 Easily tested by running the demo file by doing (if python in PATH):

101.py demo.txt

Answer 18

Common Lisp, 54 bytes (45 if trailing newline is allowed)

(dotimes(i 17)(format t"~a~&"(+(* 2 i)40))(sleep 0.5))

shorter - with trailing newline, because print adds one:

(dotimes(i 17)(print(+(* 2 i)40))(sleep 0.5))

Answer 19

RbxLua, 36 bytes

for i=40,72,2 do print(i)Wait(.5)end

Thought I'd use RbxLua, which is a modified version of Lua 5.1 used on ROBLOX.com, as it has a built-in Wait(s) function that is one byte shorter than sleep(ms) in Lua 5.3.

Edit: Didn't see the other RbxLua solution. This solution uses a non-deprecated form of wait.

Answer 20

dc, 50 bytes

0sm[40lm+p0se[le1+dse120000>j]dsjxlm2+dsm33>p]dspx

Well, this seems to be the first answer which does not utilize any sleep built-in as dc seemingly does not have one. Instead, this simply utilizes a macro loop which during each of 16 iterations increments 40 by 2*iteration #, outputs the sum on a new-line, and utilizes another macro loop which is iterated through 120000 times giving us our desired 500 millisecond sleep with a very slight and unnoticeable variance.

Answer 21

05AB1E, 11 bytes

40žvƒ=Ì₄;.W

Try it online.

Explanation:

40           # Push 40
  žvƒ        # Loop 17 times (in the range [0,16]):
     =       #  Print the top of the stack with newline (without popping)
      Ì      #  Increase the number by 2
       ₄;    #  Push 1000 halved to 500
         .W  #  And sleep that many ms

Answer 22

Javascript (ES6), 48 bytes

f=(i=40)=>alert(i)|i-72&&setTimeout(f,500,i+2)
    
f()

Based on @ETHproductions answer.

Answer 23

Zsh, 34 bytes

for i ({40..72..2})<<<$i&&sleep .5

Attempt This Online!