Вступ : Глибока думка розрахована Відповідь на життя Всесвіту та всього, що пройшло в 7,5 мільйонів років, було рішення 42.

Напишіть програму будь-якою мовою програмування, яка потребує приблизно 75секунд, щоб обчислити, починаючи з того, що ви хочете, і виведіть число 42.

Примітка. Кількість 42має бути обчислена якось (випадкові числа, що б вам не було зручніше), а не просто жорстко закодовано у вашому сценарії.

Як пропонується, ви не можете використовувати sleepабо еквівалентні функції. Будь винахідливим.

Це займе близько 75s на малиновому пі-разгоні до 1 ГГц

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

Це працює тому, що:

42 - єдине відоме значення, яке є числом наборів з чотирьох різних позитивних цілих чисел a, b, c, d, кожне менше, ніж саме значення, таким чином, що ab-cd, ac-bd і ad-bc є кожними кратними значення. Чи є інші значення, залишається відкритим питання

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

Python 2.7

Щоб відповісти на питання, треба знати питання - і питання:

Що ви отримуєте, коли множите шість на дев'ять? ^{Дякуємо TRiG за виправлення}

Тож Deep Thought покладається на зручне використання бази 13 :

6 ₁₃ х 9 ₁₃ = 42 ₁₃

Ми імпортуємо наші константи:

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

Ми представляємо Зафод - випадковий сорт, який, врешті-решт, вичерпається пари, коли ми поруч endOfTheUniverse.

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

І Марвін Параноїд Android , позитивне ставлення якого може зупинити будь-яку вечірку:

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

І ми продовжуємо запускати ці 4 символи через суміш, поки вони не обчислять його :

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)

Повний 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)

Це має закінчитися десь біля 75-секундної позначки, безумовно, закінчившись за 80 секунд. Іноді раніше на Зафодс Нескінченний привід неможливості .

DOS Batch - відповідь на життя, Всесвіт і все

Дякуємо mynameiscoffey за його спрощення!

Зберегти як answer.bat:

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

Потім запустіть його і зачекайте 75 секунд:

> answer
42

Bash (OS X)

Можливо, це може бути перенесено на інші системи без особливих проблем. Замініть sayтим, що ви використовуєте як утиліту командного рядка "текст у мові". -fПараметр приймає вхідні дані з вказаного файлу.

Маючи трохи удачі, воно може навіть вивести правильне число :-)

На мою систему потрібно майже рівно 1 хвилину 15 секунд (ОС 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

Це важкий. Оскільки ми насправді не знаємо питання, єдиний життєздатний метод отримання відповіді - це метод глобальної оптимізації. У цьому випадку я вибрав метод імітованого відпалу , оскільки він дав мені гарні відповіді на складні питання раніше.

Все, що робиться цим кодом, шукає оптимальне значення функції, входом якої є саме життя. І дивовижна річ, що вона працює. Отже, я щойно підтвердив глибоку думку?

tic;

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

Вихід:

the_answer =

    42

Elapsed time is 74.892428 seconds.

C - 1089 байт

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

Стислий:

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

Рубін

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

Вихід на мою машину:

42
Took 123 seconds; seed was 3771996

Це зловживає RNG. ;)

С

#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 - пошук "відповіді на життя і все", розв’язуючи рівняння

Давайте розглянемо це рівняння:

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

Існує багато рішень, але якщо ви хочете , rщоб бути якомога більше, і p, qі rбути натуралів є тільки два рішення:

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

з p <= q <= r, є лише одне рішення і rзавжди дорівнює42

Який найбільш (не) ефективний спосіб розв’язати рівняння?

Спробувавши всі можливі значення!

Ось код:

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

Скільки часу це займе? Якщо чесно, то я не знаю, тому що мені не вдалося це виконати до кінця.

Однак ви можете спробувати з малими nзначеннями (воно повинно бути більшим або рівним 42), і ви отримаєте правильний результат. Для невеликих значень, таких як n = 2000, на моєму ноутбуці потрібно майже одну хвилину. Тож я гадаю, що з великими значеннями, наведеними в прикладі, це займе дні, тижні, а то й роки !!!

Пошук рішення приблизно за 75 секунд:

Однією з вимог початкового запитання є те, що на виконання має знадобитися приблизно 75 секунд. Один із способів досягти цього - автоматично регулювати складність алгоритму в часі:

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

Як це працює (для допитливих): він перевіряє, скільки ітерацій було зроблено за одну секунду, а потім помножив це на 74 і відрегулював, nщоб відповідати цьому значенню. наприклад: якщо зробити 500 ітерацій, потрібно 100 секунд, щоб зробити 5000 ітерацій. Зауважте, що він помножиться на 74, а не на 75, оскільки ми вже витратили одну секунду на "бенчмаркінг".

джерело та кредити з математики

C # - 151 персонажів

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

C ++

Обчислюються перегородки з 10 з допомогою досить неефективний метод. Шукала 130-х років для запуску у версії для моєї системи, але хтось із достатньо швидким ПК повинен мати змогу запустити її через ~ 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

Це займе певний час, щоб щось попередити ... але це варто, оскільки воно покаже вам відповідь на життя Всесвіту та всього!

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

Демо

Пітон

Іноді відповідь зрозуміла лише в самому кінці розрахунку, але її аспекти видно перед припиненням.

І маловідомою є послідовність входів «Глибокої думки»:

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

Звідси:

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 - відповідь надається через 75 секунд.

Збірка (пов'язана gcc)

На досить повільному комп'ютері (швидкість процесора ~ 2 Гц) для запуску потрібно близько 75 секунд:

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

Глибока думка уважно слухає весь шлях через обчислення.

Java (227 символів)

Хто каже, що побитові маніпуляції - це не забава? Або ця Java не може бентежити?
Ми циклічаємо 75 секунд, а потім прострілюємо відповідь.

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

Безумовно

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

Відповідно до того, що різні апаратури даватимуть різні результати, на це немає чіткої відповіді. Я використовую функцію минулого часу, тому я знаю, коли припинити обчислення.

В основному, він буде обчислювати найбільші два простих числа, якщо відняти 42

Чим швидше ваша машина, тим більші будуть праймери :-)

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

Пройдіть відстань, яка займає приблизно 70/4 секунди для вашої ходьби servant^H^H^H^Hcomputer(це може бути людина, собака чи все, що може підібрати цифри). Помістіть там велику цифру 4і велику цифру 2. Помістіть свою computerточку виводу. Запустіть таймер, доведіть його до депо з цифрами та поверніть по одному номеру за раз.

Я виділив 5 секунд, щоб забрати їх і відкласти.

Ще один приклад 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);
        }
    }
}

Рубін

Програма для додавання (0,56) потужності n в 75 разів. Значенняn is 1

Де n=1слід отримати будь-яку формуTime 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

Використовуючи різницю в часі в рубіні, я перевірив час виконання - приблизно 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);
?>

Це так близько, як я сьогодні ввечері. Запустивши його на tecbrat.com , стара IBM NetVista P4 під управлінням Ubuntu 10.04 показала 69 секунд і 78 секунд на моїх останніх 2 запусках.

JavaScript (побітна обфускування) (непогано для 136 байт!)

Це може розглядатися як трохи на хитрому боці, але функції були ретельно продумані, маючи на увазі, що значення 75000 мс буде обчислено до функцій, які використовуються для обчислення 42. Насправді це досить поетично: )

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

Я не надто хороший з подібними матеріалами. Я розробник додатків, але ніколи не займався навчанням C і в основному роблю програми, які захоплюють речі з серверів і роблять інформацію красивою ...

Я не маю уявлення, чи буде це працювати, і є трохи додаткового коду там, тому що це в додатку для iphone, і я показую hud ходу та перегляд попередження, коли 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