रुक जाओ, जहां तुम हो वहीं खड़े हो जाओ!


35

चुनौती

एक फ़ंक्शन लिखें जो एक पैरामीटर लेता है: एक पूर्णांक t। आपके कार्य को tजारी रखने से पहले, time.sleep(t)पायथन और WAIT tबीबीसी बेसिक में आपके प्रोग्राम को सेकंड के लिए रोकना है ।

एक निश्चित समय के बाद कोड के निष्पादन के लिए आपको किसी भी तरह के वेटिंग फंक्शन्स या किसी भी तरह से बनाए गए फंक्शन्स का उपयोग नहीं करना चाहिए, और आपका प्रोग्राम tसेकंड के बाद फिर से शुरू होना चाहिए ।

अपने फ़ंक्शन का परीक्षण करने के लिए, tआपकी अपनी मशीन पर दिए गए से 0.1 सेकंड अधिक या कम सहनशीलता होती है : कंप्यूटर के बीच भिन्नताएं ठीक हैं।

यदि आपके जवाब को किसी ने चुनौती दी है, तो आपको फोटोग्राफिक (स्क्रीनशॉट) सबूत देना होगा कि आपका फ़ंक्शन सही तरीके से काम करता है t=1, t=5और t=25। आप अपने कंप्यूटर का विवरण भी प्रदान कर सकते हैं ताकि लोग इसे अपनी मशीन पर दोहराने की कोशिश कर सकें।

आपका प्रोग्राम कंप्यूटर पर चलना चाहिए और जिसकी घड़ी की गति 1.6 गीगाहर्ट्ज़ या उससे अधिक है।

जीतना

सबसे छोटा कार्यक्रम जीत जाता है।

इनाम

एक इनाम सबसे कम कार्यक्रम में जाएगा जो एक लूप की जाँच के बिना कार्यक्रम को रोकता है कि कितना समय बीत चुका है। यदि आप इस इनाम के लिए दौड़ रहे हैं, तो एक फुटनोट यह कहते हुए जोड़ें कि आपका जवाब इनाम के लिए है।

लीडरबोर्ड

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


क्या होगा यदि हमारी पसंद की प्रोग्रामिंग भाषा ( खांसी की खांसी ) केवल 1-सेकंड की सटीकता के लिए समय का समर्थन करती है?
डॉर्कनोब

@Doorknob खैर इनपुट एक पूर्णांक है, इसलिए यह ठीक है
बीटा

3
@Doorknob शायद आप अपने कार्यक्रम के बाहर निष्पादन समय को माप सकते हैं, उदाहरण के लिए डिबग आउटपुट और डिबगवे के समय टिकटों को देखें।
थॉमस वेलर

1
क्या शीर्षक और BBC BASICउदाहरण टीवी शो शर्लक का संदर्भ है या क्या मैं इसमें बहुत अधिक पढ़ रहा हूं?
घातक

1
ठीक है, कम से कम आपको यह एहसास हुआ कि आपका शीर्षक
निष्कलंक

जवाबों:


36

x86_64 मशीन कोड, 10 बाइट्स

कोड के Hexdump:

48 69 c9 ca fc 59 38 e2 fe c3

स्रोत कोड ( ml64विजुअल स्टूडियो द्वारा इकट्ठा किया जा सकता है ):

    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

मैंने इस प्रोग्राम को विंडोज कंप्यूटर पर चलाया, जिसमें और कुछ नहीं करना है। यदि यह कुछ एप्लिकेशन चलाता है, तो प्रतीक्षा समय अधिक अनिश्चित है।

CPU की स्पीड 3.9 GHz है। ऐसा लगता है कि यह कोड वर्तमान पीसी तकनीक के लिए मुश्किल से पर्याप्त है - अगर घड़ी की आवृत्ति 8.8 गीगाहर्ट्ज़ है, तो गुणक हस्ताक्षरित 32-बिट इंट में फिट नहीं होगा।


PS जैसा कि इस उत्तर की जाँच नहीं करता है कि कितना समय बीत चुका है, यह इनाम के लिए एक उम्मीदवार है।


4
यह अच्छा है: डी
बीटा डेके

12
3900 GHz? वाह! शायद मेगाहर्ट्ज?
WayToDoor

2
@WayToDoor फिक्स्ड! साथ ही उससे जुड़ी कुछ मजेदार जानकारी भी जोड़ी।
अनातोलीगैस

1
स्रोत 142 बाइट्स है, इसलिए इस उत्तर को स्कोर किया जाना चाहिए।
पीटर टेलर

3
@PeterTaylor विधानसभा भाषा में 142 बाइट्स ; मशीन कोड में बहुत कम । ये अलग-अलग भाषाएं हैं; मेरी राय में मशीन कोड अधिक मजेदार है (हालांकि, असेंबली भाषा एक [प्रतिबंधित-स्रोत] चुनौती में बेहतर होगी)। मशीन कोड के साथ समस्या यह है कि यह गैर-एएससीआईआई है, और मुझे लगता है कि यह एक बड़ी समस्या नहीं है। एक संबंधित मुद्दे पर यहां चर्चा की गई है ; क्या मुझे (या आप) मशीन कोड पर चर्चा शुरू करनी चाहिए?
अनातोली

21

बैश, 29 25 24 23 19 बाइट्स

w()(ping -t$1 1.2)

सटीकता परीक्षण ( time) जहां $1= 1 सेकंड:

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

धन्यवाद डेनिस बाइट को शेविंग करने के लिए 23 से 19 तक नीचे!

EDIT : मैंने pingलिनक्स पिंगिंग 0.0.0.0 से बचने के लिए आईपी बदल दिया है , जो लूपबैक डिवाइस है।


यह कैसे काम करता है

ping 1 सेकंड का डिफ़ॉल्ट टाइमआउट है, इसलिए, जब एक आईपी पते से संपर्क किया जाता है जो मौजूद नहीं है, तो पिंग जारी नहीं रह सकता है जब तक कि समय समाप्त नहीं हुआ है, या इसे आईपी से उत्तर मिला है।

-tइस फर्जी आईपी पते पर कई बार pingप्रयास करने के लिए कहता है $1, पिंग को पूरा pingकरने के लिए $1सेकंड लेने के लिए मजबूर करता है ।


यह इनाम के योग्य है! नहीं लूप!


गोल्फ: w()(ping -t$1 0.0)(हमारे पास अलग-अलग pings होना चाहिए ; मेरा आवश्यकता है -w$1और स्थानीयहोस्ट से उत्तर मिलता है।)
डेनिस

सही है, तो यह केवल ओएस एक्स पर काम करना चाहिए/dev/lo
भूगर्भिक

लिनक्स पर 0.0 से 1.2 बदलें
जार्जुनिक्स

OS X के लिए w 10, मैं 10.02 sec realउपयोग करता हूं time
जॉर्जियोनिक्स

w()(ping -w$1 1.2)एक जादू की तरह काम करता है।
डेनिस

18

मतलाब, 33 बाइट्स

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

या आप इसका उपयोग ऑक्टेव में भी कर सकते हैं: इसे ऑनलाइन आज़माएं

मतलाब, 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
टिक ... टिक ... टिक ... टॉक
कारिडोरक

4
एक अ-निरुपित समारोह संभाल भी ठीक है, तो आप भी इस्तेमाल कर सकते हैं@(t)eval('tic;while toc<t,end')
flawr

@flawr वाह! evalएक अनाम फ़ंक्शन में कई बयानों का उपयोग करने के लिए बहुत अच्छी चाल । धन्यवाद!
लुइस मेंडो

हां, यह कभी-कभी एक उपयोगी चाल है, लेकिन आप अभी भी eval के भीतर भी चर के मानों को निर्दिष्ट नहीं कर सकते हैं। मैं अभी भी पुनरावर्ती कार्यों के लिए फ़ंक्शन हैंडल का दुरुपयोग करने के तरीके पर काम कर रहा हूं =) पुनश्च: आपको आवश्यक रूप से फ़ंक्शन हैंडल को एक नाम निर्दिष्ट करने की आवश्यकता नहीं है, कभी-कभी आप किसी अन्य फ़ंक्शन के तर्क के रूप में हैंडल को सीधे पास भी कर सकते हैं, उदाहरण के लिए bsxfun
दोष

+1, लेकिन अनाम फ़ंक्शन संस्करण ऑक्टेव (v 3.8.1) में काम नहीं करता है। यह teval के अंदर वैरिएबल को पहचानने में विफल रहता है ।
pawel.boczarski

11

जावा, 63 62 बाइट्स

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

कुछ भी आश्चर्य की बात नहीं है - बस कई बार 1/1/1970 के बाद से नैनोसेकंड की संख्या को पकड़ लेता है और जांच करता है कि क्या एक सेकंड बीत चुका है।

Ypnypn और aditsu के लिए 1 बाइट धन्यवाद।


25
वाह! 100 बाइट्स से नीचे जावा प्रोग्राम; डी
बीटा डेके

5
@BetaDecay को छोड़कर यह वास्तव में एक कार्यक्रम नहीं है।
user253751

1
क्या किसी ने उल्लेख नहीं किया है कि आप इसे एक के साथ छोटा कर सकते हैं? for(long a=System.nanoTime();System.nanoTime()-a<t*1E9;);
9

क्या साथ है t->?
चमकदार

1
@ ल्यूमिनस यह एक लैम्ब्डा अभिव्यक्ति है , जिसे आमतौर पर जावा 8 में इस्तेमाल किया जाता है
टीएनटी

8

बैच, 27 बाइट्स

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

एक लोकप्रिय बैच ट्रिक, क्योंकि बैच में स्लीप फंक्शन नहीं था।

कोई लूप नहीं, इसलिए योग्य पात्र


गोल्फ: set/ac=%1+12 बाइट्स बचाता है।
स्टीववेस्टल

7

कमोडोर 64 बेसिक, 19 16 बाइट्स

1000 FORI=1TO930*N:NEXT:RETURN

एक कॉल के साथ N=<number-of-secods>:GOSUB1000

हालाँकि, मैं पर्याप्त सटीकता प्रदान नहीं कर सकता। क्योंकि C64 में लगभग 1 मेगाहर्ट्ज सीपीयू की गति थी, मुझे याद है कि इसे खाली करने के लिए पर्याप्त अच्छा था FOR- NEXT1000 बार लूप ताकि यह इसके बारे में था 1 सेकंड।

वास्तव में मशीन के दो मुख्य संस्करण थे: PAL 0.985 मेगाहर्ट्ज और NTSC 1.023 मेगाहर्ट्ज ( C64 विकिपीडिया पृष्ठ से सभी डेटा) )। जैसा कि मेरे पास 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 सेकंड की सटीकता, हालांकि सीपीयू की गति पर भी निर्भर करता है, इसलिए यह काफी प्रासंगिक नहीं है, क्योंकि यह एक ही घड़ी है)।

यहाँ छवि विवरण दर्ज करें

ऑनलाइन C64 एमुलेटर http://codeazur.com.br/stuff/fc64_final/ के साथ बनाया गया स्क्रीनशॉट ।

यह प्रोग्राम ( 1000केवल लाइन ) मेमोरी में 16 19 बाइट्स रखता है , जैसा PRINT FRE(0)+65535कि कोड टाइप करने से पहले दोनों के साथ परीक्षण किया गया (38908 बाइट्स) और उसके बाद ( 38893 38889 बाइट्स)। PRINT FRE(0)बेसिक प्रोग्राम के लिए मुफ्त मेमोरी देता है (यह एक नकारात्मक मूल्य है और निरंतर 65535जोड़ा जाना चाहिए, लेकिन वास्तव में इससे कोई फर्क नहीं पड़ता)।

क्योंकि यह कार्यक्रम एक लूप में बीता समय का परीक्षण नहीं करता है, यह एक इनाम के लिए योग्य है।


मुझे याद है कि मैंने एक परीक्षण किया था कि TI$चर कैसे सटीक है और यह लगभग 1 सेकंड प्रति सीए है। संदर्भ घड़ी (C64 के बाहर) के साथ 2 घंटे का अंतर, इसलिए सटीकता पर्याप्त है। 950हालांकि, मैं अनिश्चित हूं कि मूल्य क्या है , क्या यह कोई अन्य मूल्य होगा <1000 (जो मुझे यकीन है), यह अभी भी बाइट्स की समान राशि है
Voitcus

मुझे लगता है कि Jचर को किसी तरह वास्तविक कोड का हिस्सा होना चाहिए, न कि परीक्षण कार्यक्रम का हिस्सा - इसलिए यह केवल 1 सेकंड नहीं, एन सेकंड के लिए इंतजार करेगा। मैं नहीं जानता कि कैसे इसे BASIC के सिंटैक्स में एकीकृत किया जाए।
एंथोलीग

@anatolyg Hm, आप सही कह रहे हैं, यह 1000 FOR I=1 TO N:FOR I=1 TO 950:NEXT I:NEXTJ:RETURNकॉल जैसे कुछ होना चाहिए । 200 N=5:GOSUB 1000। इसके अलावा, मैंने देखा है कि ओपी को एक फ़ंक्शन की आवश्यकता है । मैं इसे ठीक करने की कोशिश
करूंगा

@anatolyg मैंने सही किया है, यह GOSUB- RETURNस्टेटमेंट का उपयोग करता है , क्योंकि बेसिक में कोई कार्य नहीं हैं
Voitcus

@Voitcus DEF FNबीबीसी बेसिक में भी पसंद नहीं है ?
बीटा डिके

7

जावास्क्रिप्ट ईएस 6, 50 45 40 बाइट्स

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

यह स्वयं-निष्पादित कार्यों का उपयोग करता है, यह सुनिश्चित नहीं है कि +new Dateकाम क्यों नहीं कर रहा है।


प्रयोग

मैंने सफारी नाइटली के साथ इसका परीक्षण किया है लेकिन यह फ़ायरफ़ॉक्स पर भी काम करेगा। के साथ परीक्षण किया गया:

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

यह एक ब्लॉक है जिसे निष्पादित किया जा सकता है या एक चर में संग्रहीत किया जा सकता है (इस प्रकार एक नामित फ़ंक्शन बन जाता है)। डेनिस और श्री सहमति इस बात से सहमत हैं कि केवल ब्लॉक की गिनती स्वीकार्य है :)

स्पष्टीकरण:

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
मेटा पर सहमति यह है कि फ़ंक्शन का नाम नहीं है, इसलिए मैं तर्क दूंगा कि स्टैक पर छोड़ा गया एक ब्लॉक लैम्बडा के रूप में उपयोग करने योग्य है।
डेनिस

6

जावास्क्रिप्ट, 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
अब किसी स्क्रीनशॉट की आवश्यकता नहीं है :) केवल अगर कोई व्यक्ति इस कार्यक्रम को चुनौती देता है
बीटा डेके

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 सेकंड में समय है कार्यक्रम को "हैलो, वर्ल्ड!" गूँजने से पहले इंतजार करना चाहिए।


स्पष्टीकरण:
पहले समारोह में मिलीसेकंड में वर्तमान समय मिलता है। तब फ़ंक्शन एक लूप करता है जब तक कि वर्तमान समय छोटा नहीं होता है तब पहली बार + इनपुट। बाद में "हैलो वर्ल्ड!" गूंज उठता है।

लॉग:
सहेजे गए 113 बाइट्स वॉयटस
के लिए धन्यवाद 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)

फ़ंक्शन हस्ताक्षर में परिवर्तन के कारण केवल जूलिया v0.4 में काम करता है watch_file। एक एकल पैरामीटर के साथ एक अनाम फ़ंक्शन को परिभाषित करता है tजो (ab) watch_fileफ़ंक्शन में टाइमआउट पैरामीटर का उपयोग करता है ।

यह इनाम के लिए एक उम्मीदवार है!

जूलिया 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 बाइट्स), जूलिया स्थिर में भी काम कर रहा है

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

4

आर, 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

यहाँ छवि विवरण दर्ज करें


हालांकि मैं इनाम के लिए योग्य हूं, मैं शायद ही कुछ अन्य प्रविष्टियों के साथ चल रहा हूं!


हां, आपकी बाइट गिनती ठीक है
बीटा डेके

4

विंडोज सीएमडी, 22 बाइट्स

ping -w 1000 -n %1 1.1

यह लूप (लेबल और गोटो) का उपयोग करता है इसलिए यह बाउंटी के लिए योग्य है

यह tपिंग को 1.0.0.1 (अमान्य) पर भेजता है और 1000 एमएस के लिए प्रतिसाद का इंतजार करता है


3

जावास्क्रिप्ट ईएस 6, 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)करता है? एसटीओपी और बीता हुआ क्या है?
बीटा क्षय

elapsedइस मामले में, इस मामले में STOP, जो बारी में सिर्फ पहला कोड स्निपेट है , को चलाने के लिए पहला तर्क लेने का समय । बीता हुआ दूसरा आर्ग है, जिसे अर्ग पास किया गया है STOP
डेंड्रोबियम

3

TI-BASIC (84 + SE), 21 बाइट्स

इनपुट विधि: T:prgmT। यह TI-BASIC में एक फ़ंक्शन के सबसे निकटतम बराबर है। कार्यक्रम:

For(A,1,841Ans
End

परीक्षण और त्रुटि के माध्यम से सभी सटीकता प्राप्त की जाती है; स्टॉपवॉच के साथ समय देना, दिए गए सभी परीक्षण मामलों में एक सेकंड के बीसवें हिस्से के लिए काम करता है।

डिवाइस जानकारी:

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% तक ले सकते हैं। सिस्टम चर (जैसे n , Xmin) प्रतिरक्षा हैं।
lirtosiast

@ThomasKwa हह! दिलचस्प। जब मेरे पास फ़ाइलों को स्थानांतरित करने का समय होगा, तो मैं एक साफ कैलकुलेटर के साथ पुन: जांच करूंगा।
कॉनर ओ'ब्रायन

2

पायथन, 57 बाइट्स

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

कॉल फ़ंक्शन y()


2

प्योरबेसिक, 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

पॉवरशेल, 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)){}

इसे एक कार्यक्रम में इस प्रकार बुलाया जाएगा (ऊपर दिए गए अनुमान के अनुसार "प्रतीक्षा-फ़ंक्शन.पीएस 1" और उसी फ़ोल्डर में सहेजा गया):

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

फ़ंक्शन / प्रोग्राम लिखने में हम जो कुछ भी बचाते हैं, वह वास्तव में इसे निष्पादित करने के लिए आवश्यक अतिरिक्त की तुलना में अधिक स्पष्ट नहीं है। ले आह।


2

पायथन, 66 बाइट्स

ध्यान दें, मेरा कार्यान्वयन न तो इनबिल्ट टाइम फ़ंक्शन को कॉल करता है, न ही शेड्यूलिंग सुविधा का उपयोग करता है।

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

और हाँ, यह इनाम के योग्य है।


नहीं, यह अमान्य है: आपको किसी निश्चित समय के बाद कोड के निष्पादन के लिए किसी भी
बीटा डिके

@ बाइटडेके: मेरी समझ के अनुसार, कतार () एक "निश्चित समय के बाद कोड निष्पादित करने के लिए कार्यों में निर्मित" नहीं है। कृपया बताएं कि यह एक के रूप में योग्य क्यों होगा।
अभिजीत

कई अन्य उत्तरों में कोड होते हैं जो अन्य चीजों के लिए टाइमआउट का उपयोग करते हैं, इसलिए यह भी ठीक होना चाहिए।
सोलोमन उको

2

हासियम , 55 बाइट्स

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

चलाएँ और विस्तारित देखें: http://HassiumLang.com/Hassium/index.php?code=9f4e2bdb292b14b150bba63677a11a79


बस जाँच, यह भाषा पहली बार कब बनाई गई थी?
बीटा डिके

9 अगस्त 2015
जैकब मिसिरियन

2

पायथ, 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" {}}

इसे ऑनलाइन आज़माएं!

व्याख्या की

1 ब्रैकेट से बचकर कमांड clock millisecondsको कम किया जा सकता है clock mil, इसकी व्याख्या प्रत्येक लूप में की जाएगी, और w / o सिर्फ एक बार। जैसा कि यह मिलीसेकंड को मापता है, हमें 1000 या 1e3 से गुणा करना होगा जो 1 बाइट बचाता है।


1

C # (विजुअल C # इंटरएक्टिव कंपाइलर) + /u:System.Threading, 36 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बिना किसी क्षमता के एक सेमाफोर बनाता है और इसे सेकंड की निर्दिष्ट संख्या के लिए प्राप्त करने की कोशिश करता है।

मुझे लगता है कि मैं यहाँ किसी चीज़ पर "प्रतीक्षा" कर रहा हूँ। मेरे लिए यह पिंग / टाइमआउट समाधान की तरह अधिक लगता हैThread.Sleep । कोड एक संसाधन प्राप्त करने की कोशिश करता है जिसे वह प्राप्त नहीं कर सकता है और एक सीमा के बाद प्रयास करना बंद कर देता है।

===

नीचे एक बदलाव है जो शुरू होता है Task एक अनंत लूप के साथ , फिर समय समाप्त होने के लिए इंतजार करती है। सभी आवश्यक नाम स्थान डिफ़ॉल्ट रूप से शामिल हैं, लेकिन समाधान ऊपर के एक से कुछ बाइट्स लंबा है।

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 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

स्माइलबासिक, 20 बाइट्स

INPUT T
DIALOG"",,,T

एक संवाद बॉक्स खोलता है जो Tसेकंड के बाद स्वचालित रूप से बंद हो जाता है । मुझे यकीन नहीं है कि यह "वेटिंग फंक्शन में बनाया गया" के रूप में गिना जाता है, लेकिन मुझे लगता है कि यह उपयोग करने के समान ही वैध हैping

एक वैकल्पिक 37-बाइट प्रोग्राम जो निश्चित रूप से धोखा नहीं है:

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

स्क्रीन फीका रंग को 0 (अल्फा = 0, लाल = 0, हरा = 0, नीला = 0) में बदलने के लिए (कोई प्रभाव नहीं) धीरे-धीरे Tसेकंड में बदल जाता है, फिर उस एनीमेशन के समाप्त होने की प्रतीक्षा करता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.