Introdução : Pensamento profundo calculado A solução para a vida do universo e tudo em um período de 7,5 milhões de anos, a solução foi 42.

Escreva um programa em qualquer linguagem de programação que demore aproximadamente 75alguns segundos para calcular, iniciando com o que você deseja e imprima o número 42.

NB O número 42deve ser calculado de alguma forma (números aleatórios, o que você preferir), não apenas codificado em seu script.

Como sugerido, você não pode usar sleepfunções equivalentes. Seja inventivo.

Isso leva cerca de 75s em um raspberry pi com overclock para 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

Funciona porque:

42 é o único valor conhecido que é o número de conjuntos de quatro inteiros positivos distintos a, b, c, d, cada um menor que o próprio valor, de modo que ab-cd, ac-bd e ad-bc são múltiplos de O valor que. Se existem outros valores permanece uma questão em aberto

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

Python 2.7

Para responder à pergunta, é preciso conhecê- la - e a pergunta é:

O que você ganha quando multiplica seis por nove? ^{Graças a TRiG pela correção}

O Deep Thought se baseia no uso prático da base 13 :

6 ₁₃ x 9 ₁₃ = 42 ₁₃

Importamos nossas constantes:

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

Também definimos nossas coisas terrenas, sendo um saco de azulejos , Arthur (um tipo de computador previsível, embora um pouco estranho), Trillian (nossa heroína racional),

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

Apresentamos Zaphod - um tipo aleatório, que acaba perdendo força quando nos aproximamos do endOfTheUniverse.

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

E Marvin, o Android paranóico , cuja atitude positiva poderia impedir qualquer partido:

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

E continuamos a executar esses 4 caracteres através da mistura até que calcular -lo :

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)

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

Isso deve terminar em torno da marca de 75 segundos, definitivamente terminando em 80 segundos. Às vezes, antes de Zaphods Infinite Improbability Drive .

DOS Batch - a resposta para a vida, o universo e tudo

Obrigado a mynameiscoffey por sua simplificação!

Salvar como answer.bat:

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

Em seguida, execute-o e aguarde 75 segundos:

> answer
42

Bash (OS X)

Provavelmente, isso pode ser portado para outros sistemas sem muitos problemas. Substitua saypelo que você estiver usando como um utilitário de linha de comando de conversão de texto em fala. A -fopção recebe entrada de um arquivo nomeado.

Com um pouco de sorte, pode até gerar o número correto :-)

Isso leva quase exatamente 1 minuto e 15 segundos para ser executado no meu sistema (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

Essa é difícil. Como realmente não sabemos a pergunta, o único método viável de obter a resposta é por meio de um método de otimização global. Nesse caso, optei pelo método de recozimento simulado , já que este me deu respostas legais para perguntas difíceis antes.

Tudo o que esse código está fazendo é procurar o valor ideal de uma função cuja entrada é a própria vida. E o incrível é que funciona. Acabei de validar o pensamento profundo?

tic;

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

Resultado:

the_answer =

    42

Elapsed time is 74.892428 seconds.

C - 1089 bytes

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

Comprimido:

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

Rubi

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}"

Saída na minha máquina:

42
Took 123 seconds; seed was 3771996

Isso abusa do 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 - Encontrando "a resposta para a vida e tudo", resolvendo uma equação

Vamos dar uma olhada nesta equação:

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

Há muitas soluções, mas se você quiser rser tão grande quanto possível e p, qe rpara ser naturais, há apenas duas soluções:

1/3 + 1/7 + 1/42 = 1/2 e 1/7 + 1/3 + 1/42 = 1/2

com p <= q <= r, existe apenas uma solução e rsempre igual a42

Qual é a maneira mais (in) eficiente de resolver uma equação?

Tentando todos os valores possíveis!

Aqui está o código:

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

Quanto tempo vai demorar ? Para ser sincero, não sei porque não fui capaz de executá-lo até o fim.

No entanto, você pode tentar com nvalores pequenos (tem que ser maior ou igual a 42) e obterá o resultado correto. Para valores pequenos, como n = 2000, leva quase um minuto no meu laptop. Então eu acho que com grandes valores dados no exemplo, levará dias, semanas ou até anos !!!

Localizando a solução em aproximadamente 75 segundos:

Um requisito da pergunta inicial é que deve demorar aproximadamente 75 segundos para ser executado. Uma maneira de conseguir isso é ajustar automaticamente a complexidade do algoritmo ao longo do tempo:

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

Como funciona (para os curiosos): verifica quantas iterações foram feitas em um segundo, multiplique por 74 e ajuste npara corresponder a esse valor. por exemplo: se levar um segundo para fazer 500 iterações, levará 10 segundos para fazer 5000 iterações. Observe que ele se multiplica por 74 e não 75, porque já gastamos um segundo para "benchmarking".

fonte e créditos para matemática

C # - 151 caracteres

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

C ++

Calcula as partições de 10 através de um método bastante ineficiente. Demorou 130 anos para rodar em uma versão Build no meu sistema, mas alguém com um PC suficientemente rápido deve ser capaz de executá-lo em ~ 75s ...

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

Javascript

Vai demorar um pouco para alertar alguma coisa ... mas vale a pena, pois mostrará a resposta para a vida do universo e tudo!

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

Demo

Pitão

Às vezes, uma resposta é clara apenas no final de um cálculo, mas seus aspectos são visíveis antes do término.

E pouco conhecida é a sequência de entradas que o Deep Thought foi semeado:

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

Conseqüentemente:

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 - a resposta é fornecida após 75 segundos.

Assembly (vinculado pelo gcc)

Em um computador suficientemente lento (velocidade da CPU ~ 2Hz), isso deve levar cerca de 75 segundos para ser executado:

  .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

Utilitários Bash e 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

O Pensamento Profundo está ouvindo atentamente durante todo o cálculo.

Java (227 caracteres)

Quem disse que manipulações bit a bit não são divertidas? Ou que java não pode ser confuso?
Fizemos um loop por 75 segundos e depois aumentamos a resposta.

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

PureBasic

De acordo com o fato de que hardware diferente produzirá resultados diferentes, não há resposta fixa para isso. Estou usando uma função de tempo decorrido para saber quando parar de calcular.

Basicamente, ele calculará os dois maiores números primos quando subtraídos for 42

Quanto mais rápida a sua máquina, maiores serão os números primos :-)

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

MeatSpace

Afaste-se de uma distância que leva aproximadamente 70/4 segundos para que você servant^H^H^H^Hcomputerpossa caminhar (pode ser humano, cachorro ou qualquer coisa que possa pegar ladrilhos numéricos). Coloque um número grande 4e um número grande 2lá. Coloque o seu computerno ponto de saída. Inicie o cronômetro, faça com que ele caminhe até o depósito de numeração e traga de volta um número de cada vez.

Aloquei 5 segundos para buscá-los e colocá-los no chão.

Outro exemplo de 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);
        }
    }
}

Rubi

Um programa para adicionar (0,56) energia n por 75 vezes. Valor den is 1

Onde n=1deve ser obtido de qualquer forma deTime 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

Usando a diferença de tempo de rubi, verifiquei o tempo de execução que é de aproximadamente 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);
?>

É o mais perto que estou chegando hoje à noite. A execução no tecbrat.com , um antigo IBM NetVista P4 executando o Ubuntu 10.04, mostrou 69 segundos e 78 segundos nas minhas últimas 2 execuções.

JavaScript (ofuscação bit a bit) (não é ruim para 136 bytes!)

Pode parecer um pouco caro, mas as funções foram meticulosamente pensadas, tendo em mente que o valor de 75000ms seria calculado antes das funções usadas para calcular 42. É bastante poético quando você olha para ele realmente: )

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

Eu não sou muito bom com esse tipo de coisa. Sou desenvolvedor de aplicativos, mas nunca recebi nenhum treinamento em C e geralmente faço aplicativos que pegam coisas dos servidores e tornam as informações muito bonitas ...

Não tenho idéia se isso vai funcionar e há um pouco de código extra lá, porque está em um aplicativo para iPhone e exibo um hud de progresso e uma exibição de alerta quando 42 for alcançado:

#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