停下来,站在那里!


35

挑战

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

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

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

如果你的答案是任何人的挑战,你必须提供相关图片(screenshotted)证明你的功能才能正常工作了t=1t=5t=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>


如果我们选择的编程语言(cough cough)仅支持将时间精确到1秒怎么办?
门把手

@Doorknob好吧,输入是一个整数,所以很好
Beta Decay

3
@Doorknob也许您可以测量程序外部的执行时间,例如调试输出并查看DebugView的时间戳。
Thomas Weller

1
标题和BBC BASIC示例是电视节目的参考,还是Sherlock节目?我对此读得太多吗?
致命

1
好吧,至少它使您意识到自己的头衔不准确;)
致命一击2015年

Answers:


36

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。


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


4
这很酷:D
Beta Decay 2015年

12
3900 GHz?哇 !也许MHz?
WayToDoor 2015年

2
@WayToDoor固定!还添加了一些与此有关的有趣信息。
anatolyg

1
源是142个字节,因此这就是答案的分数。
彼得·泰勒

3
@PeterTaylor 142字节的汇编语言 ; 机器代码少得多。这些是不同的语言;在我看来,机器代码更有趣(但是,在[受限源]挑战中,汇编语言会更好)。机器代码的问题在于它是非ASCII的,我认为这不是一个大问题。这里讨论一个相关的问题;我(或您)应该在那里开始有关机器代码的讨论吗?
anatolyg

21

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操作。


有资格获得赏金!没有循环!


高尔夫:(w()(ping -t$1 0.0)我们必须有不同的pings;我的要求-w$1并且要从localhost获得答复。)
Dennis

是的,那么它只能在不使用OS X的操作系统上运行/dev/lo
georgeunix

在Linux
上将

在OS X上w 10,我10.02 sec real使用time
georgeunix

w()(ping -w$1 1.2)奇迹般有效。
丹尼斯

18

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.

5
Tic ... Toc ... Tic ... Toc
Caridorc 2015年

4
如果也可以使用未分配的功能句柄,则还可以使用@(t)eval('tic;while toc<t,end')
瑕疵的

@flawr哇!非常好的技巧,eval用于将多个语句打包到一个匿名函数中。谢谢!
路易斯·门多

是的,有时这是一个有用的技巧,但是即使在eval内,您仍然无法将值分配给变量。我仍在研究为递归函数==滥用函数句柄的方法:PS:您不必一定要为函数句柄分配名称,有时您还可以将句柄直接作为参数传递给另一个函数,例如for bsxfun
flawr

+1,但匿名函数版本在Octave(v 3.8.1)中不起作用。无法识别teval中的变量。
pawel.boczarski

11

Java,63 62字节

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

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

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


25
好极了!小于100字节的Java程序; D
Beta Decay

5
@BetaDecay除了它实际上不是一个程序。
user253751

1
有人没有提到您可以用for来缩短它吗?for(long a=System.nanoTime();System.nanoTime()-a<t*1E9;);
aditsu

是什么t->
发光的

1
@Luminous这是一个lambda表达式,在Java 8常用
TNT

8

批处理,27字节

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

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

无循环,因此有赏金资格


高尔夫:set/ac=%1+1节省2个字节。
stevefestl

7

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

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


我记得我曾经进行过一次测试,测试TI$变量的准确性如何,大约为每秒钟1秒。与参考时钟(C64以外)相差2小时,因此精度足够。我不确定的是值950,但是,它是否是任何其他值<1000(我确定),它仍然是相同的字节数
Voitcus

我认为J变量应该以某种方式成为真实代码的一部分,而不是测试程序的一部分-因此它将等待N秒,而不仅仅是1秒。我不知道如何将其集成到BASIC的语法中。
anatolyg 2015年

@anatolyg嗯,你是对的,应该像是打1000 FOR I=1 TO N:FOR I=1 TO 950:NEXT I:NEXTJ:RETURN个电话一样。200 N=5:GOSUB 1000。我也注意到OP需要一个功能。我会尝试修复它
Voitcus

@anatolyg我已更正,它使用GOSUB- RETURN语句,因为BASIC中没有函数
Voitcus

@Voitcus甚至不DEF FN喜欢BBC BASIC吗?
Beta Decay 2015年

7

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

6

果酱,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

在线尝试


1
关于Meta的共识是不必命名函数,因此我认为保留在堆栈上的块与lambda一样有用。
丹尼斯

6

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

1
现在无需截图:)仅当有人挑战此程序时
Beta Decay

5

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


1
它-参见手册$get_as_float参数。同时删除$t$s-你不需要他们(见我的代码)
Voitcus

1
1e6 = 1000000一百万。echo 1e6;作品。但是,是的-浮点数是秒数,所以$e=microtime(1)+$i;足够了
Voitcus

2
一个工作拨弄
Voitcus

1
@Voitcus感谢您的帮助!
jrenk

1
您可以再保存2个字节(PHP 7中为3个字节):3v4l.org/fU11Y
axiac

5

朱莉娅,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)

4

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

1
我认为您不需要f=在字节数中包含,函数片段很好。
所罗门·乌科

4

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

在此处输入图片说明


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


是的,您的字节数很好
Beta衰减2015年

4

Windows CMD,22个字节

ping -w 1000 -n %1 1.1

这不使用循环(标签和转到),因此有资格获得赏金

它将tping发送到1.0.0.1(无效),并等待响应1000毫秒


3

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

你能解释一下elapsed(STOP, t)吗?什么是停止和过去?
Beta Decay 2015年

elapsed衡量第一个参数运行所花费的时间,在本例中为STOP,而这仅仅是第一个代码段。要经过的第二个arg是传递给的arg STOP
2015年

3

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有资格获得赏金!


1
您知道吗:计算器For(循环的速度取决于存在多少个字母变量?更多变量会堵塞增值税,最多可能占用您20%的时间。系统变量(例如ñXmin)是免疫的。
lirtosiast 2015年

@ThomasKwa Huh!有趣。有时间传输文件时,我将使用干净的计算器进行重新校准。
Conor O'Brien

2

Python,57个字节

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

通话功能 y()


2

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

2

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

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


2

Python,66个字节

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

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

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


不,这是无效的:一定时间后您不得使用任何内置的等待函数或任何内置的函数执行代码
Beta Decay 2015年

@BetaDecay:据我了解,Queue()。get不是“用于在一定时间后执行代码的内置函数”。请解释为什么这可以合而为一。
阿披吉特(Abhijit)2015年

许多其他答案的代码都将超时用于其他用途,因此也应该很好。
所罗门·乌科


2

Pyth,19个字节

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

DCNK.d0W<-.d0KNJ1))

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

在这里尝试。


真好 我得到了DCNJ+.dZN#Ig.dZJB)),它也是19个字节。
hakr14

2

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?

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

在线尝试!


1

Tcl,53字节

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

在线尝试!

讲解

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


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)

在线尝试!


0

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

0

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)(无效果),然后等待该动画完成。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.