Sfida

Scrivi una funzione che accetta un parametro: un numero intero t. La tua funzione deve interrompere il programma per alcuni tsecondi prima di continuare, simile a time.sleep(t)Python e WAIT tBBC BASIC.

Non è necessario utilizzare alcuna funzione di attesa incorporata o alcuna funzione incorporata per eseguire il codice dopo un certo tempo e il programma deve riprendere dopo alcuni tsecondi.

Per testare la tua funzione, c'è una tolleranza di 0,1 secondi in più o in meno rispetto a quella fornita tsul tuo computer: le variazioni tra i computer vanno bene.

Se la tua risposta è contestata da chiunque, devi fornire prova fotografica (schermata) che la tua funzione funzioni correttamente per t=1, t=5e t=25. Puoi anche fornire i dettagli del tuo computer in modo che le persone possano provare a replicarlo sul proprio computer.

Il programma dovrebbe e verrà eseguito su un computer con una velocità di clock di 1,6 GHz o superiore.

vincente

Vince il programma più breve.

generosità

Una taglia uscirà nel programma più breve che arresta il programma senza usare un ciclo per controllare quanto tempo è trascorso. Se sei in corsa per questa taglia, aggiungi una nota a piè di pagina che dice che la tua risposta è per la taglia.

Classifica

/* 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>

codice macchina x86_64, 10 byte

Hexdump del codice:

48 69 c9 ca fc 59 38 e2 fe c3

Codice sorgente (può essere assemblato da ml64Visual Studio):

    TITLE   heh

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

Esegue un ciclo vuoto, partendo dal valore specificato fino a 0. Ho scelto empiricamente il moltiplicatore 945421514 per tentativi ed errori, fino a quando il mio programma di test ha prodotto risultati soddisfacenti.

Programma test (attende 10 volte per ciascuna delle durate 1, 5 e 25 secondi):

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

Il risultato:

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

Ho eseguito questo programma su un computer Windows che non ha nient'altro da fare. Se esegue alcune applicazioni, i tempi di attesa sono più irregolari.

La velocità della CPU è di 3,9 GHz. Sembra che questo codice sia appena abbastanza buono per l'attuale tecnologia PC - se la frequenza di clock è di circa 8,8 GHz, il moltiplicatore non si inserirà in un int a 32 bit con segno.

PS Dato che questa risposta non controlla quanto tempo è passato, è un candidato per la taglia.

Bash, 29 25 24 23 19 byte

w()(ping -t$1 1.2)

Test di precisione ( time) dove $1= 1 secondo:

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

Grazie Dennis per aver rasato il conteggio dei byte fino a 19 da 23!

EDIT : ho cambiato l'IP per evitare pingil pinging Linux 0.0.0.0, che è il dispositivo di loopback.

Come funziona

ping ha un timeout predefinito di 1 secondo, quindi, quando si contatta un indirizzo IP che non esiste, il ping non può continuare fino a quando non è trascorso il timeout o non ha ricevuto una risposta dall'IP.

-tdice pingdi provare $1più volte su questo falso indirizzo IP, costringendo pinga impiegare $1qualche secondo per completare il ping.

Matlab, 33 byte

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

Oppure puoi anche usarlo in Octave: provalo online

Matlab, 31 byte

Come suggerito da @flawr , può essere fatto con una funzione anonima (dovrebbe essere assegnato un nome per usarlo):

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

Esempio:

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

Java, 63 62 byte

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

Niente di sorprendente: afferra il numero di nanosecondi dal 1/1/1970 più volte e controlla se è passato un secondo.

Salvato 1 byte grazie a Ypnypn e aditsu.

Lotto, 27 byte

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

Un trucco batch popolare, poiché batch non aveva una funzione sleep.

Nessun loop, quindi idoneo alla taglia

Commodore 64 BASIC, 19 16 byte

1000 FORI=1TO930*N:NEXT:RETURN

Con una chiamata N=<number-of-secods>:GOSUB1000 .

Tuttavia, non posso fornire una precisione sufficiente. A causa C64 aveva circa la velocità della CPU 1 MHz, mi ricordo che era abbastanza buono per fare un vuoto FOR- NEXTciclo 1000 volte in modo che fosse circa 1 secondo.

In effetti c'erano due versioni principali della macchina: PAL 0,985 MHz e NTSC 1,023 MHz (tutti i dati dalla pagina Wikipedia C64 ). Dato che avevo la versione NTSC, era necessario eseguire il ciclo circa 930 volte.

Test con il seguente programma ( Nsecondi, forniti dall'utente in 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

dove si TI$trova una variabile di sistema contenente stringa ( hhmmssformato) con il tempo trascorso dall'ultimo ripristino (precisione di 1 secondo, tuttavia anche in base alla velocità della CPU, quindi non è del tutto rilevante, poiché è lo stesso clock).

Screenshot realizzato con l'emulatore C64 online http://codeazur.com.br/stuff/fc64_final/ .

Questo programma ( 1000solo riga ) occupa 16 19 byte in memoria, come testato con PRINT FRE(0)+65535entrambi prima di digitare il codice (38908 byte) e dopo ( 38893 38889 byte). PRINT FRE(0)restituisce memoria libera per il programma BASIC (è un valore negativo e costante65535 deve essere aggiunta una , ma in realtà non importa).

Poiché questo programma non verifica il tempo trascorso in un ciclo, si qualifica per una taglia.

JavaScript ES6, 50 45 40 byte

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

questo utilizza funzioni auto-eseguite, non sono sicuro del perché +new Datenon funzioni .

uso

Ho provato questo con Safari Nightly ma funzionerà anche su Firefox. Testato con:

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

Puoi eseguirlo circondandolo tra parentesi:

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

O nominandolo:

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

Spiegazione

Ecco la logica principale alla base del programma:

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 versione che sto usando usa la stessa logica:

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

Questo è un blocco che può essere eseguito o memorizzato in una variabile (diventando così una funzione denominata). Dennis e Mr Consensus concordano sul fatto che contare solo il blocco sia accettabile :)

Spiegazione:

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

Provalo online

JavaScript, 68 54 51 42

Penso che non sia necessario uno screenshot. Ma sospetto che potresti giocare a golf ancora di più ...

Nuova versione: ora sono finalmente riuscito a evitare newe utilizzare Datedue volte:

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

Versioni precedenti:

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 byte

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

Uso:
chiama la funzione in questo modo:
php -d error_reporting=0 -r "require 'script.php'; a(5);echo 'Hello, World!';"
dove 5 è il tempo in secondi che il programma dovrebbe attendere prima che echi "Ciao, mondo!".

Spiegazione:
Inizialmente la funzione ottiene l'ora corrente in millisecondi. Quindi la funzione esegue un ciclo fino a quando l'ora corrente è più piccola della prima volta + l'ingresso. Successivamente "Hello World!" viene fatto eco.

Log:
Salvato 113 byte grazie a Voitcus
Salvato 2 byte grazie ad axiac

Julia, 33 20 byte

t->watch_file(".",t)

Funziona solo in Julia v0.4 a causa di cambiamenti nella firma della funzione di watch_file. Definisce una funzione anonima con un singolo parametro tche (ab) utilizza il parametro timeout inwatch_file funzione.

Questo è un candidato per la taglia!

Dimostrazione usando il REPL di Julia:

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

Risposta precedente (33 byte), funzionante anche nella stalla Julia

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

R, 48 byte

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

Dimostrazione:

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 byte

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

(Si noti che posso effettivamente ottenere questo più breve se è necessario un programma completo sfruttando gli argomenti passati sulla riga di comando. Fino a 35 )

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

Programma utilizzato per i test:

<?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);
}

risultati:

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

Anche se mi qualifico per la generosità, difficilmente sono in corsa con alcune delle altre voci!

Windows CMD, 22 byte

ping -w 1000 -n %1 1.1

Questo non usa loop (label e goto), quindi si qualifica per la taglia

Invia tping a 1.0.0.1 (non valido) e attende una risposta per 1000 ms

JavaScript ES6, 40 byte

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

Testato con il seguente:

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 byte

Metodo di input: T:prgmT. Questo è l'equivalente più vicino di una funzione in TI-BASIC. Programma:

For(A,1,841Ans
End

Tutta l'accuratezza è ottenuta tramite tentativi ed errori; il cronometraggio con un cronometro funziona per tutti i casi di test dati entro un ventesimo di secondo.

Informazioni sul dispositivo:

RAM FREE   23312
ARC FREE  889802


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

W00T idoneo per una taglia!

Python, 57 byte

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

Funzione di chiamata y()

PureBasic, 92 byte

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

È il più breve che mi venga in mente. Sospetto che questo sarà il più lungo anche qui ...

Testare:

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

PowerShell, 75 byte

Chiamate di procedura lunghe e descrittive. Yay per chiarezza in una lingua. :)

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

Chiamato all'interno di un programma con qualcosa di simile

Get-Date
w(15)
Get-Date

In alternativa, se è possibile invece chiamare programmi esterni, possiamo arrivare a 59 byte con il seguente:

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

Questo verrebbe chiamato all'interno di un programma come segue (presumendo che quanto sopra sia salvato come "wait-function.ps1" e salvato nella stessa cartella):

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

Ciò che salviamo nello scrivere la funzione / programma è più che ostruito dall'eccesso necessario per eseguirlo effettivamente, però. Le sospiro.

Python, 66 byte

Nota, la mia implementazione non chiama né una funzione di tempo integrata, né l'utilizzo della funzione di pianificazione.

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

E sì, è idoneo per la generosità.

Hassium , 55 byte

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

Esegui e visualizza espanso: http://HassiumLang.com/Hassium/index.php?code=9f4e2bdb292b14b150fba63677a11a79

Pyth, 19 byte

Entrata in ritardo ma dopo aver trovato .d0nella documentazione la scorsa notte ho deciso di provarlo.

DCNK.d0W<-.d0KNJ1))

Definisce una funzione che scorre fino al termine del tempo N secondi.

Provalo qui .

RProgN 2 , 13 byte

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

spiegato

°°°)*™+]³]™>:
°°°             # 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 taglia dice specificamente "senza usare un ciclo per controllare quanto tempo è trascorso ", cosa che non succede. Questo imposta un tempo target e continua a controllare se ha superato quel tempo target, quindi è idoneo per la taglia.

Provalo online!

Tcl , 53 byte

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

Provalo online!

spiegato

Il comando clock millisecondspuò essere ridotto a clock mil, con la 1a parentesi sfuggita, verrà interpretato ad ogni ciclo e senza una sola volta. Poiché misura millisecondi, è necessario moltiplicare per 1000 o 1e3, risparmiando 1 byte.

C # (compilatore interattivo Visual C #) + /u:System.Threading, 36 byte

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

Provalo online!

Crea un semaforo senza capacità e cerca di ottenerlo per il numero di secondi specificato.

Mi rendo conto che sto "aspettando" qualcosa su qui. A me questo sembra più simile alla soluzione ping / timeout al contrarioThread.Sleep . Il codice tenta di ottenere una risorsa che non può ottenere e smette di provare dopo un limite.

===

Di seguito è una variante che inizia Taskcon un ciclo infinito, quindi attende che si completi con un timeout. Tutti gli spazi dei nomi richiesti sono inclusi per impostazione predefinita, ma la soluzione è più lunga di alcuni byte rispetto a quella sopra.

C # (compilatore interattivo Visual C #) , 40 byte

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

Provalo online!

05AB1E , 22 byte

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

Provalo online.

NOTA: a seconda di quanti microsecondi nel secondo corrente sono già passati, la tolleranza potrebbe essere leggermente superiore a 0,1 sec. Ma dato che quasi dimezzare le risposte hanno problemi simili, ho pensato che fosse permesso.

Spiegazione:

05AB1E non ha alcun builtin per l'ora corrente. Tuttavia ha un builtin per l'anno / mese / giorno / ore / minuti / secondi / microsecondi attuali come builtin separati. Dato che usare solo i secondi può potenzialmente passare da 59 a 0 causando problemi, ho bisogno sia dei minuti che dei secondi, rendendo il codice ancora più lungo della maggior parte delle risposte in lingue non codegolfing purtroppo.

ž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 byte

INPUT T
DIALOG"",,,T

Apre una finestra di dialogo che si chiude automaticamente dopo alcuni Tsecondi. Non sono sicuro che ciò valga come "funzione di attesa integrata", ma penso che sia valido quanto l'utilizzo ping.

Un programma alternativo a 37 byte che sicuramente non tradisce:

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

Fa sì che il colore della dissolvenza dello schermo cambi a 0 (alfa = 0, rosso = 0, verde = 0, blu = 0) (nessun effetto) gradualmente per alcuni Tsecondi, quindi attende che l'animazione finisca.