简介：深入的思想计算在750万年的时间里，解决宇宙和万物生命的答案是42。

用任何编程语言编写一个程序75，从您想要的任何内容开始，大约要花费几秒钟的时间进行计算，然后输出number 42。

注意：该数字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是唯一的已知值，它是四个不同的正整数a，b，c，d的集合数，每个整数均小于该值本身，因此ab-cd，ac-bd和ad-bc分别是a的倍数价值。是否还有其他价值仍然是一个悬而未决的问题

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

Python 2.7

要回答这个问题，必须知道这个问题-问题是：

六乘九会得到什么？^{感谢TRiG的更正}

因此，Deep Thought依靠基数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

我们还定义了我们的地物，例如一袋拼字游戏的瓷砖，亚瑟（虽然有些奇怪，这是可以预见的，各种各样的计算机），特里扬（我们的理性女英雄），

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，他的积极态度可能会阻止任何聚会：

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

我们继续在混合中运行这四个字符，直到他们计算出为止：

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 无限可能性驱动。

DOS Batch –生活，宇宙和一切的答案

感谢mynameiscoffey的简化！

另存为answer.bat：

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

然后运行它，并等待75秒：

> answer
42

重击（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"

的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。;）

C

#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，我的笔记本电脑将花费近一分钟的时间。因此，我猜想示例中给出的高价值将需要几天，几周甚至几年！

在大约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次迭代，那么将花费10秒执行5000次迭代。请注意，它乘以74而不是75，因为我们已经花了一秒钟的时间进行“基准测试”。

数学的来源和学分

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秒钟在我的系统上的Release版本中运行，但是拥有足够快的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;
}

Java脚本

这将花一些时间来提醒某些事物……但是值得，因为它将向您显示生命对宇宙和一切的答案！

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 Thought的输入顺序：

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

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

Bash和Linux实用程序：

#!/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在计算过程中一直在认真听取。

Java（227个字符）

谁说按位操作不好玩？还是那个Java不能混淆？
我们循环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);
    }
}

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

肉空间

步行一段距离（大约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);
        }
    }
}

红宝石

一个将（0.56）幂n增加75次的程序。的价值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);
?>

这和我今晚接近。在tecbrat.com上运行它，运行Ubuntu 10.04的旧IBM NetVista P4在最近的两次运行中分别显示了69秒和78秒。

JavaScript（按位混淆）（136个字节还不错！）

可能看起来有些骗人，但是仔细考虑了函数，要记住，要在用于计算42的函数之前先计算75000ms的值。 ）

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

我对这种东西不太好。我是一名应用程序开发人员，但我从未接受过C语言方面的培训，我主要制作使应用程序从服务器中获取内容并使信息看起来更漂亮的应用程序...

我不知道这是否行得通，并且那里还有一些额外的代码，因为它在iphone应用程序中，当达到42时，我会显示进度hud和警报视图：

#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