Максимальное 32 битное число

Я никогда не могу вспомнить номер. Мне нужно правило памяти.

В математике[править | править код]

2 147 483 647 = 2 31 − 1 {displaystyle 2,147,483,647=2^{31}-1} {displaystyle 2,147,483,647=2^{31}-1} — простое число Мерсенна[1]. В 1772 году Леонард Эйлер опубликовал доказательство того, что число 2 31 − 1 {displaystyle 2^{31}-1} 2^{{31}}-1 является простым числом. Это было самым большим известным на тот момент простым числом. Рекорд был превзойдён только в 1867 году, когда Фортюне Ландри (фр. Fortuné Landry) доказал простоту числа 3 203 431 780 337[2].Это также третье двойное число Мерсенна и третье из четырёх известных простых. Предыдущее – 127, следующее – 170141183460469231731687303715884105727.

27 ответов

Это 2,147,483,647. Самый легкий способ запомнить его через татуировку.

ответ дан Ben Hoffstein 17 July 2019 в 08:00

поделиться

В Objective-C (iOS и OSX) просто запомните эти макросы:

#define INT8_MAX 127#define INT16_MAX 32767#define INT32_MAX 2147483647#define INT64_MAX 9223372036854775807LL#define UINT8_MAX 255#define UINT16_MAX 65535#define UINT32_MAX 4294967295U#define UINT64_MAX 18446744073709551615ULL

ответ дан juniperi 17 July 2019 в 08:00

поделиться

Запомните: 21 IQ ITEM 47

Его можно декодировать с любой телефонной панели, или вы можете просто записать его на бумаге.

Чтобы вспомнить «21 IQ ITEM 47», я бы сказал: «Hitman: Codename 47 имел 21 миссию, каждая из которых была IQ ITEM».

Или «Я чищу зубы каждый день в 21:47, потому что у меня высокий IQ и я не люблю предметы во рту».

ответ дан soprof 17 July 2019 в 08:00

поделиться

С Groovy на пути:

groovy -e ” println Integer.MAX_VALUE ”

(Groovy чрезвычайно полезен для справочника в контексте Java.)

ответ дан Peter Mortensen 17 July 2019 в 08:00

поделиться

Чтобы никогда не забывать максимальное значение любого типа:

Если оно имеет 32 бита, наибольшим возможным значением будут 32 бита с номером 1:

enter image description here

Результат будет 4294967295 в десятичном виде:

enter image description here

Но, как есть также представление отрицательных чисел, разделите 4294967295 на 2 и получите 2147483647.

Следовательно, 32-разрядное целое число может представлять от -2147483647 до 2147483647.

ответ дан Guilherme Fidelis 17 July 2019 в 08:00

поделиться

Вы найдете в двоичном формате максимальное значение Int32 1111111111111111111111111111111, но в десяти основаниях вы найдете 2147483647 или 2 ^ 31-1 или Int32.MaxValue

ответ дан trinalbadger587 17 July 2019 в 08:00

поделиться

Попробуйте на Python:

>>> int(‘1’ * 31, base=2)2147483647

ответ дан g10guang 17 July 2019 в 08:00

поделиться

В общем, вы могли бы выполнить простую операцию, которая отражает саму природу Int32, заполнить все доступные биты единицами – это то, что вы можете легко сохранить в своей памяти. Он работает в основном одинаково в большинстве языков, но я собираюсь использовать Python для примера:

max = 0bits = [1] * 31 # Generate a “bit array” filled with 1’sfor bit in bits: max = (max << 1) | bit# max is now 2147483647

Для неподписанных Int32, сделайте его 32 вместо 31 1.

Но так как опубликовано еще несколько авантюрных подходов, я начал думать о формулах, просто для удовольствия …

Формула 1 (Числа объединяются, если оператор не указан)

  • a = 4
  • b = 8
  • ba / a
  • ab-1
  • ab
  • ab-ab
  • ab-1

Python quickcheck

a = 4b = 8ab = int(‘%d%d’ % (a, b))ba = int(‘%d%d’ % (b, a))’%d%d%d%d%d’ % (ba/a, ab-1, ab, ab-a-b, ab-1)# gives ‘2147483647’

Формула 2

  • x = 48
  • x / 2-3
  • x- 1
  • x
  • x * 3/4 ​​
  • x-1

Быстрый контроль Python

x = 48’%d%d%d%d%d’ % (x/2-3, x-1, x, x*3/4, x-1) # gives ‘2147483647’

ответ дан wiesion 17 July 2019 в 08:00

поделиться

Самый простой способ запомнить это посмотреть на std::numeric_limits< int >::max()

Например ( из MSDN ),

// numeric_limits_max.cpp#include <iostream>#include <limits>using namespace std;int main() { cout << “The maximum value for type float is: ” << numeric_limits<float>::max( ) << endl; cout << “The maximum value for type double is: ” << numeric_limits<double>::max( ) << endl; cout << “The maximum value for type int is: ” << numeric_limits<int>::max( ) << endl; cout << “The maximum value for type short int is: ” << numeric_limits<short int>::max( ) << endl;}

ответ дан Seq 17 July 2019 в 08:00

поделиться

Просто помните, что 2^ (10*x) приблизительно 10^ (3*x) – Вы, вероятно, уже привыкли к этому с килобайтами/кибибайты и т.д. Это:

2^10 = 1024 ~= one thousand2^20 = 1024^2 = 1048576 ~= one million2^30 = 1024^3 = 1073741824 ~= one billion

, Так как интервал использует 31 бит (+ ~1 бит для знака), просто удвойтесь 2^30 для получения приблизительно 2 миллиардов. Для неподписанного интервала с помощью 32 битов, дважды снова для 4 миллиардов. Ошибочный фактор становится выше большее, Вы идете, конечно, но Вам не нужно точное запоминаемое значение (При необходимости в нем необходимо использовать предопределенную константу для него так или иначе). Приближенное значение достаточно хорошо для того, чтобы замечать, когда что-то могло бы быть опасно близко к переполнению.

ответ дан Brian 17 July 2019 в 08:00

поделиться

Самый корректный ответ, о котором я могу думать, Int32.MaxValue.

ответ дан Adrian Clark 17 July 2019 в 08:00

поделиться

Это – 10 цифр, поэтому притворитесь, что это – номер телефона (предполагающий, что Вы находитесь в США). 214-748-3647. Я не рекомендую назвать его.

ответ дан WildJoe 17 July 2019 в 08:00

поделиться

Вместо того, чтобы думать о нем как об одном большом количестве, попытайтесь ломать его и искать связанные идеи, например:

  • 2 максимальных снукерных повреждения (максимальное повреждение равняется 147)
  • 4 года (48 месяцев)
  • 3 года (36 месяцев)
  • 4 года (48 месяцев)

Вышеупомянутое относится к самому большому отрицательному числу; положительный это минус одно.

, Возможно, вышеупомянутая разбивка будет не более незабываема для Вас (это едва захватывающе, он!), но надо надеяться можно придумать некоторые идеи, которые являются!

ответ дан Luke Bennett 17 July 2019 в 08:00

поделиться

Самое большое отрицательное (32-битное) значение: -2147483648
(1 < < 31)

Самое большое положительное (32-битное) значение: 2147483647
~ (1 < < 31)

Мнемоника: “пьяный AKA роговой”

drunk ========= Drinking age is 21AK ============ AK 47A ============= 4 (A and 4 look the same)horny ========= internet rule 34 (if it exists, there’s 18+ material of it) 21 47 4(years) 3(years) 4(years)21 47 48 36 48

ответ дан Tim Castelijns 17 July 2019 в 08:00

поделиться

2^(x+y) = 2^x * 2^y2^10 ~ 1,0002^20 ~ 1,000,0002^30 ~ 1,000,000,0002^40 ~ 1,000,000,000,000(etc.)2^1 = 22^2 = 42^3 = 82^4 = 162^5 = 322^6 = 642^7 = 1282^8 = 2562^9 = 512

Так, 2^31 (подписанный интервал макс.) 2^30 (приблизительно 1 миллиард) времена 2^1 (2), или приблизительно 2 миллиарда. И 2^32 2^30 * 2^2 или приблизительно 4 миллиарда. Этот метод приближения достаточно точен, выравниваются к приблизительно 2^64 (где ошибка растет приблизительно до 15%).

при необходимости в точном ответе тогда необходимо потянуть калькулятор.

Удобные выровненные словом полные приближения:

  • 2^16 ~ = 64 тысячи//uint16
  • 2^32 ~ = 4 миллиарда//uint32, IPv4, unixtime
  • 2^64 ~ = 16 квинтильонов (иначе 16 миллиардов миллиардов или 16 миллионов триллионов)//uint64, “bigint”
  • 2^128 ~ = 256 квинтильонов квинтильона (иначе 256 триллионов триллионов триллионов)//IPv6, GUID

ответ дан Wedge 17 July 2019 в 08:00

поделиться

Просто примите любой достойный калькулятор и тип “7FFFFFFF” в шестнадцатеричном режиме, затем переключитесь на десятичное число.

2147483647.

ответ дан darron 17 July 2019 в 08:00

поделиться

Вот мнемоника для запоминания 2 ** 31, вычтите единицу, чтобы получить максимальное целочисленное значение.

a = 1, b = 2, c = 3, d = 4, e = 5, f = 6, g = 7, h = 8, i = 9

Boys And Dogs Go Duck Hunting, Come Friday Ducks Hide2 1 4 7 4 8 3 6 4 8

использовал способности от двух до 18 достаточно часто, чтобы помнить их, но даже я не удосужился запомнить 2 ** 31. Это слишком легко рассчитать по мере необходимости или использовать константу, или оценить как 2G.

ответ дан Mark Ransom 17 July 2019 в 08:00

поделиться

32 бита, один для знака, 31 бит информации:

2^31 – 1 = 2147483647

Почему -1?
Поскольку первый равен нулю, поэтому наибольшее значение составляет минус один .

РЕДАКТИРОВАТЬ для cantfindaname88

Число 2 ^ 31, но наибольшее не может быть 2147483648 (2 ^ 31), потому что мы считаем от 0, а не 1.

Rank 1 2 3 4 5 6 … 2147483648Number 0 1 2 3 4 5 … 2147483647

Другое объяснение только с 3 битами: 1 для знака, 2 для информации

2^2 – 1 = 3

Ниже всех возможных значений с 3 битами: (2 ^ 3 = 8 значений)

1: 100 ==> -42: 101 ==> -33: 110 ==> -24: 111 ==> -15: 000 ==> 06: 001 ==> 17: 010 ==> 28: 011 ==> 3

ответ дан Community 17 July 2019 в 08:00

поделиться

Ну, он имеет 32 бита и, следовательно, может хранить 2 ^ 32 различных значений. Половина из них отрицательны.

Решение – 2 147 483 647

, а самое низкое – 2 147 483 648.

(Обратите внимание, что есть еще одно отрицательное значение.)

ответ дан Alex 17 July 2019 в 08:00

поделиться

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

Макс. Значения без знака

8-bit 0xFF16-bit 0xFFFF32-bit 0xFFFFFFFF64-bit 0xFFFFFFFFFFFFFFFF128-bit 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

Значения со знаком, используя 7F в качестве максимального значения со знаком

8-bit 0x7F16-bit 0x7FFF32-bit 0x7FFFFFFF64-bit 0x7FFFFFFFFFFFFFFF

Значения со знаком, используя 80 в качестве максимального значение со знаком

8-bit 0x8016-bit 0x800032-bit 0x8000000064-bit 0x8000000000000000

Как это работает? Это очень похоже на двоичную тактику, и каждая шестнадцатеричная цифра составляет ровно 4 бита. Кроме того, многие компиляторы поддерживают hex намного лучше, чем двоичный.

F hex to binary: 11118 hex to binary: 10007 hex to binary: 01110 hex to binary: 0000

Таким образом, 7F равно 01111111 / 7FFF равно 0111111111111111. Кроме того, если вы используете это для «безумно высокой константы», 7F … является безопасным гексом, но достаточно легко попробуйте 7F и 80 и просто распечатайте их на экране, чтобы увидеть, какой это.

0x7FFF + 0x0001 = 0x8000, поэтому ваша потеря составляет всего одно число, поэтому использование 0x7F … обычно не является плохим компромиссом для более надежного кода, особенно после того, как вы начнете использовать 32-разрядные или более

ответ дан Joe Plante 17 July 2019 в 08:00

поделиться

Сначала напишите 47 дважды, (вам нравится Агент 47 , верно?), Оставляя пробелы, как показано (каждая черта – это слот для одной цифры. Сначала 2 слота, затем 4)

–47—-47

Думаю, у вас есть 12 в руке (потому что 12 = дюжина). Умножьте его на 4, первую цифру номера агента 47, то есть 47, и поместите результат справа от первой пары, которая у вас уже есть

12 * 4 = 48–4748–47 <– after placing 48 to the right of first 47

Затем умножьте 12 на 3 (чтобы сделать вторую цифру номера Агента 47, то есть 7, вам нужно 7 – 4 = 3) и поместить результат справа от первых 2 пар, последней пары слотов

12 * 3 = 36–47483647 <– after placing 36 to the right of first two pairs

Наконец, перетащите цифры одну за другой из вашей руки, начиная с самой правой цифры (в данном случае 2), и поместите их в первое пустое место, которое вы получите

2-47483647 <– after placing 22147483647 <– after placing 1

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

Попрактикуйтесь несколько раз, и вы освоите это!

ответ дан Sнаđошƒаӽ 17 July 2019 в 08:00

поделиться

2GB

(есть ли минимальная длина для ответов?)

ответ дан Rune 17 July 2019 в 08:00

поделиться

Принятие.NET –

Console.WriteLine(Int32.MaxValue);

ответ дан Kev 17 July 2019 в 08:00

поделиться

Если вам случится знать, что ваш ASCII-стол выключен наизусть, а не MaxInt:
!GH6G = 21 47 48 36 47

ответ дан Mark Hurd 17 July 2019 в 08:00

поделиться

Это о 2.1 * 10^9. Не нужно точно знать 2^{31} – 1 = 2,147,483,647.

Вы можете найти его в C так:

#include <stdio.h>#include <limits.h>main() { printf(“max int:tt%in”, INT_MAX); printf(“max unsigned int:t%un”, UINT_MAX);}

дает (ну, без ,)

max int: 2,147,483,647max unsigned int: 4,294,967,295 std::cout << std::numeric_limits<int>::max() << “n”;std::cout << std::numeric_limits<unsigned int>::max() << “n”;

Вы можете получить это и с Java:

System.out.println(Integer.MAX_VALUE);

Но имейте в виду, что целые числа Java всегда подписаны.

Python имеет произвольные целые числа точности. Но в Python 2 они отображаются на целые числа C. Итак, вы можете сделать это:

import syssys.maxint>>> 2147483647sys.maxint + 1>>> 2147483648L

Итак, Python переключается на long, когда целое число становится больше, чем 2^31 -1

ответ дан Martin Thoma 17 July 2019 в 08:00

поделиться

Что Вы имеете в виду? Должно быть достаточно легко помнить, что это 2^32. Если Вы хотите правило запомнить значение того числа, удобное эмпирическое правило для преобразования между двоичным файлом и десятичным числом в целом:

2^10 ~ 1000

, что означает 2^20 ~ 1,000,000

и 2^30 ~ 1,000,000,000

Двойной, что (2^31) rounghly 2 миллиарда и удвоение, которое снова (2^32) является 4 миллиардами.

Это – простой способ получить грубую оценку любого двоичного числа. 10 обнуляет в двоичном файле, становится 3, обнуляет в десятичном числе.

ответ дан jalf 17 July 2019 в 18:00

поделиться

Int32 означает, что у вас есть 32 бита для хранения вашего номера. Самый старший бит – это бит знака, он указывает, положительное или отрицательное число. Итак, у вас есть 2 ^ 31 бит для положительных и отрицательных чисел.

Если ноль является положительным числом, вы получите логический диапазон (упомянутый ранее)

от +2147483647 до -2147483648

Если вы считаете, что это слишком мало, используйте Int64:

+9223372036854775807 до -9223372036854775808

И какого черта вы хотите запомнить это число? Для использования в вашем коде? Вы всегда должны использовать Int32.MaxValue или Int32.

ответ дан 19 December 2019 в 20:14

поделиться

Другие вопросы по тегам:

Похожие вопросы:

Формат 32-битного целого числа со знаком

Поразрядные (побитовые) операторы работают с 32-битными целыми числами в их двоичном представлении.
Двоичные числа представляют из себя строки, состоящие из нулей и единиц, в которых значение каждой единицы определяется ее позицией в данной строке.

Вот так, например, вы­глядият числа, записанные в формате 32-разрядного целого двоичного числа:

Каждый сдвиг влево на одну позицию означает удвоение значения, которое соответствует предыдущей позиции, находящейся справа.

Чтобы не путать, в какой системе счисления записано число, обычно в индексе пишут основание системы счисления, в которой оно записао. Например, число 5 в десятичной системе – 510,а в двоичной – 1012.

Чтобы перевести число в двоичную систему счисления необходимо делить его нацело на 2 пока не получим , затем необходимо записать все остатки от деления в обратном порядке.

Например, число 18, записываемое в двоичной системе счисления, имеет значение:

Теперь записываем полученные остатки от деления в обратном порядке. Получаем, что число 18 в двоичном представлении будет выглядеть как 00000000000000000000000000010010 (обратите внимание, число состоит ровно из 32-битов), или, сокращенно, как 10010. Эти пять значимых битов и определяют фактическое значение числа 18.

Для преобразования из двоичной системы в десятичную используют формулу, состоящую из степеней основания 2:

где а – число в десятичной системе счисления; a, a1, … an – цифры данного числа в двоичном представлении. Причём a — это последняя или правая цифра, а an – первая.

Например, возьмём двоичное число 1010012. Для перевода в десятичное запишем его как сумму по разрядам следующим образом:

Перепишем тоже самое, возведя в степени все основания 2:

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

512
(2 10 )
256
(2 9 )
128
(2 8 )
64
(2 6 )
32
(2 5 )
16
(2 4 )
8
(2 3 )
4
(2 2 )
2
(2 1 )
1
(2 0 )
1 1 1
+32 +0 +8 +0 +0 +1

Положительные числа хранятся в настоящем двоичном формате, в котором все биты, кроме знакового (крайний левый), представляют степени двойки: первый бит (справа) соответствует 2 0 , второй – 2 1 , третий – 2 2 и т. д. Если какие-либо биты не используются, они считаются равными нулю.

Теперь под каждой двоичной единицей напишите её эквивалент в нижней строчке таблицы и сложите получившиеся десятичные числа. Таким образом, двоичное число 1010012 равнозначно десятичному 4110.

Термин «целые числа со знаком» означает, что в этой форме могут быть представлены как положительные, так и отрицательные целые числа.

Отрицательные числа также хранятся в двоичном коде, но в формате, который на­зывается «дополнителъным кодом» (англ. two’s complement, иногда twos-complement).

Представление в «дополнительном коде» означает, что отрицательное значение числа (например 5 и -5) получается путем инвертирования числа (операция «побитовое НЕ», также известное как «обратный код» или «первое дополнение») и прибавлением к инверсии единицы («второе дополнение»).

К примеру, определим двоичное представление числа -5. Начнём с двоичного представления его абсолютного значения (5):

Инвертируем все разряды числа (заменим на 1, а 1 на ), получая таким образом обратный код (первое дополнение) числа 5:

Дополнительный код (второе дополнение) двоичного числа получается добавлением 1 (обычным двоичным сложением) к младшему значащему разряду его первого дополнения:

Итак, мы получили:

В целых числах со знаком все биты, кроме 32-го, представляют само значение, тогда как 32-й бит определяет знак числа: если крайний-левый бит равен – число положительное, если 1 – число отрицательное. Поэтому этот бит называется знаковым битом.

Однако в JavaScript такое двоичное представление чисел скрыто. Например, при выводе отрицательного числа в виде двоичной строки вы получите сокращенный двоичный код абсолютного значения этого числа со знаком «минус»:

При изучении побитовых операторов вам могут пригодиться функции, которые облегчают перевод чисел из десятичного в двоичное представление и наоборот:

Терминология

Пиксель — источник цвета современного ЖК-экрана. Состоит из трех субпикселей: красного, зеленого и синего. Эти три цвета участвуют в создании всей возможной цветовой палитры устройства.

Глубина цвета — это количество оттенков, которое может отобразить матрица монитора или телевизора.

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

Формирование фиолетового цвета из красных и синих пикселей с помощью дизеринга

FRC (Frame Rate Control, временной дизеринг) — более современный способ визуального повышения разрядности матрицы путем мерцания пикселей. В последнее время это понятие объединяет в себе большую часть всех существующих алгоритмов увеличения глубины цвета.

HDR — расширенный динамический диапазон. Технология делает изображение более сочным и реалистичным. Для реализации HDR требуется (псевдо)10-битная матрица.

  • Что такое HDR в телевизоре
  • Что такое HDR в мониторах

Оговоримся сразу: в блоге речь идет именно о матрицах. Не стоит путать с глубиной цвета изображения/видео и цветовым охватом. 

Список побитовых операторов

В следующей таблице перечислены все побитовые (поразрядные) операторы JavaScript:

Оператор Использование Описание
Побитовое И (AND) a & b Возвращает 1 в тех позициях результата, в кото­рых биты каждого из операндов равны 1.
Побитовое ИЛИ (OR) a | b Возвращает 1 в тех позициях результата, в кото­рых бит хотя бы одного из операндов равен 1.
Побитовое исключающее ИЛИ (XOR) a ^ b Возвращает 1 в тех позициях результата, в кото­рых бит только одного из операндов равен 1.
Побитовое НЕ (NOT)

a

Заменяет каждый бит операнда на противопо­ложный.Сдвиг влевоaСдвигает двоичное представление числа a на b разрядов влево заполняя освободившиеся справа разряды нулями.Правый сдвиг, переносящий знакa >> bСдвигает двоичное представление а на b разрядов вправо, отбрасывая уходящие биты.Правый сдвиг с заполнением нулямиa >>> bСдвигает двоичное представление числа a на b разрядов вправо. Освобождающиеся разряды заполняются нулями.

Побитовые операторы, подобно логическим операторам, выполняют логические операции И, ИЛИ, НЕ, XOR , но с каждым отдельным битом целого числа. Cреди побитовых операторов есть также операторы сдвига >, >>> позволяющие переместить все биты числа влево или вправо на нужно количество разрядов. Побитовые операторы преобразуют свои операнды в 32-битные целые числа, представленные последовательностью битов. Дробная часть, если она есть, отбрасывается. Получившаяся в результате выполнения последовательность бит интерпретируется как обычное число.

В информатике[править | править код]

  • Это наибольшее число, которое вмещает 32-битный знаковый целый тип данных signed int32.
  • С этим связана проблема 2038 года[3], когда стандартный тип данных для хранения времени time_t переполнится на 32-битных компьютерах.

См. такжеSee also

Целочисленные константы в CC Integer Constants

Примечания[править | править код]

  1. Последовательность A000668 в OEIS (англ.)
  2. The Largest Known Prime by Year: A Brief History (англ.)
  3. BBC:”The number glitch that can lead to catastrophe” // BBC, 5 May 2015 (англ.)

External links[edit]

  • Prime curios: 2147483647
Рейтинг
( 1 оценка, среднее 5 из 5 )
Загрузка ...