Este es mi primer concurso de golf.

Qué necesitas hacer

Construirme, en la menor cantidad de bytes posible, mi sistema de control remoto de CA. Mi habitación está muy fría en este momento, y me falta mi control remoto.

Ahora, no quiero que literalmente lo construyas ni nada, solo juega al golf:

Un incremento lento de temperatura, que comienza en 40 grados y termina exactamente en 72. El tiempo de incremento siempre debe ser de 500 milis por incremento. Puede esperar otros 500 ms al final. Sin embargo, preferiría que se detuviera. El incremento en sí mismo debe aumentar en dos cada vez, como mi control remoto.

No deberías borrar la pantalla. Deberías tener nuevas líneas.

Qué debería pasar

Ejemplo de salida (todo lo que está entre paréntesis no se debe mostrar).

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

Tenga en cuenta que este es mi primer golf, así que me disculpo si es demasiado difícil para el golf. :(

¡Mucha suerte, golfistas!

Bash + utilidades de Linux, 19

seq 40 2 72|pv -qlL2

seqgenera la salida numérica. pvlo limita a 2 líneas / seg.

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

Esta solución está mejorada y no se puede ver completa en una, o incluso en dos capturas de pantalla. Utiliza dos fallas y abusa de otras dos características del juego.

Esta solución utiliza los mismos principios que el siguiente, solo un diseño más compacto de 4 bloques.

• Abusa del hecho de que los bloques de comandos de Cadena (bloques verdes) no pueden ser alimentados por redstone, solo por una señal de un bloque de comandos de impulso (naranja).

• Abusa del hecho de que los pistones tardan 0,30 segundos en extenderse por completo, y Redstone solo necesita 0,10 segundos para registrar una señal.

• También abusa de una falla doble para apagar el temporizador (TNT): la piedra roja al lado del temporizador (TNT) no solo se activa, sino que también piensa que la TNT es otra piedra roja y la alimenta.

• Además de todos estos abusos, el acortador de señal (bajo el TNT) es de un solo uso, después de que se enciende, cambia de forma, permitiendo pasar la señal a través del "incrementador" (bloque naranja superior)

Se puede ver un poco de explicación sobre la funcionalidad de sus diferentes partes en las soluciones más antiguas (pero mejor en la que se encuentra a continuación). ¡También puedes probarlo sin conexión! (la solución simplificada se incrementa en 4, funciona solo en 1.11+) ejecutando este comando en un bloque de comandos .

Solución anterior, Minecraft 1.9.0+, 186 blytes:

Como TNT normalmente explota después de 3.0s en Minecraft, este debe ser colocado por un comando ( /setblock) con un fusible especificado. También utiliza un diseño más compacto para eliminar el bloque de comandos redundante (que contiene 42 bytes) y redstone en las versiones anteriores. Estoy seguro de que esto no puede bajar más ...

Solución anterior, Minecraft 1.9.0+, 232 blytes:

Vaya, descubrí que estas soluciones anteriores aumentan en 4 ...

Utiliza la función de cadena de bloque de comando 1.9 (cosa de bloque verde) para guardar bloques. También utiliza un acortador de señal más compacto que en las soluciones más antiguas.

Solución aún más antigua, Minecraft 1.7.0+, 240 blytes:

Utiliza un temporizador más compacto (TNT) que la primera solución (a continuación).

La solución más antigua, Minecraft 1.7.0+, 262 blytes:

Esto es tan largo debido a la forma en que Minecraft maneja las variables:

• Para definir una variable (int): scoreboard objectives add <variable> dummy

• Para establecer un valor en una variable (cada entidad, incluidos los jugadores, tiene su propio valor de variable): scoreboard players set <entity> <variable> <value>

  • *se puede usar <entity>para seleccionar todas las entidades y guardar bytes.

  • solo se pueden usar variables definidas

  • el valor de la variable debe establecerse en un número, no en una variable

• Para incrementar var1 por var2: scoreboard players operation <entity> var1 += <entity> var2

  • <entity>debe ser una sola entidad, por ejemplo. @pno*

_{Las capturas de pantalla son mías, con doble licencia bajo WTFPL y qué licencia SE decide usar hoy (actualmente cc by-sa 3.0 with attribution required) :-)}

Vim, 24 , 23 bytes / pulsaciones de teclas

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

¡Un byte guardado gracias a @Kritixi Lithos!

Escrito desde mi teléfono, probado en vim móvil (que aparentemente es algo real).

Aquí hay un gif que se está ejecutando:

Y aquí hay una explicación de comando por 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 bytes

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

f()

Jalea , 13 12 bytes

40µṄœS.+2µ⁴¡

Pruébalo en línea! El programa Jelly está envuelto en un script Bash para prefijar cada línea de salida con una marca de tiempo.

Cómo funciona

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.

Después de la última iteración, el valor final de 72 se imprime implícitamente y el programa sale.

Perl 6 , 30 bytes

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

Lamento que parezca un código sin golf, no veo una forma de acortarlo ...

La versión que se detiene justo después del último número sería de 37 bytes:

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

Pyth - 12 bytes

Muy simple, usa un bucle for de 0-17.

V17+40yN.d.5

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

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

Tenga en cuenta que muchos comandos son tokens de un solo byte.

MATL , 14 bytes

17:E38+".5Y.@D

Pruébalo en MATL Online! Es posible que deba volver a cargar la página si inicialmente no funciona.

Explicación

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)

Versión anterior (antes del cambio de especificaciones), borrando la pantalla

17:E38+"5&Xx@D

Pruébalo en MATL Online!

Dyalog APL , 20 bytes

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

{ la función anónima

 ⎕DL retrasar...

 .5⊣ la mitad (un segundo) en lugar del valor de

 ⎕← imprimir (con nueva línea)

 ⍵ el argumento

}¨ aplicado a cada uno de

38+ treinta y ocho más

2× dos veces

⍳17 los enteros del 1 al 17

C compilado con Clang 3.8.1 en Linux, 62 59 58 bytes

2 bytes guardados gracias a @ranisalt

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

59 bytes

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

62 bytes

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 bloques

(espacio en disco 56.0kb)

^{(Perdón por la baja resolución!)}

Se explica por sí mismo, de verdad. El valor de la variable se muestra en un cuadro en el "escenario".

Mathematica, 34 bytes

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

Programa completo No toma entradas y salidas a STDOUT.

R, 49 bytes

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

Solución muy trivial pero hace el truco.

Perl 6 , 27 bytes

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

saydevuelve True, que se convierte en un valor numérico 1cuando se divide por 2.

Las travesuras Unicode pueden reducirlo a 23 caracteres:

sleep .say/2 for ㊵,㊷…72

Pero eso es 29 bytes codificados en UTF-8.

Python 2, 57 56 55 Bytes

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

EDITAR:

-1 Byte gracias a Mega Man

-1 Byte gracias a Flp.Tkc

Rubí, 33 bytes

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

C #, 95 bytes

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

Es un bucle simple, espera 500 ms adicionales al final.

QBIC , 21 bytes

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

QBIC inicia un bucle FOR, que va de 44 a 72 e incrementa el contador en 4 en cada bucle. Luego duerme durante 1 segundo. QBasic no tiene una fuente de control más fina sleep, por lo que he agregado una .para simular dar .5como argumento.

Kotlin, 47 bytes

Supongo que no se dijo en la declaración del problema que las soluciones deberían contener un incremento de dos, por lo 40+2*ique aquí es legal.

Si se escribe como una fuente de Kotlin normal con main:

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

^{(77 bytes)}

UPD : en Kotlin 1.3, args:Array<String>se puede eliminar, por lo que son 18 bytes menos.

Y en Kotlin Script, todo el programa sería

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

^{(47 bytes)}

Ruby 31 bytes

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

Pruébalo en línea!

Haskell, 67 bytes

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

Si solo quieres usar ghc, puedes guardar algunos bytes importando GHC.Concy usando en threadDelaylugar de usleep.

php, 38 bytes

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

usa guión bajo como delimitador. Corre con -nr.

Clojure, 54 bytes

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

Tercer ceceo ftw. Simplemente itera sobre el rango, imprimiendo y durmiendo cada iteración. Duerme al final.

Sin golf:

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

Una versión que no duerme al final, 66 bytes.

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

Tenga en cuenta que estos son programas completos ya que las instrucciones no especifican. Agregue un byte a cada uno si se requiere una función.

Raqueta 46 bytes

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

Sin golf:

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

Comando para ejecutar: (f)

Octava, 38 35 bytes

Guardado 3 bytes gracias a @LuisMendo al cambiar endforaend

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

Pruébalo en línea!

Soy nuevo en Octave, por lo que esta solución aún podría jugarse más. Cualquier consejo es bienvenido!

Sin golf

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

Python 2, 57 58 Bytes

Editar

Contaba como 57 bytes en mi mano, pero TIO dice 58 ahora que estoy de vuelta en mi propia máquina, así que esa es mi oferta final. Curiosamente, TIO no parece respetar el tiempo de espera y simplemente espera y luego imprime toda la lista de una vez. Funciona en QPython para Android y Python 2 en mi caja de Ubuntu, así que eso es lo suficientemente bueno para mí.

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

Pruébalo en línea!

Sería 58 59 en Python 3, así que no supera a @ sonrad10 de todos modos.

R, 44 42 bytes

Sencillo for-loop, es probable que haya una forma más golfista. (Además, el tachado 44 sigue siendo regular 44 ...)

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

F #, 60 bytes

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

Esta es una expresión asíncrona, para ejecutarla, pasarla a Async.Starto Async.RunSynchronously.

Noodel , 10 bytes no competitivos

No puede competir porque Noodel nació después de que se creó el desafío :(

40Ḷ16ñ++ḍh

Intentalo:)

Cómo funciona

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

No hay una versión de Noodel que admita la sintaxis utilizada en esta respuesta. Aquí hay una versión correcta:

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>