Подтвердить что ты не робот

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

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

4b9b3361

Ответ 1

Это 2 147 483 647. Самый простой способ запомнить это с помощью татуировки.

Ответ 2

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

Ответ 3

Если вы считаете, что значение слишком сложно запомнить в базе 10, попробуйте базу 2: 1111111111111111111111111111111

Ответ 4

если вы можете вспомнить все число Pi, то число, которое вы ищете, находится в позиции 1,867,996,680 до 1 867 996 689 десятичных цифр Pi

Числовая строка 2147483647 появляется на десятичной цифре 1 867 996 680 Pi. 3,14...... 86181221809936452346 2147483647 10527835665425671614...

источник: http://www.subidiom.com/pi/

Ответ 5

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

Ответ 6

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

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

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

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

Ответ 7

Наибольшее отрицательное (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 18+ material of it) 

21 47 4(years) 3(years) 4(years)
21 47 48       36       48

Ответ 8

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

[0-9]{1,9}|[0-1][0-9]{1,8}|20[0-9]{1,8}|21[0-3][0-9]{1,7}|214[0-6][0-9]{1,7}|2147[0-3][0-9]{1,6}|21474[0-7][0-9]{1,5}|214748[0-2][0-9]{1,4}|2147483[0-5][0-9]{1,3}|21474836[0-3][0-9]{1,2}|214748364[0-7]

Возможно, это поможет вам запомнить.

Ответ 9

Вот как я вспомнил 2147483647:

  • 214 - потому что 2.14 приблизительно pi-1
  • 48 = 6 * 8
  • 64 = 8 * 8

Назовите их по горизонтали:

214_48_64_
and insert:
   ^  ^  ^
   7  3  7 - which is Boeing airliner jet (thanks, sgorozco)

Теперь у вас есть 2147483647.

Надеюсь, что это поможет хотя бы немного.

Ответ 10

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 (подпись int max) составляет 2 ^ 30 (около 1 миллиарда) раз 2 ^ 1 (2), или около 2 миллиардов. И 2 ^ 32 составляет 2 ^ 30 * 2 ^ 2 или около 4 миллиардов. Этот метод аппроксимации достаточно точен, даже примерно до 2 ^ 64 (где ошибка возрастает примерно до 15%).

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

Удобные аппроксимации пропускной способности:

  • 2 ^ 16 ~ = 64 тыс. //uint 16
  • 2 ^ 32 ~ = 4 миллиарда //uint 32, IPv4, unixtime
  • 2 ^ 64 ~ = 16 квинтиллионов (или 16 миллиардов миллиардов или 16 миллионов триллионов)//uint64, "bigint"
  • 2 ^ 128 ~ = 256 quintillion quintillion (ака 256 триллионов триллионов триллионов)//IPv6, GUID

Ответ 11

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

2147483647.

Ответ 12

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

С

Вы можете найти его в 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:

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

Ответ 13

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

а = 1, B = 2, с = 3, d = 4, е = 5, F = 6, г = 7, ч = 8, г = 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.

Ответ 14

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

2^31 - 1 = 2147483647

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

EDIT для cantfindaname88

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

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

Другое объяснение с тремя битами: 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

Ответ 15

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

Решение равно 2 147 483 647

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

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

Ответ 16

В этот момент я бы сказал, что самой простой мнемонической версией является запись "stackoverflow.com" TAB "максимум int32" в Chrome.

Существует где-то шутка рекурсии → . Я просто не так уродлив.

Ответ 17

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

Вам нужно разбить свой номер на части с 3-4 цифр и запомнить их визуально, используя проекцию на клавиатуре вашего мобильного телефона. Это проще показать на картинке:

введите описание изображения здесь

Как вы можете видеть, теперь вам нужно запомнить 3 формы, 2 из них выглядят как Tetris L, и один выглядит как галочка. Это определенно намного проще, чем запоминание 10-значного числа.

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

Просто убедитесь, что вы помните направление фигур и количество цифр в каждой форме (например, в примере 2147483647 у нас есть четырехзначный тетрис L и 3-значный символ L).

Вы можете использовать эту технику, чтобы легко запомнить любые важные номера (например, я вспомнил свой 16-значный номер кредитной карты и т.д.).

Ответ 18

Самый простой способ сделать это для целых чисел - использовать шестнадцатеричный, при условии, что нет такого типа, как 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-битные или более

Ответ 19

Сначала запишите 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 больше по абсолютной величине, чем положительный предел.

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

Ответ 20

2 Гб

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

Ответ 21

Предполагая, что .NET -

Console.WriteLine(Int32.MaxValue);

Ответ 22

Интересно, что Int32.MaxValue имеет больше символов, чем 2,147,486,647.

Но опять же, у нас есть завершение кода,

Итак, я думаю, что все, что нам действительно нужно запомнить, - это Int3<period>M<enter>, который набирает всего 6 символов в визуальной студии.

UPDATE По какой-то причине я был остановлен. Единственная причина, по которой я могу думать, это то, что они не понимали моего первого заявления.

"Int32.MaxValue" занимает не более 14 символов. 2 147 486 647 занимает 10 или 13 символов для ввода в зависимости от того, вставляете ли вы запятые или нет.

Ответ 23

Если вы случайно узнали свою таблицу ASCII, а не MaxInt:
!GH6G = 21 47 48 36 47

Ответ 24

Лучшее правило для запоминания:
21 (магическое число!)
47 (просто запомните это)
48 (последовательно!)
36 (21 + 15, оба волшебства!)
47 снова

Также легче запомнить 5 пар, чем 10 цифр.

Ответ 25

Самый простой способ запомнить - посмотреть 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;
}

Ответ 26

Просто помните, что 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

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

Ответ 27

вот как я это делаю, чтобы помнить 2,147,483,647

В отдаленную саванну четверть оптимизма трио шестидесяти сорок семеричных

2 - To
1 - A
4 - Far
7 - Savannah
4 - Quarter
8 - Optimus
3 - Trio
6 - Hexed
4 - Forty
7 - Septenary

Ответ 28

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

2 ^ 10 ~ 1000

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

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

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

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

Ответ 29

В 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

Ответ 30

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

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

+2147483647 до -2147483648

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

+9223372036854775807 - -9223372036854775808

И почему, черт возьми, вы хотите запомнить этот номер? Использовать в своем коде? Вы всегда должны использовать Int32.MaxValue или Int32.MinValue в своем коде, так как это статические значения (в ядре .net) и, следовательно, быстрее используются, чем создание нового int с кодом.

Мое утверждение: если вы знаете это число по памяти, вы просто хвастаетесь!