પરીક્ષણના ઉદ્દેશ્ય માટે માન્ય, રેન્ડમ CPF (કેડાસ્ટ્રો ડે પેસોઆસ ફિઝિકાસ) નંબર જનરેટ કરો. આ સાધન એવા CPF બનાવે છે જે બ્રાઝિલીયન સત્તાવાર ફોર્મેટ અને માન્યતા નિયમોનું પાલન કરે છે, કોઈપણ વાસ્તવિક વ્યક્તિગત માહિતીનો ઉપયોગ કર્યા વિના.
CPF (Cadastro de Pessoas Físicas) એ બ્રાઝિલના નાગરિકો અને નિવાસીઓને કર માટે અનન્ય ઓળખકર્તા છે. આ જનરેટર પરીક્ષણના હેતુઓ માટે માન્ય, રેન્ડમ CPF નંબરો બનાવે છે. નોંધવું મહત્વપૂર્ણ છે કે આ જનરેટ કરેલા CPF વાસ્તવિક વ્યક્તિઓ સાથે જોડાયેલા નથી અને માત્ર પરીક્ષણના પર્યાવરણમાં જ ઉપયોગમાં લેવાયા જોઈએ છે.
CPF 11 આંકડાઓમાં બનેલું છે:
આ ફોર્મેટ સામાન્ય રીતે આ રીતે દર્શાવવામાં આવે છે: XXX.XXX.XXX-XX
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જનરેટર નીચેના પગલાંઓને અનુસરે છે:
અહીં કેટલાક જનરેટ કરેલા CPF ના ઉદાહરણો છે:
CPF જનરેટર વિવિધ સોફ્ટવેર વિકાસ અને પરીક્ષણના દ્રષ્ટિકોણમાં ઉપયોગી છે:
જ્યારે CPF બ્રાઝિલમાં મુખ્ય વ્યક્તિની ઓળખકર્તા છે, ત્યારે કેટલાક વિશિષ્ટ સંદર્ભોમાં અન્ય ઓળખકર્તાઓનો ઉપયોગ થઈ શકે છે:
CPF બ્રાઝિલમાં 1965માં દેશના કર પ્રણાલીને આધુનિક બનાવવાના વ્યાપક પ્રયાસનો એક ભાગ તરીકે રજૂ કરવામાં આવ્યો હતો. પ્રારંભમાં, તેનો ઉપયોગ મુખ્યત્વે આવક કર માટે કરવામાં આવ્યો હતો, પરંતુ સમય સાથે, તેનો ઉપયોગ બ્રાઝિલીયન બ્યુરોક્રસી અને વેપારના વિવિધ અન્ય ક્ષેત્રોમાં વિસ્તૃત થયો.
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"Generated CPF: {cpf}")
23print(f"Is valid: {validate_cpf(cpf)}")
241function 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(`Generated CPF: ${cpf}`);
25console.log(`Is valid: ${validateCPF(cpf)}`);
261import 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("Generated CPF: " + cpf);
50 System.out.println("Is valid: " + validateCPF(cpf));
51 }
52}
53આ ઉદાહરણો Python, JavaScript, અને Java માં CPF જનરેટ અને માન્ય કરવા માટેના કોડને દર્શાવે છે. તમે આ કાર્યને તમારા વિશિષ્ટ જરૂરિયાતો માટે અનુકૂળ બનાવી શકો છો અથવા CPF હેન્ડલિંગની જરૂરિયાત ધરાવતી મોટી પ્રણાલીઓમાં તેને એકીકૃત કરી શકો છો.
જનરેટ કરેલા CPF નો ઉપયોગ કરતી વખતે, નીચેના મુદ્દાઓને ધ્યાનમાં રાખવું મહત્વપૂર્ણ છે:
તમારા વર્કફ્લો માટે ઉપયોગી થવાના વધુ સાધનો શોધો