ಬ್ರಜಿಲ್ ವ್ಯಾಪಾರ ID ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಅಭಿವೃದ್ಧಿಕಾರರು ಮತ್ತು ಪರೀಕ್ಷಕರಿಗಾಗಿ ಈ ಸರಳ ಸಾಧನದೊಂದಿಗೆ ಮಾನ್ಯವಾದ ಬ್ರಜಿಲ್ CNPJ ಸಂಖ್ಯೆಗಳನ್ನ生成 ಮಾಡಿ ಮತ್ತು ಇತರ ಸಂಖ್ಯೆಗಳ ಮಾನ್ಯತೆಯನ್ನು ಪರಿಶೀಲಿಸಿ.
ಪರೀಕ್ಷಾ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಮಾನ್ಯವಾದ ಭಾರತೀಯ CNPJ ಸಂಖ್ಯೆಯನ್ನು ಉತ್ಪಾದಿಸಿ.
ಭಾರತೀಯ CNPJ ಸಂಖ್ಯೆಯು ಮಾನ್ಯವಾದುದೇ ಎಂದು ಪರಿಶೀಲಿಸಿ.
ಬ್ರಜೀಲಿಯನ್ CNPJ (Cadastro Nacional da Pessoa Jurídica) ಒಂದು ವಿಶಿಷ್ಟ ಗುರುತಿನ ಸಂಖ್ಯೆ, ಇದು ಬ್ರಜೀಲ್‌ನಲ್ಲಿ ವ್ಯಾಪಾರ ಮತ್ತು ಕಾನೂನು ವ್ಯಕ್ತಿಗಳಿಗೆ ನೀಡಲಾಗುತ್ತದೆ. ಈ ಬ್ರಜೀಲಿಯನ್ CNPJ ಜನರೇಟರ್ ಮತ್ತು ಮಾನ್ಯತಾಪತ್ರಿಕೆ ಸಾಧನವು ಪರೀಕ್ಷಾ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಮಾನ್ಯ CNPJ ಸಂಖ್ಯೆಯನ್ನು ಜನರೇಟ್ ಮಾಡಲು ಮತ್ತು ಅಧಿಕೃತ ಬ್ರಜೀಲಿಯನ್ ಅಲ್ಗೊರಿಥಮ್‌ನ ಪ್ರಕಾರ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ CNPJ ಸಂಖ್ಯೆಗಳ ಮಾನ್ಯತೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ಸರಳ, ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ನೀವು ಬ್ರಜೀಲಿಯನ್ ವ್ಯಾಪಾರ ಮಾಹಿತಿಯನ್ನು ನಿರ್ವಹಿಸುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸುತ್ತಿರುವ ಡೆವೆಲಪರ್ ಆಗಿದ್ದೀರಾ, ಪರೀಕ್ಷಾ ಪ್ರಕರಣಗಳನ್ನು ರಚಿಸುತ್ತಿರುವ QA ವೃತ್ತಿಪರರಾಗಿದ್ದೀರಾ ಅಥವಾ ಬ್ರಜೀಲ್ ಕಂಪನಿಯ ಮಾಹಿತಿಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿರುವ ಯಾರಾದರೂ, ಈ ಸಾಧನವು CNPJ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ.
ಈ ಸಾಧನದಿಂದ ಜನರೇಟ್ ಮಾಡಲಾದ CNPJಗಳು ಅಧಿಕೃತವಾಗಿ ಬ್ರಜೀಲಿಯನ್ ಫೆಡರಲ್ ರೆವೆನ್ಯೂ ಸರ್ವೀಸ್ (Receita Federal) ಮೂಲಕ ನೀಡಲಾಗುವ ವಾಸ್ತವ CNPJ ಸಂಖ್ಯೆಗಳಂತೆ, ಆದರೆ ಗಣಿತೀಯವಾಗಿ ಮಾನ್ಯವಾಗಿವೆ ಆದರೆ ವಾಸ್ತವ ಕಂಪನಿಗಳಿಗೆ ನೋಂದಾಯಿತವಾಗಿಲ್ಲ. ಇದು ಪರೀಕ್ಷಾ ದೃಶ್ಯಾವಳಿಗಳು, ಮಾದರಿ ಡೇಟಾ ಮತ್ತು ಅಭಿವೃದ್ಧಿ ಪರಿಸರಗಳಲ್ಲಿ ನೀವು ಸರಿಯಾಗಿ ರೂಪೀಕೃತ ಮತ್ತು ಮಾನ್ಯ CNPJ ಸಂಖ್ಯೆಗಳ ಅಗತ್ಯವಿರುವಾಗ ಪರಿಪೂರ್ಣವಾಗಿದೆ.
CNPJ (Cadastro Nacional da Pessoa Jurídica) 14 ಅಂಕಿಗಳ ಗುರುತಿನ ಸಂಖ್ಯೆ, ಇದು ಬ್ರಜೀಲಿಯನ್ ಫೆಡರಲ್ ರೆವೆನ್ಯೂ ಸರ್ವೀಸ್‌ನಿಂದ ವ್ಯಾಪಾರ ಮತ್ತು ಕಾನೂನು ವ್ಯಕ್ತಿಗಳಿಗೆ ನೀಡಲಾಗುತ್ತದೆ. ಇದು ಬ್ರಜೀಲ್‌ನಲ್ಲಿ ಕಂಪನಿಯ ನೋಂದಣಿ ಸಂಖ್ಯೆಯ ಅಥವಾ ತೆರಿಗೆ ID ಯ ಸಮಾನವಾಗಿದೆ. ಬ್ರಜೀಲ್‌ನಲ್ಲಿ ಕಾನೂನಾತ್ಮಕವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವ ಪ್ರತಿಯೊಬ್ಬ ವ್ಯಾಪಾರಕ್ಕೂ CNPJ ಇರಬೇಕು, ಇದು ಬಳಸಲಾಗುತ್ತದೆ:
CNPJ ಬ್ರಜೀಲ್‌ನ ವ್ಯಾಪಾರ ಪರಿಸರದಲ್ಲಿ ಪ್ರಮುಖ ಗುರುತಾಗಿದೆ ಮತ್ತು ಅಧಿಕೃತ ದಾಖಲೆಗಳು, ಒಪ್ಪಂದಗಳು ಮತ್ತು ಹಣಕಾಸು ದಾಖಲೆಗಳಲ್ಲಿ ಕಾಣಿಸುತ್ತದೆ.
ಬ್ರಜೀಲಿಯನ್ CNPJ 14 ಅಂಕಿಗಳಿಂದ ಕೂಡಿದ್ದು, ಸಾಮಾನ್ಯವಾಗಿ ಈ ರೀತಿಯ ಸ್ವರೂಪದಲ್ಲಿರುತ್ತದೆ: XX.XXX.XXX/YYYY-ZZ
ಈ ರಚನೆಯು ಹೀಗಿದೆ:
ಉದಾಹರಣೆಗೆ, ಸರಿಯಾಗಿ ರೂಪೀಕೃತ CNPJ ಇಂತಹದ್ದಾಗಿರಬಹುದು: 12.345.678/0001-95
ಪರಿಶೀಲನಾ ಅಂಕಿಗಳು (ಕೊನೆಯ ಎರಡು ಸಂಖ್ಯೆಗಳು) ನಿರ್ದಿಷ್ಟ ಗಣಿತೀಯ ಅಲ್ಗೊರಿಥಮ್‌ನ ಬಳಕೆ ಮೂಲಕ ಲೆಕ್ಕಹಾಕಲ್ಪಡುತ್ತವೆ, ಇದು CNPJ ನ ಸತ್ಯತೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಈ ಅಲ್ಗೊರಿಥಮ್ ಖಂಡಿತವಾಗಿ ಗಣಿತೀಯವಾಗಿ ಜನರೇಟ್ ಮಾಡಿದ ಸಂಖ್ಯೆಗಳು ಸರಿಯಾದ ಲೆಕ್ಕಹಾಕುವ ವಿಧಾನವನ್ನು ಅನುಸರಿಸದೇ ಮಾನ್ಯತೆಯನ್ನು ಪಡೆಯಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
CNPJ ಮಾನ್ಯತೆ ಅಲ್ಗೊರಿಥಮ್ ತೂಕದ ಲೆಕ್ಕಹಾಕುವಿಕೆ ಬಳಸುತ್ತದೆ, ಇದು ಪರಿಶೀಲನಾ ಅಂಕಿಗಳನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ:
CNPJ ಮಾನ್ಯವಾಗಲು, ಎರಡೂ ಪರಿಶೀಲನಾ ಅಂಕಿಗಳು ಲೆಕ್ಕಹಾಕಿದ ಮೌಲ್ಯಗಳಿಗೆ ಹೊಂದಿರಬೇಕು.
ನಮ್ಮ ಬ್ರಜೀಲಿಯನ್ CNPJ ಜನರೇಟರ್ ಮತ್ತು ಮಾನ್ಯತಾಪತ್ರಿಕೆ ಸಾಧನವು ಎರಡು ಪ್ರಮುಖ ಕಾರ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ: ಮಾನ್ಯ CNPJ ಗಳನ್ನು ಜನರೇಟ್ ಮಾಡುವುದು ಮತ್ತು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ CNPJ ಸಂಖ್ಯೆಗಳ ಮಾನ್ಯತೆಯನ್ನು ಪರಿಶೀಲಿಸುವುದು.
ಪರೀಕ್ಷಾ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಮಾನ್ಯ CNPJ ಅನ್ನು ಜನರೇಟ್ ಮಾಡಲು:
ಜನರೇಟ್ ಮಾಡಿದ CNPJ ವಾಸ್ತವ CNPJ ಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಎಲ್ಲಾ ಗಣಿತೀಯ ಮಾನ್ಯತೆಯ ನಿಯಮಗಳನ್ನು ಅನುಸರಿಸುತ್ತದೆ ಆದರೆ ಬ್ರಜೀಲಿಯನ್ ಫೆಡರಲ್ ರೆವೆನ್ಯೂ ಸರ್ವೀಸ್‌ನಲ್ಲಿ ನೋಂದಾಯಿತವಾಗಿಲ್ಲ.
CNPJ ಗಣಿತೀಯವಾಗಿ ಮಾನ್ಯವೇ ಎಂದು ಪರಿಶೀಲಿಸಲು:
ಮಾನ್ಯತಾಪತ್ರಿಕೆ CNPJ ಸರಿಯಾದ ಸ್ವರೂಪವನ್ನು ಅನುಸರಿಸುತ್ತಿದೆಯೇ ಮತ್ತು ಪರಿಶೀಲನಾ ಅಂಕಿಗಳು ನಿರೀಕ್ಷಿತ ಮೌಲ್ಯಗಳಿಗೆ ಹೊಂದಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.
ಈ ಬ್ರಜೀಲಿಯನ್ CNPJ ಜನರೇಟರ್ ಮತ್ತು ಮಾನ್ಯತಾಪತ್ರಿಕೆ ಸಾಧನವು ವಿಶೇಷವಾಗಿ ಈ ದೃಶ್ಯಾವಳಿಗಳಲ್ಲಿ ಉಪಯುಕ್ತವಾಗಿದೆ:
ನಮ್ಮ ಸಾಧನವು CNPJ ಗಳನ್ನು ಜನರೇಟ್ ಮತ್ತು ಮಾನ್ಯಗೊಳಿಸಲು ಸರಳ, ಬ್ರೌಸರ್ ಆಧಾರಿತ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತಿರುವಾಗ, ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳ ಆಧಾರದ ಮೇಲೆ ಕೆಲವು ಪರ್ಯಾಯಗಳಿವೆ:
CNPJ ಮಾನ್ಯತೆಯನ್ನು ನೇರವಾಗಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಅಳವಡಿಸುತ್ತಿರುವ ಡೆವೆಲಪರ್‌ಗಳಿಗೆ, ಹಲವಾರು ಭಾಷಾ-ನಿರ್ದಿಷ್ಟ ಲೈಬ್ರರಿಗಳು ಲಭ್ಯವಿವೆ:
cpf_cnpj.js, validator.jspython-cnpj, validate-docbrbrazilianutils, respect/validationcaelum-stella, commons-validatorcpf_cnpj, brazilian-railsಈ ಲೈಬ್ರರಿಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಸ್ವರೂಪ, ಪಾರ್ಸಿಂಗ್ ಮತ್ತು ಇತರ ಬ್ರಜೀಲಿಯನ್ ದಾಖಲೆಗಳ ಮಾನ್ಯತೆಗಾಗಿ ಹೆಚ್ಚುವರಿ ಕಾರ್ಯಕ್ಷಮತೆ ಒದಗಿಸುತ್ತವೆ.
ಮಾನ್ಯತೆಯನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಲು ಅಗತ್ಯವಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ, ಅಲ್ಗೊರಿಥಮ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದಿಲ್ಲ:
ಶಿಕ್ಷಣ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಅಥವಾ ಒಂದು ಬಾರಿ ಮಾನ್ಯತೆಗಾಗಿ, ನೀವು ಅಲ್ಗೊರಿಥಮ್ ಅನ್ನು ಕೈಯಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು:
ಆದರೆ, ಕೈಯಿಂದ ಲೆಕ್ಕಹಾಕುವುದು ದೋಷಕ್ಕೆ ಒಳಪಟ್ಟಿದ್ದು, ನಿಯಮಿತ ಬಳಕೆಗಾಗಿ ದುಸ್ಸಾಹಸವಾಗಿದೆ.
ಈ ಸಾಧನದಲ್ಲಿ CNPJ ಜನರೇಟರ್ ಮತ್ತು ಮಾನ್ಯತಾಪತ್ರಿಕೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸಿಕೊಂಡು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ, ಇದು ವೇಗವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಸರ್ವರ್‌ಗೆ ಕಳುಹಿಸದೇ ಸಂಪೂರ್ಣವಾಗಿ ನಿಮ್ಮ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಇಲ್ಲಿದೆ ಮುಖ್ಯ ಕಾರ್ಯಗಳ ಕಾರ್ಯವಿಧಾನ:
1function generateCNPJ() {
2 // ಮೊದಲ 12 ಅಂಕಿಗಳನ್ನು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಜನರೇಟ್ ಮಾಡಿ
3 const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4
5 // ಮೊದಲ ಪರಿಶೀಲನಾ ಅಂಕಿಯನ್ನು ಲೆಕ್ಕಹಾಕಿ
6 const firstCheckDigit = calculateCheckDigit(digits);
7 digits.push(firstCheckDigit);
8
9 // ಎರಡನೇ ಪರಿಶೀಲನಾ ಅಂಕಿಯನ್ನು ಲೆಕ್ಕಹಾಕಿ
10 const secondCheckDigit = calculateCheckDigit(digits);
11 digits.push(secondCheckDigit);
12
13 // CNPJ ಅನ್ನು ರೂಪೀಕರಿಸಿ
14 return formatCNPJ(digits.join(''));
15}
16
17function calculateCheckDigit(digits) {
18 const weights = digits.length < 13
19 ? [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
20 : [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
21
22 const sum = digits.reduce((acc, digit, index) => {
23 return acc + digit * weights[index];
24 }, 0);
25
26 const remainder = sum % 11;
27 return remainder < 2 ? 0 : 11 - remainder;
28}
291function validateCNPJ(cnpj) {
2 // ಅಂಕಿಯಲ್ಲದ ಅಕ್ಷರಗಳನ್ನು ತೆಗೆದು ಹಾಕಿ
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // ಸರಿಯಾದ ಉದ್ದವನ್ನು ಪರಿಶೀಲಿಸಿ
6 if (cleanCNPJ.length !== 14) return false;
7
8 // ಎಲ್ಲ ಸಂಖ್ಯೆಗಳು ಒಂದೇ ಇದ್ದರೆ ಪರಿಶೀಲಿಸಿ (ಎಲ್ಲಾ ಒಂದೇ ಅಂಕಿಗಳು)
9 if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10
11 // ಅಂಕಿಗಳ ಪಟ್ಟಿಗೆ ಪರಿವರ್ತಿಸಿ
12 const digits = cleanCNPJ.split('').map(Number);
13
14 // ಮೊದಲ ಪರಿಶೀಲನಾ ಅಂಕಿಯನ್ನು ಪರಿಶೀಲಿಸಿ
15 const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16 if (digits[12] !== expectedFirstDigit) return false;
17
18 // ಎರಡನೇ ಪರಿಶೀಲನಾ ಅಂಕಿಯನ್ನು ಪರಿಶೀಲಿಸಿ
19 const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20 if (digits[13] !== expectedSecondDigit) return false;
21
22 return true;
23}
241function formatCNPJ(cnpj) {
2 // ಅಂಕಿಯಲ್ಲದ ಅಕ್ಷರಗಳನ್ನು ತೆಗೆದು ಹಾಕಿ
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // ಉದ್ದವನ್ನು ಆಧರಿಸಿ ಸ್ವರೂಪೀಕರಿಸಿ
6 if (cleanCNPJ.length <= 2) {
7 return cleanCNPJ;
8 } else if (cleanCNPJ.length <= 5) {
9 return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2)}`;
10 } else if (cleanCNPJ.length <= 8) {
11 return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5)}`;
12 } else if (cleanCNPJ.length <= 12) {
13 return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5, 8)}/${cleanCNPJ.slice(8)}`;
14 } else {
15 return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5, 8)}/${cleanCNPJ.slice(8, 12)}-${cleanCNPJ.slice(12, 14)}`;
16 }
17}
18ಈ ಮುಖ್ಯ ಕಾರ್ಯಗಳನ್ನು ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಒಂದೇ ತತ್ವವನ್ನು ಅನುಸರಿಸುತ್ತಾ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. ಇಲ್ಲಿ ಪೈಥಾನ್ ಮತ್ತು ಜಾವಾದ ಉದಾಹರಣೆಗಳಿವೆ:
1import random
2
3def calculate_check_digit(digits):
4 weights = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2] if len(digits) < 13 else [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
5
6 total = 0
7 for i in range(len(digits)):
8 total += digits[i] * weights[i]
9
10 remainder = total % 11
11 return 0 if remainder < 2 else 11 - remainder
12
13def generate_cnpj():
14 # ಮೊದಲ 12 ಅಂಕಿಗಳನ್ನು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಜನರೇಟ್ ಮಾಡಿ
15 digits = [random.randint(0, 9) for _ in range(12)]
16
17 # ಮೊದಲ ಪರಿಶೀಲನಾ ಅಂಕಿಯನ್ನು ಲೆಕ್ಕಹಾಕಿ
18 first_check = calculate_check_digit(digits)
19 digits.append(first_check)
20
21 # ಎರಡನೇ ಪರಿಶೀಲನಾ ಅಂಕಿಯನ್ನು ಲೆಕ್ಕಹಾಕಿ
22 second_check = calculate_check_digit(digits)
23 digits.append(second_check)
24
25 # CNPJ ಅನ್ನು ರೂಪೀಕರಿಸಿ
26 cnpj = ''.join(map(str, digits))
27 return f"{cnpj[:2]}.{cnpj[2:5]}.{cnpj[5:8]}/{cnpj[8:12]}-{cnpj[12:]}"
28
29def validate_cnpj(cnpj):
30 # ಅಂಕಿಯಲ್ಲದ ಅಕ್ಷರಗಳನ್ನು ತೆಗೆದು ಹಾಕಿ
31 cnpj = ''.join(filter(str.isdigit, cnpj))
32
33 # ಉದ್ದವನ್ನು ಪರಿಶೀಲಿಸಿ
34 if len(cnpj) != 14:
35 return False
36
37 # ಎಲ್ಲ ಸಂಖ್ಯೆಗಳು ಒಂದೇ ಇದ್ದರೆ ಪರಿಶೀಲಿಸಿ
38 if len(set(cnpj)) == 1:
39 return False
40
41 # ಅಂಕಿಗಳ ಪಟ್ಟಿಗೆ ಪರಿವರ್ತಿಸಿ
42 digits = [int(d) for d in cnpj]
43
44 # ಮೊದಲ ಪರಿಶೀಲನಾ ಅಂಕಿಯನ್ನು ಪರಿಶೀಲಿಸಿ
45 first_check = calculate_check_digit(digits[:12])
46 if digits[12] != first_check:
47 return False
48
49 # ಎರಡನೇ ಪರಿಶೀಲನಾ ಅಂಕಿಯನ್ನು ಪರಿಶೀಲಿಸಿ
50 second_check = calculate_check_digit(digits[:13])
51 if digits[13] != second_check:
52 return False
53
54 return True
551import java.util.Random;
2
3public class CNPJUtils {
4
5 public static String generateCNPJ() {
6 Random random = new Random();
7 int[] digits = new int[14];
8
9 // ಮೊದಲ 12 ಅಂಕಿಗಳನ್ನು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಜನರೇಟ್ ಮಾಡಿ
10 for (int i = 0; i < 12; i++) {
11 digits[i] = random.nextInt(10);
12 }
13
14 // ಮೊದಲ ಪರಿಶೀಲನಾ ಅಂಕಿಯನ್ನು ಲೆಕ್ಕಹಾಕಿ
15 digits[12] = calculateCheckDigit(digits, 12);
16
17 // ಎರಡನೇ ಪರಿಶೀಲನಾ ಅಂಕಿಯನ್ನು ಲೆಕ್ಕಹಾಕಿ
18 digits[13] = calculateCheckDigit(digits, 13);
19
20 // CNPJ ಅನ್ನು ರೂಪೀಕರಿಸಿ
21 return String.format("%02d.%03d.%03d/%04d-%02d",
22 digits[0] * 10 + digits[1],
23 digits[2] * 100 + digits[3] * 10 + digits[4],
24 digits[5] * 100 + digits[6] * 10 + digits[7],
25 digits[8] * 1000 + digits[9] * 100 + digits[10] * 10 + digits[11],
26 digits[12] * 10 + digits[13]);
27 }
28
29 private static int calculateCheckDigit(int[] digits, int length) {
30 int[] weights = length < 13
31 ? new int[]{5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2}
32 : new int[]{6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2};
33
34 int sum = 0;
35 for (int i = 0; i < length; i++) {
36 sum += digits[i] * weights[i];
37 }
38
39 int remainder = sum % 11;
40 return remainder < 2 ? 0 : 11 - remainder;
41 }
42
43 public static boolean validateCNPJ(String cnpj) {
44 // ಅಂಕಿಯಲ್ಲದ ಅಕ್ಷರಗಳನ್ನು ತೆಗೆದು ಹಾಕಿ
45 cnpj = cnpj.replaceAll("\\D", "");
46
47 // ಉದ್ದವನ್ನು ಪರಿಶೀಲಿಸಿ
48 if (cnpj.length() != 14) {
49 return false;
50 }
51
52 // ಎಲ್ಲ ಸಂಖ್ಯೆಗಳು ಒಂದೇ ಇದ್ದರೆ ಪರಿಶೀಲಿಸಿ
53 boolean allDigitsSame = true;
54 for (int i = 1; i < cnpj.length(); i++) {
55 if (cnpj.charAt(i) != cnpj.charAt(0)) {
56 allDigitsSame = false;
57 break;
58 }
59 }
60 if (allDigitsSame) {
61 return false;
62 }
63
64 // ಅಂಕಿಗಳ ಪಟ್ಟಿಗೆ ಪರಿವರ್ತಿಸಿ
65 int[] digits = new int[14];
66 for (int i = 0; i < 14; i++) {
67 digits[i] = Character.getNumericValue(cnpj.charAt(i));
68 }
69
70 // ಮೊದಲ ಪರಿಶೀಲನಾ ಅಂಕಿಯನ್ನು ಪರಿಶೀಲಿಸಿ
71 int firstCheck = calculateCheckDigit(digits, 12);
72 if (digits[12] != firstCheck) {
73 return false;
74 }
75
76 // ಎರಡನೇ ಪರಿಶೀಲನಾ ಅಂಕಿಯನ್ನು ಪರಿಶೀಲಿಸಿ
77 int secondCheck = calculateCheckDigit(digits, 13);
78 if (digits[13] != secondCheck) {
79 return false;
80 }
81
82 return true;
83 }
84}
85ಈ CNPJ ಜನರೇಟರ್ ಮತ್ತು ಮಾನ್ಯತಾಪತ್ರಿಕೆ ಸಾಧನವನ್ನು ಬಳಸಿದಾಗ, ಈ ಕೆಳಗಿನ ಪರಿಗಣನೆಗಳನ್ನು ಗಮನದಲ್ಲಿಟ್ಟುಕೊಳ್ಳಿ:
CNPJ ಬ್ರಜೀಲ್‌ನಲ್ಲಿ ವ್ಯಾಪಾರ ಮತ್ತು ಕಾನೂನು ವ್ಯಕ್ತಿಗಳ ರಾಷ್ಟ್ರೀಯ ನೋಂದಣಿ ಸಂಖ್ಯೆ. ಇದು ತೆರಿಗೆ ಉದ್ದೇಶಗಳಿಗೆ, ವ್ಯಾಪಾರ ನೋಂದಣಿಗೆ, ಬ್ಯಾಂಕ್ ಖಾತೆಗಳನ್ನು ತೆರೆಯಲು ಮತ್ತು ಅಧಿಕೃತ ವ್ಯವಹಾರಗಳಲ್ಲಿ ಕಂಪನಿಗಳನ್ನು ಗುರುತಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
ಇಲ್ಲ. ಈ ಸಾಧನದಿಂದ ಜನರೇಟ್ ಮಾಡಿದ CNPJ ಗಳು ಪರಿಶೀಲನಾ ಅಂಕಿ ಅಲ್ಗೊರಿಥಮ್ ಪ್ರಕಾರ ಗಣಿತೀಯವಾಗಿ ಮಾನ್ಯವಾಗಿವೆ, ಆದರೆ ಬ್ರಜೀಲಿಯನ್ ಫೆಡರಲ್ ರೆವೆನ್ಯೂ ಸರ್ವೀಸ್‌ನಲ್ಲಿ ನೋಂದಾಯಿತವಲ್ಲ ಮತ್ತು ವಾಸ್ತವ ಕಂಪನಿಗಳಿಗೆ ಸೇರಿಲ್ಲ.
ಇಲ್ಲ. ವ್ಯಾಪಾರಕ್ಕೆ ಮಾನ್ಯ CNPJ ಅನ್ನು ಪಡೆಯಲು, ನೀವು ಬ್ರಜೀಲಿಯನ್ ಫೆಡರಲ್ ರೆವೆನ್ಯೂ ಸರ್ವೀಸ್ (Receita Federal) ಗೆ ಅಧಿಕೃತವಾಗಿ ನೋಂದಾಯಿಸಬೇಕು. ಜನರೇಟ್ ಮಾಡಿದ CNPJ ಗಳು ಪರೀಕ್ಷಾ ಉದ್ದೇಶಗಳಿಗೆ ಮಾತ್ರ.
CNPJ ವಾಸ್ತವ ಕಂಪನಿಗೆ ನೋಂದಾಯಿತವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು, ನೀವು ಬ್ರಜೀಲಿಯನ್ ಫೆಡರಲ್ ರೆವೆನ್ಯೂ ಸರ್ವೀಸ್ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಪರಿಶೀಲಿಸಬೇಕಾಗಿದೆ. ನಮ್ಮ ಸಾಧನವು CNPJ ಗಣಿತೀಯವಾಗಿ ಮಾನ್ಯವೇ ಎಂಬುದನ್ನು ಮಾತ್ರ ಪರಿಶೀಲಿಸುತ್ತದೆ, ಆದರೆ ಅಧಿಕೃತವಾಗಿ ನೋಂದಾಯಿತವಲ್ಲ.
ಎಲ್ಲಾ ಒಂದೇ ಅಂಕಿಗಳ CNPJ ಗಳು (ಹಾಗೆಂದರೆ 11.111.111/1111-11) ಸ್ವಯಂ-ಮಾನ್ಯತೆಯನ್ನು ಪಡೆಯುವುದಿಲ್ಲ, ಆದರೆ ಗಣಿತೀಯವಾಗಿ ಮಾನ್ಯವಾಗಿದ್ದರೂ ಸಹ, ತಕ್ಷಣವೇ ಅಮಾನ್ಯವಾಗಿರುತ್ತದೆ. ಇದು ಬ್ರಜೀಲಿಯನ್ ಫೆಡರಲ್ ರೆವೆನ್ಯೂ ಸರ್ವೀಸ್ ಮೂಲಕ ಸ್ಥಾಪಿತವಾದ ನಿಯಮವಾಗಿದೆ.
ಇಲ್ಲ. ಎಲ್ಲಾ ಪ್ರಕ್ರಿಯೆ ನಿಮ್ಮ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ನಡೆಯುತ್ತದೆ, ಮತ್ತು ನಾವು ನೀವು ಜನರೇಟ್ ಅಥವಾ ಮಾನ್ಯಗೊಳಿಸಿದ CNPJ ಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದಿಲ್ಲ.
ಈ ಸಾಧನದ ಪ್ರಸ್ತುತ ಆವೃತ್ತಿ ಒಂದು CNPJ ಅನ್ನು ಮಾತ್ರ ಜನರೇಟ್ ಮಾಡುತ್ತದೆ. ಬಹುಜನರೇಶನ್‌ಗಾಗಿ, ನೀವು ಪರ್ಯಾಯ ವಿಭಾಗದಲ್ಲಿ ಉಲ್ಲೇಖಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಲೈಬ್ರರಿಯಲ್ಲಿಯೇ ಪರಿಗಣಿಸಲು ಬಯಸಬಹುದು.
ಇದು ಬ್ರಜೀಲಿಯನ್ ಅಧಿಕಾರಿಗಳಿಂದ ಅಗತ್ಯವಿರುವ ಅಧಿಕೃತ ಸ್ವರೂಪವಾಗಿದೆ. ನಿರ್ದಿಷ್ಟ ಗುಂಪುಗಳು CNPJ ಯ ವಿವಿಧ ಭಾಗಗಳನ್ನು ಗುರುತಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಮೂಲ ಸಂಖ್ಯೆ ಮತ್ತು ಶಾಖೆ ಗುರುತಿಸುವಿಕೆ.
ನೀವು ತಾಂತ್ರಿಕ ಅನುಷ್ಠಾನ ವಿಭಾಗದಲ್ಲಿ ನೀಡಲಾದ ಕೋಡ್ ಉದಾಹರಣೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅಥವಾ ಪರ್ಯಾಯ ವಿಭಾಗದಲ್ಲಿ ಉಲ್ಲೇಖಿತ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಆಯ್ಕೆ ಮಾಡಿದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿ ಮಾನ್ಯತೆ ಅಲ್ಗೊರಿಥಮ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.
ಹೌದು. ಬ್ರಜೀಲ್‌ನಲ್ಲಿ ಸರ್ಕಾರದ ಘಟಕಗಳಿಗೆ ನಿರ್ದಿಷ್ಟ CNPJ ಮಾದರಿಗಳು ಇವೆ. ಉದಾಹರಣೆಗೆ, ಫೆಡರಲ್ ಸರ್ಕಾರದ ಘಟಕಗಳು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಆರಂಭಿಸುತ್ತವೆ. ನಮ್ಮ ಜನರೇಟರ್ ಯಾದೃಚ್ಛಿಕ CNPJ ಗಳನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಸರ್ಕಾರದ ಘಟಕ CNPJ ಗಳನ್ನು ವಿಶೇಷವಾಗಿ ರಚಿಸುವುದಿಲ್ಲ.
ನಮ್ಮ ಬ್ರಜೀಲಿಯನ್ CNPJ ಜನರೇಟರ್ ಮತ್ತು ಮಾನ್ಯತಾಪತ್ರಿಕೆ ಸಾಧನವು ಈ ಗುರುತಿನ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಸರಳ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಮಾಡುತ್ತದೆ. ನೀವು ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸುತ್ತಿದ್ದೀರಾ, ಮಾದರಿ ಡೇಟಾ ತಯಾರಿಸುತ್ತಿದ್ದೀರಾ ಅಥವಾ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ CNPJ ಗಳನ್ನು ಮಾನ್ಯಗೊಳಿಸುತ್ತಿದ್ದೀರಾ, ಈ ಸಾಧನವು API ಅಂತರಾಯಗಳು ಅಥವಾ ಉನ್ನತ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳ ಸಂಕೀರ್ಣತೆಯಿಲ್ಲದೆ ಸರಳ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಈಗ ನಿಮ್ಮ ಮೊದಲ ಮಾನ್ಯ CNPJ ಅನ್ನು ಜನರೇಟ್ ಮಾಡಿ ಅಥವಾ ನಮ್ಮ ಸರಳ ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ CNPJ ಅನ್ನು ಮಾನ್ಯಗೊಳಿಸಿ!
ನಿಮ್ಮ ಕೆಲಸದ ಹಂತಕ್ಕೆ ಉಪಯೋಗಿಸಬಹುದಾದ ಹೆಚ್ಚು ಉಪಕರಣಗಳನ್ನು ಹುಡುಕಿ ಹೊಸ ಉಪಕರಣಗಳನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ