Défi

Ecrivez une fonction qui prend un paramètre: un entier t. Votre fonction doit arrêter votre programme pendant tquelques secondes avant de continuer, comme time.sleep(t)dans Python et WAIT tBBC BASIC.

Vous ne devez utiliser aucune fonction intégrée en attente ni aucune fonction intégrée pour exécuter du code après un certain temps et votre programme doit reprendre après tquelques secondes.

Pour tester votre fonction, il existe une tolérance de 0,1 seconde supérieure ou inférieure à celle indiquée tsur votre propre ordinateur: les écarts entre ordinateurs sont corrects.

Si quiconque conteste votre réponse, vous devez fournir une preuve photographique (avec capture d'écran) indiquant que votre fonction fonctionne correctement pour t=1, t=5et t=25. Vous pouvez également fournir les détails de votre ordinateur pour que les utilisateurs puissent essayer de le répliquer sur leur propre ordinateur.

Votre programme devrait et sera exécuté sur un ordinateur dont la vitesse d'horloge est de 1,6 GHz ou plus.

Gagnant

Le programme le plus court gagne.

Prime

Une prime ira au programme le plus court qui l'arrête sans utiliser de boucle vérifiant le temps écoulé. Si vous êtes en lice pour cette prime, ajoutez une note de bas de page indiquant que votre réponse concerne cette prime.

Classement

/* Configuration */

var QUESTION_ID = 55293; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 30525;

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "http://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "http://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });

    var patt = new RegExp(/[Bb]ounty/);
    var res = patt.test(body);
    var bountyyn = "no";

    if (res) {
      bountyyn = "yes";
    }
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
        bounty: bountyyn
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link)
                   .replace("{{BOUNTY}}", a.bounty);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 400px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td><td>Bounty?</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td>{{BOUNTY}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

x86_64 code machine, 10 octets

Hexdump du code:

48 69 c9 ca fc 59 38 e2 fe c3

Code source (peut être assemblé par ml64Visual Studio):

    TITLE   heh

PUBLIC  mywait
_TEXT   SEGMENT
mywait  PROC
    imul rcx, 945421514
myloop:
    loop myloop
    ret
mywait  ENDP
_TEXT   ENDS
END

Effectue une boucle vide, en partant de la valeur spécifiée jusqu'à 0. J'ai choisi le multiplicateur 945421514 empiriquement par essais et erreurs, jusqu'à ce que mon programme de test produise des résultats satisfaisants.

Programme de test (attend 10 fois pour chacune des durées 1, 5 et 25 secondes):

#include <stdio.h>
#include <time.h>

extern "C" void mywait(int);

int main()
{
    int durations[] = {1, 5, 25};
    for (int duration: durations)
    {
        for (int i = 0; i < 10; ++i)
        {
            clock_t before = clock();
            mywait(duration);
            clock_t after = clock();
            printf("%f\n", (after - before) / (double)CLOCKS_PER_SEC);
        }
    }
    getchar(); // now take a screenshot
}

Le résultat:

1.003000
1.000000
1.004000
1.006000
1.005000
0.998000
0.995000
1.000000
1.005000
1.004000
4.999000
5.003000
5.035000
5.010000
4.992000
5.003000
5.003000
5.019000
5.026000
4.989000
25.041000
24.993000
25.049000
24.988000
25.038000
24.948000
25.007000
25.014000
25.053000
25.021000

J'ai exécuté ce programme sur un ordinateur Windows qui n'a rien d'autre à faire. Si certaines applications sont exécutées, les temps d’attente sont plus irréguliers.

La vitesse du processeur est de 3,9 GHz. Il semble que ce code est à peine suffisant pour la technologie PC actuelle - si la fréquence d'horloge est d'environ 8,8 GHz, le multiplicateur ne s'intégrera pas dans un int signé 32 bits.

PS Comme cette réponse ne vérifie pas combien de temps s'est écoulé, c'est un candidat à la prime.

Bash, 29 25 24 23 19 octets

w()(ping -t$1 1.2)

Test de précision ( time) où $1= 1 seconde:

real    0m1.012s
user    0m0.001s
sys     0m0.002s

Merci Dennis d'avoir réduit le décompte d'octets à 23 sur 19!

EDIT : J'ai changé l'adresse IP pour éviter pingle ping 0.0.0.0 sur Linux, qui est le périphérique de bouclage.

Comment ça marche

ping Le délai d'attente par défaut est de 1 seconde. Par conséquent, lorsque vous contactez une adresse IP qui n'existe pas, la commande ping ne peut pas continuer tant que le délai d'attente n'est pas écoulé ou si une réponse est fournie par l'adresse IP.

-tindique pingd'essayer le $1nombre de fois sur cette fausse adresse IP, ce pingqui oblige à prendre $1quelques secondes pour terminer le ping.

Matlab, 33 octets

function f(t)
tic;while toc<t,end

Ou vous pouvez aussi l'utiliser dans Octave: essayez-le en ligne

Matlab, 31 octets

Comme suggéré par @flawr , cela peut être fait avec une fonction anonyme (il faut lui donner un nom pour pouvoir l'utiliser):

@(t)eval('tic;while toc<t,end')

Exemple:

>> f=@(t)eval('tic;while toc<t,end');
>> tic, f(2), toc
Elapsed time is 2.000323 seconds.

Java, 63 62 octets

t->{for(long a=System.nanoTime();System.nanoTime()-a<t*1E9;);}

Rien d’étonnant, il suffit de saisir le nombre de nanosecondes depuis le 1/1/1970 à plusieurs reprises et de vérifier si une seconde s’est écoulée.

Enregistré 1 octet grâce à Ypnypn et aditsu.

Lot, 27 octets

set /a c=%1+1
ping -n %c% 0

Une astuce de lot populaire, puisque batch n'avait pas de fonction de veille.

Pas de boucle, donc prime éligible

Commodore 64 BASIC, 19 16 octets

1000 FORI=1TO930*N:NEXT:RETURN

Avec un appel N=<number-of-secods>:GOSUB1000.

Cependant, je ne peux pas fournir assez de précision. Parce que C64 avait environ 1 MHz vitesse du processeur, je me souviens qu'il était assez bon pour faire un vide FOR- NEXTboucle 1000 fois de sorte qu'il était sur les 1 seconde.

En fait, il existait deux versions principales de la machine: PAL 0,985 MHz et NTSC 1,023 MHz (toutes les données de la page Wikipedia C64 ). Comme j'avais la version NTSC, il était nécessaire d'exécuter la boucle environ 930 fois.

Tests avec le programme suivant ( Nsecondes, fournies par l'utilisateur dans INPUT):

10 INPUT N
20 PRINT TI$
30 GOSUB 1000
40 PRINT TI$
50 END
1000 FOR I=1 TO 930*N:NEXT I:RETURN

où TI$est une variable système contenant une chaîne ( hhmmssformat) avec le temps écoulé depuis la dernière réinitialisation (précision d'une seconde, mais également en fonction de la vitesse du processeur, ce qui n'est donc pas tout à fait pertinent, car c'est la même horloge).

Capture d'écran réalisée avec l'émulateur C64 en ligne http://codeazur.com.br/stuff/fc64_final/ .

Ce programme (ligne 1000uniquement) occupe 16 19 octets en mémoire, comme testé avec à la PRINT FRE(0)+65535fois avant de taper le code (38908 octets) et après ( 38893 38889 octets). PRINT FRE(0)retourne de la mémoire libre pour le programme BASIC (c'est une valeur négative et une constante 65535doit être ajoutée, mais en réalité cela n'a pas d'importance).

Parce que ce programme ne teste pas le temps écoulé dans une boucle, il se qualifie pour une prime.

JavaScript ES6, 50 45 40 octets

n=>{for(g=Date.now,z=g();z+n*1e3>g(););}

cela utilise des fonctions auto-exécutables, vous ne savez pas pourquoi +new Datene fonctionne pas.

Usage

J'ai testé cela avec Safari Nightly, mais cela fonctionnera également sur Firefox. Testé avec:

(
  n=>{for(g=Date.now,z=g();z+n*1e3>g(););}
)(1); // 1 is the delay is seconds
console.log( 'foo' );

Vous pouvez l'exécuter soit en l'entourant de parenthèses:

( n=>{for(g=Date.now,z=g();z+n*1e3>g(););} )(5)

Ou en le nommant:

const wait=n=>{for(g=Date.now,z=g();z+n*1e3>g(););}
wait(5)

Explication

Voici la logique principale du programme:

function (n) {
    var start = Date.now();   // Save start time (ms)
    while (                   // while is synchronous, it'll block the code execution until it has finished
           start + (n * 1000) // This is the end time (start + delay)
            > Date.now()      // When the current time is 1 ms past the target end time, stop. resuming the code execution
          );
}

La version que j'utilise utilise la même logique:

n=>{ // Function with argument n, { is required if the functions is not just an expression
   for(           // For will also block code execution
                  // This first part is used to define variables
      g=Date.now, // Add an alias for Date.now as "g"
      z=g()       // get current time and store in z
      ;           // Next part, condition
      z + n*1e3   // Target end time, ( start + delay (converted to seconds) ) 1e3 is 1000 but in big e notation
      ;           // Is required for a valid for loop
   );
}

CJam, 15

{e3es+{_es>}g;}

C'est un bloc qui peut être exécuté ou stocké dans une variable (devenant ainsi une fonction nommée). Dennis et M. Consensus s'accordent pour dire qu'il est acceptable de ne compter que le bloc :)

Explication:

e3       multiply the argument by 1000 (to get milliseconds)
es       get the current timestamp in milliseconds
+        add the values, obtaining the stopping time
{…}g     do…while
  _      duplicate the stopping time
  es>    check if we reached that time yet (loop condition)
;        discard the stopping time

Essayez-le en ligne

JavaScript, 68 54 51 42

Je pense qu'aucune capture d'écran n'est nécessaire. Mais je suppose que vous pourriez jouer au golf encore plus ...

Nouvelle version: j'ai enfin réussi à éviter newet à utiliser Datedeux fois:

f=t=>{for(x=(d=Date.now)();d()<x+t*1e3;);}

Versions plus anciennes:

f=t=>{for(x=new Date();(new Date()|0)<x|0+t*1e3;);}

f=t=>{x=(new Date())|0;while((new Date()|0)<x+t*1e3);}

f=t=>{x=new Date().getSeconds();while(new Date().getSeconds()<x+t);}

PHP, 171 177 84 79 65 64 62 octets

<?php function a($i){for($f=microtime,$e=$f(1)+$i;$f(1)<$e;);}

Utilisation:
Appelez la fonction comme suit:
php -d error_reporting=0 -r "require 'script.php'; a(5);echo 'Hello, World!';"
Où 5 est le temps en secondes pendant lequel le programme doit attendre avant de faire écho à "Hello, World!".

Explication:
La fonction obtient d'abord l'heure actuelle en millisecondes. Ensuite, la fonction effectue une boucle jusqu'à ce que l'heure actuelle soit inférieure à la première fois + l'entrée. Après "Hello World!" se fait écho.

Journal:
enregistré 113 octets grâce à Voitcus
enregistré 2 octets grâce à axiac

Julia, 33 20 octets

t->watch_file(".",t)

Fonctionne uniquement dans Julia v0.4 en raison de modifications de la signature de fonction de watch_file. Définit une fonction anonyme avec un paramètre unique tqui (ab) utilise le paramètre timeout dans la watch_filefonction.

C'est un candidat à la prime!

Démonstration à l'aide du Julia REPL:

julia> f=t->watch_file(".",t)
(anonymous function)

julia> @elapsed f(1)
1.002134983

julia> @elapsed f(5)
5.006161965

julia> @elapsed f(25)
25.026096192

Réponse précédente (33 octets), travaillant également dans Julia stable

t->(b=time();while b+t>time()end)

R, 48 octets

f=function(t){a={g=Sys.time}();while(g()<a+t){}}

Manifestation:

t0 <- Sys.time();f(1); Sys.time() - t0 
## Time difference of 1.000272 secs

t0 <- Sys.time();f(5); Sys.time() - t0 
## Time difference of 5.011189 secs

t0 <- Sys.time();f(25); Sys.time() - t0 
## Time difference of 25.00848 secs

PHP, 39 octets

function a($a){while($i++<.4583e8*$a);}

(Notez que je peux réellement raccourcir cette étape si un programme complet est requis en tirant parti des arguments passés en ligne de commande. Jusqu'à 35 )

<?php while($i++<.4583e8*$argv[1]);

Programme utilisé pour les tests:

<?php function a($a){while($i++<.4583e8*$a);}

record(1);
record(5);
record(25);

function record($t)
{
    $time = microtime_float();
    a($t);
    echo microtime_float() - $time."\n";
}

function microtime_float()
{
    list($usec, $sec) = explode(" ", microtime());
    return ((float)$usec + (float)$sec);
}

Résultats:

JamesWebster:Documents jameswebster$ php A.php
1.0093479156494
4.9945771694183
24.971961975098

Bien que je sois admissible à la prime, je suis à peine en lice avec certaines des autres entrées!

CMD Windows, 22 octets

ping -w 1000 -n %1 1.1

Ceci n'utilise pas de boucle (label et goto), donc cela donne droit à la prime

Il envoie des tpings à 1.0.0.1 (invalide) et attend une réponse pendant 1000 ms

JavaScript ES6, 40 octets

t=>{for(t=(d=Date.now)()+t*1e3;d()<t;);}

Testé avec les éléments suivants:

elapsed=(f,t,b=(d=Date.now)())=>(f(t),console.log(d()-b+"ms elapsed")) // accepts func, delay
STOP=t=>{for(t=(d=Date.now)()+t*1e3;d()<t;);}
elapsed(STOP,1)  // prints 1000ms elapsed
elapsed(STOP,5)  // prints 5000ms elapsed
elapsed(STOP,25) // prints 25000ms elapsed

TI-BASIC (84 + SE), 21 octets

Procédé entrée: T:prgmT. C'est l'équivalent le plus proche d'une fonction dans TI-BASIC. Programme:

For(A,1,841Ans
End

Toute précision est obtenue par essais et erreurs; chronométrer avec un chronomètre fonctionne pour tous les cas de test donnés à un vingtième de seconde.

Informations sur le périphérique:

RAM FREE   23312
ARC FREE  889802


 TI-84 Plus Silver Edition
          2.55MP
PROD #: 0A-3-02-37
ID: 0A3DC-C3469-FFE8

W00T éligible à une prime!

Python, 57 octets

import time
b=time.time
def y(i):
 x=b()
 while x+i>b():x

Fonction d'appel y()

PureBasic, 92 octets

Procedure z(t)
t=t*1e3+ElapsedMilliseconds()
While t>ElapsedMilliseconds():Wend
EndProcedure

C'est le plus court auquel je puisse penser. Je pense que ce sera la plus longue ici aussi ...

Tester:

OpenConsole()
i=Val(Input())
s=ElapsedMilliseconds()
z(i)
PrintN(Str(ElapsedMilliseconds()-s))
Input()

PowerShell, 75 octets

Appels de procédure longs et descriptifs. Yay pour la clarté dans une langue. :)

function w{param($i);$n=(Get-Date).AddSeconds($i);while($n-gt(Get-Date)){}}

Appelé dans un programme avec quelque chose comme

Get-Date
w(15)
Get-Date

Alternativement, si nous sommes autorisés à appeler des programmes externes, nous pouvons descendre à 59 octets avec les éléments suivants:

$n=(Get-Date).AddSeconds($args[0]);while($n-lt(Get-Date)){}

Ceci sera appelé dans un programme comme suit (en supposant que ce qui précède soit enregistré sous le nom "wait-function.ps1" et enregistré dans le même dossier):

Get-Date
& ((Split-Path $MyInvocation.InvocationName) + "\wait-function.ps1 15")
Get-Date

Ce que nous économisons en écrivant la fonction / le programme est cependant plus que saturé par l'excès nécessaire pour l'exécuter réellement. Le soupir.

Python, 66 octets

Notez que mon implémentation n’appelle ni une fonction horaire intégrée, ni une fonction de planification.

def S(t):
 try:__import__("Queue").Queue().get(1,t)
 except:pass

Et oui, il est éligible à la prime.

Hassium , 55 octets

func w(t){p=time().second;while((p+t)>time().second)0;}

Exécuter et voir développé: http://HassiumLang.com/Hassium/index.php?code=9f4e2bdb292b14b150fba63677a11a79

Pyth, 19 octets

Entrée tardive mais après avoir trouvé .d0la documentation la nuit dernière, j'ai décidé de tenter le coup.

DCNK.d0W<-.d0KNJ1))

Définit une fonction qui boucle jusqu'à ce que le temps écoulé soit N quelques secondes.

Essayez ici .

RProgN 2 , 13 octets

°°°)*™+]³]™>:

A expliqué

°°°)*™+]³]™>:
°°°             # Push 3 tens to the stack.
   )*           # Get the product of the entire stack, including the implicit input. This is the shortest way to multiply the input by 1000.
     ™+         # Add it to the current time in miliseconds.
       ]        # Duplicate it to use as a (throwaway) conditional.
        ³   :   # Create a function using the next 3 concepts, and while the top of the stack is truthy, execute it.
         ]      # Duplicate the target time
          ™>    # Is it larger than the current time?

La prime dit spécifiquement "sans utiliser de boucle pour vérifier combien de temps s'est écoulé ", ce que cela ne fait pas. Cela définit une heure cible et continue de vérifier si elle est passée, elle est donc éligible pour la prime.

Essayez-le en ligne!

Tcl , 53 octets

proc W t {while "\[clock mil]-[clock mil]<$t*1e3" {}}

Essayez-le en ligne!

A expliqué

La commande clock millisecondspeut être réduite à clock mil, avec le premier crochet échappé, elle sera interprétée à chaque boucle et sans une fois. Comme il mesure des millisecondes, nous devons multiplier par 1000 ou 1e3, ce qui économise 1 octet.

C # (compilateur interactif Visual C #) + /u:System.Threading, 36 octets

x=>new SemaphoreSlim(0).Wait(x*1000)

Essayez-le en ligne!

Crée un sémaphore sans capacité et tente de l'obtenir pendant le nombre de secondes spécifié.

Je me rends compte que j'attends quelque chose ici. Pour moi, cela ressemble plus à la solution ping / timeout, par opposition àThread.Sleep . Le code essaie d'obtenir une ressource qu'il ne peut pas obtenir et arrête d'essayer après une limite.

===

Vous trouverez ci-dessous une variante qui commence Taskpar une boucle infinie, puis attend qu'elle se termine avec un délai d'attente. Tous les espaces de noms requis sont inclus par défaut, mais la solution a quelques octets de plus que celle ci-dessus.

C # (compilateur interactif Visual C #) , 40 octets

x=>Task.Run(()=>{for(;;);}).Wait(x*1000)

Essayez-le en ligne!

05AB1E , 22 octets

žcžb60*+[Džcžb60*+αIQ#

Essayez-le en ligne.

REMARQUE: En fonction du nombre de microsecondes de la seconde en cours, la tolérance peut être légèrement supérieure à 0,1 s. Mais étant donné que presque la moitié des réponses ont des problèmes similaires, je me suis dit que c'était permis.

Explication:

05AB1E n'a pas d'intégrité pour l'heure actuelle. Cependant, il possède une structure intégrée pour l'année en cours / mois / jour / heures / minutes / secondes / microsecondes en tant que fonctions intégrées séparées. Étant donné que seules les secondes peuvent potentiellement générer des problèmes de 59 à 0, il me faut à la fois des minutes et des secondes, ce qui rend le code encore plus long que la plupart des réponses dans les langues autres que le codage.

žc                # Push the current seconds
  žb              # Push the current minutes
    60*           # Multiply it by 60
       +          # Add them together
[                 # Start an infinite loop:
 D                #  Duplicate the initial (minutes*60 + seconds) from before the loop
  žcžb60*+        #  Push the current (minutes*60 + seconds) again
          α       #  And take the absolute difference between the two
           IQ     #  And if this is equal to the input:
             #    #   Stop the infinite loop

SmileBASIC, 20 octets

INPUT T
DIALOG"",,,T

Ouvre une boîte de dialogue qui se ferme automatiquement après Tquelques secondes. Je ne sais pas si cela compte comme une "fonction d’attente intégrée", mais je pense que cela est aussi valable que d’utiliserping .

Un programme alternatif de 37 octets qui ne triche certainement pas:

INPUT T
FADE.,T*60WHILE FADECHK()WEND

Fait en sorte que la couleur de fondu de l'écran passe à 0 (alpha = 0, rouge = 0, vert = 0, bleu = 0) (pas d'effet) progressivement sur Tsecondes, puis attend la fin de l'animation.