Отметить это для удаления

Question

Пометка для удаления.Пожалуйста, удалите.

Answer 1

Выделите около миллиона символов и установите их изначально для всех 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()

И вывод:

0.00001
0.00002
0.00003
0.00004
0.00005
0.00006
0.00007
0.00008
0.00009
0.0001
0.00011
0.00012
0.00013
0.00014
0.00015

Answer 2

Псевдокод, который может делать то, что вы, кроме гарантии без повторов.

1. Возьмите выделение 1 МБ.
2. Случайно установить каждый байт.
3. Эхо к stdout как "0.<bytes as integer string>" (будет очень длинным)
4. Перейти к # 2

Ваше «Никогда не возвращает одно и то же число» не гарантируется, но крайне маловероятно (1 из 2 ^ 8192), если предположить хорошую реализацию Random.

Answer 3

Если вы программируете на C, семейство функций nextafter() - это Posix-совместимые функции, полезные для получения следующего двойного числа после или перед любым заданным значением.Это даст вам около 2 ^ 64 различных значений для вывода, если вы выводите как положительные, так и отрицательные значения.

Если вам необходимо распечатать значения, используйте формат% a или% A для точного представления.Со страницы руководства printf (3): «Для преобразования« a »двойной аргумент преобразуется в шестнадцатеричное представление (с использованием букв abcdef) в стиле [-] 0xh.hhhhp ± d ...» «Достаточная точность по умолчаниюдля точного представления значения, если существует точное представление в базе 2 ... "

Если вы хотите генерировать случайные числа, а не последовательные по возрастанию, возможно, выполните поиск в Google для 64-битного KISS RNG.Реализации на Java, C , Ada, Fortran и др. Доступны в Интернете.Период 64-разрядного KISS RNG сам по себе равен ~ 2 ^ 250, но 64-разрядных чисел с двойной точностью не так много, поэтому некоторые числа вновь появятся на выходах 2 ^ 64, но с другими соседними значениями.В некоторых системах длинные двойники имеют 128-битные значения;в других - только 80 или 96. Используя длинные двойники, вы могли бы соответственно увеличить число различных выходных значений, комбинируя два случайных числа в каждом выходном.

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

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

(Он отличается от вашего, потому что я генерирую все строки из одного символа, затем все строки из двух символов, затем все строки из трех символов, ... поэтому я считаю, что нет необходимости в состоянии, отличном от последнего сгенерированного числа.)

Тогда опять я могу ошибаться; Я не пробовал это.

ДОПОЛНЕНИЕ

Хорошо, я попробую. Вот такой генератор в Ruby

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

Выглядит хорошо для меня ....

Answer 5

Ваш метод в конечном итоге будет использовать более 1 Мб памяти. Каждый раз, когда вы представляете числа, если вы ограничены 1 Мб кучи, тогда существует только конечное число значений. Я бы взял максимально возможное количество памяти и увеличил младший бит на единицу при каждом вызове. Это обеспечит работу как можно дольше перед возвратом повторного числа.