Introduction : Calcul de la pensée profonde La solution à la vie de l’univers et de toute chose sur une période de 7,5 millions d’années 42.

Ecrivez un programme dans n'importe quel langage de programmation dont le 75calcul prend environ 5 secondes, en commençant par ce que vous voulez, et affichez le nombre 42.

NB: le nombre 42doit être calculé d'une manière ou d'une autre (nombres aléatoires, ce que vous préférez), pas simplement codé en dur dans votre script.

Comme suggéré, vous ne pouvez pas utiliser de sleepfonctions équivalentes. Soyez inventif.

Cela prend environ 75 secondes sur une framboise pi overclockée à 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

Cela fonctionne parce que:

42 est la seule valeur connue qui correspond au nombre d'ensembles de quatre nombres entiers positifs distincts a, b, c, d, chacun étant inférieur à la valeur elle-même, de sorte que ab-cd, ac-bd et ad-bc sont chacun des multiples de la valeur. Reste à savoir s'il existe d'autres valeurs

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

Python 2.7

Pour répondre à la question, il faut connaître la question - et la question est:

Qu'est-ce que vous obtenez quand vous multipliez six par neuf? ^{Merci à TRiG pour la correction}

So Deep Thought repose sur l' utilisation pratique de la base 13 :

6 ₁₃ x 9 ₁₃ = 42 ₁₃

Nous importons nos constantes:

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

Nous définissons également nos choses de la terre, étant un sac de tuiles de scrabble , Arthur (un prédictible quoique légèrement étrange, une sorte d'ordinateur), Trillian (notre héroïne rationnelle),

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

Nous présentons Zaphod - un type aléatoire, qui finit par s'essouffler à l'approche du endOfTheUniverse.

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

Et Marvin l'Androïde Android , dont l'attitude positive pourrait empêcher toute fête:

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

Et nous continuons à exécuter ces 4 personnages à travers le mélange jusqu'à ce qu'ils calculent qu'il :

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)

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

Cela devrait finir quelque part autour de la barre des 75 secondes, terminant définitivement par 80 secondes. Parfois plus tôt pour Zaphods Infinite Improbability Drive .

Lot DOS - la réponse à la vie, à l'univers et à tout

Merci à mynameiscoffey pour sa simplification!

Enregistrer sous answer.bat:

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

Puis lancez-le et attendez 75 secondes:

> answer
42

Bash (OS X)

Cela pourrait probablement être porté sur d'autres systèmes sans trop de problèmes. Remplacez-le saypar ce que vous utilisez comme utilitaire de ligne de commande de synthèse vocale. L' -foption prend l'entrée d'un fichier nommé.

Avec un peu de chance, il pourrait même sortir le bon numéro :-)

Cela prend presque exactement 1 minute 15 secondes pour fonctionner sur mon système (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

Ceci est une question difficile. Comme nous ne connaissons pas vraiment la question, la seule méthode viable pour obtenir la réponse consiste à utiliser une méthode d'optimisation globale. Dans ce cas, j’ai opté pour la méthode de recuit simulé , car celle-ci m’a déjà apporté de belles réponses à des questions difficiles.

Tout ce code est en train de chercher la valeur optimale d'une fonction dont l'entrée est la vie elle-même. Et la chose étonnante est que cela fonctionne. Alors, est-ce que je viens de valider Deep Thought?

tic;

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

Sortie:

the_answer =

    42

Elapsed time is 74.892428 seconds.

C - 1089 octets

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

Comprimé:

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

Rubis

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

Sortie sur ma machine:

42
Took 123 seconds; seed was 3771996

Cela abuse du 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 - Trouver "la réponse à la vie et à tout" en résolvant une équation

Regardons cette équation:

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

Il y a beaucoup de solutions, mais si vous voulez rêtre aussi grand que possible et p, qet rd'être Naturals il n'y a que deux solutions:

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

avec p <= q <= r, il n'y a qu'une solution et rtoujours égale à42

Quel est le moyen le plus (in) efficace de résoudre une équation?

En essayant toutes les valeurs possibles!

Voici le code:

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

Combien de temps cela prendra ? Pour être honnête, je ne le sais pas car je n’ai pas été capable de l’exécuter jusqu’à la fin.

Cependant, vous pouvez essayer avec de petites nvaleurs (il doit être supérieur ou égal à 42) et vous obtiendrez un résultat correct. Pour les petites valeurs telles que n = 2000, cela prend presque une minute sur mon ordinateur portable. Donc, je suppose qu'avec les grandes valeurs données dans l'exemple, cela prendra des jours, des semaines, voire des années !!!

Trouver la solution en environ 75 secondes:

Une des exigences de la question initiale est que l’exécution nécessite environ 75 secondes. Un moyen d'y parvenir consiste à ajuster automatiquement la complexité de l'algorithme au fil du temps:

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

Comment ça marche (pour les curieux): il vérifie le nombre d'itérations effectuées en une seconde, puis multiplie ce chiffre par 74 et ajuste npour correspondre à cette valeur. Exemple: s'il faut une seconde pour effectuer 500 itérations, il faudra 10 secondes pour effectuer 5000 itérations. Notez qu'il est multiplié par 74 et non par 75 car nous avons déjà passé une seconde pour "l'analyse comparative".

source et crédits pour les mathématiques

C # - 151 Caractères

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

C ++

Calcule les partitions de 10 via une méthode plutôt inefficace. Pris 130s pour fonctionner dans une version de compilation sur mon système, mais quelqu'un avec un PC suffisamment rapide devrait être capable de l'exécuter dans ~ 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

Cela prendra un certain temps pour alerter quelque chose ... mais ça vaut la peine, car cela vous montrera La réponse à la vie de l'univers et de tout!

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

Démo

Python

Parfois, une réponse n’est claire qu’à la fin d’un calcul, mais certains de ses aspects sont visibles avant la fin du calcul.

Et peu connue est la séquence des entrées Deep Thought a été semé avec:

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

Par conséquent:

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 réponse est fournie après 75 secondes.

Assembly (lié par gcc)

Sur un ordinateur suffisamment lent (vitesse du processeur ~ 2Hz), l’exécution de ce test devrait prendre environ 75 secondes:

  .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

Utilitaires Bash et 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 écoute attentivement tout au long du calcul.

Java (227 caractères)

Qui a dit que les manipulations au niveau des bits ne sont pas amusantes? Ou que Java ne peut pas être déroutant?
Nous bouclons pendant 75 secondes, puis la réponse résonne.

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

Compte tenu du fait que des matériels différents produiront des résultats différents, il n’existe pas de réponse fixe à cela. J'utilise une fonction de temps écoulé pour que je sache quand arrêter de calculer.

Fondamentalement, il calculera les deux plus grands nombres premiers après soustraction 42

Plus votre machine est rapide, plus les nombres premiers seront grands :-)

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

Marchez sur une distance d'environ 70/4 secondes servant^H^H^H^Hcomputer(que ce soit un humain, un chien ou tout ce qui peut ramasser des tuiles numérotées). Placez un grand chiffre 4et un grand chiffre à 2cet endroit . Placez votre computersur le point de sortie. Démarrez le chronomètre, faites-le marcher jusqu'au dépôt des chiffres et ramenez-y un nombre à la fois.

J'ai alloué 5 secondes pour les ramasser et les poser.

Un autre exemple en 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);
        }
    }
}

Rubis

Un programme pour ajouter (0,56) puissance n 75 fois. Valeur den is 1

Où n=1doit-on obtenir de toute forme 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

En utilisant la différence de temps ruby, j'ai vérifié le temps d'exécution qui est d'environ 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);
?>

Ceci est aussi proche que je deviens ce soir. Son exécution sur tecbrat.com , un ancien IBM NetVista P4 exécutant Ubuntu 10.04, affichait 69 secondes et 78 secondes lors de mes 2 dernières exécutions.

JavaScript (obscurcissement au niveau des bits) (pas mal pour 136 octets!)

Cela peut sembler un peu trompeur, mais les fonctions ont été méticuleusement pensées, sachant que la valeur de 75 000 ms serait calculée avant les fonctions utilisées pour calculer 42. C’est assez poétique quand on le regarde, vraiment: )

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

Je ne suis pas trop bon avec ce genre de choses. Je suis un développeur d'applications, mais je n'ai jamais suivi de formation en langage C et je réalise principalement des applications qui récupèrent des éléments sur des serveurs et rendent les informations plus jolies ...

Je ne sais pas si cela fonctionnera et il y a un peu de code supplémentaire car il est dans une application pour iPhone et j'affiche un hud progrès et une vue d'alerte lorsque 42 sont atteints:

#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