जीवन, ब्रह्मांड और सब कुछ का जवाब [बंद]

Question

परिचय : डीप थॉट की गणना ब्रह्मांड और जीवन की हर चीज का जवाब 7.5 मिलियन वर्षों की अवधि में, समाधान था 42।

किसी भी प्रोग्रामिंग भाषा में एक प्रोग्राम लिखें जो 75गणना करने के लिए लगभग सेकंड लेता है , जो आप चाहते हैं, और नंबर को आउटपुट करें 42।

एनबी संख्या 42को किसी भी तरह से गणना की जानी चाहिए (यादृच्छिक संख्या, जो भी आप पसंद करते हैं), न केवल आपकी स्क्रिप्ट में हार्ड-कोडित।

जैसा कि सुझाव दिया गया है, आप sleepकार्यों का उपयोग या समकक्ष नहीं कर सकते । आविष्कारशील बनें।

Comments

यह एक लोकप्रियता प्रतियोगिता के रूप में बेहतर हो सकता है यह देखने के लिए कि लोग किन तरीकों से रचनात्मक रूप से जवाब देने के बजाय आ सकते हैंsleep(75);print("%d\n",41+1);

— जोश

गणना करने के लिए लगभग 75 सेकंड लगते हैं? लेकिन कंप्यूटर चिप्स बहुत विविध हैं ... यह कैसे संभव हो सकता है - मेरी मशीन पर 75 सेकंड लग सकते हैं, लेकिन अगला कंप्यूटर इसे 7.5 सेकंड में राक्षस कर सकता है ...

— फोजआउट

sleepउपलब्ध जवाब के बिना बहुत हार्डवेयर निर्भर होने जा रहे हैं जो मैं कल्पना करता हूं ... आपकी मशीन पर 75 का समय लगता है, शायद मेरी मशीन पर 750 ले लेंगे: पी

— जोश

timeapi.org/utc/now । यह आपकी भाषा की नींद की तरह पुस्तकालयों का उपयोग करने के लिए सबसे अच्छा विकल्प लगता है। यह सब कुछ HTTP अनुरोध है।

— क्रंचर

मुझे गलती से 10 मिनट लग गए! : हे

— दरवाज़े

Answer 1

यह एक रास्पबेरी पाई पर लगभग 75s लेता है जिसे 1GHz पर ओवरक्लॉक किया गया है

#!/usr/bin/env python
from itertools import product, count

for n in count(1):
    i = 0
    for a, b, c, d in product(range(n), repeat=4):
        if a > b > c > d > 0 == (a*b-c*d)%n == (a*c-b*d)%n == (a*d-b*c)%n:
            i += 1
    if i == n:
        break
print i

यह काम करता है क्योंकि:

42 एकमात्र ज्ञात मूल्य है जो चार अलग-अलग सकारात्मक पूर्णांक के सेटों की संख्या है a, b, c, d, प्रत्येक स्वयं के मान से कम है, जैसे कि ab-cd, ac-bd, और ad-bc प्रत्येक के गुणक हैं महत्व। क्या अन्य मूल्य खुले प्रश्न हैं

http://www.mathpages.com/home/kmath255.htm

Comments

तो आपको या तो एक नया नंबर मिलेगा जो इस समीकरण को संतुष्ट करता है या आप 42 :)

— Assaf G.

@FezVrasta, क्योंकि अंतिम पंक्ति गायब हो गई थी। doh!

— जिब्बलर

वाह! एकदम सही गणित रीबस और ओवरक्लॉकिंग चीज़ ... हा हा हा +1!

— टॉमस

यह इस उत्तर 42 का (upvoting नहीं) एक कठिन टोपी स्कोर है कि मज़ेदार है

— pwned

मैं वास्तव में ओवरलॉक वाले रास्पबेरी पाई के कारण इसे उभारना चाहता हूं, लेकिन मैं इसे वर्तमान स्कोर नहीं दे सकता। मैं एक बुरा लग रहा है हम एक टाई करने जा रहे हैं है

— agweber

Answer 2

पायथन 2.7

प्रश्न का उत्तर देने के लिए, किसी को प्रश्न जानना चाहिए - और प्रश्न यह है:

जब आप छह को नौ से गुणा करते हैं तो आपको क्या मिलता है? ^{सुधार के लिए TRiG को धन्यवाद}

इसलिए डीप थॉट आधार 13 के उपयोग पर निर्भर करता है :

६ _१३ x ९ _१३ = ४२ _१३

हम अपने स्थिरांक का आयात करते हैं:

from random import randrange as scrabbleBag, randint
from datetime import datetime,timedelta
life,universe,everything,nothing=6,9,1,-3
endOfTheUniverse = 80

हम अपनी पृथ्वी-चीजों को भी परिभाषित करते हैं, स्क्रैबल टाइल्स का एक बैग होने के नाते , आर्थर (यह एक अनुमान के मुताबिक थोड़ा अजीब है, कंप्यूटर का प्रकार), ट्रिलियन (हमारी तर्कसंगत नायिका),

tile = lambda i: scrabbleBag(26)
arthur = lambda i: int(`i`,life+universe+everything+nothing)
trillian = lambda i: ''.join(map(str,divmod(i,life+universe+everything+nothing)))

हम ज़ेफोड का परिचय देते हैं - एक यादृच्छिक प्रकार, जो अंततः भाप से बाहर निकलता है जैसा कि हम पास हैं endOfTheUniverse।

zaphod = lambda : not(randint(0,(endOfTheUniverse-(datetime.now() - start).seconds)**3))

और मार्विन द पैरानॉयड एंड्रॉइड , जिसका सकारात्मक रवैया किसी भी पार्टी को रोक सकता है:

marvin = lambda : endOfTheUniverse<(datetime.now() - start).seconds

और हम इन 4 वर्णों को मिक्स के माध्यम से तब तक चलाना जारी रखते हैं जब तक वे इसकी गणना नहीं करते :

while answer is not life * universe * everything:
  rack = sum(tile(i) for i in range(7))
  answer = (zaphod or marvin) and arthur(rack)
print trillian(answer)

पूरा deepthought.py:

from random import randrange as scrabbleBag, randint
from datetime import datetime,timedelta
life,universe,everything,nothing=6,9,1,-3
endOfTheUniverse = 80

tile = lambda i: scrabbleBag(26)
arthur = lambda i: int(`i`,life+universe+everything+nothing)
trillian = lambda i: ''.join(map(str,divmod(i,life+universe+everything+nothing)))

start = datetime.now()

zaphod = lambda: not(randint(0,(endOfTheUniverse-(datetime.now() - start).seconds)**3))
marvin = lambda: endOfTheUniverse<(datetime.now() - start).seconds

answer = None
while answer is not life * universe * everything:
  rack = sum(tile(i) for i in range(7))
  answer = (zaphod() or marvin()) and arthur(rack)
print trillian(answer)

यह 75 सेकंड के निशान के आसपास कहीं खत्म होना चाहिए, निश्चित रूप से 80 सेकंड तक खत्म होना चाहिए। कभी कभी पहले Zaphods अनंत सुधार ड्राइव के लिए ।

Comments

जवाब बहुत अच्छा है, लेकिन अगर मैं इसे 2.7.2 पर चलाता हूं, तो यह एक त्रुटि फेंकता है File "main.py", line 13, in zaphod = not(randint(i,(80-(datetime.now() - start).seconds)**3)) NameError: name 'i' is not defined:(

— Fez Vrasta

@FezVrasta क्षमा करें, मैंने गलती से कुछ गलत कोड जोड़ा है। इसे अभी तय किया है, काम करना चाहिए।

कमाल है, यह काम करता है :) अब हमें प्रश्न की गणना करने के लिए एक बड़े कंप्यूटर की आवश्यकता है!

— फेज़ वेस्टा

"मैं एक खेद का मामला हो सकता है, लेकिन मैं बेस -13 में चुटकुले नहीं लिखता।" - डीएनए

— 15

यह अब 42 वोटों पर बैठा है। क्या मुझे अधिक वोट चाहिए, या क्या मुझे इस प्रश्न के लिए सबसे अच्छा संभव स्कोर चाहिए?

Answer 3

डॉस बैच - जीवन का उत्तर, ब्रह्मांड और सब कुछ

उनके सरलीकरण के लिए mynameiscoffey को धन्यवाद!

इस रूप में सहेजें answer.bat:

@ ping 127.0.0.1 -n 76 >nul && @ echo %~z0

फिर इसे चलाएं, और 75 सेकंड प्रतीक्षा करें:

> answer
42

Comments

ऐसा लगता है कि आपके डीप थॉट का एक अलग विचार है, यह मुझे 40 : पी

— फ़ेज़ वेस्टा

मैंने नोटपैड ++ का उपयोग किया है, मैंने

— फ़ेज़ वर्स्टा

नोटपैड के साथ भी कोई भाग्य नहीं, विस्मयादिबोधक चिह्न के साथ संस्करण काम करता है

— Fez Vrasta

कूल, क्या आप अनुमान लगा सकते हैं कि यह कैसे काम करता है?

सिर्फ गन्दी CRLF समस्या से बचने के लिए इसे एक पंक्ति में क्यों नहीं बनाया जाए, CRLF की @ ping 127.0.0.1 -n 76 >nul && @ echo %~z0एक जोड़ी पर निर्भर होने के बजाय `&&` का उपयोग करते हुए

— mynameiscisceyey

Answer 4

बैश (OS X)

यह संभवतः बहुत अधिक परेशानी के बिना अन्य प्रणालियों में पोर्ट किया जा सकता है। sayटेक्स्ट-टू-स्पीच कमांड लाइन उपयोगिता के रूप में जो भी आप उपयोग कर रहे हैं, उसे बदलें । -fविकल्प के लिए एक नाम की फ़ाइल से इनपुट लेता है।

थोड़ी सी किस्मत के साथ, यह सही संख्या का उत्पादन भी कर सकता है :-)

यह मेरे सिस्टम (OS X 10.5) पर चलने के लिए लगभग 1 मिनट 15 सेकंड लेता है।

#!/bin/bash
grep -E '^life|universe|and.everything|[ultimate]question$' /usr/share/dict/words | sed 's/$/,/' | nl > "$TMPDIR/deepthought"
say -v Alex -f "$TMPDIR/deepthought"
nw=`cat $TMPDIR/deepthought | wc -l`
say -v Alex "The answer, to the ultimate question, is: $nw"
echo $nw
rm "$TMPDIR/deepthought"

Answer 5

Matlab

यह कठिन है। चूंकि हम वास्तव में सवाल नहीं जानते हैं, इसलिए उत्तर पाने की एकमात्र व्यवहार्य विधि वैश्विक अनुकूलन विधि है। इस मामले में मैंने नकली एनालिंग विधि का विकल्प चुना , क्योंकि इससे पहले मुझे कठिन सवालों के अच्छे जवाब मिले।

यह सब कोड एक फ़ंक्शन के इष्टतम मूल्य की तलाश में है जो इनपुट ही जीवन है। और कमाल की बात यह है कि यह काम करता है। तो, क्या मैंने सिर्फ डीप थॉट को मान्य किया है?

tic;

the_answer=round(simulannealbnd(@(life)abs(3.7376696-log(life)),140489, ...
           -inf,inf,saoptimset('MaxFunEvals',10^16)))
toc;

आउटपुट:

the_answer =

    42

Elapsed time is 74.892428 seconds.

Answer 6

सी - 1089 बाइट्स

#include <time.h>
#include <stdio.h>

int answer(int the)
{
   int to = 0;

   while (the != 0) {
      to *= 10;
      to += the%10;
      the /= 10;
   }
   return to;
}

int optimism(int the)
{
    return abs(the);
}

int getRandomNumber()
{
    return 4; // chosen by fair dice roll.
              // guaranteed to be random.
}

int main()
{
    // initialize
    int life = getRandomNumber(), universe, everything;

    // get inverse answer
    int question = clock();
    while (clock()-question < CLOCKS_PER_SEC*75) {
        life += getRandomNumber();
    }
    life = optimism(life); // optimism is the best way to see life
    life %= 1000;

    // avoids unwanted race conditions with the answer by "Lego Stormtroopr"
    if (life<100 || life>997) {life -= getRandomNumber()*100;}
    if (optimism(life/100%10 - life%10) < 2) {life += getRandomNumber();}
    universe = answer(life);
    everything = optimism(life<universe?life-universe:universe-life);

    printf("%d\n", (answer(everything)+everything+3)/26);

    return 0;
}

---

दबा हुआ:

#include <time.h>

int f(int d) {
   int e = 0;
   while (d != 0) e = e*10+d%10, d /= 10;
   return e;
}

int main() {
    int a = 4, b, c, d = clock();
    while (clock()-d < CLOCKS_PER_SEC*75) a += 4;
    a = abs(a)%1000;
    a -= a<100||a>997?400:0;
    a += abs(a/100%10-a%10)<2?4:0;
    b = f(a);
    c = abs(a<b?a-b:b-a);
    return (f(c)+c+3)/26;
}

Answer 7

माणिक

t = Time.new.to_i
n = 0
loop{
  break if Random.new(n).rand(2000000) == Random.new(374076).rand(1000000)
  n += 1
}
puts Random.new(n).rand(2000000)
puts "Took #{Time.new.to_i - t} seconds; seed was #{n}"

मेरी मशीन पर आउटपुट:

42
Took 123 seconds; seed was 3771996

यह आरएनजी को गाली देता है। ;)

Comments

आप इसे 75 सेकंड तक कैसे सुनिश्चित कर सकते हैं?

— पियरे अरलाउड

@ अरलूड यह एक लूप के 3.7 मिलियन पुनरावृत्तियों के माध्यम से चलता है, जो प्रति पुनरावृत्ति 2 यादृच्छिक संख्या उत्पन्न करता है! तकनीकी रूप से अगर आपके पास कुछ सुपरकंप्यूटर थे तो यह तेज हो सकता है, लेकिन किसी भी उचित हार्डवेयर के लिए कम से कम 75 सेकंड लगेंगे, और मैं उबाऊ नहीं होना चाहता और नींद या समय के तरीकों का उपयोग करना चाहता हूं।

— दरवाज़े

अपडेट: ... अब यह Took 25 seconds; seed was 3771996मेरे औसत-प्रदर्शन लैपटॉप पर प्रिंट करता है। तो, उह ... मैंने झूठ बोला। : पी

— दरवाज़े

Answer 8

सी

#include <stdio.h>
#include <time.h>

int i, j;

int main() {
    i = clock();
    while(clock() - i < 75 * CLOCKS_PER_SEC);
    for(i = j = 0 ; i < 48 ; i++)
        j += "The answer to Life, the Universe, and everything"[i];
    printf("%i", j % 157);
}

Comments

जबकि लूपिंग clock()कुछ मूल्य से अधिक होने तक no sleep()नियम का उल्लंघन करता प्रतीत होता है , क्योंकि यह मूल रूप से एक सीपीयू-गहन नींद है

— mniip

लोकप्रियता-प्रतियोगिता।

— पियरे अरलाउड

@ArlaudPierre जब मैंने जवाब प्रस्तुत किया तो यह कोड-गोल्फ था । वैसे भी, यह अब तय हो गया है।

— ओबेरॉन

Answer 9

जावास्क्रिप्ट - एक समीकरण को हल करके "जीवन और हर चीज का उत्तर" खोजना

आइए इस समीकरण पर एक नजर डालते हैं:

1 / p  +  1 / q  +  1 / r  =  1 / 2

कई समाधान हैं, लेकिन यदि आप rजितना संभव हो उतना बड़ा होना चाहते हैं p, qऔर rभीलों होने के लिए केवल दो समाधान हैं:

1/3 + 1/7 + 1/42 = 1/2 तथा 1/7 + 1/3 + 1/42 = 1/2

के साथ p <= q <= r, केवल एक ही समाधान है और rहमेशा बराबर होता है42

किसी समीकरण को हल करने का सबसे कुशल तरीका क्या है?

सभी कब्जे मूल्यों की कोशिश करके!

यहाँ कोड है:

var n = Math.pow(2, 32); 
for (var i = 1; i <= n; i++)  
{ 
    for (var j = 1; j <= n;  j++)
    {
        for (var k = 1; k <= n; k++)
        {
            if ((1 / i + 1 / j + 1 / k) == 1 / 2)                
               throw k;                
        }
    }
}

इसमे कितना टाइम लगेगा ? ईमानदार होने के लिए, मुझे नहीं पता क्योंकि मैं इसे अंत तक चलाने में सक्षम नहीं हूं।

हालांकि, आप छोटे nमूल्यों के साथ कोशिश कर सकते हैं (यह बड़ा या बराबर होना चाहिए 42) और आपको सही परिणाम मिलेगा। जैसे छोटे मूल्यों के लिए n = 2000, मेरे लैपटॉप पर लगभग एक मिनट लगता है। इसलिए मैं उदाहरण में दिए गए बड़े मूल्यों के साथ अनुमान लगाता हूं कि इसमें दिन, सप्ताह या साल लगेंगे !!!

लगभग 75 सेकंड में समाधान खोजना:

प्रारंभिक प्रश्न से एक आवश्यकता यह है कि निष्पादित करने के लिए लगभग 75 सेकंड लेना चाहिए। इसे प्राप्त करने का एक तरीका समय के साथ एल्गोरिथ्म की जटिलता को स्वचालित रूप से समायोजित करना है:

var now = new Date().getTime();
var iterations = 0; 
var n = Math.pow(2, 32); 
for (var i = 1; i <= n; i++)
{
    for (var j = 1; j <= n; j++)
    {
        for (var k = 1; k <= n; k++)
        {
            if ((1 / i + 1 / j + 1 / k) == 1 / 2)               
                throw k;

            if (new Date().getTime() - now > 1000) //one second has elapsed
            {
                now *= 2; //never wanna see you again
                n = 42;   //this is the minimum               
                while(3 * n * n + 7 * n + 42 < iterations * 74) n++;
                i = j = k = 0; //reset
            }
            iterations++;
        }
    }
}

यह कैसे काम करता है (जिज्ञासु के लिए): यह जाँचता है कि एक सेकंड में कितने पुनरावृत्तियों को किया गया है, फिर इसे 74 से गुणा करें और nउस मान से मिलान करने के लिए समायोजित करें। उदाहरण: यदि 500 ​​पुनरावृत्तियों को करने में एक सेकंड लगता है, तो 5000 पुनरावृत्तियों को करने में 10 सेकंड लगेंगे। ध्यान दें कि यह 74 नहीं 75 से गुणा करता है क्योंकि हम पहले से ही "बेंचमार्किंग" के लिए एक सेकंड का खर्च करते हैं।

गणित के लिए स्रोत और क्रेडिट

Answer 10

सी # - 151 वर्ण

class P
{
   static void Main()
   {
      var w = new System.Diagnostics.Stopwatch();
      w.Start();
      while (w.ElapsedMilliseconds < 75000);
      System.Console.Write((int)'*');
   }
}

Comments

यह थ्रेड स्लीप के बराबर कैसे नहीं है?

— वल्देतेरो

बेशक यह थ्रेड स्लीप के बराबर नहीं है। थ्रेड स्लीप मुख्य थ्रेड को निर्दिष्ट समय के लिए निष्क्रिय बनाती है। यह प्रोग्राम मुख्य थ्रेड को निष्क्रिय नहीं करता है। इसमें बीते हुए समय की तुलना करने के लिए मुख्य सूत्र शामिल है। और जब वह निर्दिष्ट समय (75s) बीत जाता है, तो यह आउटपुट प्रिंट करता है।

— मेरिन नाकामरी

मैं जानता हूं <i> कार्यात्मक रूप से </ i> यह समान नहीं है, लेकिन एक ही आधार का अनुसरण करता है। ओपी चाहता था कि यह रचनात्मक हो और भाषा का 75 सेकंड तक इंतजार न हो - जो कि यह कर रहा है।

— Valdetero 21

मेरे लिए यह समाधान उतना ही अच्छा / बुरा है जितना कि डॉस के लिए समाधान। डॉस समाधान कार्यक्रम को पिंग करके व्यस्त रखता है, और यह समय बीतने की तुलना करके खुद को व्यस्त रखता है। मुझे कोई मतभेद नज़र नहीं आ रहा है। यदि वह कई अपवोट प्राप्त कर सकता है तो यह भी मिलना चाहिए। वैसे, पिंग कमांड आंतरिक रूप से एक 'नींद' करता है।

— माइक्रोबियन

Answer 11

सी ++

बल्कि एक अक्षम विधि के माध्यम से 10 के विभाजन की गणना करता है । मेरे सिस्टम पर रिलीज़ बिल्ड में चलाने के लिए 130s लिया, लेकिन पर्याप्त रूप से तेज़ पीसी वाले व्यक्ति को इसे ~ 758 में चलाने में सक्षम होना चाहिए ...

#include <algorithm>
#include <iostream>
#include <numeric>
#include <set>
#include <vector>

using namespace std;

bool NextPermutationWithRepetition(vector<int>& perm, int n) {
    int carry = 1;
    auto it = begin(perm);
    while (it != end(perm) && carry) {
        ++*it;
        carry = (*it - 1) / n;
        *it = ((*it - 1) % n) + 1;
        ++it;
    }
    if (carry) {
        if (perm.size() == n) return false;
        perm.push_back(carry);
    }
    return true;
}

int main() {
    vector<int> perm;
    set<vector<int>> uniquePartitions;
    const int n = 10;
    while (NextPermutationWithRepetition(perm, n)) {
        if (accumulate(begin(perm), end(perm), 0) == n)  {
            auto sortedPerm = perm;
            sort(begin(sortedPerm), end(sortedPerm));
            uniquePartitions.insert(sortedPerm);
        }
    }
    cout << uniquePartitions.size() << endl;
}

Answer 12

जावास्क्रिप्ट

कुछ को सचेत करने में थोड़ा समय लगेगा ... लेकिन यह लायक है क्योंकि यह आपको ब्रह्मांड और सब कुछ के जीवन का उत्तर दिखाएगा!

var x = 0, b = document.body.children[0];
var theAnswer = function(){
  b.textContent = ++x;
  if(x == 125774) alert(Math.pow(x, 1/Math.PI)).toFixed(0);  
  else setTimeout(theAnswer);
};
theAnswer();

डेमो

Comments

75 सेकंड से बहुत अधिक ...

— 14

लेकिन यह कुल मिलाकर लायक है!

— राफेलकास्ट्रोक्टो

Answer 13

अजगर

कभी-कभी एक गणना के अंत में एक उत्तर केवल स्पष्ट होता है, लेकिन समाप्ति से पहले इसके पहलू दिखाई देते हैं।

और थोड़ा ज्ञात है कि इनपुट का अनुक्रम डीप थॉट के साथ बोया गया था:

271, 329, 322, 488, 79, 15, 60, 1, 9

अत:

from datetime import datetime
n = datetime.now
o = n().second

def bs(x,n,t,f):
    return ([t]+bs(x-2**(n-1),n-1,t,f) if x>=2**(n-1) else [f]+bs(x,n-1,t,f)) if n>0 else []

u = [271,329,322,488,79,15,60,1,9,'#',' ','',]
for i, g in enumerate(u[:5]):
    while n().second!=(o+(i+u[7])*u[5])%u[6]:
        pass # the dice
    print u[11].join(bs(g,*u[8:11]))

Et voila - उत्तर 75 सेकंड के बाद प्रदान किया जाता है।

Answer 14

असेंबली (gcc द्वारा लिंक)

एक पर्याप्त धीमी गति से कंप्यूटर (सीपीयू की गति ~ 2 हर्ट्ज) पर चलने के लिए लगभग 75 सेकंड चाहिए:

  .globl        main
main:
  movl  $52, %edx
  movl  $0, %edi
l4:
  addl $1, %edi
  cmp %edx, %edi
  jl l4
  call  putchar
  movl  $50, %edx
  movl  $0, %edi
l2:
  addl $1, %edi
  cmp %edx, %edi
  jl l2
  call  putchar
  movl  $10, %edx
  movl  $0, %edi
ln:
  addl $1, %edi
  cmp %edx, %edi
  jl ln
  call  putchar
  ret

Answer 15

बैश और लिनक्स के बर्तन:

#!/bin/bash

if [ $(uname) == "Linux" ]; then
    : $(arecord -q | head -c 600000)
    man -s4 random | head -n1 | tr -d ' ' | wc -c
else
    echo "Deep Thought didn't run $(uname)"
fi

डीप थॉट गणना के माध्यम से सभी तरह से ध्यान से सुन रहा है।

Answer 16

जावा (227 अक्षर)

कौन कहता है कि बिटकॉइन जोड़तोड़ मजेदार नहीं है? या उस जावा को भ्रमित नहीं किया जा सकता है?
हम 75 सेकंड के लिए लूप करते हैं और फिर उत्तर को उछाल देते हैं।

public class T{public static void main(String[]b){long d=(1<<16^1<<13^1<<10^31<<3);long t=System.currentTimeMillis();long e=t+d;for(;e>System.currentTimeMillis();){}d=d%((((d&~(1<<16))>>7)^(1<<4))^1<<2);System.out.println(d);}}

Ungolfed

public class T
{
    public static void main(String[] b)
    {
        long d = (1 << 16 ^ 1 << 13 ^ 1 << 10 ^ 31 << 3);
        long t = System.currentTimeMillis();
        long e = t + d;
        for (; e > System.currentTimeMillis();){}
        d = d % ((((d & ~(1 << 16)) >> 7) ^ (1 << 4)) ^ 1 << 2);
        System.out.println(d);
    }
}

Answer 17

PureBasic

इस तथ्य को ध्यान में रखते हुए कि विभिन्न हार्डवेयर अलग-अलग परिणाम उत्पन्न करेंगे, इसके लिए कोई निश्चित उत्तर नहीं है। मैं एक बीता हुआ समय फ़ंक्शन का उपयोग कर रहा हूं इसलिए मुझे पता है कि गणना कब बंद करनी है।

मूल रूप से, यह सबसे बड़ा दो अभाज्य संख्याओं की गणना करेगा जब घटाया गया 42 होगा

अपनी मशीन को तेज़ करें, बड़े अपराध :-) होंगे

OpenConsole()

sw = ElapsedMilliseconds()
FoundFigure1 = 0
FoundFigure2 = 0

PreviousPrime = 1

For i = 3 To 10000000000 Step 2
  PrimeFound = #True
  For j = 2 To i-1
    If i % j = 0
      PrimeFound = #False
      Break
    EndIf
  Next
  If PrimeFound = #True
    If i - PreviousPrime = 41+1
      FoundFigure1 = PreviousPrime
      FoundFigure2 = i
    EndIf

    PreviousPrime = i
  EndIf

  If ElapsedMilliseconds() - sw > 75000
    Break
  EndIf
Next

Print("Answer: ")
Print(Str(FoundFigure2 - FoundFigure1))
Input()

Answer 18

MeatSpace

ऐसी दूरी तय करें जो आपके लिए लगभग 70/4 सेकंड का समय लेती है servant^H^H^H^Hcomputer(यह मानव, कुत्ता, या ऐसा कुछ भी हो सकता है जो पैदल चलने के लिए अंक टाइल उठा सकता है)। वहां एक बड़ा अंक 4और एक बड़ा अंक रखें 2। अपने computerआउटपुट पॉइंट पर रखें। टाइमर शुरू करें, क्या यह अंकन डिपो तक चलता है और एक बार में एक नंबर वापस लाता है।

मैंने उन्हें लेने और उन्हें नीचे रखने के लिए 5 सेकंड आवंटित किए।

Answer 19

एक और C # उदाहरण

using System;
using System.Threading;

namespace FourtyTwo
{
    class Program
    {
        static void Main(string[] args)
        {
            DateTime then = DateTime.Now;
            Thread.Sleep(42000);
            DateTime now = DateTime.Now;
            TimeSpan t = now - then;
            Console.WriteLine(t.Seconds);
        }
    }
}

Comments

आप "नींद" का प्रयोग कर रहे हैं

— Fez Vrasta

उफ़, इसे पढ़ें क्योंकि मेरे लिए नींद -10 का उपयोग कर सकते हैं!

— लैंडर्स

Answer 20

माणिक

75 बार के लिए (0.56) शक्ति n जोड़ने का कार्यक्रम। का मूल्यn is 1

कहां n=1से किसी भी रूप में प्राप्त किया जाना चाहिएTime diffrence

def solve
  a=0.56
  i=0
  t1=Time.now
  while(i < 75)
        t1 = Time.now
        while((b=Time.now-t1) < 1.0)
        end
        a += 0.56 ** b.to_i
        i += 1
  end
  a.to_i
end

puts solve

माणिक समय अंतर का उपयोग करके मैंने निष्पादन समय को सत्यापित किया है जो लगभग है 75.014267762

Answer 21

पीएचपी

<?php
set_time_limit(80);
ini_set('max_execution_time', 80);
//$start=time();
$count=0;
do{
$rand=rand(0,(75000000/40+2));  
$rand=rand(0,$rand);
    if(($rand==42 || $rand==75-42 || $rand== floor(75/42)) && (!rand(0,(4*2)))
      ){
      $count++;
    }
}while($count!=42);
echo $count;
//echo '<br>elapsed time is '.(time()-$start);
?>

यह आज रात के करीब है। इसे tecbrat.com पर चलाकर , एक पुराना IBM NetVista P4, Ubuntu 10.04 पर चल रहा है, इसने 69 सेकंड और 78 सेकंड मेरे 2 2 रनों पर दिखाए।

Answer 22

जावास्क्रिप्ट (बिटवाइस ऑबफ्यूशन) (136 बाइट्स के लिए बुरा नहीं है!)

यह धोखा देने वाले पक्ष के रूप में देखा जा सकता है, लेकिन कार्यों को सावधानी से सोचा गया था, यह ध्यान में रखते हुए कि 75000ms मूल्य की गणना 42 से गणना किए जाने वाले कार्यों से पहले की जाएगी। यह काफी काव्यात्मक है जब आप इसे देखते हैं, वास्तव में: )

setTimeout("alert($=((_=_=>(_<<-~-~[])|-~[])(_(-~[])))<<-~[])",($=$=>$<<-~-~-~[]|-~[])((_=_=>_<<-~[]|-~[])(_(_(_($($($(-~[]))))))))^-~[])

Comments

मुझे एक वाक्यविन्यास त्रुटि मिल रही है ...Unexpected token >

— rafaelcastrocouto

मेरे पास फ़ायरफ़ॉक्स 26.0 पर यह काम है जो x = x => f (x) संकेतन को स्वीकार करता है ... आप इसे किस संस्करण पर चला रहे हैं?

— वॉलीवेस्ट

मैं विंडोज़ 7 पर क्रोम 31 चला रहा हूं ...

— राफेलकास्ट्रोकोटो

@rafaelcastrocouto आह, दुखी वसा तीर संकेतन का उपयोग केवल 22 और इसके बाद के संस्करण के प्रत्येक कथन में दो कार्यों को परिभाषित करने के लिए किया जाता है ...

— WallyWest

मैं लगभग रो रहा हूँ ... आपका समाधान वास्तव में सौंदर्यपूर्ण है!

— राफेलकास्ट्रोक्टो

Answer 23

मैं इस तरह के सामान के साथ बहुत अच्छा नहीं हूं। मैं एक ऐप डेवलपर हूं लेकिन मैंने सी में कभी कोई प्रशिक्षण नहीं लिया है और मैं ज्यादातर ऐसे ऐप बनाता हूं जो सर्वर से सामान हड़पते हैं और जानकारी को सुंदर बनाते हैं ...

मुझे पता नहीं है कि यह काम करेगा और वहाँ एक अतिरिक्त कोड है क्योंकि यह एक iphone ऐप में है और मैं एक प्रगति हड और एक चेतावनी दृश्य प्रदर्शित करता हूं जब 42 तक पहुंच गया है:

#import "ViewController.h"
#import "MBProgressHUD.h"

@interface ViewController ()

@property (nonatomic, retain) MBProgressHUD * hud;

-(IBAction)answer:(id)sender;

@end

int number;
int initialCounter;

@implementation ViewController
@synthesize hud;

-(IBAction)answer:(id)sender
{
    hud = [MBProgressHUD showHUDAddedTo:self.view animated:YES];
    hud.mode = MBProgressHUDModeIndeterminate;
    hud.labelText = @"Calculating";

    [self calculate];

    number = arc4random();
}

-(void)calculate
{

    int random = arc4random();

    if (number == 42){
        hud.hidden = YES;
        UIAlertView *message = [[UIAlertView alloc] initWithTitle:@"Complete!"
                                                          message:@"The answer is 42."
                                                         delegate:nil
                                                cancelButtonTitle:@"OK"
                                                otherButtonTitles:nil];

        [message show];
    }

    else if(number<42){
        number = number + random;
        dispatch_async(dispatch_get_main_queue(), ^{
             [self calculate];
        });
    }

    else if(number>42){
        number = number - random;
        dispatch_async(dispatch_get_main_queue(), ^{
             [self calculate];
        });
    }
}

@end