Einleitung : Tiefes Denken berechnet Die Antwort auf das Leben des Universums und alles in einem Zeitraum von 7,5 Millionen Jahren war die Lösung 42.

Schreiben Sie ein Programm in einer beliebigen Programmiersprache 75, dessen Berechnung ca. Sekunden in Anspruch nimmt , und geben Sie die Zahl aus 42.

NB Die Zahl 42muss auf irgendeine Weise berechnet werden (Zufallszahlen, was auch immer Sie bevorzugen) und nicht nur in Ihrem Skript fest codiert sein.

Wie vorgeschlagen, können Sie keine sleepoder gleichwertige Funktionen verwenden. Seien Sie erfinderisch.

Dies dauert ungefähr 75s auf einem Himbeer-Pi, der auf 1 GHz übertaktet ist

#!/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

Es funktioniert, weil:

42 ist der einzige bekannte Wert, der die Anzahl der Sätze von vier verschiedenen positiven ganzen Zahlen a, b, c, d ist, die jeweils kleiner sind als der Wert selbst, so dass ab-cd, ac-bd und ad-bc jeweils ein Vielfaches von sind der Wert. Ob es andere Werte gibt, bleibt offen

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

Python 2.7

Um die Frage zu beantworten, muss man wissen , die Frage - und die Frage ist:

Was bekommst du, wenn du sechs mal neun multiplizierst? ^{Danke an TRiG für die Korrektur}

So Deep Thought stützt sich auf die handliche Verwendung von Basis 13 :

6 ₁₃ x 9 ₁₃ = 42 ₁₃

Wir importieren unsere Konstanten:

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

Wir definieren auch unsere Erden-Dinge als eine Tüte Scrabble-Kacheln , Arthur (ein vorhersehbarer, wenn auch etwas seltsamer Computer), Trillian (unsere rationale Heldin),

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

Wir stellen Zaphod vor - eine zufällige Sorte, der irgendwann der Dampf ausgeht, als wir uns dem nähern endOfTheUniverse.

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

Und Marvin the Paranoid Android , dessen positive Einstellung jede Party aufhalten könnte:

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

Und wir weiterhin diese 4 Zeichen durch den Mix laufen , bis sie berechnen sie :

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)

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

Dies sollte irgendwo um die 75 Sekunden-Marke enden und definitiv um 80 Sekunden enden. Manchmal früher zu Zaphods Infinite Improbability Drive .

DOS Batch - die Antwort auf das Leben, das Universum und alles

Vielen Dank an mynameiscoffey für seine Vereinfachung!

Speichern als answer.bat:

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

Dann starte es und warte 75 Sekunden:

> answer
42

Bash (OS X)

Dies könnte wahrscheinlich problemlos auf andere Systeme portiert werden. Ersetzen Sie sie saydurch das, was Sie als Text-zu-Sprache-Befehlszeilenprogramm verwenden. Die -fOption nimmt Eingaben von einer benannten Datei entgegen.

Mit etwas Glück könnte es sogar die richtige Zahl ausgeben :-)

Auf meinem System (OS X 10.5) dauert die Ausführung fast genau 1 Minute und 15 Sekunden.

#!/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

Dies ist eine schwierige Frage. Da wir die Frage nicht wirklich kennen, ist die einzig praktikable Methode, die Antwort zu erhalten, eine globale Optimierungsmethode. In diesem Fall habe ich mich für die simulierte Glühmethode entschieden , da diese mir zuvor gute Antworten auf schwierige Fragen gegeben hat.

All dieser Code sucht nach dem optimalen Wert einer Funktion, deren Eingabe das Leben selbst ist. Und das Erstaunliche ist, dass es funktioniert. Habe ich gerade Deep Thought validiert?

tic;

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

Ausgabe:

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

Komprimiert:

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

Rubin

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

Ausgabe auf meinem Computer:

42
Took 123 seconds; seed was 3771996

Dies missbraucht das 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 - Finden der "Antwort auf das Leben und alles" durch Lösen einer Gleichung

Werfen wir einen Blick auf diese Gleichung:

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

Es gibt viele Lösungen, aber wenn Sie wollen , rso groß wie möglich sein , und p, qund rNaturals zu sein gibt es nur zwei Lösungen:

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

mit p <= q <= rgibt es nur eine lösung und rimmer gleich42

Was ist der effizienteste Weg, eine Gleichung zu lösen?

Indem Sie alle möglichen Werte ausprobieren!

Hier ist der 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;                
        }
    }
}

Wie lange wird es dauern ? Um ehrlich zu sein, ich weiß es nicht, weil ich es nicht bis zum Ende durchspielen konnte.

Sie können es jedoch mit kleinen nWerten versuchen (es muss größer oder gleich sein 42), und Sie erhalten das richtige Ergebnis. Für kleine Werte wie n = 2000dauert es auf meinem Laptop fast eine Minute. Ich schätze also, dass es mit den im Beispiel angegebenen großen Werten Tage, Wochen oder sogar Jahre dauern wird !!!

Finden der Lösung in ungefähr 75 Sekunden:

Eine Anforderung aus der ersten Frage ist, dass die Ausführung ca. 75 Sekunden dauern sollte. Eine Möglichkeit, dies zu erreichen, besteht darin, die Komplexität des Algorithmus über die Zeit automatisch anzupassen:

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

So funktioniert es (für Neugierige): Es überprüft, wie viele Iterationen in einer Sekunde durchgeführt wurden, multipliziert diese dann mit 74 und passt sie nan diesen Wert an. Beispiel: Wenn eine Sekunde für 500 Iterationen benötigt wird, dauert die Ausführung von 5000 Iterationen 10 Sekunden. Beachten Sie, dass es mit 74 und nicht mit 75 multipliziert wird, da wir bereits eine Sekunde für das "Benchmarking" aufgewendet haben.

Quelle und Credits für Mathe

C # - 151 Zeichen

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

C ++

Berechnet die Partitionen von 10 mit einer ziemlich ineffizienten Methode. Es hat 130s gedauert, um in einem Release-Build auf meinem System ausgeführt zu werden, aber jemand mit einem ausreichend schnellen PC sollte in der Lage sein, es in ~ 75s auszuführen ...

#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

Es wird eine Weile dauern, bis etwas alarmiert wird ... aber es lohnt sich, da es Ihnen die Antwort auf das Leben des Universums und alles zeigt!

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

Python

Manchmal ist eine Antwort erst ganz am Ende einer Berechnung klar, aber Aspekte davon sind vor der Beendigung sichtbar.

Und wenig bekannt ist die Reihenfolge der Eingaben, mit denen Deep Thought geimpft wurde:

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

Daher:

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 - die Antwort wird nach 75 Sekunden bereitgestellt.

Versammlung (verbunden durch gcc)

Auf einem ausreichend langsamen Computer (CPU-Geschwindigkeit ~ 2 Hz) sollte dies ungefähr 75 Sekunden dauern:

  .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- und Linux-Utils:

#!/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 hört während der gesamten Berechnung aufmerksam zu.

Java (227 Zeichen)

Wer sagt, dass bitweise Manipulationen keinen Spaß machen? Oder dass Java nicht verwirrend sein kann?
Wir schleifen 75 Sekunden und geben dann die Antwort.

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

Entsprechend der Tatsache, dass unterschiedliche Hardware unterschiedliche Ergebnisse liefert, gibt es keine feste Antwort darauf. Ich verwende eine Funktion für die abgelaufene Zeit, damit ich weiß, wann ich die Berechnung beenden muss.

Grundsätzlich werden die zwei größten Primzahlen berechnet, wenn 42 subtrahiert werden

Je schneller Ihre Maschine ist, desto größer werden die Primzahlen :-)

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

Gehen Sie eine Strecke zurück, die ungefähr 70/4 Sekunden dauert servant^H^H^H^Hcomputer(es kann sich um einen Menschen, einen Hund oder irgendetwas handeln, das Zahlenkacheln aufnehmen kann). Platzieren Sie dort eine große Zahl 4und eine große Zahl 2. Platzieren Sie Ihre computerzum Ausgabepunkt. Starten Sie den Timer, lassen Sie ihn zum Nummerndepot laufen und bringen Sie jeweils eine Nummer zurück.

Ich gab 5 Sekunden Zeit, um sie aufzunehmen und abzulegen.

Ein weiteres C # -Beispiel

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

Rubin

Ein Programm zum 75-fachen Hinzufügen von (0,56) Potenz n. Wert vonn is 1

Wo n=1sollte von irgendeiner Form von erhalten werdenTime 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

Unter Verwendung der Ruby-Zeitdifferenz habe ich die Ausführungszeit überprüft 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);
?>

Das ist so nah, wie ich heute Nacht komme. Bei tecbrat.com , einem alten IBM NetVista P4 mit Ubuntu 10.04, wurden bei meinen letzten zwei Läufen 69 Sekunden und 78 Sekunden angezeigt.

JavaScript (bitweise Verschleierung) (nicht schlecht für 136 Bytes!)

Es mag als etwas betrügerisch angesehen werden, aber die Funktionen wurden akribisch durchdacht, wobei zu berücksichtigen ist, dass der 75000ms-Wert vor den Funktionen berechnet wird, die zur Berechnung von 42 verwendet werden. )

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

Ich bin nicht so gut mit solchen Sachen. Ich bin ein App-Entwickler, aber ich habe noch nie in C trainiert und mache hauptsächlich Apps, die Dinge von Servern holen und die Informationen hübsch aussehen lassen ...

Ich habe keine Ahnung, ob dies funktionieren wird, und es ist ein bisschen zusätzlicher Code enthalten, da er in einer iPhone-App enthalten ist und ich einen Fortschrittsbalken und eine Warnmeldung anzeige, wenn 42 erreicht wurde:

#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