挑战

编写一个带有一个参数的函数：一个integer t。函数必须t继续执行几秒钟才能停止程序，这与time.sleep(t)Python和WAIT tBBC BASIC中的类似。

在一定时间后，您不得使用任何内置的等待函数或任何内置函数来执行代码，并且程序必须在t几秒钟后恢复。

为了测试您的功能，t与您自己的机器所给定的容忍度相比，容错度要高出或小于0.1秒：计算机之间的差异很小。

如果你的答案是任何人的挑战，你必须提供相关图片（screenshotted）证明你的功能才能正常工作了t=1，t=5和t=25。您还可以提供计算机的详细信息，以便人们可以尝试在自己的计算机上复制它。

您的程序应该并且将在时钟速度为1.6 GHz或更高的计算机上运行。

获奖

最短的程序获胜。

赏金

赏金将进入最短的程序，该程序将停止该程序，而无需使用循环检查已花费了多少时间。如果您正在为获得赏金而奔波，请添加脚注，说您的答案是针对赏金的。

排行榜

/* 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机器码，10个字节

代码的十六进制转储：

48 69 c9 ca fc 59 38 e2 fe c3

源代码（可以由ml64Visual Studio 汇编）：

    TITLE   heh

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

执行空循环，从指定值开始减小到0。我通过反复试验凭经验选择了乘法器945421514，直到测试程序输出满意的结果。

测试程序（持续时间1、5和25秒分别等待10次）：

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

结果：

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

我在没有其他操作的Windows计算机上运行了该程序。如果运行某些应用程序，则等待时间更加不稳定。

CPU速度为3.9 GHz。对于当前的PC技术而言，此代码似乎还不够好 -如果时钟频率约为8.8 GHz，则乘法器将无法装入带符号的32位int。

附言：由于此答案不会检查已经过去了多少时间，因此是赏金的候选人。

Bash，29 25 24 23 19字节

w()(ping -t$1 1.2)

精度测试（time），其中$1= 1秒：

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

感谢Dennis将字节数从23减少到19！

编辑：我已更改IP，以避免ping在Linux上ping 0.0.0.0，这是回送设备。

如何运作

ping 的默认超时时间为1秒，因此，当联系一个不存在的IP地址时，直到超时时间过去或收到IP的回复后，才能继续执行ping操作。

-t告诉ping尝试$1对该虚假IP地址进行尝试的次数，从而迫使ping您花费$1几秒钟来完成ping操作。

Matlab，33个字节

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

或者，您也可以在Octave中使用它：在线尝试

Matlab，31个字节

正如@flawr建议的那样，可以使用匿名函数来完成此操作（应为其指定名称才能使用它）：

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

例：

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

Java，63 62字节

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

毫不奇怪-只需多次捕获自1970年1月1日以来的纳秒数，并检查是否已过去一秒。

感谢Ypnypn和aittsu，节省了1个字节。

批处理，27字节

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

一种流行的批处理技巧，因为批处理没有睡眠功能。

无循环，因此有赏金资格

Commodore 64 BASIC，19 16字节

1000 FORI=1TO930*N:NEXT:RETURN

打电话N=<number-of-secods>:GOSUB1000。

但是，我无法提供足够的准确性。因为C64的CPU速度约为1 MHz，所以我记得它足以使一个空循环FOR- NEXT循环1000次，因此大约为 1秒。

实际上，该机器有两个主要版本：PAL 0.985 MHz和NTSC 1.023 MHz（所有数据均来自C64 Wikipedia Page）。由于我使用的是NTSC版本，因此需要运行930次循环。

使用以下程序进行测试（N秒，由用户在中提供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

其中TI$是一个系统变量，其中包含字符串（hhmmss格式），其时间是自上次复位以来经过的时间（精度为1秒，但是还取决于CPU速度，因此不太相关，因为它是相同的时钟）。

使用在线C64模拟器http://codeazur.com.br/stuff/fc64_final/制作的屏幕截图。

该程序（1000仅行）在输入代码之前（38908字节）和之后（38893 38889字节）都经过测试，占用内存16 16个字节。返回BASIC程序的可用内存（这是一个负值，应添加常数，但实际上并不重要）。PRINT FRE(0)+65535PRINT FRE(0)65535

由于此程序不测试循环中经过的时间，因此有资格获得赏金。

的JavaScript ES6，50个 45 40字节

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

这使用了自执行功能，不确定为什么+new Date不起作用。

用法

我已经使用Safari Nightly进行了测试，但是它也可以在Firefox上运行。经过测试：

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

您可以通过将其括在括号中来运行它：

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

或通过命名：

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

说明

这是程序背后的主要逻辑：

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

我使用的版本使用相同的逻辑：

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

果酱，15岁

{e3es+{_es>}g;}

这是一个可以执行或存储到变量中的块（因此成为命名函数）。丹尼斯（Dennis）和共识先生（Consensus）同意只计算该区块是可以接受的：

说明：

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

在线尝试

JavaScript，68 54 51 42

我认为不需要截图。但是我怀疑你还能打更多的高尔夫球...

新版本：我现在终于设法避免new使用Date两次：

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

旧版本：

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字节

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

用法：
像这样调用函数：
php -d error_reporting=0 -r "require 'script.php'; a(5);echo 'Hello, World!';"
其中5是程序回显“ Hello，World！”之前应等待的时间（以秒为单位）。

说明：
首先，该函数获取以毫秒为单位的当前时间。然后，该函数循环执行，直到当前时间小于第一个时间+输入。之后是“ Hello World！” 得到回声。

日志：
Voitcus节省了113个字节，axiac
节省了2个字节

朱莉娅，33 20字节

t->watch_file(".",t)

由于的功能签名发生变化，因此仅在Julia v0.4中有效watch_file。使用一个参数定义一个匿名函数，该参数t（ab）使用watch_file函数中的timeout参数。

这是赏金的候选人！

使用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

先前的答案（33个字节），也在Julia稳定版中工作

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

R，48个字节

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

示范：

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字节

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

（请注意，如果需要一个完整的程序，我可以利用命令行中传递的参数来缩短这个时间。降低到35）

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

用于测试的程序：

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

结果：

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

尽管我有资格获得赏金，但我几乎没有参加其他比赛！

Windows CMD，22个字节

ping -w 1000 -n %1 1.1

这不使用循环（标签和转到），因此有资格获得赏金

它将tping发送到1.0.0.1（无效），并等待响应1000毫秒

JavaScript ES6，40个字节

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

经过以下测试：

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个字节

输入法：T:prgmT。这是TI-BASIC中最接近的功能。程序：

For(A,1,841Ans
End

所有的准确性都是通过反复试验获得的；对于所有给定的测试用例，使用秒表对其计时都可以在20秒之内完成。

设备信息：

RAM FREE   23312
ARC FREE  889802


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

W00T有资格获得赏金！

Python，57个字节

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

通话功能 y()

PureBasic，92个字节

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

这是我能想到的最短的时间。我怀疑这也是这里最长的...

去测试：

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

PowerShell，75个字节

冗长的描述性过程调用。是的，为了使语言更清晰。:)

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

在程序中用类似

Get-Date
w(15)
Get-Date

或者，如果允许我们调用外部程序，则可以使用以下内容将字节数降至59字节：

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

可以在程序中按如下方式调用它（假定以上内容保存为“ wait-function.ps1”并保存在同一文件夹中）：

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

但是，在编写函数/程序时，我们所节省的不只是实际执行它所需要的额外开销。叹。

Python，66个字节

注意，我的实现既不调用内置时间函数，也不使用调度功能。

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

是的，它有资格获得赏金。

Hassium，55字节

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

运行并查看展开的内容：http : //HassiumLang.com/Hassium/index.php?code=9f4e2bdb292b14b150fba63677a11a79

Pyth，19个字节

进入较晚，但.d0昨晚在文档中找到之后，我决定尝试一下。

DCNK.d0W<-.d0KNJ1))

定义一个循环运行直到经过的时间为N秒的函数。

在这里尝试。

RProgN 2，13字节

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

讲解

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

赏金特意说“不使用循环检查已经过去了多少时间”，这是不行的。这将设置目标时间，并继续检查是否已超过该目标时间，因此有资格获得赏金。

在线尝试！

Tcl，53字节

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

在线尝试！

讲解

clock milliseconds可以将命令简化为clock mil，并使用第一个括号转义，它将在每个循环中解释，并且一次不执行。因为它以毫秒为单位，所以我们需要乘以1000或1e3，这样可以节省1个字节。

C＃（Visual C＃交互式编译器） + /u:System.Threading，36个字节

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

在线尝试！

创建一个没有容量的信号灯，并尝试在指定的秒数内获取它。

我意识到我在这里“等待”某事。在我看来，这更像是ping / timeout解决方案，而不是Thread.Sleep。代码尝试获取无法获取的资源，并在限制后停止尝试。

===

以下是一个变体，Task它以无限循环开始，然后等待超时结束。默认情况下，所有必需的名称空间都包括在内，但是解决方案比上面的名称空间长几个字节。

C＃（Visual C＃交互式编译器），40字节

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

在线尝试！

05AB1E，22 字节

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

在线尝试。

注意：根据当前秒已过去多少微秒，容差可能会略大于0.1秒。但是由于几乎一半的答案都有类似的问题，所以我认为这是允许的。

说明：

05AB1E当前没有任何内置函数。但是，它确实具有当前年/月/日/小时/分钟/秒/微秒的内建函数（作为单独的内建函数）。由于仅使用几秒钟就可能会导致59到0的范围内出现问题，因此我需要分钟和秒钟，这使得代码甚至比大多数非编解码语言中的答案还要长。

ž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个字节

INPUT T
DIALOG"",,,T

打开一个对话框，T几秒钟后自动关闭。我不确定这是否算作“内置的等待功能”，但我认为这与using一样有效ping。

另一个绝对不会作弊的37字节程序：

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

在T几秒钟内逐渐使屏幕淡入淡出的颜色变为0（alpha = 0，red = 0，green = 0，blue = 0）（无效果），然后等待该动画完成。