මට කවදාවත් අංකය මතක නැහැ. මට මතක රීතියක් අවශ්‍යයි.

එය 2,147,483,647 කි. එය කටපාඩම් කර ගැනීමට පහසුම ක්‍රමය වන්නේ පච්චයක් හරහාය.

මට සිතිය හැකි වඩාත්ම නිවැරදි පිළිතුර නම් Int32.MaxValue.

10 වන පාදයේ අගය මතක තබා ගැනීම දුෂ්කර යැයි ඔබ සිතන්නේ නම්, 2: 1111111111111111111111111111111 උත්සාහ කරන්න

ඔබට සම්පූර්ණ Pi අංකය මතක තබා ගත හැකි නම්, ඔබ සොයන අංකය Pi හි දශම සංඛ්‍යා වලින් 1,867,996,689 දක්වා 1,867,996,680 ස්ථානයේ ඇත.

2147483647 යන සංඛ්‍යාත්මක නූල Pi හි දශම සංඛ්‍යා 1,867,996,680 හි දැක්වේ. 3.14 ...... 86181221809936452346 2147483647 10527835665425671614 ...

මූලාශ්‍රය: http://www.subidiom.com/pi/

එය ඉලක්කම් 10 යි, එබැවින් එය දුරකථන අංකයක් ලෙස මවාපානවා (ඔබ එක්සත් ජනපදයේ යැයි උපකල්පනය කරන්න). 214-748-3647. මම එය ඇමතීමට නිර්දේශ නොකරමි.

එය එක් විශාල සංඛ්‍යාවක් ලෙස සිතනවා වෙනුවට, එය බිඳ දමා ආශ්‍රිත අදහස් සෙවීමට උත්සාහ කරන්න උදා:

• උපරිම ස්නූකර් බිඳීම් 2 ක් (උපරිම විවේකයක් 147)
• අවුරුදු 4 (මාස 48)
• අවුරුදු 3 (මාස 36)
• අවුරුදු 4 (මාස 48)

ඉහත සඳහන් වන්නේ විශාලතම negative ණ සංඛ්‍යාවට ය; ධනාත්මක වන්නේ එය us ණ එකකි.

සමහර විට ඉහත බිඳවැටීම ඔබට තවත් මතක තබා ගත නොහැකි වනු ඇත (එය එතරම් සිත්ගන්නාසුළු දෙයක් නොවේ!), නමුත් ඔබට සමහර අදහස් ඉදිරිපත් කළ හැකිය.

විශාලතම negative ණ (32bit) අගය: -2147483648
(1 << 31)

විශාලතම ධනාත්මක (32bit) අගය: 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

කෙසේ වෙතත්, මෙම රීජෙක්ස් එක ගන්න (එය තීරණය කරන්නේ නූලට සෘණ නොවන පූර්ණ සංඛ්‍යාවක් දශම ස්වරූපයෙන් තිබේද යන්න තීරණය වන අතර එය 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]

සමහර විට එය ඔබට මතක තබා ගැනීමට උපකාරී වනු ඇත.

මට මතක් වූයේ එලෙස ය 2147483647:

• 214 - 2.14 ආසන්න වශයෙන් pi-1 නිසා
• 48 = 6 * 8
• 64 = 8 * 8

මේවා තිරස් අතට ලියන්න:

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

දැන් ඔබට 2147483647 ඇත.

මෙය අවම වශයෙන් ටිකක් උපකාරී වේ යැයි සිතමි.

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, "බිගින්ට්"
• 2 ^ 128 ~ = ක්වින්ටිලියන් 256 ක් (ට්‍රිලියන ට්‍රිලියන 256 ක්) // IPv6, GUID

ඕනෑම හොඳ කැල්කියුලේටරයක් ​​ගෙන "7FFFFFF" හෙක්ස් මාදිලියේ ටයිප් කර දශමයට මාරු වන්න.

2147483647.

ඒක ගැන 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

සී ++ 11

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

ජාවා

ඔබට මෙය ජාවා සමඟ ද ලබා ගත හැකිය:

System.out.println(Integer.MAX_VALUE);

නමුත් ජාවා නිඛිල සෑම විටම අත්සන් කර ඇති බව මතක තබා ගන්න.

පයිතන් 2

පයිතන්ට අත්තනෝමතික නිරවද්‍යතා සංඛ්‍යා ඇත. නමුත් පයිතන් 2 හි ඒවා සී නිඛිලවලට අනුරූපණය වේ. එබැවින් ඔබට මෙය කළ හැකිය:

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

එබැවින් පයිතන් longපූර්ණ සංඛ්‍යාවට වඩා විශාල වන විට මාරු වේ2^31 -1

මෙන්න 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 දක්වා බලයන් ඒවා මතක තබා ගැනීමට බොහෝ විට භාවිතා කර ඇත, නමුත් 2 ** 31 කටපාඩම් කිරීම ගැන මම කරදර වී නැත. අවශ්‍ය පරිදි ගණනය කිරීම හෝ නියතයක් භාවිතා කිරීම හෝ 2G ලෙස තක්සේරු කිරීම පහසු නැත.

බිටු 32 ක්, ලකුණක් සඳහා එකක්, තොරතුරු බිටු 31 ක්:

2^31 - 1 = 2147483647

ඇයි -1?
පළමු වැන්න ශුන්‍ය බැවින් විශාලතම අගය us ණ එකකි .

Cantfindaname88 සඳහා සංස්කරණය කරන්න

ගණන 2 ^ 31 නමුත් විශාලතම අගය 2147483648 (2 ^ 31) විය නොහැක, මන්ද අප ගණන් කරන්නේ 0 සිට 1 නොව 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

හොඳයි, එහි බිටු 32 ක් ඇති අතර එම නිසා විවිධ අගයන් 2 ^ 32 ක් ගබඩා කළ හැකිය. ඒවායින් අඩක් .ණ වේ.

විසඳුම 2,147,483,647 කි

අඩුම අගය −2,147,483,648 වේ.

(තවත් එක් negative ණ අගයක් ඇති බව සැලකිල්ලට ගන්න.)

හොඳයි, විහිළු පසෙක තබා, ඔබ සැබවින්ම ප්‍රයෝජනවත් මතක රීතියක් සොයන්නේ නම්, විශාල සංඛ්‍යා මතක තබා ගැනීම සඳහා මම සැමවිටම භාවිතා කරන එකක් තිබේ.

ඔබේ අංකය ඉලක්කම් 3-4 කින් කොටස් වලට බෙදිය යුතු අතර ඔබේ ජංගම දුරකථන යතුරුපුවරුවේ ප්‍රක්ෂේපණය භාවිතා කරමින් ඒවා දෘශ්‍යමය වශයෙන් මතක තබා ගන්න. පින්තූරයක් පෙන්වීම පහසුය:

ඔබට පෙනෙන පරිදි, මෙතැන් සිට ඔබට හැඩ 3 ක් මතක තබා ගත යුතුය, ඒවායින් 2 ක් ටෙට්රිස් එල් මෙන් පෙනේ, එකක් ටික් එකක් මෙන් පෙනේ . ඉලක්කම් 10 ක අංකයක් කටපාඩම් කිරීමට වඩා එය අනිවාර්යයෙන්ම පහසුය.

ඔබට අංකය සිහිපත් කිරීමට අවශ්‍ය වූ විට හැඩතල සිහිපත් කරන්න, දුරකථන යතුරුපුවරුවක සිතන්න / බලන්න සහ එහි හැඩතල ප්‍රක්ෂේපණය කරන්න. සමහර විට මුලදී ඔබට යතුරුපුවරුව දෙස බැලීමට සිදුවනු ඇත, නමුත් මඳක් පුහුණුවීමෙන් පසුව, සංඛ්‍යා ඉහළ වමේ සිට පහළ දකුණට යන බව ඔබට මතක ඇති, එවිට ඔබට එය ඔබේ හිසෙහි මවාගත හැකිය.

හැඩයේ දිශාව සහ එක් එක් හැඩයේ ඉලක්කම් ගණන ඔබට මතක ඇති බවට වග බලා ගන්න (නිදසුනක් ලෙස, 2147483647 උදාහරණයේ අපට ඉලක්කම් 4 ටෙට්‍රිස් එල් සහ ඉලක්කම් 3 එල් ඇත).

ඕනෑම වැදගත් අංකයක් පහසුවෙන් මතක තබා ගැනීමට ඔබට මෙම තාක්ෂණය භාවිතා කළ හැකිය (නිදසුනක් ලෙස, මගේ අංක 16 ක්‍රෙඩිට් කාඩ් අංකය ආදිය මට මතකයි).

පූර්ණ සංඛ්‍යා සඳහා මෙය කිරීමට ඇති පහසුම ක්‍රමය නම් 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 කි. එසේම, බොහෝ සම්පාදකයින් ද්විමය සඳහා සහය දක්වනවාට වඩා හෙක්ස් සඳහා සහාය වේ.

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

එබැවින් 7F 01111111 / 7FFF 011111111111111 ට සමාන වේ. එසේම, ඔබ මෙය "ඉතා ඉහළ නියතයක්" සඳහා භාවිතා කරන්නේ නම්, 7F ... ආරක්ෂිත හෙක්ස් වේ, නමුත් 7F සහ 80 අත්හදා බලා ඒවා මුද්‍රණය කිරීමට තරම් පහසුය එය කුමන එකක් දැයි බැලීමට ඔබගේ තිරයට.

0x7FFF + 0x0001 = 0x8000, එබැවින් ඔබේ අලාභය එක් අංකයක් පමණි, එබැවින් 0x7F භාවිතා කිරීම ... සාමාන්‍යයෙන් වඩා විශ්වාසදායක කේතයක් සඳහා නරක වෙළඳාමක් නොවේ, විශේෂයෙන් ඔබ බිටු 32 හෝ ඊට වැඩි භාවිතා කිරීමට පටන් ගත් පසු

පළමුවෙන් 47 ක් දෙවරක් ලියන්න, (ඔබ නියෝජිත 47 ට කැමතිද ?), පෙන්වා ඇති පරිදි අවකාශය තබා ගන්න (සෑම ඉරක්ම තනි ඉලක්කම් සඳහා තව් වේ. පළමු තව් 2, පසුව 4)

--47----47

ඔබ 12අතේ ඇතැයි සිතන්න (මන්ද 12 = දුසිමක්). 4නියෝජිත 47 ගේ අංකයේ පළමු ඉලක්කම් වලින් එය ගුණනය කරන්න 47, සහ ප්‍රති already ලය ඔබ දැනටමත් ඇති පළමු යුගලයේ දකුණට තබන්න

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

අන්න ඔයාට ඒක තියෙනවා! Negative ණාත්මක සීමාව සඳහා, ධනාත්මක සීමාවට වඩා නිරපේක්ෂ වටිනාකමෙන් 1 ක් ලෙස ඔබට සිතිය හැකිය .

කිහිප වතාවක් පුහුණු වන්න, එවිට ඔබට එය එල්ලෙනු ඇත!

2GB

(පිළිතුරු සඳහා අවම දිගක් තිබේද?)

.NET උපකල්පනය කිරීම -

Console.WriteLine(Int32.MaxValue);

ඔබේ ASCII වගුව හදවතින්ම දැන ගැනීමට ඔබට සිදුවුවහොත් මිස MaxInt:
!GH6G = 21 47 48 36 47

එය කටපාඩම් කිරීමට ඇති හොඳම රීතිය නම්:
21 (මැජික් අංකය!)
47 (එය මතක තබා ගන්න)
48 (අනුක්‍රමික!)
36 (21 + 15, මැජික් දෙකම!)
47 නැවතත්

ඉලක්කම් 10 ට වඩා යුගල 5 ක් මතක තබා ගැනීම පහසුය.

මතක තබා ගැනීමට ඇති පහසුම ක්‍රමය නම් බැලීම ය 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;
}

Int32.MaxValue හි අක්ෂර 2,147,486,647 ට වඩා වැඩි ගණනක් තිබීම සිත්ගන්නා කරුණකි.

නමුත් නැවතත්, අපට කේත සම්පුර්ණ කර ඇත,

ඒ නිසා මම හිතන්නේ අපට මතක තබා ගත Int3<period>M<enter>යුතුව ඇත්තේ දෘශ්‍ය චිත්‍රාගාරයේ ටයිප් කිරීමට අක්ෂර 6 ක් පමණි.

යාවත්කාලීන කිරීම කිසියම් හේතුවක් නිසා මාව පහත් කොට සලකන ලදි. මට සිතිය හැකි එකම හේතුව ඔවුන් මගේ පළමු ප්‍රකාශය තේරුම් නොගැනීමයි.

"Int32.MaxValue" ටයිප් කිරීමට උපරිම අක්ෂර 14 ක් ගනී. 2,147,486,647 යතුරු ලියනය කිරීමට අක්ෂර 10 ක් හෝ 13 ක් ගතවේ.

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 ක් ලබා ගැනීම සඳහා 2 ^ 30 ක් දෙගුණ කරන්න. බිටු 32 ක් භාවිතා කර අත්සන් නොකළ, නැවත බිලියන 4 ක් සඳහා දෙගුණයක් කරන්න. දෝෂ සාධකය ඔබ වැඩි වන තරමට විශාල වන නමුත් ඔබට මතක තබා ගත යුතු නිශ්චිත අගය අවශ්‍ය නොවේ (ඔබට එය අවශ්‍ය නම්, කෙසේ හෝ ඒ සඳහා කලින් නිර්වචනය කළ නියතයක් භාවිතා කළ යුතුය). යම් දෙයක් පිටාර ගැලීමට අනතුරුදායක ලෙස ආසන්න විය හැකි විට එය හඳුනා ගැනීමට ආසන්න වටිනාකම ප්‍රමාණවත් වේ.

2,147,483,647 මතක තබා ගැනීම සඳහා මම මෙය කරන්නේ මෙයයි

Sa ත සවානා කාර්තුවකට ප්‍රශස්ත ත්‍රිත්වයට හතළිස් හතළිහක් විය

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

ඔයා අදහස් කරන්නේ කුමක් ද? එය 2 ^ 32 බව මතක තබා ගැනීමට තරම් පහසු විය යුතුය. එම අංකයේ අගය කටපාඩම් කර ගැනීමට ඔබට රීතියක් අවශ්‍ය නම්, සාමාන්‍යයෙන් ද්විමය හා දශම අතර පරිවර්තනය කිරීම සඳහා ඉතා වැදගත් නියමය:

2 ^ 10 ~ 1000

ඒ කියන්නේ 2 ^ 20 ~ 1,000,000

සහ 2 ^ 30 ~ 1,000,000,000

දෙගුණයක් (2 ^ 31) දළ වශයෙන් බිලියන 2 ක් වන අතර නැවත දෙගුණ කිරීම (2 ^ 32) බිලියන 4 කි.

ඕනෑම ද්විමය අංකයක දළ ඇස්තමේන්තුවක් ලබා ගැනීමට එය පහසු ක්‍රමයකි. ද්විමය තුළ ශුන්‍ය 10 ක් දශමයෙන් ශුන්‍ය 3 ක් බවට පත්වේ.

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

Int32 යන්නෙන් අදහස් කරන්නේ ඔබේ අංකය ගබඩා කිරීම සඳහා බිටු 32 ක් ඇති බවයි. ඉහළම බිට් යනු සං sign ා-බිට් ය, මෙය පෙන්නුම් කරන්නේ අංකය ධනාත්මක හෝ .ණාත්මක ද යන්නයි. එබැවින් ඔබට ධනාත්මක හා negative ණ සංඛ්‍යා සඳහා බිටු 2 ^ 31 ක් ඇත.

ශුන්‍යය ධනාත්මක සංඛ්‍යාවක් වීමත් සමඟ ඔබට තාර්කික පරාසය ලැබේ (පෙර සඳහන් කළ)

+2147483647 සිට -2147483648 දක්වා

එය කුඩා යැයි ඔබ සිතන්නේ නම්, Int64 භාවිතා කරන්න:

+9223372036854775807 සිට -9223372036854775808 දක්වා

ඇයි ඔබට මෙම අංකය මතක තබා ගැනීමට අවශ්‍ය? ඔබේ කේතයේ භාවිතා කිරීමට? ඔබේ කේතය තුළ ඔබ සැමවිටම Int32.MaxValue හෝ Int32.MinValue භාවිතා කළ යුතුය. මේවා ස්ථිතික අගයන් (.net core තුළ) වන අතර එමඟින් කේත සමඟ නව int එකක් නිර්මාණය කිරීමට වඩා වේගවත් වේ.

මගේ ප්‍රකාශය: මෙම අංකය මතකයෙන් දන්නේ නම් .. ඔබ පෙන්වන්නේ!

මෙය මතක තබා ගන්න: 21 IQ ITEM 47

එය ඕනෑම දුරකථන පෑඩ් එකකින් ඩී-කේතනය කළ හැකිය, නැතහොත් ඔබට කඩදාසි මත එකක් ලිවිය හැකිය.

"21 IQ ITEM 47" මතක තබා ගැනීම සඳහා, මම "හිට්මන්: කේත නාම 47 හි මෙහෙයුම් 21 ක් ඇති අතර ඒවා සෑම IQ ITEM එකක්ම තනිවම විය".

නැතහොත් "මම සෑම දිනකම 21:47 ට දත් පිරිසිදු කරමි, මන්ද මට ඉහළ IQ ඇති අතර මගේ මුඛයේ ඇති අයිතම වලට කැමති නැත".