Question

将此标记为删除。请删除。

Answer 1

除了保证没有重复之外，可以执行您的操作的伪代码。

分配1 MB。
随机设置每个字节。
向stdout回复为“0.<bytes as integer string>”（将会非常长）
转到＃2

您的“永远不会返回相同的数字”并不能保证，但假设一个良好的Random实现，它极不可能（1 ^ 2 8192）。

Answer 2

分配大约一百万个字符，并将它们初始设置为所有0。

然后每次调用函数只会递增数字并返回它，如：

# Gives you your 1MB heap space.

num = new digit/byte/char/whatever[about a million]

# Initialise all digits to zero (1-based arrays).

def init():
    for posn ranges from 1 to size(num):
        set num[posn] to 0

# Print next value.

def printNext():
    # Carry-based add-1-to-number.
    # Last non-zero digit stored for truncated output.

    set carry to 1
    set posn to size(num)
    set lastposn to posn

    # Keep going until no more carry or out of digits.

    while posn is greater than 0 and carry is 1:
        # Detect carry and continue, or increment and stop.

        if num[posn] is '9':
            set num[posn] to '0'
            set lastposn to posn minus 1
        else:
            set num[posn] to num[posn] + 1
            set carry to 0
        set posn to posn minus one

    # Carry set after all digits means you've exhausted all numbers.

    if carry is 1:
        exit badly

    # Output the number.

    output "0."
    for posn ranges from 1 to lastposn
        output num[posn]

lastposn的使用会阻止尾随零的输出。如果您不关心这一点，则可以删除其中包含lastposn的每一行，然后从1 to size(num)运行输出循环。

每毫秒调用一次这样可以得到超过10个^{一些 - 大数量产生的运行时间 - 超过这个年龄的宇宙}年运行时间。

我不会选择基于时间的解决方案，因为时间可能会改变 - 想想夏令时或夏令时以及人们因漂移而调整时钟。

这是一些演示它的实际Python代码：

import sys
num = "00000"
def printNext():
    global num
    carry = 1
    posn = len(num) - 1
    lastposn = posn

    while posn >= 0 and carry == 1:
        if num[posn:posn+1] == '9':
            num = num[:posn] + '0' + num[posn+1:]
            lastposn = posn - 1
        else:
            num = num[:posn] + chr(ord(num[posn:posn+1]) + 1) + num[posn+1:]
            carry = 0
        posn = posn - 1

    if carry == 1:
        print "URK!"
        sys.exit(0)

    s = "0."
    for posn in range (0,lastposn+1):
        s = s + num[posn:posn+1];
    print s

for i in range (0,15):
    printNext()

输出：

Answer 3

您的方法最终将使用超过1mb的堆内存。每种方式表示数字，如果受到1mb的约束，那么只有有限数量的值。我会尽可能地获取最大内存量，并在每次调用时将最低有效位增加1。这样可以确保在返回重复的数字之前尽可能长时间地运行。

Answer 4

是的，因为没有随机要求，所以你有很大的灵活性。

我认为这个想法与非常接近，而不是通过几个修改来枚举正则表达式[0-9]*上的所有字符串：

真实字符串以序列0.
你不能结束 0

那么你会如何枚举？一个想法是

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 0.11 0.12 0.13 0.14 0.15 ... 0.19 0.21 0.22 ... 0.29 0.31 ... 0.99 0.101 0.102 ...

这里你需要的唯一状态是我认为的整数。只是聪明地在最后跳过那些零（真的不难）。 1 MB的内存应该没问题。它存储了一个巨大的整数，所以我认为你会很好。

（它与你的不同，因为我生成所有一个字符串，然后是所有两个字符串，然后是所有三个字符串，...所以我相信除了生成的最后一个数字之外不需要其他状态。）< / p>

然后我可能错了;我没试过这个。

<强>附录

好的，我会试一试。这是Ruby中的生成器

i = 0
while true
  puts "0.#{i}" if i % 10 != 0
  i += 1
end

看起来对我好......

Answer 5

如果使用C编程，nextafter()函数族是Posix兼容函数，可用于在任何给定值之后或之前生成下一个double。如果输出正值和负值，这将为您提供大约2 ^ 64个不同的输出值。

如果您需要打印出值，请使用％a或％A格式进行精确表示。从printf（3）手册页：“对于'a'转换，双参数在样式[ - ] 0xh.hhhhp±d中转换为十六进制表示法（使用字母abcdef）”“”默认精度就足够了如果存在基数2中的精确表示，则用于精确表示值...“

如果你想生成随机数而不是顺序升序，也许可以谷歌搜索64位KISS RNG。 Java中的实现，C，Ada，Fortran等可在网上获得。 64位KISS RNG本身的周期约为2 ^ 250，但没有那么多的64位双精度数，因此有些数字将重新出现在2 ^ 64输出中，但具有不同的邻居值。在某些系统中，长双精度值具有128位值;在其他方面，只有80或96.使用long double，你可以相应地通过将两个random组合到每个输出来增加不同值输出的数量。

在接受采访时，问题的关键在于弄清楚当你看到它时是否能识别出愚蠢的规范。

将此标记为删除

5 个答案: