Как ты считаешь в другой базе?

Question

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

Например, если бы я хотел сосчитать до 1 байта, я бы начал с 00000001, добавил 1 и получил 00000010, добавил 1, чтобы получить 00000011 и т. Д., Пока не достигну 11111111.

Кроме того, как ты мог сделать то же самое в гексе? вы начинаете с 0x00, добавляете единицу и выводите 0x01, 0x02, 0x03 и т. д., пока не доберетесь до 0xFF?

Кроме того, как я могу вывести значения в виде строки (как в моих примерах)?

Какой-то псевдо-код:

byteSize = 3
counter = 0
    while counter.size <= byteSize
      print counter /* prints 00000001, 00000010, etc. 
      count += 1
    loop

Обновление:

Меня интересует не только отображение числа в другой базе, это была только его часть. Я вижу свою ошибку в том, что функция отображения - это то, что определяет, как отображается число (как указал Джереми). Так что с запчастями это не проблема.

Обновление 2:

Обещаю, я не полный идиот. Вот контекст:

Это началось сегодня, когда я прочитал это на Reddit: http://www.elliottkember.com/kember_identity.html

Тогда это: http://www.reddit.com/r/programming/comments/8iguu/md5_gamechallenge_for_you_reddit/

что привело к этому: http://www.olegkikin.com/md5game/

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

Answer 1

Binary

for (int i = 0; i <= byte.MaxValue; i++)
{
    Console.WriteLine(Convert.ToString(i, 2).PadLeft(8, '0'));
}

шестнадцатеричный

for (int i = 0; i <= byte.MaxValue; i++)
{
    Console.WriteLine("0x" + i.ToString("X").PadLeft(2, '0'));
}

или

for (int i = 0; i <= byte.MaxValue; i++)
{
    Console.WriteLine(Convert.ToString(i, 16).PadLeft(2, '0'));
}

Несколько байтов

int numBytes = 3;
for (int i = 0; i < Math.Pow(2, numBytes * 8); i++)
{
    Console.WriteLine(Convert.ToString(i, 2).PadLeft(numBytes * 8, '0'));
}

Я бы не сделал больше 3, или ты будешь ждать очень долго ...

Ответ на обновление:

Надеюсь, вы пошутили насчет "считать до 20 байтов в двоичном виде". Это 160 бит. Это создает список чисел со счетом где-то в области число атомов во всей вселенной . Я надеюсь, что у вас есть достаточно времени (то есть гугол тысячелетий), чтобы дождаться этого, чтобы закончить

Answer 2

База, на которую вы «рассчитываете», полностью зависит от функции, которая выводит число на экран (или преобразует его в строку перед тем, как сделать это). Разные базы - это просто разные способы визуального представления одних и тех же чисел. Таким образом, чтобы «считать» в двоичном формате, вы просто сказали бы своей функции «число в строку» использовать базу 2 вместо базы по умолчанию 10.

Answer 3

Для произвольной глубины.

Вы можете легко переключить это на 64-битный режим, если это имеет смысл (например, 64-битный процессор).

Примечание: это полностью от руки, и я не скомпилировал и, очевидно, не проверял. Я даже не могу догадаться, сколько времени потребуется, чтобы распечатать 2 ^ 160 значений (это 1.46e48 значений) или больше, если вы сделаете более 5 32-битных счетчиков.

Это крайне неэффективно, но какого черта.

// A word is 32-bits
void CountBytes(int numberOfWords)
{
    uint[] numbers = new uint[numberOfWords];

    while(true)
    {
        // Show most-significant first
        for (int i=numbers.Length-1; i>=0; i--)
        {
            Console.Write(Convert.ToString(numbers[i], 2).PadLeft(32, '0'));
        }

        // Hit max on all uint's, bail
        bool done = true;
        for (int i=numbers.Length-1; i >= 0; i--)
        {
            if (numbers[i] != uint.MaxValue)
            {
                done = false;
                break;
            }
        }
        if (done)
        {
            break;
        }

        // Check for overflow
        for (int i=numbers.Length-2; i >= 0; i--)
        {
            // Overflow for numbers[i] is if it and all beneath it are MaxValue
            bool overflow = true;
            for (int k=i; k>=0; k--)
            {
                if (numbers[k] != uint.MaxValue)
                {
                    overflow = false;
                    break;
                }
            }

            if (overflow)
            {
                numbers[i+1]++;
                numbers[i] = 0;
            }
        }

        // Increment counter
        numbers[0]++;
    }
}