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

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

NB. Число 42должно быть рассчитано каким-либо образом (случайные числа, что вы предпочитаете), а не просто жестко закодировано в вашем скрипте.

Как предполагается, вы не можете использовать sleepили эквивалентные функции. Будьте изобретательны.

Это займет около 75 с на Raspberry Pi, разогнанной до 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 ₁₃ x 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)))

Мы представляем Zaphod - случайную сортировку, которая в конце концов выдыхается, когда мы приближаемся к 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 секунд. Иногда раньше Zaphods Infinite Невероятность Drive .

DOS Batch - ответ на жизнь, вселенную и все

Спасибо mynameiscoffey за его упрощение!

Сохранить как answer.bat:

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

Затем запустите его и подождите 75 секунд:

> answer
42

Баш (OS X)

Это, вероятно, может быть перенесено на другие системы без особых проблем. Замените sayна то, что вы используете в качестве утилиты преобразования текста в речь. -fПараметр принимает входные данные из указанного файла.

Если повезет, он может даже вывести правильное число :-)

Это занимает почти ровно 1 минуту 15 секунд для запуска в моей системе (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

Это сложный вопрос. Поскольку мы на самом деле не знаем вопроса, единственный реальный способ получить ответ - это метод глобальной оптимизации. В этом случае я выбрал метод имитации отжига , так как этот дал мне хорошие ответы на сложные вопросы раньше.

Весь этот код ищет оптимальное значение функции, входом которой является сама жизнь. И удивительно то, что это работает. Итак, я только что проверил Deep Thought?

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

Это злоупотребляет ГСЧ. ;)

С

#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 итераций потребуется одна секунда, для выполнения 5000 итераций потребуется 10 секунд. Обратите внимание, что он умножается на 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 секунд, чтобы запустить сборку Release на моей системе, но кто-то с достаточно быстрым ПК должен был запустить его за ~ 75 секунд ...

#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

Deep Thought внимательно слушает весь расчёт.

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

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

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

По сути, он вычислит два самых больших простых числа, когда вычтено 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, и я показываю индикацию прогресса и отображение предупреждений, когда достигнуто 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