Pare, fique lá onde está!

35

Desafio

Escreva uma função que aceite um parâmetro: um número inteiro t. Sua função precisa interromper o programa por tsegundos antes de continuar, semelhante ao time.sleep(t)Python e WAIT tao BBC BASIC.

Você não deve usar nenhuma função incorporada em espera ou executada para executar código após um certo tempo, e seu programa deve continuar após tsegundos.

Para testar sua função, há tolerância de 0,1 segundos a mais ou a menos do que a fornecida tem sua própria máquina: as variações entre os computadores são boas.

Se a sua resposta é desafiado por qualquer pessoa, você deve fornecer prova fotográfica (screenshotted) que a sua função funciona corretamente para t=1, t=5e t=25. Você também pode fornecer os detalhes do seu computador para que as pessoas possam tentar replicá-lo em sua própria máquina.

Seu programa deve e será executado em um computador cuja velocidade de clock seja de 1,6 GHz ou superior.

Ganhando

O programa mais curto vence.

Recompensa

Uma recompensa vai para o programa mais curto que interrompe o programa sem usar um loop para verificar quanto tempo se passou. Se você está concorrendo a essa recompensa, adicione uma nota de rodapé dizendo que sua resposta é para a recompensa.

Entre os melhores

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

Beta Decay
fonte
E se a nossa linguagem de programação preferida ( tosse ) apenas suportar a precisão do tempo em 1 segundo?
Maçaneta
@Doorknob Bem, a entrada é um número inteiro, então tudo bem.
Decay Beta
3
@ Doorknob talvez você possa medir o tempo de execução fora do seu programa, por exemplo, saída de depuração e verificar os carimbos de hora do DebugView.
Thomas Weller
11
O título e o BBC BASICexemplo são uma referência ao programa de TV Sherlock ou estou lendo muito sobre isso?
Fatalize 26/08/15
11
Bem, pelo menos ele fez você perceber que seu título era inexata;)
Fatalize

Respostas:

36

código de máquina x86_64, 10 bytes

Hexdump do código:

48 69 c9 ca fc 59 38 e2 fe c3

Código fonte (pode ser montado pelo ml64Visual Studio):

    TITLE   heh

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

Executa um loop vazio, iniciando do valor especificado até 0. Escolhi o multiplicador 945421514 empiricamente por tentativa e erro, até que meu programa de teste produza resultados satisfatórios.

Programa de teste (aguarda 10 vezes por cada uma das durações 1, 5 e 25 segundos):

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

O resultado:

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

Eu executei este programa em um computador Windows que não tem mais nada para fazer. Se ele executa alguns aplicativos, os tempos de espera são mais irregulares.

A velocidade da CPU é de 3,9 GHz. Parece que esse código é mal bom o suficiente para a tecnologia atual do PC - se a frequência do relógio for de 8,8 GHz, o multiplicador não se ajustará a um int assinado de 32 bits.


PS Como essa resposta não verifica quanto tempo se passou, ela é candidata à recompensa.

anatolyg
fonte
4
Isso é legal: D
Deterioração beta
12
3900 GHz? Woah! Talvez MHz?
WayToDoor
2
@WayToDoor Fixed! Também adicionamos algumas informações divertidas relacionadas a isso.
precisa saber é
11
A fonte é de 142 bytes, então é como essa resposta deve ser pontuada.
Peter Taylor
3
@ Petereteray 142 bytes na linguagem assembly ; muito menos em código de máquina . Esses são idiomas diferentes; na minha opinião, o código da máquina é mais divertido (no entanto, a linguagem assembly seria melhor em um desafio [de origem restrita]). O problema com o código da máquina é que ele não é ASCII e acho que não é um grande problema. Uma questão relacionada é discutida aqui ; devo (ou você) iniciar uma discussão sobre código de máquina lá?
Anatolyg
21

Bash, 29 25 24 23 19 bytes

w()(ping -t$1 1.2)

Teste de precisão ( time) em que $1= 1 segundo:

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

Obrigado Dennis por reduzir a contagem de bytes para 19 a partir de 23!

EDIT : Eu mudei o IP para evitar pingping no Linux 0.0.0.0, que é o dispositivo de loopback.


Como isso funciona

ping tem um tempo limite padrão de 1 segundo; portanto, ao entrar em contato com um endereço IP que não existe, o ping não pode continuar até que o tempo limite se esgote ou que tenha recebido uma resposta do IP.

-tdiz pingque tentar $1várias vezes sobre este endereço IP falso, forçando pinga tomar $1segundos para completar o ping.


É elegível para a recompensa! No loop!

georgeunix
fonte
Golfed: w()(ping -t$1 0.0)(Devemos ter diferentes pings; mina requer -w$1e obtém uma resposta do localhost.)
Dennis
Certo, então ele só deve trabalhar no OS X sem/dev/lo
georgeunix
Alterar 0,0-1,2 no Linux
georgeunix
No OS X, para w 10, eu 10.02 sec realuso time.
Georgeunix
w()(ping -w$1 1.2)Funciona como um encanto.
Dennis
18

Matlab, 33 bytes

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

Ou você também pode usar isso no Octave: experimente on-line

Matlab, 31 bytes

Como sugerido por @flawr , isso pode ser feito com uma função anônima (deve ser atribuído um nome para usá-lo):

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

Exemplo:

>> f=@(t)eval('tic;while toc<t,end');
>> tic, f(2), toc
Elapsed time is 2.000323 seconds.
Luis Mendo
fonte
5
Tic ... Toc ... Tic ... Toc
Caridorc
4
Se um identificador de função não atribuída é ok também, você também pode usar@(t)eval('tic;while toc<t,end')
flawr
@flawr Wow! truque muito bom, usando evalpara empacotar várias instruções em uma função anônima. Obrigado!
Luis Mendo
Sim, isso às vezes é um truque útil, mas você ainda não pode atribuir valores a variáveis, mesmo dentro de avaliação. Ainda estou trabalhando em uma maneira de abusar dos identificadores de função para funções recursivas =) PS: Você não precisa necessariamente atribuir um nome ao identificador da função; às vezes também é possível passar o identificador diretamente como argumento para outra função, por exemplo, para bsxfun.
flawr
+1, mas a versão da função anônima não funciona no Octave (v 3.8.1). Falha ao reconhecer tvariável dentro de avaliação.
pawel.boczarski
11

Java, 63 62 bytes

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

Nada de surpreendente - basta pegar o número de nanossegundos desde 1/1/1970 várias vezes e verificar se um segundo se passou.

Economizou 1 byte graças a Ypnypn e aditsu.

TNT
fonte
25
Yay! Um programa Java abaixo de 100 bytes; D
Beta Decay
5
@BetaDecay Exceto que não é realmente um programa.
user253751
11
Alguém não mencionou que você pode abreviá-lo com um favor? for(long a=System.nanoTime();System.nanoTime()-a<t*1E9;);
Aditsu 26/08/2015
O que há com o t->?
Luminous
11
@Luminous É uma expressão lambda , comumente usado em Java 8.
TNT
8

Lote, 27 bytes

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

Um truque popular de lote, pois o lote não tinha uma função de suspensão.

Nenhum loop, portanto, a recompensa é elegível

tomkandy
fonte
Golfe: set/ac=%1+1economiza 2 bytes.
Stevefestl 20/05
7

Commodore 64 BASIC, 19 16 bytes

1000 FORI=1TO930*N:NEXT:RETURN

Com uma chamada N=<number-of-secods>:GOSUB1000 .

No entanto, não posso fornecer precisão suficiente. Como o C64 tinha cerca de 1 MHz de velocidade da CPU, lembro que era bom o suficiente para fazer um vazioFOR - NEXTciclo 1000 vezes de modo que era sobre 1 segundo.

De fato, havia duas versões principais da máquina: PAL 0,985 MHz e NTSC 1,023 MHz (todos os dados da página C64 da Wikipedia) ). Como eu tinha a versão NTSC, era necessário executar o loop cerca de 930 vezes.

Testes com o seguinte programa ( Nsegundos, fornecidos pelo usuário em 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

onde TI$é uma variável do sistema contendo string ( hhmmssformato) com o tempo decorrido desde a última redefinição (precisão de 1 segundo, mas também dependendo da velocidade da CPU, portanto, isso não é muito relevante, porque é o mesmo relógio).

insira a descrição da imagem aqui

Captura de tela feita com o emulador C64 on-line http://codeazur.com.br/stuff/fc64_final/ .

Este programa ( 1000somente linha ) ocupa 16 19 bytes na memória, conforme testado PRINT FRE(0)+65535antes de digitar o código (38908 bytes) e depois ( 38893 38889 bytes). PRINT FRE(0)retorna memória livre para o programa BASIC (é um valor negativo e uma constante 65535deve ser adicionada, mas na verdade não importa).

Como este programa não testa o tempo decorrido em um loop, ele se qualifica para receber uma recompensa.

Voitcus
fonte
Lembro-me de ter realizado um teste de TI$precisão da variável e foi de cerca de 1 segundo por ca. 2 horas de diferença com o relógio de referência (fora de C64), portanto a precisão é suficiente. O que eu tenho certeza é o valor 950, no entanto, seria qualquer outro valor <1000 (que estou certo), ainda é a mesma quantidade de bytes
Voitcus
Eu acho que a Jvariável deve, de alguma forma, fazer parte do código real, não parte do programa de teste - portanto, esperaria N segundos, não apenas 1 segundo. Mas não sei como integrá-lo à sintaxe do BASIC.
precisa saber é
@anatolyg Hm, você está certo, deve ser algo como 1000 FOR I=1 TO N:FOR I=1 TO 950:NEXT I:NEXTJ:RETURNcom uma chamada, por exemplo. 200 N=5:GOSUB 1000. Também notei que o OP exigia uma função . Vou tentar consertar
Voitcus
@anatolyg Eu corrigi, ele usa GOSUB- RETURNstatement, pois não há funções no BASIC
Voitcus
@ Voitcus Nem mesmo DEF FNna BBC BASIC?
Decay Beta
7

JavaScript ES6, 50 45 40 bytes

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

isso usa funções de execução automática, não sei por que +new Datenão está funcionando.


Uso

Eu testei isso com o Safari Nightly, mas também funcionará no Firefox. Testado com:

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

Você pode executá-lo colocando-o entre parênteses:

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

Ou nomeando-o:

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

Explicação

Aqui está a principal lógica por trás do programa:

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

A versão que estou usando usa a mesma lógica:

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
   );
}
Downgoat
fonte
6

CJam, 15

{e3es+{_es>}g;}

Este é um bloco que pode ser executado ou armazenado em uma variável (tornando-se uma função nomeada). Dennis e Mr Consensus concordam que contar apenas o bloco é aceitável :)

Explicação:

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

Experimente online

aditsu
fonte
11
O consenso no Meta é que as funções não precisam ser nomeadas, então eu argumentaria que um bloco deixado na pilha é tão útil quanto um lambda.
Dennis
6

JavaScript, 68 54 51 42

Eu acho que nenhuma captura de tela é necessária. Mas suspeito que você possa jogar golfe ainda mais ...

Nova versão: agora finalmente consegui evitar newe usar Dateduas vezes:

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

Versões mais antigas:

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);}
flawr
fonte
11
Nenhuma captura de tela é necessária agora :) Somente se alguém desafiar este programa
Decay Beta
5

PHP, 171 177 84 79 65 64 62 bytes

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


Uso:
Chame a função da seguinte maneira:
php -d error_reporting=0 -r "require 'script.php'; a(5);echo 'Hello, World!';"
Onde 5 é o tempo em segundos que o programa deve esperar antes de ecoar "Olá, Mundo!".


Explicação:
Inicialmente, a função obtém o tempo atual em milissegundos. Então a função faz um loop até que o tempo atual seja menor que a primeira vez + a entrada. Depois "Olá Mundo!" recebe eco.

Log:
Economizado 113 bytes graças ao Voitcus
Economizado 2 bytes graças ao axiac

empurrão
fonte
11
É - veja manual , $get_as_floatparâmetro. Também remover $t, $s- você não precisa deles (ver o meu código)
Voitcus
11
1e6 = 1000000 um milhão. echo 1e6;trabalho. Mas sim - ficando como float é o número de segundos, por isso $e=microtime(1)+$i;seria o suficiente
Voitcus
2
Um violino trabalhar para você
Voitcus
11
Obrigado por sua ajuda!
jrenk
11
Você pode salvar mais 2 bytes (3 bytes no PHP 7): 3v4l.org/fU11Y
axiac
5

Julia, 33 20 bytes

t->watch_file(".",t)

Só funciona na Julia v0.4 devido a alterações na assinatura da função de watch_file. Define uma função anônima com um único parâmetro tque (ab) usa o parâmetro timeout nowatch_file função.

Este é um candidato à recompensa!

Demonstração usando o 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

Resposta anterior (33 bytes), também trabalhando em Julia stable

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

R, 48 bytes

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

Demonstração:

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
jbaums
fonte
11
Eu não acho que você precise incluir o f=na contagem de bytes, os trechos de função estão corretos.
Solomon Ucko
4

PHP, 39 bytes

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

(Observe que, na verdade, posso diminuir isso se um programa completo for necessário, aproveitando os argumentos passados ​​na linha de comando. Abaixo de 35 )

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

Programa usado para teste:

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

Resultados:

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

insira a descrição da imagem aqui


Apesar de me qualificar para a recompensa, dificilmente concordo com algumas das outras entradas!

James Webster
fonte
Sim, sua contagem de bytes está boa
Beta Decay
4

Windows CMD, 22 bytes

ping -w 1000 -n %1 1.1

Isso não usa loop (label e goto), portanto, qualifica-se para a recompensa

Ele envia tpings para 1.0.0.1 (inválido) e aguarda uma resposta por 1000 ms

Grant Davis
fonte
3

JavaScript ES6, 40 bytes

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

Testado com o seguinte:

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
Dendrobium
fonte
Você pode explicar o que elapsed(STOP, t)faz? O que são STOP e decorridos?
Beta Decay
elapsedmede o tempo que levou o primeiro argumento a ser executado, neste caso STOP, que, por sua vez, é apenas o primeiro trecho de código. O segundo argumento decorrido é o argumento passado para STOP.
Dendrobium
3

TI-BASIC (84 + SE), 21 bytes

Método de entrada: T:prgmT. Este é o equivalente mais próximo de uma função no TI-BASIC. Programa:

For(A,1,841Ans
End

Toda a precisão é obtida através de tentativa e erro; cronometrando-o com um cronômetro funciona para todos os casos de teste fornecidos dentro de um vigésimo de segundo.

Informação de dispositivo:

RAM FREE   23312
ARC FREE  889802


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

W00T elegível para uma recompensa!

Conor O'Brien
fonte
11
Você sabia: a velocidade dos For(loops da sua calculadora depende de quantas variáveis ​​de letras existem? Mais variáveis ​​obstruem o IVA e podem levar até 20% do seu tempo. Variáveis ​​do sistema (por exemplo , nXmin ) são imunes.
Lirtosiast
@ThomasKwa Huh! Interessante. Vou recalibrar com uma calculadora limpa quando tiver tempo para transferir arquivos.
Conor O'Brien
2

Python, 57 bytes

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

Função de chamada y()

Azul
fonte
2

PureBasic, 92 bytes

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

É o mais curto que consigo pensar. Eu suspeito que este será o mais longo aqui também ...

Testar:

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

PowerShell, 75 bytes

Chamadas de procedimento longas e descritivas. Yay para maior clareza em um idioma. :)

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

Chamado dentro de um programa com algo como

Get-Date
w(15)
Get-Date

Como alternativa, se for permitido chamar programas externos, podemos reduzir para 59 bytes com o seguinte:

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

Isso seria chamado dentro de um programa da seguinte maneira (presumindo que o acima foi salvo como "wait-function.ps1" e salvo na mesma pasta):

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

O que economizamos ao escrever a função / programa é mais do que prejudicado pelo excesso necessário para realmente executá-la. Le suspiro.

AdmBorkBork
fonte
2

Python, 66 bytes

Observe que minha implementação nem chama uma função de tempo embutida nem usa o recurso de agendamento.

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

E sim, é elegível para recompensa.

Abhijit
fonte
Nope, this invalid: You must not use any built in waiting functions or any built in functions for executing code after a certain time
Beta Decay
@BetaDecay: As per my understanding, Queue().get is not a "built in functions for executing code after a certain time". Please explain why this would qualify as one.
Abhijit
Many other answers have code that uses timeouts for other things, so this should be fine too.
Solomon Ucko
2

Pyth, 19 bytes

Late entry but after finding .d0 in the docs last night I decided to give it a go.

DCNK.d0W<-.d0KNJ1))

Defines a function which loops until the time elapsed is N seconds.

Try it here.

Beta Decay
fonte
Nice. I got DCNJ+.dZN#Ig.dZJB)), which is also 19 bytes.
hakr14
2

RProgN 2, 13 bytes

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

Explained

°°°)*™+]³]™>:
°°°             # 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?

The bounty specifically says "without using a loop checking how much time has elapsed", which this does not do. This sets a target time, and keeps checking if it's passed that target time, thus it's eligible for the bounty.

Try it online!

ATaco
fonte
1

Tcl, 53 bytes

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

Try it online!

Explained

Command clock milliseconds can be reduced to clock mil, with escaped 1st bracket, it'll be interpreted at each loop, and w/o just once. As it measures milliseconds, we need to multpily by 1000 or 1e3 which saves 1 Byte.

david
fonte
1

C# (Visual C# Interactive Compiler) + /u:System.Threading, 36 bytes

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

Try it online!

Creates a semaphore with no capacity and tries to get it for the specified number of seconds.

I realize I am "wait"ing on something here. To me this seems more like the ping/timeout solution as opposed to Thread.Sleep. The code tries to get a resource that it cannot get and stops trying after a limit.

===

Below is a variation that starts a Task with an infinite loop, then waits for it to complete with a timeout. All required namespaces are included by default, but the solution is a few bytes longer than the one above.

C# (Visual C# Interactive Compiler), 40 bytes

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

Try it online!

dana
fonte
0

05AB1E, 22 bytes

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

Try it online.

NOTE: Depending on how many microseconds in the current second have already passed, the tolerance might be slightly larger than 0.1 sec. But since almost halve the answers have similar issues, I figured it's allowed.

Explanation:

05AB1E doesn't have any builtins for the current time. It does however have a builtin for the current year/month/day/hours/minutes/seconds/microseconds as separated builtins. Since only using seconds can potentially wrap around from 59 to 0 causing issues, I need both the minutes and seconds, making the code even longer than most answers in non-codegolfing languages unfortunately.

ž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
Kevin Cruijssen
fonte
0

SmileBASIC, 20 bytes

INPUT T
DIALOG"",,,T

Opens a dialog box that closes automatically after T seconds. I'm not sure if this counts as a "built in waiting function", but I think this is just as valid as using ping.

An alternative 37-byte program which definitely isn't cheating:

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

Causes the screen fade color to change to 0 (alpha=0,red=0,green=0,blue=0) (no effect) gradually over T seconds, then waits for that animation to finish.

12Me21
fonte