Ceci est mon premier concours de golf.

Qu'as tu besoin de faire

Construisez-moi, en un minimum d'octets, mon système de contrôle à distance AC. Ma chambre est trop froide en ce moment et il me manque ma télécommande.

Maintenant, je ne veux pas que vous le construisiez littéralement ou quoi que ce soit, simplement jouer au golf ceci:

Incrément de température lent, commençant à 40 degrés et se terminant à exactement 72 ° C. Le temps d'incrémentation doit toujours être de 500 millisecondes par incrément. Il peut attendre encore 500ms à la fin. Je préférerais que ça s'arrête cependant. L'incrément lui-même doit augmenter de deux à chaque fois, comme ma télécommande.

Vous ne devriez pas effacer l'écran. Vous devriez avoir de nouvelles lignes.

Ce qui devrait arriver

Exemple de sortie (tout ce qui est entre parenthèses ne devrait pas être sorti).

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

N'oubliez pas que c'est mon premier golf, alors je m'excuse si c'est trop difficile à jouer. :(

Bonne chance, golfeurs!

Utilitaires Bash + Linux, 19

seq 40 2 72|pv -qlL2

seqgénère la sortie numérique. pvle limite à 2 lignes / sec.

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

Cette solution est loupée et ne peut pas être vue entière dans un, ou même deux captures d'écran. Utilise deux erreurs et abuse deux autres caractéristiques du jeu

Cette solution utilise les mêmes principes que celle ci-dessous, à savoir un design plus compact de 4 blocs.

• Abuse du fait que les blocs de commande en chaîne (blocs verts) ne peuvent pas être alimentés par redstone, uniquement par un simple extrait d'un bloc de commande d'impulsion (orange).

• Abuse du fait que les pistons ont besoin de 0,30 seconde pour s’étirer complètement, et Redstone n’a besoin que de 0,10 seconde pour enregistrer un signal.

• Abuse également un double problème pour désactiver le minuteur (TNT): le redstone situé à côté du minuteur (TNT) est non seulement alimenté, mais pense également que le TNT est un autre redstone et le met sous tension.

• En plus de tous ces abus, le signal raccourcisseur (chose sous la TNT) est à usage unique , après il obtient alimenté il change de forme, ce qui permet de faire passer le signal à travers à la « incrémenteur » (bloc supérieure orange)

Un peu d'explication sur la fonctionnalité de ses différentes parties peut être vu dans les solutions plus anciennes (mais mieux dans celle ci-dessous). Vous pouvez également l' essayer hors ligne! (solution simplifiée incrémentée de 4, fonctionne uniquement dans 1.11+) en exécutant cette commande dans un bloc de commandes .

Ancienne solution, Minecraft 1.9.0+, 186 blytes:

Puisque TNT explose normalement après les versions 3.0 dans Minecraft, celle-ci doit être placée par un command ( /setblock) avec un fusible spécifié. Utilise également une conception plus compacte pour supprimer le bloc de commande redondant (contenant 42 octets) et redstone par rapport aux versions antérieures. Je suis sûr que ça ne peut pas être plus bas ...

Ancienne solution, Minecraft 1.9.0+, 232 blytes:

Oups, j'ai découvert ces anciennes solutions par incréments de 4 ...

Utilise la fonction de chaîne de blocs de commande 1.9 (élément de bloc vert) pour enregistrer des blocs. Utilise également un raccourcisseur de signal plus compact que dans les solutions plus anciennes

Même solution plus ancienne, Minecraft 1.7.0+, 240 blytes:

Utilise une minuterie plus compacte (TNT) que la première solution (ci-dessous).

La solution la plus ancienne, Minecraft 1.7.0+, 262 blytes:

C'est si long à cause de la façon dont Minecraft gère les variables:

• Pour définir une variable (int): scoreboard objectives add <variable> dummy

• Pour définir une valeur sur une variable (chaque entité, y compris les joueurs, a sa propre valeur de variable): scoreboard players set <entity> <variable> <value>

  • *peut être utilisé <entity>pour sélectionner toutes les entités et économiser des octets.

  • seules des variables définies peuvent être utilisées

  • la valeur de la variable doit être définie sur un nombre et non sur une variable

• Pour incrémenter var1 de var2: scoreboard players operation <entity> var1 += <entity> var2

  • <entity>doit être une seule entité, par exemple. @p, ne pas*

_{Les captures d’écran sont de moi, sous licence double sous WTFPL et quelle licence SE décide d’utiliser aujourd’hui (actuellement cc by-sa 3.0 with attribution required) :-)}

Vim, 24 , 23 octets / frappes

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

Un octet enregistré grâce à @Kritixi Lithos!

Écrit à partir de mon téléphone, testé sur vim mobile (ce qui est apparemment une chose réelle).

Voici un gif de celui-ci en cours d'exécution:

Et voici une explication commande par commande:

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 octets

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

f()

Gelée , 13 à 12 octets

40µṄœS.+2µ⁴¡

Essayez-le en ligne! Le programme Jelly est encapsulé dans un script Bash pour préfixer chaque ligne de sortie par un horodatage.

Comment ça fonctionne

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.

Après la dernière itération, la valeur finale de 72 est imprimée implicitement et le programme se ferme.

Perl 6 , 30 octets

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

Désolé que cela ressemble à du code sans jeu, je ne vois pas comment le rendre plus court ...

La version qui s’arrête juste après le dernier numéro serait 37 octets:

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

Pyth - 12 octets

Très simple, utilise une boucle for de 0 à 17.

V17+40yN.d.5

TI-Basic (CE ou CSE uniquement), 16 octets

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

Notez que de nombreuses commandes sont des jetons sur un octet.

MATL , 14 octets

17:E38+".5Y.@D

Essayez-le dans MATL Online! Vous devrez peut-être recharger la page si cela ne fonctionne pas initialement.

Explication

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)

Ancienne version (avant modification des spécifications), effacement de l'écran

17:E38+"5&Xx@D

Essayez-le dans MATL Online!

Dyalog APL , 20 octets

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

{ la fonction anonyme

 ⎕DL retard...

 .5⊣ demi (une seconde) plutôt que la valeur de

 ⎕← print (avec nouvelle ligne)

 ⍵ l'argument

}¨ appliqué à chacun des

38+ trente huit plus

2× deux fois

⍳17 les entiers de 1 à 17

C compilé avec Clang 3.8.1 sur Linux, 62 59 58 octets

2 octets enregistrés grâce à @ranisalt

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

59 octets

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

62 octets

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 blocs

(espace disque 56.0kb)

^{(désolé pour la basse résolution!)}

Explicite, vraiment. La valeur de la variable est affichée dans une case sur la "scène".

Mathematica, 34 octets

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

Programme complet. Ne prend aucune entrée et ne sort pas vers STDOUT.

R, 49 octets

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

Solution très triviale mais ça fait l'affaire.

Perl 6 , 27 octets

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

sayretourne True, qui est forcé à un numérique 1quand divisé par 2.

Les manigances Unicode peuvent le réduire à 23 caractères:

sleep .say/2 for ㊵,㊷…72

Mais cela représente 29 octets codés en UTF-8.

Python 2, 57 56 55 octets

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

MODIFIER:

-1 octet grâce à Mega Man

-1 octet grâce à Flp.Tkc

Ruby, 33 octets

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

C #, 95 octets

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

C'est une boucle simple, elle attend 500 ms de plus à la fin.

QBIC , 21 octets

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

QBIC commence une boucle FOR, allant de 44 à 72 et incrémentant le compteur de 4 à chaque boucle. Il dort ensuite pendant 1 seconde. QBasic n’a pas de contrôle plus fin sleep, donc j’ai ajouté un .pour simuler le fait de donner .5comme argument.

Kotlin, 47 octets

Je suppose que l’énoncé du problème n’indique pas que les solutions doivent en réalité comporter des incréments de deux, c’est donc 40+2*ilégal ici.

Si écrit en tant que source Kotlin standard avec main:

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

^{(77 octets)}

UPD : Dans Kotlin 1.3, args:Array<String>peut être supprimé, donc 18 octets de moins.

Et dans Kotlin Script, tout le programme serait

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

^{(47 octets)}

Ruby 31 octets

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

Essayez-le en ligne!

Haskell, 67 octets

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

Si vous voulez utiliser uniquement ghc, vous pouvez enregistrer quelques octets en important GHC.Concet en utilisant threadDelayplutôt que usleep.

php, 38 octets

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

utilise le trait de soulignement comme délimiteur. Courez avec -nr.

Clojure, 54 octets

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

Troisième lisp ftw. Il suffit de parcourir la plage, d’imprimer et de dormir chaque itération. Dort à la fin.

Ungolfed:

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

Une version qui ne dort pas à la fin, 66 octets

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

Notez que ce sont des programmes complets puisque les instructions ne spécifient pas. Ajoutez un octet à chacun si une fonction est requise.

Raquette 46 octets

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

Ungolfed:

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

Commande à exécuter: (f)

Octave, 38 35 octets

Vous avez enregistré 3 octets grâce à @LuisMendo en passant endforàend

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

Essayez-le en ligne!

Je suis nouveau chez Octave, alors cette solution pourrait encore être jouée plus loin. Tous les conseils sont les bienvenus!

Ungolfed

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

Python 2, 57 58 octets

Modifier

Compté comme 57 octets sur ma pratique, mais TIO dit 58 maintenant que je suis de retour sur ma propre machine, donc c’est ma dernière offre. Il est intéressant de noter que TIO ne semble pas respecter le délai d’attente et attend simplement, puis affiche la liste entière en une seule fois. Fonctionne sur QPython pour Android et Python 2 sur ma machine Ubuntu, donc ça me suffit.

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

Essayez-le en ligne!

Serait 58 59 en Python 3 alors ne bat pas @ sonrad10 de toute façon.

R, 44 42 octets

Simple pour la boucle, il y a probablement une manière plus golfeuse. (En outre, le 44 barré est toujours régulier 44 ...)

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

F #, 60 octets

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

Ceci est une expression asynchrone, afin de l'exécuter, transmettez-la à Async.Startou Async.RunSynchronously.

Noodel , non concurrent de 10 octets

Ne peut pas rivaliser parce que Noodel est né après la création du défi :(

40Ḷ16ñ++ḍh

Essayez-le :)

Comment ça fonctionne

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

Aucune version de Noodel ne prend en charge la syntaxe utilisée dans cette réponse. Voici une version qui est correcte:

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>