Este é o meu primeiro concurso de golfe.

O que você precisa fazer

Construa-me, no menor número de bytes possível, meu sistema de controle remoto CA. Meu quarto está muito frio agora e sinto falta do meu controle remoto.

Agora, eu não quero que você literalmente a construa ou algo assim, apenas jogue o seguinte:

Um incremento lento de temperatura, começando em 40 graus e terminando em exatamente 72. O tempo de incremento deve sempre ser 500 milis por incremento. Pode esperar mais 500ms no final. Eu preferiria parar no entanto. O incremento em si deve subir duas vezes a cada vez, como meu controle remoto.

Você não deve limpar a tela. Você deve ter novas linhas.

O que deveria acontecer

Exemplo de saída (tudo entre parênteses não deve ser gerado).

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

Lembre-se de que este é meu primeiro golfe, então peço desculpas se isso é muito difícil de jogar. :(

Boa sorte, golfistas!

Utilitários Bash + Linux, 19

seq 40 2 72|pv -qlL2

seqgera a saída numérica. pvlimita-o a 2 linhas / s.

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

Esta solução é eficiente e não pode ser vista inteira em uma ou até duas capturas de tela. Usa duas falhas e abusa de outras duas características do jogo

Esta solução utiliza os mesmos princípios que o abaixo, apenas um design mais compacto em 4 blocos.

• Abusa do fato de que os blocos de comando em cadeia (blocos verdes) não podem ser alimentados por redstone, apenas por um sinal de um bloco de comando por impulso (laranja).

• Abusa o fato de os pistões levarem 0,30 segundos para se estender completamente, e o redstone precisa de apenas 0,10s para registrar um sinal.

• Também abusa de uma falha dupla para desativar o timer (TNT): o redstone próximo ao timer (TNT) fica não apenas energizado, mas também acha que o TNT é outro redstone e o aciona.

• Além de todos esses abusos, o encurtador de sinal (que fica sob o TNT) é de uso único, depois de ser energizado, muda de forma, permitindo passar o sinal através dele para o "incrementador" (bloco laranja mais alto)

Um pouco de explicação sobre a funcionalidade de suas diferentes partes pode ser vista em soluções mais antigas (mas melhor na que está logo abaixo). Você também pode experimentar offline! (solução simplificada incrementada por 4, funciona apenas em 1.11+) executando este comando em um bloco de comandos .

Solução antiga, Minecraft 1.9.0+, 186 blytes:

Como o TNT normalmente explode após o 3.0s no Minecraft, este deve ser colocado por um comando ( /setblock) com um fusível especificado. Também usa um design mais compacto para remover o bloco de comando redundante (contendo 42 bytes) e o redstone nas versões mais antigas. Tenho certeza que isso não pode ficar mais baixo ...

Solução mais antiga, Minecraft 1.9.0+, 232 blytes:

Ops, eu descobri que essas soluções mais antigas aumentam 4 vezes ...

Usa o recurso de cadeia de bloco de comando 1.9 (coisa de bloco verde) para salvar blocos. Também usa um encurtador de sinal mais compacto do que nas soluções mais antigas

Solução ainda mais antiga, Minecraft 1.7.0+, 240 blytes:

Usa um timer mais compacto (TNT) do que a primeira solução (abaixo).

Solução mais antiga, Minecraft 1.7.0+, 262 blytes:

Isso é muito longo devido à maneira como o Minecraft lida com variáveis:

• Para definir uma variável (int): scoreboard objectives add <variable> dummy

• Para definir um valor para uma variável (cada entidade, incluindo jogadores, tem seu próprio valor variável): scoreboard players set <entity> <variable> <value>

  • *pode ser usado <entity>para selecionar todas as entidades e salvar bytes.

  • somente variáveis ​​definidas podem ser usadas

  • o valor da variável deve ser definido como um número, não uma variável

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

  • <entity>deve ser uma entidade única, por exemplo. @p, não*

_{As capturas de tela são minhas, com licença dupla sob WTFPL e qual licença a SE decide usar hoje (atualmente cc by-sa 3.0 with attribution required) :-)}

Vim, 24 , 23 bytes / pressionamentos de tecla

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

Um byte economizado graças a @Kritixi Lithos!

Escrito no meu telefone, testado no mobile vim (que aparentemente é uma coisa real).

Aqui está um gif dele em execução:

E aqui está uma explicação 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()

Geléia , 13 12 bytes

40µṄœS.+2µ⁴¡

Experimente online! O programa Jelly é agrupado em um script Bash para prefixar cada linha de saída por um carimbo de data / hora.

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

Após a última iteração, o valor final de 72 é impresso implicitamente e o programa é encerrado.

Perl 6 , 30 bytes

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

Lamento que pareça um código sem golfe, não vejo uma maneira de reduzi-lo ...

A versão que para logo após o último número seria 37 bytes:

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

Pitão - 12 bytes

Muito simples, usa um loop for de 0 a 17.

V17+40yN.d.5

TI-Basic (somente CE ou CSE), 16 bytes

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

Observe que muitos comandos são tokens de byte único.

MATL , 14 bytes

17:E38+".5Y.@D

Experimente no MATL Online! Pode ser necessário recarregar a página se ela não funcionar inicialmente.

Explicação

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)

Versão antiga (antes da alteração das especificações), limpando a tela

17:E38+"5&Xx@D

Experimente no MATL Online!

Dyalog APL , 20 bytes

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

{ a função anônima

 ⎕DL demora...

 .5⊣ meio (um segundo) ao invés do valor de

 ⎕← imprimir (com nova linha)

 ⍵ o argumento

}¨ aplicado a cada um

38+ trinta e oito mais

2× duas vezes

⍳17 os números inteiros de 1 a 17

C compilado com o Clang 3.8.1 no Linux, 62 59 58 bytes

2 bytes salvos graças 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

Arranhão, 5 blocos

(espaço em disco 56.0kb)

^{(desculpe pela baixa resolução!)}

Auto-explicativo, realmente. O valor da variável é exibido em uma caixa no "palco".

Mathematica, 34 bytes

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

Programa completo. Não leva nenhuma entrada e saída para STDOUT.

R, 49 bytes

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

Solução muito trivial, mas funciona.

Perl 6 , 27 bytes

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

sayretorna True, que é coagido a um numérico 1quando dividido por 2.

As travessuras Unicode podem reduzi-lo a 23 caracteres:

sleep .say/2 for ㊵,㊷…72

Mas são 29 bytes codificados em 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 graças ao Mega Man

-1 Byte graças ao Flp.Tkc

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

É um loop simples, aguarda 500ms extras no final.

QBIC , 21 bytes

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

O QBIC inicia um loop FOR, executando de 44 a 72 e incrementando o contador em 4 em cada loop. Em seguida, dorme por 1 segundo. O QBasic não possui um controle mais sofisticado sleep, então adicionei um .para simular doações .5como argumento.

Kotlin, 47 bytes

Eu acho que não foi dito na declaração do problema que as soluções devem realmente conter um incremento de dois, então o 40+2*i é legal aqui.

Se escrito como uma fonte normal do Kotlin com main:

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

^{(77 bytes)}

UPD : No Kotlin 1.3, args:Array<String>pode ser removido, por isso é 18 bytes a menos.

E no Kotlin Script, todo o programa seria

(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}

Experimente online!

Haskell, 67 bytes

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

Se você quiser usar apenas o ghc, poderá salvar alguns bytes importando GHC.Conce usando em threadDelayvez de usleep.

php, 38 bytes

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

usa sublinhado como delimitador. Corra com -nr.

Clojure, 54 bytes

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

Terceiro lisp ftw. Apenas itera no intervalo, imprimindo e adormecendo cada iteração. Dorme no final.

Ungolfed:

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

Uma versão que não dorme no final, 66 bytes

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

Observe que esses são programas completos, pois as instruções não especificam. Adicione um byte a cada um, se uma função for necessária.

Raquete 46 bytes

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

Ungolfed:

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

Comando para executar: (f)

Oitava, 38 35 bytes

Salvo 3 bytes graças a @LuisMendo, alterando endforparaend

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

Experimente online!

Eu sou novo no Octave, portanto essa solução ainda pode ser ainda mais prejudicada. Todas as dicas são bem-vindas!

Ungolfed

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

Python 2, 57 58 bytes

Editar

Contado como 57 bytes, mas o TIO diz 58 agora que estou de volta à minha máquina, então essa é minha oferta final. Curiosamente, o TIO parece não respeitar o tempo limite, apenas espera e depois imprime a lista inteira de uma só vez. Funciona no QPython para Android e Python 2 na minha caixa do Ubuntu, o que é bom o suficiente para mim.

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

Experimente online!

Seria 58 59 em Python 3, por isso não bate @ sonrad10 de qualquer maneira.

R, 44 bytes 42

For-loop simples, provavelmente existe uma maneira de jogar golfe. (Além disso, 44 ​​riscado ainda é 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 é uma expressão assíncrona, para executá-la e transmiti-la para Async.Startou Async.RunSynchronously.

Noodel , 10 bytes não- concorrentes

Não é possível competir porque Noodel nasceu depois que o desafio foi criado :(

40Ḷ16ñ++ḍh

Tente:)

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

Não existe uma versão do Noodel que suporte a sintaxe usada nesta resposta. Aqui está uma versão correta:

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>