소개 : 심층적 사고 계산 우주와 모든 생명체에 대한 대답 은 750 만 년 동안이었습니다 42.

원하는 언어 75부터 계산 하는 데 약 초가 걸리는 프로그래밍 언어로 프로그램을 작성 하고 숫자를 출력하십시오 42.

NB 숫자 42는 스크립트에 하드 코딩 된 것이 아니라 어떻게 든 계산해야합니다 (무작위 숫자, 원하는 숫자).

제안한 바와 같이 sleep기능을 사용할 수 없습니다 . 창의력을 발휘하십시오.

1GHz로 오버 클럭 된 라즈베리 파이에서 약 75 초 소요

#!/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는 유일하게 알려진 값으로, 각각의 값 자체보다 작은 4 개의 양의 정수 a, b, c, d의 세트 수이며, 따라서 ab-cd, ac-bd 및 ad-bc는 각각 가치. 다른 가치가 있는지는 여전히 의문의 여지가 남아 있습니다

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

파이썬 2.7

질문에 대답하려면 질문을 알아야 하며 질문은 다음과 같습니다.

6에 9를 곱하면 무엇을 얻습니까? ^{수정을위한 TRiG에 감사합니다}

따라서 Deep Thought 은 base 13 의 편리한 사용에 의존합니다 .

6 ₁₃ x 9 ₁₃ = 42 ₁₃

상수를 가져옵니다.

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

우리는 또한 우리의 지구를 정의하고, 글자 맞추기 타일 한 자루 , Arthur (약간 이상하지만 컴퓨터는 예측 가능), Trillian (우리의 합리적인 헤로인),

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

우리는 Zaphod ( 임의의 종류)를 소개 합니다 endOfTheUniverse.

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

그리고 Marvin the Paranoid Android 는 긍정적 인 태도로 파티를 막을 수 있습니다.

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 Infinite Improbability Drive 이전 .

DOS 배치-삶, 우주 및 모든 것에 대한 답변

단순화를 위해 mynameiscoffey에게 감사합니다!

다른 이름으로 저장 answer.bat:

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

그런 다음 실행하고 75 초 동안 기다리십시오.

> answer
42

배쉬 (OS X)

이것은 너무 많은 문제없이 다른 시스템으로 이식 될 수 있습니다. 대체 say당신은 텍스트를 음성으로 명령 행 유틸리티로 사용하고 무엇이든지. 이 -f옵션은 명명 된 파일에서 입력을받습니다.

운이 좋으면 올바른 숫자를 출력 할 수도 있습니다 :-)

내 시스템에서 실행하는 데 거의 정확히 1 분 15 초가 걸립니다 (OS X 10.5).

#!/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"

MATLAB

이것은 힘든 일입니다. 우리는 실제로 질문을 알지 못하기 때문에 대답을 얻는 유일한 실행 가능한 방법은 전역 최적화 방법입니다. 이 경우 시뮬레이션 어닐링 방법을 선택했습니다.이 방법은 이전에 어려운 질문에 대한 훌륭한 답변을 제공했기 때문입니다.

이 코드가 수행하는 모든 것은 입력 자체가 생명 인 함수의 최적 값을 찾는 것입니다. 그리고 놀라운 것은 그것이 작동한다는 것입니다. 방금 Deep Thought을 검증 했습니까?

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.

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

루비

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

이것은 RNG를 남용합니다. ;)

씨

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

JavaScript-방정식을 풀어서 "인생과 모든 것에 대한 해답 찾기"

이 방정식을 살펴 봅시다.

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랩톱에서 거의 1 분이 걸립니다. 따라서 예제에 주어진 큰 값으로 며칠, 몇 주 또는 몇 년이 걸릴 것이라고 생각합니다 !!!

약 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++;
        }
    }
}

작동 방식 (호기심) : 1 초 동안 얼마나 많은 반복이 수행되었는지 n확인한 다음 74를 곱하고 해당 값에 맞게 조정하십시오 . 예 : 500 회 반복하는 데 1 초가 걸리면 5000 회 반복하는 데 10 초가 걸립니다. 이미 "벤치마킹"에 1 초를 소비했기 때문에 75가 아니라 74가 곱해집니다.

수학의 출처와 학점

C #-151 자

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

C ++

다소 비효율적 인 방법을 통해 10 의 파티션 을 계산합니다 . 내 시스템에서 릴리스 빌드로 130 초를 실행했지만 충분히 빠른 PC를 가진 사람은 ~ 75 초 안에이를 실행할 수 있어야합니다 ...

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

자바 스크립트

이것은 무언가를 경고하는 데 시간이 걸릴 것입니다 ...하지만 그것은 당신에게 보여줄 것이기 때문에 가치가 있습니다.

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

데모

파이썬

때로는 계산이 끝날 때만 답이 명확하지만 종료 전에 그 내용을 볼 수 있습니다.

그리고 Deep Thinkt에 시드 된 일련의 입력은 거의 알려져 있지 않습니다.

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 초 후에 제공됩니다.

조립 (gcc로 연결)

충분히 느린 컴퓨터 (CPU 속도 ~ 2Hz)에서 다음을 실행하려면 약 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

배쉬 및 리눅스 유틸리티 :

#!/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

Deep Thought은 계산 과정을 철저히 듣고 있습니다.

자바 (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);}}

언 골프

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

순수한 기본

다른 하드웨어가 다른 결과를 낳을 것이라는 사실에 따라, 이에 대한 정답은 없습니다. 경과 시간 기능을 사용하고 있으므로 계산을 언제 중지해야하는지 알고 있습니다.

기본적으로 빼면 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()

미트 스페이스

당신의 servant^H^H^H^Hcomputer(사람, 개, 또는 숫자 타일을 집어들 수있는 어떤 것이 든 가능) 걷는 데 약 70/4 초가 걸리는 거리를 치십시오 . 거기에 큰 숫자 4와 큰 숫자를 넣으십시오 2. 당신의 배치 computer출력 점. 타이머를 시작하고 숫자 저장소로 걸어 가서 한 번에 하나의 숫자를 다시 가져옵니다.

나는 그들을 데리러 내려 놓기 위해 5 초를 할당했습니다.

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

루비

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

PHP

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

오늘 밤에 가깝습니다. Ubuntu 10.04를 실행하는 이전 IBM NetVista P4 인 tecbrat.com 에서 실행하면 마지막 2 회 실행에서 69 초와 78 초가 표시되었습니다.

JavaScript (비트 난독 화) (136 바이트에는 나쁘지 않습니다!)

그것은 치타 한 측면에서 약간 보일 수 있지만, 75000ms 값은 42를 계산하는 데 사용되는 함수보다 먼저 계산 될 것이라는 점을 염두에두고 기능을 세 심하게 고려했습니다. 실제로 보면 매우 시적입니다. )

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

나는 이런 종류의 물건에 너무 좋지 않다. 나는 앱 개발자이지만 C에 대한 교육을받은 적이 없으며 서버에서 물건을 가져 와서 정보를 예쁘게 만드는 앱을 주로 만듭니다 ...

이것이 작동하는지 알 수 없으며 아이폰 앱에 있기 때문에 약간의 추가 코드가 있으며 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