Wprowadzenie : Obliczenie głębokiej myśli Odpowiedź na życie wszechświata i wszystko w ciągu 7,5 miliona lat było rozwiązaniem 42.

Napisz program w dowolnym języku programowania, którego 75obliczenie zajmuje około sekund, zaczynając od tego, co chcesz, i wypisz liczbę 42.

Uwaga: Liczbę 42należy jakoś obliczyć (liczby losowe, cokolwiek wolisz), a nie tylko na stałe w skrypcie.

Jak sugerowano, nie można używać sleepani równoważnych funkcji. Bądź pomysłowy.

To zajmuje około 75s na Raspberry Pi podkręconym do 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

Działa, ponieważ:

42 jest jedyną znaną wartością, która jest liczbą zestawów czterech różnych dodatnich liczb całkowitych a, b, c, d, z których każda jest mniejsza niż sama wartość, tak że ab-cd, ac-bd i ad-bc są wielokrotnościami wartość. Czy istnieją inne wartości, pozostaje otwartym pytaniem

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

Python 2.7

Aby odpowiedzieć na pytanie, trzeba znać pytanie - a pytanie brzmi:

Co otrzymujesz, gdy pomnożysz sześć przez dziewięć? ^{Dzięki TRiG za korektę}

Tak więc Głęboka Myśl opiera się na poręcznym użyciu bazy 13 :

6 ₁₃ x 9 ₁₃ = 42 ₁₃

Importujemy nasze stałe:

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

Definiujemy również nasze ziemskie rzeczy, będące woreczkiem płytek do scrabble , Arthur (przewidywalny, choć nieco dziwny, rodzaj komputera), Trillian (nasza racjonalna bohaterka),

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

Przedstawiamy Zaphod - losowy rodzaj, który w końcu zaczyna brakować pary, gdy zbliżamy się do endOfTheUniverse.

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

I Marvin, Paranoidalny Android , którego pozytywne nastawienie może powstrzymać każdą imprezę:

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

A my nadal prowadzony przez te 4 znaki mieszanki aż obliczyć go :

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)

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

Powinno to zakończyć się gdzieś w okolicach 75 sekund, zdecydowanie kończąc o 80 sekund. Czasami wcześniej do Zaphods Infinite Improbability Drive .

DOS Batch - odpowiedź na życie, wszechświat i wszystko

Dzięki mynameiscoffey za jego uproszczenie!

Zapisz jako answer.bat:

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

Następnie uruchom go i poczekaj 75 sekund:

> answer
42

Bash (OS X)

Prawdopodobnie można go przenieść do innych systemów bez większych problemów. Zamień na saywszystko, czego używasz jako narzędzie wiersza polecenia zamiany tekstu na mowę. -fOpcja zajmuje wejście z nazwanego pliku.

Przy odrobinie szczęścia może nawet podać prawidłową liczbę :-)

Uruchomienie tego systemu zajmuje prawie dokładnie 1 minutę i 15 sekund (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

To jest trudne. Ponieważ tak naprawdę nie znamy pytania, jedyną realną metodą uzyskania odpowiedzi jest globalna metoda optymalizacji. W tym przypadku wybrałem metodę symulowanego wyżarzania , ponieważ ta dała mi wcześniej dobre odpowiedzi na trudne pytania.

Cały ten kod polega na szukaniu optymalnej wartości funkcji, której wejściem jest samo życie. Niesamowite jest to, że działa. Czy więc właśnie zweryfikowałem Głęboką Myśl?

tic;

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

Wynik:

the_answer =

    42

Elapsed time is 74.892428 seconds.

C - 1089 bajtów

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

Sprężony:

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

Dane wyjściowe na moim komputerze:

42
Took 123 seconds; seed was 3771996

To narusza 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 - znalezienie „odpowiedzi na życie i wszystko” poprzez rozwiązanie równania

Spójrzmy na to równanie:

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

Istnieje wiele rozwiązań, ale jeśli chcesz rbyć tak duży, jak to możliwe p, qi rbyć naturalsami, są tylko dwa rozwiązania:

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

z p <= q <= r, istnieje tylko jedno rozwiązanie i rzawsze równe42

Jaki jest najbardziej (nie) skuteczny sposób rozwiązania równania?

Próbując wszystkich możliwych wartości!

Oto kod:

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

Ile czasu to zajmie ? Szczerze mówiąc, nie wiem, ponieważ nie byłem w stanie doprowadzić go do końca.

Możesz jednak spróbować z małymi nwartościami (musi być większa lub równa 42) i uzyskasz poprawny wynik. W przypadku niewielkich wartości, takich jak n = 2000, trwa prawie minuta na moim laptopie. Myślę, że przy dużych wartościach podanych w przykładzie zajmie to dni, tygodnie, a nawet lata !!!

Znalezienie rozwiązania w około 75 sekund:

Jednym z wymagań wstępnego pytania jest wykonanie około 75 sekund. Jednym ze sposobów osiągnięcia tego jest automatyczne dostosowanie złożoności algorytmu w czasie:

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

Jak to działa (dla ciekawskich): sprawdza, ile iteracji wykonano w ciągu jednej sekundy, a następnie pomnóż to przez 74 i dostosuj, naby dopasować tę wartość. np .: jeśli wykonanie jednej 500 iteracji zajmie jedną sekundę, wykonanie 5000 iteracji zajmie 10 sekund. Zauważ, że mnoży się przez 74, a nie 75, ponieważ spędziliśmy już jedną sekundę na „testowaniu”.

źródło i kredyty matematyczne

C # - 151 znaków

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

C ++

Oblicza partycje o 10 za pomocą metody raczej nieefektywne. Trwało 130 sekund, aby uruchomić wersję Release w moim systemie, ale ktoś z wystarczająco szybkim komputerem powinien być w stanie uruchomić go w ~ 75 sekund ...

#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

To zajmie trochę czasu, aby coś zaalarmować ... ale warto, ponieważ pokaże Ci Odpowiedź na życie wszechświata i wszystko!

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

Próbny

Pyton

Czasami odpowiedź jest jasna tylko na samym końcu obliczeń, ale jej aspekty są widoczne przed zakończeniem.

I mało znana jest sekwencja danych wejściowych Głębokiej Myśli zaszczepiono:

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

W związku z tym:

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 - odpowiedź zostanie udzielona po 75 sekundach.

Zestaw (połączony przez gcc)

Na wystarczająco wolnym komputerze (szybkość procesora ~ 2 Hz) uruchomienie powinno zająć około 75 sekund:

  .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

Narzędzia Bash i 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 słucha uważnie przez cały czas obliczeń.

Java (227 znaków)

Kto powiedział, że manipulacje bitowe nie są zabawne? Czy ta Java nie może być myląca?
Wykonujemy pętlę przez 75 sekund, a następnie wyświetlamy odpowiedź.

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

Nie golfił

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

Biorąc pod uwagę fakt, że inny sprzęt będzie dawał różne wyniki, nie ma na to stałej odpowiedzi. Używam funkcji upływającego czasu, więc wiem, kiedy przestać obliczać.

Zasadniczo obliczy dwie największe liczby pierwsze, po odjęciu 42

Im szybciej maszyna, tym większe liczby pierwsze :-)

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

Odsuń się na odległość, która zajmuje około 70/4 sekund servant^H^H^H^Hcomputer(może to być człowiek, pies lub cokolwiek, co może zbierać płytki numeryczne). Umieść tam dużą cyfrę 4i dużą cyfrę 2. Umieść swój computerpunkt wyjściowy. Uruchom licznik, poprowadź go do składu liczb i przynieś jedną liczbę na raz.

Poświęciłem 5 sekund na ich podniesienie i odłożenie.

Kolejny przykład 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);
        }
    }
}

Rubin

Program do dodania (0,56) mocy n 75 razy. Wartośćn is 1

Gdzie n=1należy uzyskać z dowolnej formyTime 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

Korzystając z różnicy czasu ruby, zweryfikowałem czas wykonania, który wynosi około 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);
?>

To jest tak blisko, jak dziś wieczorem. Uruchomienie go na stronie tecbrat.com , stary IBM NetVista P4 z Ubuntu 10.04, pokazał 69 sekund i 78 sekund w moich ostatnich 2 uruchomieniach.

JavaScript (bitowe zaciemnianie) (nieźle jak na 136 bajtów!)

Może to być trochę oszukane, ale funkcje zostały starannie przemyślane, biorąc pod uwagę, że wartość 75000 ms zostanie obliczona przed funkcjami użytymi do obliczenia 42. Jest to dość poetyckie, jeśli spojrzysz na to, naprawdę: )

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

Nie jestem zbyt dobry w tego typu sprawach. Jestem programistą aplikacji, ale nigdy nie miałem żadnego szkolenia w języku C i głównie tworzę aplikacje, które pobierają rzeczy z serwerów i sprawiają, że informacje wyglądają ładnie ...

Nie mam pojęcia, czy to zadziała, i jest tam trochę dodatkowego kodu, ponieważ jest w aplikacji na iPhone'a, a po osiągnięciu 42 wyświetlam ekran postępu i widok alertu:

#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