Questa è la mia prima gara di golf.

Cosa devi fare

Costruiscimi, nel minor numero di byte possibile, il mio sistema di controllo remoto AC. La mia stanza è troppo fredda in questo momento, e mi manca il mio telecomando.

Ora, non voglio che tu lo costruisca letteralmente o altro, basta golf questo:

Un lento aumento della temperatura, che inizia a 40 gradi e termina esattamente a 72. Il tempo di incremento deve essere sempre di 500 millis per incremento. Può attendere altri 500 ms alla fine. Preferirei che smettesse comunque. L'incremento stesso deve aumentare di due ogni volta, come il mio telecomando.

Non dovresti cancellare lo schermo. Dovresti avere newline.

Cosa dovrebbe succedere

Esempio di output (non deve essere emesso tutto tra parentesi).

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

Tieni presente che questo è il mio primo golf, quindi mi scuso se è troppo difficile da golf. :(

Buona fortuna, golfisti!

Utilità Bash + Linux, 19

seq 40 2 72|pv -qlL2

seqgenera l'output numerico. pvratelimita a 2 righe / sec.

Minecraft 1.9.0+, 204 162 byte + 58 36 28 24 20 blocchi = 262 240 232 186 182 blytes

Questa soluzione è ridotta al minimo e non può essere vista intera in uno o due schermate. Usa due glitch e abusa di altre due caratteristiche del gioco

Questa soluzione utilizza gli stessi principi di quella di seguito, solo un design più compatto di 4 blocchi.

• Abusa del fatto che i blocchi di comando Chain (blocchi verdi) non possono essere alimentati da redstone, ma solo da un singal da un blocco di comando ad impulso (arancione).

• Abusa del fatto che i pistoni impiegano 0,30 secondi per estendersi completamente e la pietra rossa richiede solo 0,10 secondi per registrare un segnale.

• Inoltre, abusa di una doppia anomalia per disattivare il timer (TNT): la pietra rossa accanto al timer (TNT) non solo viene alimentata, ma pensa anche che la TNT sia un'altra pietra rossa e la alimenta.

• Oltre a tutti questi abusi, l'accorciatore di segnale (cosa sotto il TNT) è monouso, dopo che viene alimentato cambia forma, consentendo di passare il segnale attraverso di esso al "incrementatore" (blocco arancione più in alto)

Un po 'di spiegazione sulla funzionalità delle sue diverse parti può essere vista in soluzioni più vecchie (ma la migliore in quella appena sotto). Puoi anche provarlo offline! (soluzione semplificata con incremento di 4, funziona solo in 1.11+) eseguendo questo comando in un blocco comandi .

Vecchia soluzione, Minecraft 1.9.0+, 186 blytes:

Poiché TNT normalmente esplode dopo 3.0s in Minecraft, questo deve essere inserito da un comando ( /setblock) con un fusibile specificato. Utilizza anche un design più compatto per rimuovere il blocco di comandi ridondante (contenente 42 byte) e la pietra rossa rispetto alle versioni precedenti. Sono sicuro che questo non può essere più basso ...

Soluzione precedente, Minecraft 1.9.0+, 232 blytes:

Spiacenti, ho scoperto che queste soluzioni precedenti aumentano di 4 ...

Usa la funzione di catena di blocchi di comando 1.9 (cosa di blocco verde) per salvare i blocchi. Utilizza anche un accorciatore di segnale più compatto rispetto alle soluzioni precedenti

Soluzione ancora più vecchia, Minecraft 1.7.0+, 240 blytes:

Utilizza un timer più compatto (TNT) rispetto alla prima soluzione (di seguito).

Soluzione più vecchia, Minecraft 1.7.0+, 262 blytes:

Questo è così lungo a causa del modo in cui Minecraft gestisce le variabili:

• Per definire una variabile (int): scoreboard objectives add <variable> dummy

• Per impostare un valore su una variabile (ogni entità, inclusi i giocatori, ha il proprio valore variabile): scoreboard players set <entity> <variable> <value>

  • *può essere usato <entity>per selezionare tutte le entità e salvare i byte.

  • possono essere utilizzate solo variabili definite

  • il valore della variabile deve essere impostato su un numero, non su una variabile

• Per incrementare var1 di var2: scoreboard players operation <entity> var1 += <entity> var2

  • <entity>deve essere una singola entità, ad es. @pno*

_{Le schermate sono mie, con doppia licenza in base a WTFPL e quale licenza SE decide di utilizzare oggi (attualmente cc by-sa 3.0 with attribution required) :-)}

Vim, 24 , 23 byte / sequenze di tasti

i40<esc>qq:sl500m
Yp2<C-a>q15@q

Un byte salvato grazie a @Kritixi Lithos!

Scritto dal mio telefono, testato su mobile vim (che apparentemente è una cosa reale).

Ecco una gif in esecuzione:

Ed ecco una spiegazione comando per comando:

i40<esc>            " Insert '40' into the buffer
        qq          " Start recording into register 'q'
          :sl500m   " Sleep form 500 ms
Y                   " Yank this line
 p                  " and paste it on a newline
  2<C-a>            " Increment this line twice
        q           " Stop recording
         15@q       " Callback register 'q' 15 times

JavaScript (ES6), 52 byte

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

f()

Gelatina , 13 12 byte

40µṄœS.+2µ⁴¡

Provalo online! Il programma Jelly è racchiuso in uno script Bash per anteporre a ogni riga di output un timestamp.

Come funziona

40µṄœS.+2µ⁴¡  Main link. No arguments.

40             Set the return value to 40.
  µ      µ⁴¡  Execute the chain between the two µ 16 times.

   Ṅ           Print the return value, followed by a linefeed.
      .        Yield 0.5.
    œS         Sleep for 0.5 seconds. Yield the previous result.
       +2      Add 2.

Dopo l'ultima iterazione, il valore finale di 72 viene stampato implicitamente e il programma termina.

Perl 6 , 30 byte

for 20..36 {sleep .5;say 2*$_}

Mi dispiace che sembra un codice non golfato, non vedo un modo per renderlo più breve ...

La versione che si ferma subito dopo l'ultimo numero, sarebbe 37 byte:

for 20..36 {sleep .5 if $++;say 2*$_}

Pyth - 12 byte

Molto semplice, usa un ciclo for 0-17.

V17+40yN.d.5

TI-Basic (solo CE o CSE), 16 byte

:For(A,40,72
:Pause A,.5
:End

Si noti che molti comandi sono token a byte singolo.

MATL , 14 byte

17:E38+".5Y.@D

Provalo in MATL online! Potrebbe essere necessario ricaricare la pagina se inizialmente non funziona.

Spiegazione

17:     % Push array [1 2 ... 17]
E       % Multiply by 2, element-wise
38+     % Add 38, element-wise. This gives [40 42 ... 72]
"       % For each k in that array
  .5Y.  %   Pause 0.5 seconds
  @D    %   Push k and display
        % End (implicit)

Vecchia versione (prima della modifica delle specifiche), cancellando lo schermo

17:E38+"5&Xx@D

Provalo in MATL online!

Dyalog APL , 20 byte

{⎕DL.5⊣⎕←⍵}¨38+2×⍳17

{ la funzione anonima

 ⎕DL ritardo...

 .5⊣ metà (un secondo) anziché il valore di

 ⎕← stampa (con newline)

 ⍵ l'argomento

}¨ applicato a ciascuno di

38+ trentotto plus

2× due volte

⍳17 i numeri interi da 1 a 17

C compilato con Clang 3.8.1 su Linux, 62 59 58 byte

2 byte salvati grazie a @ranisalt

s=38;main(){for(;s<74;printf("%d\n",s+=2))usleep(500000);}

59 byte

s=38;main(){for(;s<73;printf("%d\n",s+=2+usleep(500000)));}

62 byte

s=38;main(){for(;s!=72;){printf("%d\n",s+=2);usleep(500000);}}

s=38                # Initializes a global (int) variable, this is only possible in C, in other languages from the C family variables must have an explicit type.
main()              # Is the main entry point, again as before, in case a type isn't specified C defaults to int
printf("%d\n",s+=2) # printf outputs to stdout based on the pattern defined in the first parameter 
                    # %d is a placeholder for an int variable
                    # \n appends a newline to stdout
                    # The second parameter increments the s variable and afterwards it goes in the placeholder's spot.
usleep(500000)      # This function is Linux specific, it takes an int as parameter, it represents how much time the app needs to sleep in microseconds

Scratch, 5 blocchi

(spazio su disco 56.0kb)

^{(scusate per la bassa risoluzione!)}

Autoesplicativo, davvero. Il valore della variabile viene visualizzato in una casella sullo "stage".

Mathematica, 34 byte

Pause[Print@#;.5]&/@Range[40,72,2]

Programma completo. Non accetta input e output su STDOUT.

R, 49 byte

x=38;while(x<72){Sys.sleep(.5);x=x+2;cat(x,"\n")}

Soluzione molto banale ma fa il trucco.

Perl 6 , 27 byte

sleep .say/2 for 40,42...72

sayrestituisce True, che viene forzato in un valore numerico 1quando diviso per 2.

Gli shenanigans Unicode possono arrivare a 23 caratteri:

sleep .say/2 for ㊵,㊷…72

Ma sono 29 byte con codifica UTF-8.

Python 2, 57 56 55 byte

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

MODIFICARE:

-1 Byte grazie a Mega Man

-1 Byte grazie a Flp.Tkc

Rubino, 33 byte

(40).step(72,2){|n|p n;sleep 0.5}

C #, 95 byte

()=>{for(int i=40;i<73;i+=2){System.Console.WriteLine(i);System.Threading.Thread.Sleep(500);}};

È un loop semplice, attende alla fine altri 500ms.

QBIC , 21 byte

[44,72,4|?a┘'sleep 1.

QBIC avvia un ciclo FOR, che va da 44 a 72 e incrementa il contatore di 4 su ogni ciclo. Dorme quindi per 1 secondo. QBasic non ha un controllo più preciso sleep, quindi ho aggiunto a .per simulare il dare .5come argomento.

Kotlin, 47 byte

Immagino che non sia stato detto nella dichiarazione del problema che le soluzioni dovrebbero effettivamente contenere l'incremento di due, quindi 40+2*iqui è legale.

Se scritto come una normale fonte di Kotlin con main:

fun main(args:Array<String>){(0..16).map{println(40+2*it);Thread.sleep(500)}}

^{(77 byte)}

UPD : In Kotlin 1.3, args:Array<String>può essere rimosso, quindi è 18 byte in meno.

E in Kotlin Script, l'intero programma sarebbe

(0..16).map{println(40+2*it);Thread.sleep(500)}

^{(47 byte)}

Ruby 31 byte

20.upto(36){|n|p n*2
sleep 0.5}

Provalo online!

Haskell, 67 byte

import System.Posix.Unistd
mapM((>>usleep 500000).print)[40,42..70]

Se si desidera utilizzare solo ghc, è possibile salvare alcuni byte importando GHC.Conce utilizzando threadDelayanziché usleep.

php, 38 byte

for(;35>$t+=2;usleep(5e5))echo$t+38,_;

usa il trattino basso come delimitatore. Corri con -nr.

Clojure, 54 byte

(doseq[t(range 32 73 2)](println t)(Thread/sleep 500))

Third lisp ftw. Esegue l'iterazione dell'intervallo, stampando e dormendo ogni iterazione. Dorme alla fine.

Ungolfed:

(doseq [t (range 32 73 2)]
    (println t)
    (Thread/sleep 500)))

Una versione che alla fine non dorme, 66 byte

(doseq[t(range 32 73 2)](println t)(if(< t 72)(Thread/sleep 500)))

Nota, questi sono programmi completi poiché le istruzioni non specificano. Aggiungi un byte a ciascuno se è necessaria una funzione.

Racchetta 46 byte

(for((i(range 40 73 2)))(println i)(sleep .5))

Ungolfed:

(define (f)
  (for ((i (range 40 73 2)))
    (println i)
    (sleep .5)))

Comando da eseguire: (f)

Ottava, 38 35 byte

Salvato 3 byte grazie a @LuisMendo cambiando endforinend

for i=20:36;disp(2*i);sleep(.5);end

Provalo online!

Sono nuovo di Octave, quindi questa soluzione potrebbe ancora essere ulteriormente migliorata. Tutti i suggerimenti sono benvenuti!

Ungolfed

for i=20:36
  disp(2*i)
  sleep(.5)
end

Python 2, 57 58 byte

modificare

Conta come 57 byte sul mio pratico ma TIO dice 58 ora che sono tornato sulla mia macchina, quindi questa è la mia offerta finale. È interessante notare che TIO non sembra rispettare il timeout e attende solo di stampare l'intero elenco in una volta sola. Funziona su QPython per Android e Python 2 sulla mia casella Ubuntu, quindi è abbastanza buono per me.

import time
for x in range(40,74,2):print x;time.sleep(.5)

Provalo online!

Sarebbe 58 59 in Python 3, quindi non battere @ sonrad10 comunque.

R, 44 42 byte

Semplicemente a circuito chiuso, c'è probabilmente un modo più golfista. (Inoltre, il 44 barrato è ancora regolare 44 ...)

for(i in 20:36*2)cat(i,"\n",Sys.sleep(.5))

F #, 60 byte

async{for i in 40..2..72 do printfn"%d"i;do!Async.Sleep 500}

Questa è un'espressione asincrona, per eseguirla passa in Async.Starto Async.RunSynchronously.

Noodel , 10 byte non competitivi

Impossibile competere perché Noodel è nato dopo la creazione della sfida :(

40Ḷ16ñ++ḍh

Provalo:)

Come funziona

40         # Creates the literal number 40 and places it into the pipe.
  Ḷ16      # Loop the following code 16 times.
     ñ     # Print what is in the front of the pipe with a new line.
      ++   # Increment what is in the pipe by two.
        ḍh # Delay for a half a second (500ms).

Non esiste una versione di Noodel che supporti la sintassi utilizzata in questa risposta. Ecco una versione corretta:

kȥḶ16ñ⁺2ḍh

<div id="noodel" code="kȥḶ16ñ⁺2ḍh" input="" cols="10" rows="17"></div>

<script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>