CPF ಜನರೇಟರ್

ಪರಿಚಯ

CPF (Cadastro de Pessoas Físicas) ಬ್ರಾಜೀಲ್ ನಾಗರಿಕರು ಮತ್ತು ನಿವಾಸಿಗಳಿಗೆ ತೆರಿಗೆ ಉದ್ದೇಶಗಳಿಗಾಗಿ ನೀಡಲ್ಪಟ್ಟ ವೈಶಿಷ್ಟ್ಯಪೂರ್ಣ ಗುರುತಿನ ಸಂಖ್ಯೆಯಾಗಿದೆ. ಈ ಜನರೇಟರ್ ಮಾನ್ಯ, ಯಾದೃಚ್ಛಿಕ CPF ಸಂಖ್ಯೆಗಳ ಉತ್ಪಾದನೆ ಮಾಡುತ್ತದೆ. ಈ ಉತ್ಪಾದಿತ CPFs ವಾಸ್ತವ ವ್ಯಕ್ತಿಗಳೊಂದಿಗೆ ಸಂಬಂಧಿತವಾಗಿಲ್ಲ ಮತ್ತು ಕೇವಲ ಪರೀಕ್ಷಾ ಪರಿಸರದಲ್ಲಿ ಮಾತ್ರ ಬಳಸಬೇಕು ಎಂಬುದನ್ನು ಗಮನಿಸಲು ಮುಖ್ಯವಾಗಿದೆ.

CPF ರಚನೆ

CPF 11 ಸಂಖ್ಯೆಗಳನ್ನೊಳಗೊಂಡಿದೆ:

• ಮೊದಲ 9 ಸಂಖ್ಯೆಗಳು ಆಧಾರ ಸಂಖ್ಯೆಗಳಾಗಿವೆ
• ಕೊನೆಯ 2 ಸಂಖ್ಯೆಗಳು ಪರಿಶೀಲನಾ ಸಂಖ್ಯೆಗಳಾಗಿವೆ

ಆಕೃತಿಯು ಸಾಮಾನ್ಯವಾಗಿ ಈ ರೀತಿಯಾಗಿ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ: XXX.XXX.XXX-XX

CPF ಪರಿಶೀಲನಾ ಆಲ್ಗೋರಿದಮ್

CPF ಪರಿಶೀಲನಾ ಆಲ್ಗೋರಿದಮ್ ಸಂಖ್ಯೆಯ ಶ್ರೇಣಿಯ ಸಮಗ್ರತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ:

1. ಮೊದಲ 9 ಸಂಖ್ಯೆಗಳನ್ನೂ ತೂಕಗಳೊಂದಿಗೆ (10 ರಿಂದ 2) ಗುಣಿಸುವುದು
2. ಫಲಿತಾಂಶಗಳನ್ನು ಸೇರಿಸುವುದು
3. 11 ರಿಂದ ಭಾಗಿತಾದ ಶ್ರೇಣಿಯ ಶೇಷವನ್ನು ಲೆಕ್ಕಹಾಕುವುದು
4. ಶೇಷ 2 ಕಿಂತ ಕಡಿಮೆ ಇದ್ದರೆ, ಮೊದಲ ಪರಿಶೀಲನಾ ಸಂಖ್ಯೆಯು 0; ಇಲ್ಲದಿದ್ದರೆ, ಶೇಷವನ್ನು 11 ಕ್ಕೆ ಕಡಿಮೆ ಮಾಡುವುದು
5. ಮೊದಲ 10 ಸಂಖ್ಯೆಗಳಿಗಾಗಿ (ಮೊದಲ ಪರಿಶೀಲನಾ ಸಂಖ್ಯೆಯನ್ನು ಒಳಗೊಂಡಂತೆ) ಪುನರಾವೃತ್ತ ಪ್ರಕ್ರಿಯೆ ನಡೆಸುವುದು, ತೂಕಗಳು 11 ರಿಂದ 2
6. ಮೊದಲದಂತೆ ಎರಡನೇ ಪರಿಶೀಲನಾ ಸಂಖ್ಯೆಯನ್ನು ಲೆಕ್ಕಹಾಕುವುದು

ಈ ಜನರೇಟರ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು

1. "CPF ಜನರೇಟ್ ಮಾಡಿ" ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿ
2. ಮಾನ್ಯ, ಯಾದೃಚ್ಛಿಕ CPF ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ
3. ನಿಮ್ಮ ಪರೀಕ್ಷಾ ದೃಶ್ಯಗಳಲ್ಲಿ ಬಳಸಲು ಉತ್ಪಾದಿತ CPF ಅನ್ನು ನಕಲಿಸಬಹುದು

ಸೂತ್ರ

ಮಾನ್ಯ CPF ಅನ್ನು ಉತ್ಪಾದಿಸಲು ಸೂತ್ರವು ಈ ರೀತಿಯಾಗಿದೆ:

1def generate_cpf():
2    # 9 ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳ ಉತ್ಪಾದನೆ
3    base_cpf = [random.randint(0, 9) for _ in range(9)]
4    
5    # ಮೊದಲ ಪರಿಶೀಲನಾ ಸಂಖ್ಯೆಯನ್ನು ಲೆಕ್ಕಹಾಕುವುದು
6    sum_1 = sum((10 - i) * digit for i, digit in enumerate(base_cpf))
7    check_digit_1 = (sum_1 * 10 % 11) % 10
8    
9    # ಎರಡನೇ ಪರಿಶೀಲನಾ ಸಂಖ್ಯೆಯನ್ನು ಲೆಕ್ಕಹಾಕುವುದು
10    sum_2 = sum((11 - i) * digit for i, digit in enumerate(base_cpf + [check_digit_1]))
11    check_digit_2 = (sum_2 * 10 % 11) % 10
12    
13    return base_cpf + [check_digit_1, check_digit_2]
14

ಲೆಕ್ಕಹಾಕುವುದು

ಜನರೇಟರ್ ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸುತ್ತದೆ:

1. 9 ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳ ಉತ್ಪಾದನೆ
2. ಮೇಲಿನ ವಿವರಿಸಿದ ಆಲ್ಗೋರಿದಮ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮೊದಲ ಪರಿಶೀಲನಾ ಸಂಖ್ಯೆಯನ್ನು ಲೆಕ್ಕಹಾಕುವುದು
3. ಎರಡನೇ ಪರಿಶೀಲನಾ ಸಂಖ್ಯೆಯನ್ನು ಲೆಕ್ಕಹಾಕುವುದು
4. ಸಂಪೂರ್ಣ CPF ಅನ್ನು ರೂಪಿಸಲು ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳನ್ನೂ ಒಟ್ಟುಗೂಡಿಸುವುದು

ಉದಾಹರಣೆಗಳು

ಇಲ್ಲಿ ಉತ್ಪಾದಿತ CPFs ನ ಕೆಲವು ಉದಾಹರಣೆಗಳು:

1. 123.456.789-09
2. 987.654.321-00
3. 111.222.333-96

ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

CPF ಜನರೇಟರ್ ವಿವಿಧ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಪರೀಕ್ಷಾ ದೃಶ್ಯಗಳಲ್ಲಿ ಉಪಯುಕ್ತವಾಗಿದೆ:

1. ಡೇಟಾಬೇಸ್ ಪರೀಕ್ಷೆ: ಮಾನ್ಯ CPF ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಪರೀಕ್ಷಾ ಡೇಟಾಬೇಸ್ ಅನ್ನು ತುಂಬಿಸಲು
2. ಫಾರ್ಮ್ ಪರಿಶೀಲನೆ: ಬ್ರಾಜೀಲ್ ಬಳಕೆದಾರ ನೋಂದಣಿ ಫಾರ್ಮ್‌ಗಳಿಗೆ ಇನ್ಪುಟ್ ಪರಿಶೀಲನೆಯ ಪರೀಕ್ಷೆ
3. API ಪರೀಕ್ಷೆ: ಮಾನ್ಯ ಬ್ರಾಜೀಲ್ ಗುರುತಿನ ಸಂಖ್ಯೆಯನ್ನು ಅಗತ್ಯವಿರುವ API ವಿನಂತಿಗಳಲ್ಲಿ ಬಳಸುವುದು
4. ಕಾರ್ಯಕ್ಷಮತೆ ಪರೀಕ್ಷೆ: ಲೋಡ್ ಪರೀಕ್ಷೆಗಾಗಿ ವಿಭಿನ್ನ, ಮಾನ್ಯ CPFs ನ ದೊಡ್ಡ ಸೆಟ್ಗಳನ್ನು ಉತ್ಪಾದಿಸುವುದು
5. UI/UX ಪರೀಕ್ಷೆ: ಬಳಕೆದಾರ ಇಂಟರ್‌ಫೇಸ್‌ಗಳಲ್ಲಿ CPF ಸಂಖ್ಯೆಗಳ ಸರಿಯಾದ ರೂಪಾಂತರ ಮತ್ತು ಪ್ರದರ್ಶನವನ್ನು ಖಚಿತಪಡಿಸುವುದು

ಪರ್ಯಾಯಗಳು

CPF ಬ್ರಾಜೀಲ್‌ನಲ್ಲಿ ಪ್ರಮುಖ ವೈಯಕ್ತಿಕ ಗುರುತಿನ ಸಂಖ್ಯೆಯಾಗಿದ್ದರೂ, ಕೆಲವು ನಿರ್ದಿಷ್ಟ ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಳಸಬಹುದಾದ ಇತರ ಗುರುತಿನ ಸಂಖ್ಯೆಗಳಿವೆ:

1. RG (Registro Geral): ರಾಜ್ಯದಿಂದ ನೀಡಲ್ಪಟ್ಟ ಗುರುತಿನ ದಾಖಲೆ
2. CNPJ (Cadastro Nacional da Pessoa Jurídica): ವ್ಯವಹಾರಗಳು ಮತ್ತು ಕಾನೂನು ವ್ಯಕ್ತಿಗಳಿಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ
3. PIS/PASEP: ಉದ್ಯೋಗ ಸಂಬಂಧಿತ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ

ಐತಿಹಾಸಿಕ

CPF 1965ರಲ್ಲಿ ಬ್ರಾಜೀಲ್ನಲ್ಲಿ ಪರಿಚಯಿಸಲಾಯಿತು, ದೇಶದ ತೆರಿಗೆ ವ್ಯವಸ್ಥೆಯನ್ನು ಆಧುನಿಕಗೊಳಿಸಲು ವ್ಯಾಪಕ ಪ್ರಯತ್ನದ ಭಾಗವಾಗಿ. ಪ್ರಾರಂಭದಲ್ಲಿ, ಇದು ಮುಖ್ಯವಾಗಿ ಆದಾಯ ತೆರಿಗೆ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಬಳಸಲಾಗುತ್ತಿತ್ತು, ಆದರೆ ಸಮಯದೊಂದಿಗೆ, ಇದರ ಬಳಕೆ ಬ್ರಾಜೀಲ್‌ನ ಕಚೇರಿಯ ಮತ್ತು ವ್ಯಾಪಾರದ ವಿವಿಧ ಇತರ ಕ್ಷೇತ್ರಗಳಿಗೆ ವಿಸ್ತಾರಗೊಳ್ಳಿತು.

CPF ಐತಿಹಾಸದಲ್ಲಿ ಪ್ರಮುಖ ಮೈಲುಗಲ್ಲುಗಳು:

• 1965: ವ್ಯಕ್ತಿಗಳಿಗೆ CPF ಪರಿಚಯಿಸಲಾಗಿದೆ
• 1972: ಎಲ್ಲಾ ತೆರಿಗೆ ನೀಡುವ ವ್ಯಕ್ತಿಗಳಿಗೆ CPF ಕಡ್ಡಾಯವಾಗುತ್ತದೆ
• 1990ರ ದಶಕ: ವ್ಯಾಪಾರ ಮತ್ತು ಹಣಕಾಸು ವ್ಯವಹಾರಗಳಲ್ಲಿ CPF ಹೆಚ್ಚು ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ
• 2000ರ ದಶಕ: ಡಿಜಿಟಲ್ ವ್ಯವಸ್ಥೆಗಳು CPF ಅನ್ನು ಬ್ರಾಜೀಲ್‌ನಲ್ಲಿ ದೈನಂದಿನ ಜೀವನದಲ್ಲಿ ಇನ್ನಷ್ಟು ಏಕೀಕೃತಗೊಳಿಸುತ್ತವೆ

ಇಂದು, CPF ಬ್ರಾಜೀಲ್ ನಾಗರಿಕರು ಮತ್ತು ನಿವಾಸಿಗಳ ಸರ್ಕಾರದ ಸೇವೆಗಳ, ಹಣಕಾಸು ಸಂಸ್ಥೆಗಳ ಮತ್ತು ಹಲವಾರು ವ್ಯಾಪಾರ ವ್ಯವಹಾರಗಳೊಂದಿಗೆ ಪರಸ್ಪರ ಸಂಬಂಧಗಳ ಪ್ರಮುಖ ಭಾಗವಾಗಿದೆ.

ಕೋಡ್ ಉದಾಹರಣೆಗಳು

ಬ್ರಾಜೀಲ್‌ನಲ್ಲಿ CPFಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಮತ್ತು ಪರಿಶೀಲಿಸಲು ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಕೋಡ್ ತುಣುಕுகள் ಇಲ್ಲಿವೆ:

1import random
2
3def generate_cpf():
4    cpf = [random.randint(0, 9) for _ in range(9)]
5    for _ in range(2):
6        value = sum((cpf[num] * ((len(cpf) + 1) - num) for num in range(len(cpf)))) % 11
7        cpf.append(11 - value if value > 1 else 0)
8    return ''.join(map(str, cpf))
9
10def validate_cpf(cpf):
11    numbers = [int(digit) for digit in cpf if digit.isdigit()]
12    if len(numbers) != 11 or len(set(numbers)) == 1:
13        return False
14    for i in range(9, 11):
15        value = sum((numbers[num] * ((i + 1) - num) for num in range(i))) % 11
16        if numbers[i] != (11 - value if value > 1 else 0):
17            return False
18    return True
19
20## ಉದಾಹರಣೆಯ ಬಳಕೆ
21cpf = generate_cpf()
22print(f"ಉತ್ಪಾದಿತ CPF: {cpf}")
23print(f"ಮಾನ್ಯವಾಗಿದೆ: {validate_cpf(cpf)}")
24

1function generateCPF() {
2    const cpf = Array.from({length: 9}, () => Math.floor(Math.random() * 10));
3    for (let i = 0; i < 2; i++) {
4        let sum = cpf.reduce((acc, cur, idx) => acc + cur * (cpf.length + 1 - idx), 0);
5        let digit = 11 - (sum % 11);
6        cpf.push(digit > 9 ? 0 : digit);
7    }
8    return cpf.join('');
9}
10
11function validateCPF(cpf) {
12    const numbers = cpf.match(/\d/g).map(Number);
13    if (numbers.length !== 11 || new Set(numbers).size === 1) return false;
14    for (let i = 9; i < 11; i++) {
15        let sum = numbers.slice(0, i).reduce((acc, cur, idx) => acc + cur * (i + 1 - idx), 0);
16        let digit = 11 - (sum % 11);
17        if (numbers[i] !== (digit > 9 ? 0 : digit)) return false;
18    }
19    return true;
20}
21
22// ಉದಾಹರಣೆಯ ಬಳಕೆ
23const cpf = generateCPF();
24console.log(`ಉತ್ಪಾದಿತ CPF: ${cpf}`);
25console.log(`ಮಾನ್ಯವಾಗಿದೆ: ${validateCPF(cpf)}`);
26

1import java.util.Random;
2
3public class CPFGenerator {
4    private static final Random random = new Random();
5
6    public static String generateCPF() {
7        int[] cpf = new int[11];
8        for (int i = 0; i < 9; i++) {
9            cpf[i] = random.nextInt(10);
10        }
11        cpf[9] = calculateCheckDigit(cpf, 10);
12        cpf[10] = calculateCheckDigit(cpf, 11);
13        return formatCPF(cpf);
14    }
15
16    private static int calculateCheckDigit(int[] cpf, int factor) {
17        int sum = 0;
18        for (int i = 0; i < factor - 1; i++) {
19            sum += cpf[i] * (factor - i);
20        }
21        int result = 11 - (sum % 11);
22        return result > 9 ? 0 : result;
23    }
24
25    private static String formatCPF(int[] cpf) {
26        return String.format("%d%d%d.%d%d%d.%d%d%d-%d%d",
27                cpf[0], cpf[1], cpf[2], cpf[3], cpf[4], cpf[5], cpf[6], cpf[7], cpf[8], cpf[9], cpf[10]);
28    }
29
30    public static boolean validateCPF(String cpf) {
31        cpf = cpf.replaceAll("[^0-9]", "");
32        if (cpf.length() != 11) return false;
33        int[] numbers = cpf.chars().map(Character::getNumericValue).toArray();
34        if (allEqual(numbers)) return false;
35        int digit10 = calculateCheckDigit(numbers, 10);
36        int digit11 = calculateCheckDigit(numbers, 11);
37        return numbers[9] == digit10 && numbers[10] == digit11;
38    }
39
40    private static boolean allEqual(int[] array) {
41        for (int i = 1; i < array.length; i++) {
42            if (array[i] != array[0]) return false;
43        }
44        return true;
45    }
46
47    public static void main(String[] args) {
48        String cpf = generateCPF();
49        System.out.println("ಉತ್ಪಾದಿತ CPF: " + cpf);
50        System.out.println("ಮಾನ್ಯವಾಗಿದೆ: " + validateCPF(cpf));
51    }
52}
53

ಈ ಉದಾಹರಣೆಗಳು Python, JavaScript ಮತ್ತು Java ನಲ್ಲಿ CPFಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಮತ್ತು ಪರಿಶೀಲಿಸಲು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತವೆ. ನೀವು ಈ ಕಾರ್ಯಗಳನ್ನು ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳಿಗೆ ಹೊಂದಿಸಲು ಅಥವಾ CPF ನಿರ್ವಹಣೆಯನ್ನು ಅಗತ್ಯವಿರುವ ದೊಡ್ಡ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಒಂದರಂತೆ ಸೇರಿಸಲು ಹೊಂದಿಸಬಹುದು.

ಕಾನೂನು ಮತ್ತು ನೈತಿಕ ಪರಿಗಣನೆಗಳು

ಉತ್ಪಾದಿತ CPFs ಅನ್ನು ಬಳಸುವಾಗ, ಈ ಕೆಳಗಿನ ಅಂಶಗಳನ್ನು ಗಮನಿಸುವುದು ಅತ್ಯಂತ ಮುಖ್ಯವಾಗಿದೆ:

1. ಉತ್ಪಾದಿತ CPFs ಕೇವಲ ಪರೀಕ್ಷಾ ಉದ್ದೇಶಗಳಿಗೆ ಮಾತ್ರ ಮತ್ತು ವಾಸ್ತವ ವ್ಯಕ್ತಿಗಳನ್ನು ನಕಲಿಸಲು ಅಥವಾ ಯಾವುದೇ ಮೋಸಕಾರಕ ಚಟುವಟಿಕೆಗಳಿಗೆ ಬಳಸಬಾರದು.
2. ಯಾವುದೇ ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ಉತ್ಪಾದಿತ CPFs ಅನ್ನು ಒಳಗೊಂಡಂತೆ ಸ್ಪಷ್ಟವಾಗಿ ಲೇಬಲ್ ಮಾಡಬೇಕು, ವಾಸ್ತವ ವೈಯಕ್ತಿಕ ಮಾಹಿತಿಯೊಂದಿಗೆ ಗೊಂದಲವನ್ನು ತಡೆಯಲು.
3. ವಾಸ್ತವ ಅಥವಾ ಉತ್ಪಾದಿತ CPFs ಅನ್ನು ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ನಿರ್ವಹಿಸುವಾಗ ನಿಮ್ಮ ನ್ಯಾಯಕ್ಷೇತ್ರದಲ್ಲಿ ಡೇಟಾ ರಕ್ಷಣಾ ಕಾನೂನುಗಳು ಮತ್ತು ನಿಯಮಗಳನ್ನು ಗಮನದಲ್ಲಿಟ್ಟುಕೊಳ್ಳಿ.
4. ಉತ್ಪಾದನಾ ಪರಿಸರದಲ್ಲಿ, ಯಾವಾಗಲೂ ಬಳಕೆದಾರರು ಅಥವಾ ಅಧಿಕಾರಿತ ಮೂಲಗಳಿಂದ ಒದಗಿಸಿದ ವಾಸ್ತವ, ದೃಢೀಕೃತ CPFs ಅನ್ನು ಬಳಸಬೇಕು.
5. ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ವಾಸ್ತವ ಮತ್ತು ಉತ್ಪಾದಿತ CPFs ಅನ್ನು ರಕ್ಷಿಸಲು ಸೂಕ್ತ ಭದ್ರತಾ ಕ್ರಮಗಳನ್ನು ಜಾರಿಗೆ ತರಬೇಕು.

ಉಲ್ಲೇಖಗಳು

1. Receita Federal do Brasil. "CPF - Cadastro de Pessoas Físicas." https://www.gov.br/receitafederal/pt-br/assuntos/orientacao-tributaria/cadastros/cpf
2. Serpro. "Validador de CPF." https://www.serpro.gov.br/links-fixos-superiores/validador-cpf
3. Ministério da Fazenda. "História do CPF." https://www.gov.br/fazenda/pt-br/assuntos/receita-federal
4. Lei nº 4.862, de 29 de novembro de 1965. "Altera a legislação do impôsto de renda, adota diversas medidas de ordem fiscal e fazendária, e dá outras providências."