DouKaku?

(defconstant *primes*
  '(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97))

(defun primes (n) (loop repeat n for p in *primes* collect p))
(defun basis (n) (loop repeat n for x = (expt 10 (1- n)) then (/ x 10) collect x))

(defun f (primes basis bound prod sum zero-ok)
  (if primes
      (loop for i from (if zero-ok 0 1) to 9
        as dp = (expt (car primes) i) and ds = (* i (car basis))
        while (<= dp bound) nconc
        (f (cdr primes) (cdr basis) (floor bound dp)
           (* prod dp) (+ sum ds)
           t))
    (if (= prod sum) (list sum) nil)))

(defun meertens (n)
  (loop for i from 1 to n nconc (f (primes i) (basis i) (expt 10 i) 1 0 nil)))

fun goedel n = let
  open IntInf

  val p = [
     2,  3,  5,  7, 11, 13, 17, 19, 23, 29,
    31, 37, 41, 43, 47, 53, 59, 61, 67, 71
    ]
  val a = map (valOf o Int.fromString o str) ((explode o toString) n)
in
  ListPair.foldl (fn (x, y, z) => pow (x, y) * z) 1 (p, a)
end

fun meertens n = let
  fun loop i =
    if i > n then ()
    else
      if goedel n = n then (print (IntInf.toString n ^ "\n"); loop (i + 1))
      else loop (i + 1)
  in
    loop 0
  end

val _ = (meertens o valOf o IntInf.fromString o hd o CommandLine.arguments) ()

using System;
using System.Collections.Generic;
static class Program {
    static void Main() {
        DateTime before = DateTime.Now;
        Console.WriteLine("meertens = {0}", string.Join(", ",
            Array.ConvertAll<long, string>(Meertens(), delegate(long x) { return x.ToString(); })
        ));
        Console.WriteLine("time = {0}", DateTime.Now - before);
    }
    static long[] Meertens() {
        int[] primes = Primes(20);
        List<long> meertens = new List<long>();
        for(long num = uint.MaxValue; 0 <= num; num--)
            if (Goedel(num, primes) == num)
                meertens.Add(num);
        return meertens.ToArray();
    }
    static double Goedel(long num, int[] primes) {
        double goedel = 1;
        string numstr = num.ToString();
        for(int i = 0; i < numstr.Length; i++)
            goedel *= Math.Pow(primes[i], numstr[i] - '0');
        return goedel;
    }
    static int[] Primes(int count) {
        List<int> primes = new List<int>();
        primes.Add(2);
        for(int num = 3; primes.Count < count; num += 2) {
            foreach(int p in primes)
                if (num % p == 0)
                    goto SKIP;
            primes.Add(num);
        SKIP:;
        }
        return primes.ToArray();
    }
}

import time

def CreatePrimes(n):
    primes = []
    c = 2
    while len(primes) < n:
        primes.append(c)
        for x in primes[:-1]:
            if c%x == 0:
                primes.pop();
                break
        c += 1
    return primes

def searchMeertens(keta):
    def _search(keta,count,r,n,primes,first):
        n *= 10
        for x in range(first,10):
            if x:
                r *= primes[count]
                n += 1
            if r == n:
                print "Found Meertens.",n
            if keta > 1:
                _search(keta - 1, count + 1, r ,n ,primes, 0)
    p = CreatePrimes(20)
    _search(keta,0,1,0,p,1)


keta = 10
t0 = time.time()
t1 = t0

for n in range(1,keta+1):
    searchMeertens(n)
    print n , time.time() - t1 , "sec"
    t1 = time.time()
    
print "total time", time.time() - t0

#include <time.h>
#include <iostream>
#include <bitset>

#ifndef ARRAYSIZE
#define ARRAYSIZE(x)  (sizeof(x)/sizeof(x[0]))
#endif

#define BITSET_SIZE (64*2+8)
//#define BITSET_SIZE (32*2+8)

static unsigned long long digit_base[] = {
0x0000000000000001, 0x000000000000000a,
0x0000000000000064, 0x00000000000003E8,
0x0000000000002710, 0x00000000000186A0,
0x00000000000F4240, 0x0000000000989680,
0x0000000005F5E100, 0x000000003B9ACA00,
0x00000002540BE400, 0x000000174876E800,
0x000000E8D4A51000, 0x000009184E72A000,
0x00005AF3107A4000, 0x00038D7EA4C68000,
0x002386F26FC10000, 0x016345785D8A0000,
0x0DE0B6B3A7640000, 0x8AC7230489E80000 };

static unsigned long long prime[20] = {
 2,  3,  5,  7, 11, 13, 17, 19, 23, 29,
31, 37, 41, 43, 47, 53, 59, 61, 67, 71 };

static std::bitset<BITSET_SIZE> PRIME_TABLE[ARRAYSIZE(prime)][10];

int CompareBitset(std::bitset<BITSET_SIZE> a, std::bitset<BITSET_SIZE> b) {
    for (int n = BITSET_SIZE - 1; n >= 0; n--) {
        if (a[n] != b[n]) { return a[n] ? 1 : -1; }
    }
    return 0;
}

std::bitset<BITSET_SIZE> bitset_add(std::bitset<BITSET_SIZE> a, std::bitset<BITSET_SIZE> b) {
    std::bitset<BITSET_SIZE> c = (a & b) << 1;
    if (c.any()) { return bitset_add((a ^ b), c); }
    else         { return (a ^ b); }
}

std::bitset<BITSET_SIZE> bitset_multi(std::bitset<BITSET_SIZE> a, std::bitset<BITSET_SIZE> b) {
    std::bitset<BITSET_SIZE> ans;
    if (a.any() && b.any()) {
        for (int i = 0; a.any() && (i < BITSET_SIZE); i++, a <<= 1) {
            if (b[i]) { ans = bitset_add(ans, a); }
        }
    }
    return ans;
}

std::bitset<BITSET_SIZE> bitset_pow(std::bitset<BITSET_SIZE> a, unsigned int n) {
    std::bitset<BITSET_SIZE> v((unsigned long)1);
    while (n != 0) {
        if (n & 0x1)       { v = bitset_multi(v, a); }
        if ((n /= 2) != 0) { a = bitset_multi(a, a); }
    }
    return v;
}

unsigned int digit(unsigned long long n, unsigned int base)
{
    unsigned int d = 1;
    for (; n > (base - 1); n /= base) { d++; }
    return d;
}

std::bitset<BITSET_SIZE> ulonglong2bitset(unsigned long long v) {
    std::bitset<BITSET_SIZE> high((unsigned long)(v >> (sizeof(v)*4)));
    std::bitset<BITSET_SIZE> low((unsigned long)v);
    return ((high << (sizeof(v)*4)) | low);
}

void InitPrimeTable() {
    for (int i = 0; i < ARRAYSIZE(PRIME_TABLE); i++) {
        for (int j = 0; j < ARRAYSIZE(PRIME_TABLE[0]); j++) {
            PRIME_TABLE[i][j] = bitset_pow(ulonglong2bitset(prime[i]), j);
        }
    }
}

int CheckMeertensNumber(unsigned long long n) {
    std::bitset<BITSET_SIZE> m = ulonglong2bitset(n);
    std::bitset<BITSET_SIZE> g(1UL);
    for (unsigned int d = digit(n, 10); d > 0; d--, n /= 10) {
        unsigned int p = (unsigned int)(n % 10);
        if (CompareBitset(PRIME_TABLE[d - 1][p], m) > 0)
            return 1;
        g = bitset_multi(g, PRIME_TABLE[d - 1][p]);
        if (CompareBitset(g, m) > 0)
            return 1;
    }
    return (m == g) ? 0 : -1;
}

int SearchMeertensNumber(unsigned long long base, unsigned int d, int& cnt) {
    if (d <= 0) {
        int ret = CheckMeertensNumber(base);
        if (ret == 0) {
            std::cout << base << std::endl;
            cnt++;
        }
        return ret;
    }
    if (SearchMeertensNumber(base, d - 1, cnt) > 0)
        return (base == 0) ? 0 : 1;
    for (unsigned long long i = 1; i < 10; i++) {
        base += digit_base[d - 1];
        if (SearchMeertensNumber(base, d - 1, cnt) > 0)
            break;
    }
    return 0;
}

void main(int argc, char