1def calculate_verification_digit(type_code, dni):
2    # ਸਟਰਿੰਗ ਵਿੱਚ ਬਦਲੋ ਅਤੇ ਯਕੀਨੀ ਬਣਾਓ ਕਿ DNI 8 ਅੰਕਾਂ ਵਿੱਚ ਹੈ ਜਿਸ ਵਿੱਚ ਅਗੇ ਦੇ ਜ਼ੀਰੋ ਹਨ
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # ਟਾਈਪ ਕੋਡ ਅਤੇ DNI ਨੂੰ ਜੋੜੋ
7    digits = type_code_str + dni_str
8    
9    # ਹਰ ਪੋਜ਼ੀਸ਼ਨ ਲਈ ਭਾਰ
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # ਉਤਪਾਦਾਂ ਦੇ ਜੋੜ ਦੀ ਗਣਨਾ ਕਰੋ
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ ਦੀ ਗਣਨਾ ਕਰੋ
16    verification_digit = 11 - (sum_products % 11)
17    
18    # ਖਾਸ ਮਾਮਲੇ
19    if verification_digit == 11:
20        verification_digit = 0
21    elif verification_digit == 10:
22        verification_digit = 9
23    
24    return verification_digit
25
26def generate_cuit_cuil(type_code, dni=None):
27    import random
28    
29    # ਸਹੀ ਟਾਈਪ ਕੋਡ
30    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
31    
32    if type_code not in valid_type_codes:
33        raise ValueError(f"ਗਲਤ ਟਾਈਪ ਕੋਡ। ਇਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ: {valid_type_codes}")
34    
35    # ਜੇ ਨਾ ਦਿੱਤਾ ਗਿਆ ਤਾਂ ਯਾਦਗਾਰ DNI ਬਣਾਓ
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ ਦੀ ਗਣਨਾ ਕਰੋ
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # CUIT/CUIL ਦਾ ਫਾਰਮੈਟ
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # ਹਾਈਫਨ ਹਟਾਓ ਜੇ ਉਪਸਥਿਤ ਹੋ
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # ਬੁਨਿਆਦੀ ਫਾਰਮੈਟ ਦੀ ਜਾਂਚ ਕਰੋ
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "ਗਲਤ ਫਾਰਮੈਟ"
52    
53    # ਹਿੱਸੇ ਕੱਢੋ
54    type_code = int(cuit_cuil_clean[0:2])
55    dni = int(cuit_cuil_clean[2:10])
56    verification_digit = int(cuit_cuil_clean[10])
57    
58    # ਟਾਈਪ ਕੋਡ ਦੀ ਵੈਰੀਫਿਕੇਸ਼ਨ ਕਰੋ
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "ਗਲਤ ਟਾਈਪ ਕੋਡ"
62    
63    # ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ ਦੀ ਗਣਨਾ ਅਤੇ ਤੁਲਨਾ ਕਰੋ
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "ਗਲਤ ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ"
67    
68    return True, "ਸਹੀ CUIT/CUIL"
69
70# ਉਦਾਹਰਣ ਵਰਤੋਂ
71print(generate_cuit_cuil(20, 12345678))  # ਵਿਸ਼ੇਸ਼ DNI ਲਈ ਜਨਰੇਟ ਕਰੋ
72print(generate_cuit_cuil(27))  # ਯਾਦਗਾਰ DNI ਨਾਲ ਜਨਰੇਟ ਕਰੋ
73print(validate_cuit_cuil("20-12345678-9"))  # CUIT/CUIL ਦੀ ਵੈਰੀਫਿਕੇਸ਼ਨ ਕਰੋ
74

1function calculateVerificationDigit(typeCode, dni) {
2  // ਸਟਰਿੰਗ ਵਿੱਚ ਬਦਲੋ ਅਤੇ ਯਕੀਨੀ ਬਣਾਓ ਕਿ DNI 8 ਅੰਕਾਂ ਵਿੱਚ ਹੈ ਜਿਸ ਵਿੱਚ ਅਗੇ ਦੇ ਜ਼ੀਰੋ ਹਨ
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // ਟਾਈਪ ਕੋਡ ਅਤੇ DNI ਨੂੰ ਜੋੜੋ
7  const digits = typeCodeStr + dniStr;
8  
9  // ਹਰ ਪੋਜ਼ੀਸ਼ਨ ਲਈ ਭਾਰ
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // ਉਤਪਾਦਾਂ ਦੇ ਜੋੜ ਦੀ ਗਣਨਾ ਕਰੋ
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ ਦੀ ਗਣਨਾ ਕਰੋ
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // ਖਾਸ ਮਾਮਲੇ
22  if (verificationDigit === 11) {
23    verificationDigit = 0;
24  } else if (verificationDigit === 10) {
25    verificationDigit = 9;
26  }
27  
28  return verificationDigit;
29}
30
31function generateCuitCuil(typeCode, dni) {
32  // ਸਹੀ ਟਾਈਪ ਕੋਡ
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`ਗਲਤ ਟਾਈਪ ਕੋਡ। ਇਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // ਜੇ ਨਾ ਦਿੱਤਾ ਗਿਆ ਤਾਂ ਯਾਦਗਾਰ DNI ਬਣਾਓ
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ ਦੀ ਗਣਨਾ ਕਰੋ
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // CUIT/CUIL ਦਾ ਫਾਰਮੈਟ
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // ਹਾਈਫਨ ਹਟਾਓ ਜੇ ਉਪਸਥਿਤ ਹੋ
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // ਬੁਨਿਆਦੀ ਫਾਰਮੈਟ ਦੀ ਜਾਂਚ ਕਰੋ
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'ਗਲਤ ਫਾਰਮੈਟ' };
58  }
59  
60  // ਹਿੱਸੇ ਕੱਢੋ
61  const typeCode = parseInt(cuitCuilClean.substring(0, 2));
62  const dni = parseInt(cuitCuilClean.substring(2, 10));
63  const verificationDigit = parseInt(cuitCuilClean.substring(10, 11));
64  
65  // ਟਾਈਪ ਕੋਡ ਦੀ ਵੈਰੀਫਿਕੇਸ਼ਨ ਕਰੋ
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'ਗਲਤ ਟਾਈਪ ਕੋਡ' };
69  }
70  
71  // ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ ਦੀ ਗਣਨਾ ਅਤੇ ਤੁਲਨਾ ਕਰੋ
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'ਗਲਤ ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ' };
75  }
76  
77  return { isValid: true };
78}
79
80// ਉਦਾਹਰਣ ਵਰਤੋਂ
81console.log(generateCuitCuil(20, 12345678)); // ਵਿਸ਼ੇਸ਼ DNI ਲਈ ਜਨਰੇਟ ਕਰੋ
82console.log(generateCuitCuil(27)); // ਯਾਦਗਾਰ DNI ਨਾਲ ਜਨਰੇਟ ਕਰੋ
83console.log(validateCuitCuil("20-12345678-9")); // CUIT/CUIL ਦੀ ਵੈਰੀਫਿਕੇਸ਼ਨ ਕਰੋ
84

1import java.util.Arrays;
2import java.util.List;
3import java.util.Random;
4
5public class CuitCuilUtils {
6    private static final List<Integer> VALID_TYPE_CODES = Arrays.asList(20, 23, 24, 27, 30, 33, 34);
7    private static final int[] WEIGHTS = {5, 4, 3, 2, 7, 6, 5, 4, 3, 2};
8    
9    public static int calculateVerificationDigit(int typeCode, int dni) {
10        // ਸਟਰਿੰਗ ਵਿੱਚ ਬਦਲੋ ਅਤੇ ਯਕੀਨੀ ਬਣਾਓ ਕਿ DNI 8 ਅੰਕਾਂ ਵਿੱਚ ਹੈ ਜਿਸ ਵਿੱਚ ਅਗੇ ਦੇ ਜ਼ੀਰੋ ਹਨ
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // ਟਾਈਪ ਕੋਡ ਅਤੇ DNI ਨੂੰ ਜੋੜੋ
15        String digits = typeCodeStr + dniStr;
16        
17        // ਹਰ ਪੋਜ਼ੀਸ਼ਨ ਲਈ ਭਾਰ
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ ਦੀ ਗਣਨਾ ਕਰੋ
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // ਖਾਸ ਮਾਮਲੇ
27        if (verificationDigit == 11) {
28            verificationDigit = 0;
29        } else if (verificationDigit == 10) {
30            verificationDigit = 9;
31        }
32        
33        return verificationDigit;
34    }
35    
36    public static String generateCuitCuil(int typeCode, Integer dni) {
37        if (!VALID_TYPE_CODES.contains(typeCode)) {
38            throw new IllegalArgumentException("ਗਲਤ ਟਾਈਪ ਕੋਡ। ਇਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ: " + VALID_TYPE_CODES);
39        }
40        
41        // ਜੇ ਨਾ ਦਿੱਤਾ ਗਿਆ ਤਾਂ ਯਾਦਗਾਰ DNI ਬਣਾਓ
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ ਦੀ ਗਣਨਾ ਕਰੋ
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // CUIT/CUIL ਦਾ ਫਾਰਮੈਟ
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // ਹਾਈਫਨ ਹਟਾਓ ਜੇ ਉਪਸਥਿਤ ਹੋ
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // ਬੁਨਿਆਦੀ ਫਾਰਮੈਟ ਦੀ ਜਾਂਚ ਕਰੋ
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "ਗਲਤ ਫਾਰਮੈਟ");
61        }
62        
63        // ਹਿੱਸੇ ਕੱਢੋ
64        int typeCode = Integer.parseInt(cuitCuilClean.substring(0, 2));
65        int dni = Integer.parseInt(cuitCuilClean.substring(2, 10));
66        int verificationDigit = Integer.parseInt(cuitCuilClean.substring(10, 11));
67        
68        // ਟਾਈਪ ਕੋਡ ਦੀ ਵੈਰੀਫਿਕੇਸ਼ਨ ਕਰੋ
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "ਗਲਤ ਟਾਈਪ ਕੋਡ");
71        }
72        
73        // ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ ਦੀ ਗਣਨਾ ਅਤੇ ਤੁਲਨਾ ਕਰੋ
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "ਗਲਤ ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ");
77        }
78        
79        return new ValidationResult(true, null);
80    }
81    
82    public static class ValidationResult {
83        private final boolean isValid;
84        private final String errorMessage;
85        
86        public ValidationResult(boolean isValid, String errorMessage) {
87            this.isValid = isValid;
88            this.errorMessage = errorMessage;
89        }
90        
91        public boolean isValid() {
92            return isValid;
93        }
94        
95        public String getErrorMessage() {
96            return errorMessage;
97        }
98    }
99    
100    public static void main(String[] args) {
101        // ਉਦਾਹਰਣ ਵਰਤੋਂ
102        System.out.println(generateCuitCuil(20, 12345678)); // ਵਿਸ਼ੇਸ਼ DNI ਲਈ ਜਨਰੇਟ ਕਰੋ
103        System.out.println(generateCuitCuil(27, null)); // ਯਾਦਗਾਰ DNI ਨਾਲ ਜਨਰੇਟ ਕਰੋ
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // CUIT/CUIL ਦੀ ਵੈਰੀਫਿਕੇਸ਼ਨ ਕਰੋ
105    }
106}
107

1<?php
2
3function calculateVerificationDigit($typeCode, $dni) {
4    // ਸਟਰਿੰਗ ਵਿੱਚ ਬਦਲੋ ਅਤੇ ਯਕੀਨੀ ਬਣਾਓ ਕਿ DNI 8 ਅੰਕਾਂ ਵਿੱਚ ਹੈ ਜਿਸ ਵਿੱਚ ਅਗੇ ਦੇ ਜ਼ੀਰੋ ਹਨ
5    $typeCodeStr = (string)$typeCode;
6    $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT);
7    
8    // ਟਾਈਪ ਕੋਡ ਅਤੇ DNI ਨੂੰ ਜੋੜੋ
9    $digits = $typeCodeStr . $dniStr;
10    
11    // ਹਰ ਪੋਜ਼ੀਸ਼ਨ ਲਈ ਭਾਰ
12    $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
13    
14    // ਉਤਪਾਦਾਂ ਦੇ ਜੋੜ ਦੀ ਗਣਨਾ ਕਰੋ
15    $sumProducts = 0;
16    for ($i = 0; $i < 10; $i++) {
17        $sumProducts += (int)$digits[$i] * $weights[$i];
18    }
19    
20    // ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ ਦੀ ਗਣਨਾ ਕਰੋ
21    $verificationDigit = 11 - ($sumProducts % 11);
22    
23    // ਖਾਸ ਮਾਮਲੇ
24    if ($verificationDigit == 11) {
25        $verificationDigit = 0;
26    } else if ($verificationDigit == 10) {
27        $verificationDigit = 9;
28    }
29    
30    return $verificationDigit;
31}
32
33function generateCuitCuil($typeCode, $dni = null) {
34    // ਸਹੀ ਟਾਈਪ ਕੋਡ
35    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
36    
37    if (!in_array($typeCode, $validTypeCodes)) {
38        throw new Exception("ਗਲਤ ਟਾਈਪ ਕੋਡ। ਇਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ: " . implode(', ', $validTypeCodes));
39    }
40    
41    // ਜੇ ਨਾ ਦਿੱਤਾ ਗਿਆ ਤਾਂ ਯਾਦਗਾਰ DNI ਬਣਾਓ
42    if ($dni === null) {
43        $dni = rand(10000000, 99999999);
44    }
45    
46    // ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ ਦੀ ਗਣਨਾ ਕਰੋ
47    $verificationDigit = calculateVerificationDigit($typeCode, $dni);
48    
49    // CUIT/CUIL ਦਾ ਫਾਰਮੈਟ
50    return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit);
51}
52
53function validateCuitCuil($cuitCuil) {
54    // ਹਾਈਫਨ ਹਟਾਓ ਜੇ ਉਪਸਥਿਤ ਹੋ
55    $cuitCuilClean = str_replace('-', '', $cuitCuil);
56    
57    // ਬੁਨਿਆਦੀ ਫਾਰਮੈਟ ਦੀ ਜਾਂਚ ਕਰੋ
58    if (!preg_match('/^\d{11}$/', $cuitCuilClean)) {
59        return ['isValid' => false, 'errorMessage' => 'ਗਲਤ ਫਾਰਮੈਟ'];
60    }
61    
62    // ਹਿੱਸੇ ਕੱਢੋ
63    $typeCode = (int)substr($cuitCuilClean, 0, 2);
64    $dni = (int)substr($cuitCuilClean, 2, 8);
65    $verificationDigit = (int)substr($cuitCuilClean, 10, 1);
66    
67    // ਟਾਈਪ ਕੋਡ ਦੀ ਵੈਰੀਫਿਕੇਸ਼ਨ ਕਰੋ
68    $validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
69    if (!in_array($typeCode, $validTypeCodes)) {
70        return ['isValid' => false, 'errorMessage' => 'ਗਲਤ ਟਾਈਪ ਕੋਡ'];
71    }
72    
73    // ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ ਦੀ ਗਣਨਾ ਅਤੇ ਤੁਲਨਾ ਕਰੋ
74    $calculatedDigit = calculateVerificationDigit($typeCode, $dni);
75    if ($calculatedDigit !== $verificationDigit) {
76        return ['isValid' => false, 'errorMessage' => 'ਗਲਤ ਵੈਰੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਿਟ'];
77    }
78    
79    return ['isValid' => true];
80}
81
82// ਉਦਾਹਰਣ ਵਰਤੋਂ
83echo generateCuitCuil(20, 12345678) . "\n"; // ਵਿਸ਼ੇਸ਼ DNI ਲਈ ਜਨਰੇਟ ਕਰੋ
84echo generateCuitCuil(27) . "\n"; // ਯਾਦਗਾਰ DNI ਨਾਲ ਜਨਰੇਟ ਕਰੋ
85var_dump(validateCuitCuil("20-12345678-9")); // CUIT/CUIL ਦੀ ਵੈਰੀਫਿਕੇਸ਼ਨ ਕਰੋ
86?>
87