Introduzione : il pensiero profondo calcolato La risposta alla vita dell'universo e tutto in un periodo di 7,5 milioni di anni, la soluzione era42 .

Scrivi un programma in qualsiasi linguaggio di programmazione che impiega circa 75secondi per calcolare, partendo da quello che vuoi, e genera il numero42 .

NB Il numero 42 deve essere calcolato in qualche modo (numeri casuali, qualunque cosa tu preferisca), non solo codificato nel tuo script.

Come suggerito, non è possibile utilizzare sleepo funzioni equivalenti. Sii creativo.

Questo richiede circa 75 secondi su un lampone pi overcloccato a 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

Funziona perché:

42 è l'unico valore noto che è il numero di insiemi di quattro interi positivi distinti a, b, c, d, ciascuno inferiore al valore stesso, tale che ab-cd, ac-bd e ad-bc sono ciascuno multipli di il valore. Se ci sono altri valori rimane una domanda aperta

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

Python 2.7

Per rispondere alla domanda, è necessario conoscere la domanda e la domanda è:

Cosa ottieni quando moltiplichi sei per nove? ^{Grazie a TRiG per la correzione}

So Deep Thought si basa sull'uso pratico della base 13 :

6 ₁₃ x 9 ₁₃ = 42 ₁₃

Importiamo le nostre costanti:

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

Definiamo anche le nostre cose terrene, essendo una borsa di tessere scrabble , Arthur (un prevedibile anche se leggermente strano, computer di sorta), Trillian (la nostra eroina razionale),

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

Introduciamo Zaphod - una sorta casuale, che alla fine si esaurisce di vapore come ci avviciniamo al endOfTheUniverse.

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

E Marvin il Paranoid Android , il cui atteggiamento positivo potrebbe fermare qualsiasi festa:

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

E continuiamo a eseguire questi 4 personaggi attraverso il mix fino a quando non calcolano che :

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)

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

Questo dovrebbe finire da qualche parte intorno al segno di 75 secondi, terminando definitivamente di 80 secondi. A volte prima di Zaphods Infinite Improbability Drive .

DOS Batch: la risposta alla vita, all'universo e a tutto

Grazie a mynameiscoffey per la sua semplificazione!

Salva come answer.bat:

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

Quindi eseguilo e attendi 75 secondi:

> answer
42

Bash (OS X)

Questo potrebbe probabilmente essere portato su altri sistemi senza troppi problemi. Sostituisci saycon tutto ciò che stai usando come utility da riga di comando di sintesi vocale. L' -fopzione accetta l'input da un file denominato.

Con un po 'di fortuna, potrebbe persino emettere il numero corretto :-)

Questo richiede quasi esattamente 1 minuto e 15 secondi per essere eseguito sul mio 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

Questo è difficile. Poiché non conosciamo davvero la domanda, l'unico metodo praticabile per ottenere la risposta è tramite un metodo di ottimizzazione globale. In questo caso ho optato per la ricottura simulata metodo di , poiché questo mi ha già dato delle belle risposte a domande difficili.

Tutto ciò che questo codice sta facendo è cercare il valore ottimale di una funzione quale input è la vita stessa. E la cosa sorprendente è che funziona. Quindi, ho appena convalidato Deep Thought?

tic;

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

Produzione:

the_answer =

    42

Elapsed time is 74.892428 seconds.

C - 1089 byte

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

compressa:

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

Rubino

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

Uscita sulla mia macchina:

42
Took 123 seconds; seed was 3771996

Questo abusa dell'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 - Trovare "la risposta alla vita e tutto" risolvendo un'equazione

Diamo un'occhiata a questa equazione:

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

Esistono molte soluzioni, ma se vuoi ressere il più grande possibile e p, qe rper essere naturale, ci sono solo due soluzioni:

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

con p <= q <= r, c'è solo una soluzione e rsempre uguale a42

Qual è il modo più (in) efficiente per risolvere un'equazione?

Provando tutti i possibili valori!

Ecco il codice:

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 ci vorrà? Ad essere sincero, non lo so perché non sono stato in grado di eseguirlo fino alla fine.

Tuttavia, puoi provare con nvalori piccoli (deve essere maggiore o uguale a 42) e otterrai risultati corretti. Per piccoli valori come n = 2000, ci vuole quasi un minuto sul mio laptop. Quindi immagino che con grandi valori dati nell'esempio ci vorranno giorni, settimane o persino anni !!!

Trovare la soluzione in circa 75 secondi:

Un requisito della domanda iniziale è che dovrebbero essere necessari circa 75 secondi per essere eseguiti. Un modo per raggiungere questo obiettivo è regolare automaticamente la complessità dell'algoritmo nel 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++;
        }
    }
}

Come funziona (per i curiosi): controlla quante iterazioni sono state fatte in un secondo, quindi moltiplicalo per 74 e aggiusta nper abbinare quel valore. es: se ci vogliono un secondo per fare 500 iterazioni, ci vorranno 10 secondi per fare 5000 iterazioni. Si noti che si moltiplica per 74 non per 75 perché abbiamo già speso un secondo per il "benchmarking".

fonte e crediti per la matematica

C # - 151 Personaggi

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

C ++

Calcola le partizioni di 10 tramite un metodo piuttosto inefficiente. Ci sono voluti 130 secondi per l'esecuzione in una versione di Release sul mio sistema, ma qualcuno con un PC sufficientemente veloce dovrebbe essere in grado di eseguirlo in ~ 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

Ci vorrà del tempo per avvisare qualcosa ... ma vale la pena poiché ti mostrerà la risposta alla vita dell'universo e di tutto!

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

dimostrazione

Pitone

A volte una risposta è chiara solo alla fine di un calcolo, ma alcuni aspetti sono visibili prima della conclusione.

E poco nota è la sequenza di input con cui Deep Thought è stata seminata:

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

Quindi:

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 voilà: la risposta viene fornita dopo 75 secondi.

Assembly (collegato da gcc)

Su un computer sufficientemente lento (velocità della CPU ~ 2Hz) l'operazione dovrebbe richiedere circa 75 secondi:

  .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à 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

Deep Thought sta ascoltando attentamente durante tutto il calcolo.

Java (227 caratteri)

Chi dice che le manipolazioni bit per bit non sono divertenti? O che Java non può essere fonte di confusione?
Ripetiamo in loop per 75 secondi e poi boom la risposta.

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

In linea con il fatto che hardware diverso produrrà risultati diversi, non esiste una risposta fissa per questo. Sto usando una funzione di tempo trascorso, quindi so quando interrompere il calcolo.

Fondamentalmente, calcolerà i due numeri primi più grandi quando sottratto è 42

Più veloce è la tua macchina, più grandi saranno i numeri primi :-)

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

Allontanati da una distanza che impiega circa 70/4 secondi affinché il tuo servant^H^H^H^Hcomputer(potrebbe essere umano, cane o qualsiasi cosa che possa raccogliere tessere numeriche) per camminare. Inserire un numero grande 4e un numero grande 2lì. Inserisci la tuacomputer al punto di uscita. Avvia il timer, fallo camminare fino al deposito numerico e riporta un numero alla volta.

Ho assegnato 5 secondi per raccoglierli e metterli giù.

Un altro esempio di 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);
        }
    }
}

Rubino

Un programma per aggiungere (0,56) potenza n per 75 volte. Valore din is 1

Dove n=1dovrebbe essere ottenuto da qualsiasi forma diTime 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

Utilizzando la differenza di tempo rubino ho verificato il tempo di esecuzione che è di ca. 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);
?>

Questo è il più vicino possibile per stasera. Eseguendolo su tecbrat.com , un vecchio IBM NetVista P4 con Ubuntu 10.04, ha mostrato 69 secondi e 78 secondi nelle mie ultime 2 corse.

JavaScript (offuscamento bit per bit) (non male per 136 byte!)

Può essere visto come un po 'caro, ma le funzioni sono state meticolosamente pensate, tenendo presente che il valore di 75000ms sarebbe calcolato prima delle funzioni utilizzate per calcolare 42. È piuttosto poetico quando lo guardi, davvero: )

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

Non sono troppo bravo con questo tipo di cose. Sono uno sviluppatore di app ma non ho mai avuto alcuna formazione in C e principalmente creo app che catturano roba dai server e rendono le informazioni piuttosto carine ...

Non ho idea se questo funzionerà e c'è un po 'di codice extra lì dentro perché è in un'app per iPhone e visualizzo un hud di avanzamento e una vista di avviso quando è stato raggiunto 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