математическое руководство, необходимое для шестнадцатеричного числа (числа) - PullRequest
Новая
       32

математическое руководство, необходимое для шестнадцатеричного числа (числа)

1 голос
/ 10 июля 2019

Я хочу создать текстовый файл или, может быть, базу данных? из всех возможных шестнадцатеричных значений между следующими двумя шестнадцатеричными значениями. 

00251eb27d8d2deb15d615edd08dd7cf402638697a4aba6c7c199ce4ef858962
002526837f828960f7d3c1e8359eaea84e38183c7ab9345a663b474063ca9e20

ограничения:

  • 64-значные шестнадцатеричные значения
  • только между двумя числами выше.
  • не более 3-х повторяющихся одинаковых значений (например, 777 - это хорошо, а 7777 - нет.)

Может ли кто-нибудь помочь мне понять, сколько будет вообще возможностей? Или помогите мне понять, если это даже реалистичный вариант? Я думал о том, чтобы использовать что-то вроде хруста для генерации вывода текстового файла, но хочу посмотреть, реалистично ли это в первую очередь, и у меня возникают проблемы с выяснением того, как сделать для него математику. Я действительно хотел бы понять, как сделать математику, чтобы понять это.

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

1 Ответ

1 голос
/ 10 июля 2019

  1. приблизительная оценка всех чисел

    , как предложил Ален Мериго, вы просто подсчитываете количество цифр от первого изменения (от MSB до LSB): 

    00251eb27d8d2deb15d615edd08dd7cf402638697a4aba6c7c199ce4ef858962h
002526837f828960f7d3c1e8359eaea84e38183c7ab9345a663b474063ca9e20h
    |<---------------------60 digitis------------------------->|

    , что дает нам 16^60 возможностей. Если вы хотите десятичные дроби, то преобразование выполняется следующим образом: 

    dec_digits/hex_digits = log(16)/log(10) = 1.204119982655924780854955578898
dec_digits = hex_digits * 1.204119982655924780854955578898
dec_digits = 60 * 1.204119982655924780854955578898 = ~72.25

    , поскольку соотношение между целыми числами любой базы постоянно, что приводит к возможностям 10^72.25.

  2. все числа точно

    просто вычтите 2 числа, чтобы результат был не отрицательным (это выполнимо для строк с одиночным циклом for, если у вас нет bigints) 

    -00251eb27d8d2deb15d615edd08dd7cf402638697a4aba6c7c199ce4ef858962h
+002526837f828960f7d3c1e8359eaea84e38183c7ab9345a663b474063ca9e20h
------------------------------------------------------------------
 000007D101F55B75E1FDABFA6510D6D90E11DFD3006E79EDEA21AA5B744514BEh

    если я преобразую его в dec с использованием этого str_hex2dec результат будет: 

    53947059527385558921671339033187394318456441692296348428515181989270718 = 5.39*10^70

    вместо этого мы можем сделать приблизительную оценку по гексам: 

    000007D101F55B75E1FDABFA6510D6D90E11DFD3006E79EDEA21AA5B744514BEh
     ||<----------------------58 hex digits------------------->|
     |
     7h -> 0111b -> 3 bits

    таким образом, мы получили 59 шестнадцатеричных цифр, каждая шестнадцатеричная цифра составляет 4 двоичных бита, кроме первого, который состоит из 3 битов, что дает нам приблизительную оценку (но гораздо более точную, чем тогда в # 1): 

    3 + 58*4 = 235 bits -> 2^235 numbers

    снова преобразуется в десятичные: 

    235 * log(2)/log(10) = 70.74

    ведет к оценке: 

    10^70.74 = 10^0.74 * 10^70 = 5.4954*10^70

    , что довольно близко к реальной сделке выше.

  3. ограничение на повторяющиеся цифры

    этот сложный. Нам нужно вычесть количество всех возможных чисел с повторением цифр. Это вероятностная математика (не моя сильная сюита), но вы можете подойти к ней так:

    Например, мы получили 58 шестнадцатеричных цифр. Итак, сколько последовательных n=4 цифр, таких как 7777, мы можем иметь там? Если мы поместим 7777 от начала до конца, то это будет digits-n = 58+1-4 возможных мест ...

    Для каждого местоположения результирующие цифры могут иметь «любую» комбинацию, поэтому возможности будут умножаться на неиспользованные цифры: 

    (digits+1-n)*16^(digits-n)

    теперь n = <4 , digits>, поэтому возможности объединились: 

    (digits+1-4)*16^(digits+1-4) + (digits+1-5)*16^(digits-5) + (digits+1-6)*16^(digits-6) ... + 1
(digits-3)*16^(digits-4) + (digits-4)*16^(digits-5) + (digits-5)*16^(digits-6) ... + 1

    Теперь повторяющаяся цифра может быть любой от 0..F, поэтому весь материал умножается также на 16 ... 

    (digits-3)*16^(digits-3) + (digits-4)*16^(digits-4) + (digits-5)*16^(digits-5) ... + 16

    снова это приблизительная оценка, не учитывающая крайние случаи и дублирование (вы знаете, если есть 2 или более повторений, они учитываются больше раз, чем один раз, также соседние цифры повторяющейся последовательности не могут иметь одно и то же значение и т. д. ... учет всех случаев точно приведет к безумным уравнениям, которые не будут сильно отличаться от грубой оценки), поэтому полученная грубая оценка будет: 

    16^digits - sum[i=1,2,3,...,digits-3]( i*16^i )

Теперь создание будет «простым», вы просто реализуете приращение шестнадцатеричного значения в строке и проверяете на достоверность (повторы): 

1. increment
2. test validity
3. if valid store result
4. if end still not reached goto 1

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

...