Introducción : Pensamiento profundo calculado La respuesta a la vida del universo y todo en un período de 7,5 millones de años, la solución fue 42.

Escriba un programa en cualquier lenguaje de programación que tome aproximadamente 75segundos para calcular, comenzando desde lo que desee, y genere el número 42.

NB El número 42debe calcularse de alguna manera (números aleatorios, lo que prefiera), no solo codificado en su secuencia de comandos.

Como se sugiere, no puede usar sleepfunciones equivalentes. Se inventivo.

Esto toma alrededor de 75 segundos en una frambuesa pi overclockeada a 1 GHz

#!/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 es el único valor conocido que es el número de conjuntos de cuatro enteros positivos distintos a, b, c, d, cada uno menor que el valor en sí mismo, de modo que ab-cd, ac-bd y ad-bc son múltiplos de el valor. Si hay otros valores sigue siendo una pregunta abierta

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

Python 2.7

Para responder la pregunta, uno debe saber la pregunta, y la pregunta es:

¿Qué obtienes cuando multiplicas seis por nueve? ^{Gracias a TRiG por la corrección}

Entonces Deep Thought se basa en el uso práctico de la base 13 :

6 ₁₃ x 9 ₁₃ = 42 ₁₃

Importamos nuestras constantes:

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

También definimos nuestras cosas de la tierra, como una bolsa de baldosas de Scrabble , Arthur (algo predecible, aunque un poco extraño, una especie de computadora), Trillian (nuestra 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)))

Presentamos a Zaphod , un tipo aleatorio, que finalmente se queda sin fuerza cuando nos acercamos al endOfTheUniverse.

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

Y Marvin, el Android paranoico , cuya actitud positiva podría detener cualquier fiesta:

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

Y seguimos ejecutar estos 4 personajes a través de la mezcla hasta que se calculan que :

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)

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

Esto debería terminar en algún lugar alrededor de la marca de 75 segundos, definitivamente terminando en 80 segundos. A veces antes de Zaphods Infinite Improbability Drive .

DOS Batch: la respuesta a la vida, el universo y todo

¡Gracias a mynameiscoffey por su simplificación!

Guardar como answer.bat:

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

Luego ejecútelo y espere 75 segundos:

> answer
42

Bash (OS X)

Esto probablemente podría ser portado a otros sistemas sin demasiados problemas. Reemplácelo saycon lo que esté utilizando como una utilidad de línea de comandos de texto a voz. La -fopción toma la entrada de un archivo con nombre.

Con un poco de suerte, incluso podría generar el número correcto :-)

Esto tarda casi exactamente 1 minuto y 15 segundos en ejecutarse en mi 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

Esta es una pregunta difícil. Como realmente no conocemos la pregunta, el único método viable para obtener la respuesta es mediante un método de optimización global. En este caso, opté por el método de recocido simulado , ya que este me ha dado buenas respuestas a preguntas difíciles antes.

Todo lo que hace este código es buscar el valor óptimo de una función cuya entrada es la vida misma. Y lo sorprendente es que funciona. Entonces, ¿acabo de validar el pensamiento profundo?

tic;

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

Salida:

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

Rubí

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

Salida en mi máquina:

42
Took 123 seconds; seed was 3771996

Esto abusa del RNG. ;)

do

#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: encontrar "la respuesta a la vida y todo" resolviendo una ecuación

Echemos un vistazo a esta ecuación:

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

Hay muchas soluciones, pero si quieres rser tan grande como sea posible y p, qy rser naturales sólo hay dos soluciones:

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

con p <= q <= r, solo hay una solución y rsiempre igual a42

¿Cuál es la forma más (in) eficiente de resolver una ecuación?

Al probar todos los valores posibles!

Aquí está el 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;                
        }
    }
}

Cuanto tiempo llevara ? Para ser honesto, no lo sé porque no he podido ejecutarlo hasta el final.

Sin embargo, puede intentar con nvalores pequeños (tiene que ser mayor o igual a 42) y obtendrá el resultado correcto. Para valores pequeños como n = 2000, toma casi un minuto en mi computadora portátil. ¡Así que supongo que con los grandes valores dados en el ejemplo, tomará días, semanas o incluso años!

Encontrar la solución en aproximadamente 75 segundos:

Un requisito de la pregunta inicial es que debería tomar aproximadamente 75 segundos para ejecutarse. Una forma de lograr esto es ajustar automáticamente la complejidad del algoritmo a lo largo del tiempo:

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

Cómo funciona (para los curiosos): comprueba cuántas iteraciones se han realizado en un segundo, luego multiplica esto por 74 y se ajusta npara que coincida con ese valor. por ejemplo: si toma un segundo hacer 500 iteraciones, tomará 10 segundos hacer 5000 iteraciones. Tenga en cuenta que se multiplica por 74, no 75 porque ya pasamos un segundo para "benchmarking".

fuente y créditos para matemáticas

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 las particiones de 10 a través de un método bastante ineficiente. Tomó 130 segundos para ejecutarse en una versión de lanzamiento en mi sistema, pero alguien con una PC suficientemente rápida debería poder ejecutarlo en ~ 75 segundos ...

#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

Esto llevará un tiempo alertar algo ... pero vale la pena, ya que te mostrará la respuesta a la vida del universo y todo.

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

Manifestación

Pitón

A veces, una respuesta solo es clara al final de un cálculo, pero algunos aspectos son visibles antes de la terminación.

Y poco conocido es la secuencia de entradas con Deep Thought sembrada con:

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

Por lo tanto:

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: la respuesta se proporciona después de 75 segundos.

Ensamblaje (vinculado por gcc)

En una computadora suficientemente lenta (velocidad de CPU ~ 2Hz), esto debería tomar alrededor de 75 segundos para ejecutarse:

  .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 y utilidades de 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 está escuchando atentamente todo el proceso.

Java (227 caracteres)

¿Quién dice que las manipulaciones bit a bit no son divertidas? ¿O que Java no puede ser confuso?
Realizamos un bucle durante 75 segundos y luego aumentamos la respuesta.

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

Sin golf

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 acuerdo con el hecho de que hardware diferente producirá resultados diferentes, no hay una respuesta fija para esto. Estoy usando una función de tiempo transcurrido, así que sé cuándo dejar de calcular.

Básicamente, calculará los dos números primos más grandes cuando se reste es 42

Más rápido su máquina, más grandes serán los 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

Recorre una distancia que toma aproximadamente 70/4 segundos para que tu servant^H^H^H^Hcomputer(podría ser humano, perro o cualquier cosa que pueda recoger fichas numéricas) para caminar. Coloque un número grande 4y un número grande 2allí. Coloque su computeral punto de salida. Inicie el temporizador, haga que camine hasta el depósito de números y recupere un número a la vez.

Le asigné 5 segundos para recogerlos y soltarlos.

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

Rubí

Un programa para agregar (0.56) potencia n por 75 veces. Valor den is 1

¿Dónde se n=1debe obtener de cualquier 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 la diferencia de tiempo de rubí, he verificado el tiempo de ejecución, que es 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);
?>

Esto es lo más cerca que estoy esta noche. Ejecutándolo en tecbrat.com , un viejo IBM NetVista P4 con Ubuntu 10.04, mostró 69 segundos y 78 segundos en mis últimas 2 ejecuciones.

JavaScript (ofuscación a nivel de bit) (¡no está mal para 136 bytes!)

Puede verse como un poco engañoso, pero las funciones se pensaron meticulosamente, teniendo en cuenta que el valor de 75000 ms se calcularía antes de las funciones utilizadas para calcular 42. Es bastante poético cuando lo miras, realmente: )

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

No soy demasiado bueno con este tipo de cosas. Soy desarrollador de aplicaciones, pero nunca he recibido capacitación en C y sobre todo creo aplicaciones que toman cosas de los servidores y hacen que la información se vea bonita ...

No tengo idea de si esto funcionará y hay un poco de código adicional allí porque está en una aplicación de iPhone y muestro un hud de progreso y una vista de alerta cuando se ha alcanzado el 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