ഐഡി കൂട്ടിയിടി സാധ്യതാ കാൽക്കുലേറ്റർ

ഐഡി കൂട്ടിയിടി സാധ്യതാ കാൽക്കുലേറ്റർ

UUID, ULID, ഷോർട്ട് URL സ്ലഗ്, വൺ-ടൈം കോഡ് എന്നിവ പോലുള്ള റാൻഡം ഐഡന്റിഫയറുകൾ സൃഷ്ടിക്കുന്ന ഏതൊരു സിസ്റ്റവും, രണ്ട് ഐഡികളും ഒരിക്കലും ഒരുപോലെ വരില്ല എന്ന സാധ്യതയെ നിശബ്ദമായി ആശ്രയിക്കുന്നു. പ്രശസ്തമായ "ബർത്ത്ഡേ പാരഡോക്സ്" പിന്നിലെ അതേ ഗണിതം ഉപയോഗിച്ചാണ് ഈ ടൂൾ ആ അപകടസാധ്യത കണക്കാക്കുന്നത്: അവബോധം സൂചിപ്പിക്കുന്നതിനേക്കാൾ വളരെ വേഗത്തിൽ കൂട്ടിയിടികൾ സാധ്യമാകും.

ഇത് പ്രധാനമായിരിക്കുന്നത് എന്തുകൊണ്ട്

ഒരു നിശ്ചിത വലുപ്പമുള്ള സ്പേസിൽ നിന്ന് ധാരാളം റാൻഡം ഐഡികൾ സൃഷ്ടിച്ചാൽ, ഒടുവിൽ രണ്ടെണ്ണം യാദൃച്ഛികമായി പൊരുത്തപ്പെടും. ഇതിന് എത്ര കുറച്ച് ഐഡികൾ മാത്രമേ വേണ്ടിവരൂ എന്നതാണ് അതിശയകരമായ കാര്യം. 23 പേർ മാത്രമുള്ള ഒരു മുറിയിൽ, 365 സാധ്യമായ ദിവസങ്ങളിൽ നിന്ന് രണ്ടുപേർക്ക് ഒരേ ജന്മദിനം വരാനുള്ള സാധ്യത ഇതിനകം 50% ആണ്. ഇതേ ഗണിതം ഡാറ്റാബേസ് ഐഡികൾക്കും സെഷൻ ടോക്കണുകൾക്കും ഷോർട്ട് കോഡുകൾക്കും ബാധകമാണ്, കൂടുതൽ വലിയ തോതിൽ മാത്രം.

ഇത് അറിയുന്നത്, നിങ്ങളുടെ സിസ്റ്റം അതിന്റെ ജീവിതകാലത്ത് യഥാർത്ഥത്തിൽ സൃഷ്ടിക്കുന്ന ഐഡികളുടെ എണ്ണത്തിന് കൂട്ടിയിടി സാധ്യത സ്വീകാര്യമായ നിലയിൽ കുറച്ചു നിർത്തുന്ന ഒരു ഐഡി സ്കീം (ബിറ്റ്-ദൈർഘ്യം) തിരഞ്ഞെടുക്കാൻ നിങ്ങളെ സഹായിക്കുന്നു.

ഫോർമുല

N (ഇവിടെ N = 2^bits) വലുപ്പമുള്ള ഒരു സ്പേസിൽ നിന്ന് റാൻഡമായി സൃഷ്ടിച്ച n ഐഡികൾക്ക്, ചുരുങ്ങിയത് ഒരു കൂട്ടിയിടിയുടെയെങ്കിലും ഏകദേശ സാധ്യത ഇതാണ്:

$$P \approx 1 - e^{-\frac{n(n-1)}{2N}}$$

ഒരു ലക്ഷ്യ കൂട്ടിയിടി സാധ്യത p എത്തുന്നതിനു മുൻപ് നിങ്ങൾക്ക് എത്ര ഐഡികൾ n സൃഷ്ടിക്കാം എന്ന് കണ്ടെത്താൻ, ഫോർമുല ഇങ്ങനെ പുനഃക്രമീകരിക്കുന്നു:

$$n \approx \sqrt{2N \cdot \ln\left(\frac{1}{1-p}\right)}$$

കൂട്ടിയിടി സാധ്യത കൃത്യമായി 50% ആകുന്ന ഐഡികളുടെ എണ്ണം ഒരു ഉപയോഗപ്രദമായ റഫറൻസ് പോയിന്റാണ് — ഇതിനെ "ബർത്ത്ഡേ ബൗണ്ട്" എന്ന് വിളിക്കുന്നു:

$$n_{50} \approx 1.1774 \sqrt{N}$$

ഈ കാൽക്കുലേറ്റർ എങ്ങനെ ഉപയോഗിക്കാം

1. ഡ്രോപ്ഡൗണിൽ നിന്ന് ഒരു ഐഡി തരം തിരഞ്ഞെടുക്കുക — UUIDv4, UUIDv7, ULID, 8-അക്ഷര Base62 ഷോർട്ട് കോഡ്, അല്ലെങ്കിൽ 6-അക്ക നമ്പർ OTP പോലുള്ള സാധാരണ സ്കീമുകൾക്ക് അവയുടെ അറിയപ്പെടുന്ന റാൻഡം എൻട്രോപ്പി മുൻകൂട്ടി പൂരിപ്പിച്ചിരിക്കും.
2. നിങ്ങൾ സ്വന്തമായി ഒരു ഐഡി സ്കീം രൂപകൽപ്പന ചെയ്യുകയാണെങ്കിൽ പകരം "Custom bit length" തിരഞ്ഞെടുക്കുക, അത് ഉപയോഗിക്കുന്ന റാൻഡം ബിറ്റുകളുടെ എണ്ണം നൽകുക.
3. നിങ്ങളുടെ സിസ്റ്റം മൊത്തത്തിൽ (അതിന്റെ ജീവിതകാലം മുഴുവനും, അല്ലെങ്കിൽ ഒരു നിശ്ചിത കാലയളവിൽ) സൃഷ്ടിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്ന ഐഡികളുടെ എണ്ണം നൽകുക.
4. ഒരു ലക്ഷ്യ കൂട്ടിയിടി സാധ്യത (ശതമാനത്തിൽ) സജ്ജീകരിക്കുക — ഇത് നിങ്ങൾ അംഗീകരിക്കാൻ തയ്യാറുള്ള അപകടസാധ്യതാ പരിധിയാണ്, സാധാരണയായി നിർണായക ഐഡന്റിഫയറുകൾക്ക് 1% അല്ലെങ്കിൽ 0.01%.
5. സമർപ്പിച്ച് കാണുക: ആ എണ്ണത്തിലെ നിങ്ങളുടെ യഥാർത്ഥ കൂട്ടിയിടി സാധ്യത, ലക്ഷ്യ അപകടസാധ്യതയിൽ എത്തുന്നതിനു മുൻപ് നിങ്ങൾക്ക് സൃഷ്ടിക്കാവുന്ന ഐഡികളുടെ എണ്ണം, ബർത്ത്ഡേ-ബൗണ്ട് റഫറൻസ് പോയിന്റ്, കൂടാതെ സാധാരണ തോതുകളിൽ സാധ്യത എങ്ങനെ ഉയരുന്നു എന്ന് കാണിക്കുന്ന ഒരു പട്ടികയും.

പരിഹരിച്ച ഉദാഹരണം

നിങ്ങൾ സ്റ്റാൻഡേർഡ് UUIDv4 മൂല്യങ്ങൾ സൃഷ്ടിക്കുന്നു എന്ന് കരുതുക (122 ബിറ്റ് റാൻഡം എൻട്രോപ്പി, അതായത് N = 2^122), കൂടാതെ നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ ജീവിതകാലത്ത് 100 കോടി (n = 1,000,000,000) എണ്ണം സൃഷ്ടിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു.

ഫോർമുലയിൽ ചേർത്താൽ:

$$P \approx 1 - e^{-\frac{(10^9)^2}{2 \times 2^{122}}} \approx 9.4 \times 10^{-20}$$

ഇത് ഏകദേശം 10.6 ക്വിന്റില്യണിൽ 1 എന്ന സാധ്യതയാണ് — പ്രായോഗികമായി പൂജ്യം, അതുകൊണ്ടാണ് ഏതാണ്ട് ഏത് യാഥാർത്ഥ്യ ജോലിഭാരത്തിനും UUIDv4 കൂട്ടിയിടി-സുരക്ഷിതം ആയി കണക്കാക്കുന്നത്. 6-അക്ക നമ്പർ OTP-യുമായി (N = 10^6, ഏകദേശം 19.9 ബിറ്റ്) ഇത് താരതമ്യം ചെയ്യുക: വെറും 1,177 എണ്ണം സൃഷ്ടിച്ചാൽ തന്നെ 50% കൂട്ടിയിടി പരിധി കടക്കും, അതുകൊണ്ടാണ് OTP-കൾ ഹ്രസ്വകാലത്തേക്ക് മാത്രം സാധുവായതും ഒരു പൊതു ആഗോള പൂളിൽ നിന്നല്ലാതെ ഒരു സമയം ഒരു ഉപയോക്താവിന് മാത്രമായി പരിമിതപ്പെടുത്തിയതും.

സാധാരണ ഐഡി സ്കീമുകളും അവയുടെ എൻട്രോപ്പിയും

സ്കീം	ഏകദേശ റാൻഡം ബിറ്റുകൾ
UUIDv4	122 ബിറ്റ്
ULID (റാൻഡം ഭാഗം)	80 ബിറ്റ്
UUIDv7 (റാൻഡം ഭാഗം)	74 ബിറ്റ്
8-അക്ഷര Base62 സ്ട്രിംഗ്	~47.6 ബിറ്റ്
6-അക്ക നമ്പർ കോഡ് (OTP)	~19.9 ബിറ്റ്

മറ്റെന്തിനും — വ്യത്യസ്ത അക്ഷരമാല/ദൈർഘ്യമുള്ള nanoid, ഒരു നമ്പർ പരിധി, അല്ലെങ്കിൽ ഒരു ആന്തരിക ഐഡി ഫോർമാറ്റ് — "Custom" ഓപ്ഷൻ ഉപയോഗിച്ച് bits = log2(നിങ്ങളുടെ ഐഡി സ്പേസിന്റെ വലുപ്പം) കണക്കാക്കുക.