Какое максимальное значение для int32?

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

1383
задан Jean-François Fabre 17 July 2019 в 08:00
поделиться

27 ответов

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

5077
ответ дан 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
6
ответ дан juniperi 17 July 2019 в 08:00
поделиться

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

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

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

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

5
ответ дан soprof 17 July 2019 в 08:00
поделиться

С Groovy на пути:

groovy -e " println Integer.MAX_VALUE "

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

4
ответ дан 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.

2
ответ дан Guilherme Fidelis 17 July 2019 в 08:00
поделиться

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

1
ответ дан trinalbadger587 17 July 2019 в 08:00
поделиться

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

>>> int('1' * 31, base=2)
2147483647
1
ответ дан g10guang 17 July 2019 в 08:00
поделиться

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

max = 0
bits = [1] * 31 # Generate a "bit array" filled with 1's
for 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 = 4
b = 8
ab = 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'
0
ответ дан 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;
}
14
ответ дан Seq 17 July 2019 в 08:00
поделиться

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

2^10 = 1024                ~= one thousand
2^20 = 1024^2 = 1048576    ~= one million
2^30 = 1024^3 = 1073741824 ~= one billion

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

11
ответ дан Brian 17 July 2019 в 08:00
поделиться

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

493
ответ дан Adrian Clark 17 July 2019 в 08:00
поделиться

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

290
ответ дан WildJoe 17 July 2019 в 08:00
поделиться

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

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

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

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

172
ответ дан Luke Bennett 17 July 2019 в 08:00
поделиться

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

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

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

drunk ========= Drinking age is 21
AK ============ AK 47
A ============= 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
144
ответ дан Tim Castelijns 17 July 2019 в 08:00
поделиться
2^(x+y) = 2^x * 2^y

2^10 ~ 1,000
2^20 ~ 1,000,000
2^30 ~ 1,000,000,000
2^40 ~ 1,000,000,000,000
(etc.)

2^1 = 2
2^2 = 4
2^3 = 8
2^4 = 16
2^5 = 32
2^6 = 64
2^7 = 128
2^8 = 256
2^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
56
ответ дан Wedge 17 July 2019 в 08:00
поделиться

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

2147483647.

46
ответ дан 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 Hide
2    1   4    7  4    8        3    6      4     8

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

35
ответ дан 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 ... 2147483648
Number 0 1 2 3 4 5 ... 2147483647

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

2^2 - 1 = 3

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

1: 100 ==> -4
2: 101 ==> -3
3: 110 ==> -2
4: 111 ==> -1
5: 000 ==>  0
6: 001 ==>  1
7: 010 ==>  2
8: 011 ==>  3
31
ответ дан Community 17 July 2019 в 08:00
поделиться

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

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

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

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

30
ответ дан Alex 17 July 2019 в 08:00
поделиться

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

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

8-bit 0xFF
16-bit 0xFFFF
32-bit 0xFFFFFFFF
64-bit 0xFFFFFFFFFFFFFFFF
128-bit 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

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

8-bit 0x7F
16-bit 0x7FFF
32-bit 0x7FFFFFFF
64-bit 0x7FFFFFFFFFFFFFFF

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

8-bit 0x80
16-bit 0x8000
32-bit 0x80000000
64-bit 0x8000000000000000

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

F hex to binary: 1111
8 hex to binary: 1000
7 hex to binary: 0111
0 hex to binary: 0000

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

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

21
ответ дан 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 2
2147483647 <-- after placing 1

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

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

21
ответ дан Sнаđошƒаӽ 17 July 2019 в 08:00
поделиться

2GB

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

20
ответ дан Rune 17 July 2019 в 08:00
поделиться

Принятие.NET -

Console.WriteLine(Int32.MaxValue);
15
ответ дан Kev 17 July 2019 в 08:00
поделиться

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

15
ответ дан Mark Hurd 17 July 2019 в 08:00
поделиться

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

C

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

#include <stdio.h>
#include <limits.h>

main() {
    printf("max int:\t\t%i\n", INT_MAX);
    printf("max unsigned int:\t%u\n", UINT_MAX);
}

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

max int:          2,147,483,647
max unsigned int: 4,294,967,295

C ++ 11

std::cout << std::numeric_limits<int>::max() << "\n";
std::cout << std::numeric_limits<unsigned int>::max() << "\n";

Java

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

System.out.println(Integer.MAX_VALUE);

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

Python 2

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

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

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

36
ответ дан 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, обнуляет в десятичном числе.

7
ответ дан jalf 17 July 2019 в 18:00
поделиться

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

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

от +2147483647 до -2147483648

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

+9223372036854775807 до -9223372036854775808

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

5
ответ дан 19 December 2019 в 20:14
поделиться