લુહ્ન અલ્ગોરિધમનો ઉપયોગ કરીને સંખ્યાઓને માન્ય બનાવો અને જનરેટ કરો, જે સામાન્ય રીતે ક્રેડિટ કાર્ડ નંબરો, કેનેડિયન સામાજિક વીમા નંબરો અને અન્ય ઓળખાણ નંબરો માટે વપરાય છે. તપાસો કે કોઈ સંખ્યા લુહ્ન ચેક પાસ કરે છે કે નહીં અથવા અલ્ગોરિધમને અનુરૂપ માન્ય નંબરો જનરેટ કરો.
લુહ્ન અલ્ગોરિધમ, જેને "મોડ્યુલસ 10" અથવા "મોડ 10" અલ્ગોરિધમ તરીકે પણ ઓળખવામાં આવે છે, તે એક સરળ ચેકસમ ફોર્મ્યુલા છે જે વિવિધ ઓળખાણ નંબર, જેમ કે ક્રેડિટ કાર્ડ નંબર, કેનેડિયન સામાજિક સુરક્ષા નંબર, IMEI નંબર અને યુનાઇટેડ સ્ટેટ્સમાં નેશનલ પ્રોવાઇડર આઈડેન્ટિફાયર નંબરને માન્ય કરવા માટે ઉપયોગમાં લેવાય છે. આ કેલ્ક્યુલેટર તમને લુહ્ન અલ્ગોરિધમનો ઉપયોગ કરીને નંબરને માન્ય કરવા અને લુહ્ન ચેક પાસ કરનારા માન્ય નંબર જનરેટ કરવા માટેની મંજૂરી આપે છે.
લુહ્ન અલ્ગોરિધમ નીચે મુજબ કાર્ય કરે છે:
લુહ્ન અલ્ગોરિધમનું દૃશ્ય પ્રદર્શન અહીં છે:
લુહ્ન અલ્ગોરિધમને ગણિતીય રીતે નીચે મુજબ વ્યક્ત કરી શકાય છે:
ચાલો -મો ડિજિટ છે, જમણેથી ડિજિટ (ચેક ડિજિટને છોડી દેવા) અને ડાબી તરફ જતાં. પછી ચેક ડિજિટ એ તે રીતે પસંદ કરવામાં આવે છે કે:
જ્યાં મોડ્યુલો ઓપરેશન છે.
લુહ્ન અલ્ગોરિધમના વિવિધ ક્ષેત્રોમાં વિવિધ એપ્લિકેશન્સ છે:
જ્યારે લુહ્ન અલ્ગોરિધમ વ્યાપક રીતે ઉપયોગમાં લેવાય છે, ત્યારે વિવિધ હેતુઓ માટે અન્ય ચેકસમ અલ્ગોરિધમ્સ છે:
લુહ્ન અલ્ગોરિધમને હાન્સ પીટર લુહ્ને, એક આઈબીએમ કમ્પ્યુટર વૈજ્ઞાનિક, 1954 માં બનાવ્યું. લુહ્ન માહિતી વિજ્ઞાનના ક્ષેત્રમાં એક પાયોનિયર હતા અને તેમને ઘણા નવાં વિચારો માટે ક્રેડિટ આપવામાં આવે છે, જેમાં KWIC (કી વર્ડ ઇન કોન્ટેક્સ્ટ) ઇન્ડેક્સિંગ સિસ્ટમનો સમાવેશ થાય છે.
આ અલ્ગોરિધમ મૂળભૂત રીતે અકસ્માતની ભૂલો સામે સુરક્ષા માટે ડિઝાઇન કરવામાં આવ્યો હતો, દુષ્ટ હુમલાઓ માટે નહીં. નોંધનીય છે કે જ્યારે લુહ્ન અલ્ગોરિધમ ઘણી સામાન્ય ભૂલોને શોધી શકે છે, તે ડેટા સુરક્ષા માટે સુરક્ષિત સ્વરૂપ નથી અને આ માટે આધાર રાખવા માટે નથી.
તેની ઉંમર છતાં, લુહ્ન અલ્ગોરિધમ તેની સરળતા અને સામાન્ય ટ્રાન્સ્ક્રિપ્શન ભૂલોને પકડવામાંની અસરકારકતાને કારણે વ્યાપક રીતે ઉપયોગમાં લેવાય છે.
અહીં વિવિધ પ્રોગ્રામિંગ ભાષાઓમાં લુહ્ન અલ્ગોરિધમને અમલમાં મૂકવા માટે કેટલાક કોડ ઉદાહરણો છે:
1import random
2
3def luhn_validate(number):
4 digits = [int(d) for d in str(number)]
5 checksum = 0
6 for i in range(len(digits) - 1, -1, -1):
7 d = digits[i]
8 if (len(digits) - i) % 2 == 0:
9 d = d * 2
10 if d > 9:
11 d -= 9
12 checksum += d
13 return checksum % 10 == 0
14
15def generate_valid_number(length):
16 digits = [random.randint(0, 9) for _ in range(length - 1)]
17 checksum = sum(digits[::2]) + sum(sum(divmod(d * 2, 10)) for d in digits[-2::-2])
18 check_digit = (10 - (checksum % 10)) % 10
19 return int(''.join(map(str, digits + [check_digit])))
20
21## ઉદાહરણ ઉપયોગ:
22print(luhn_validate(4532015112830366)) # True
23print(luhn_validate(4532015112830367)) # False
24print(generate_valid_number(16)) # માન્ય 16-ડિજિટ નંબર જનરેટ કરે છે
251function luhnValidate(number) {
2 const digits = number.toString().split('').map(Number);
3 let checksum = 0;
4 for (let i = digits.length - 1; i >= 0; i--) {
5 let d = digits[i];
6 if ((digits.length - i) % 2 === 0) {
7 d *= 2;
8 if (d > 9) d -= 9;
9 }
10 checksum += d;
11 }
12 return checksum % 10 === 0;
13}
14
15function generateValidNumber(length) {
16 const digits = Array.from({length: length - 1}, () => Math.floor(Math.random() * 10));
17 const checksum = digits.reduce((sum, digit, index) => {
18 if ((length - 1 - index) % 2 === 0) {
19 digit *= 2;
20 if (digit > 9) digit -= 9;
21 }
22 return sum + digit;
23 }, 0);
24 const checkDigit = (10 - (checksum % 10)) % 10;
25 return parseInt(digits.join('') + checkDigit);
26}
27
28// ઉદાહરણ ઉપયોગ:
29console.log(luhnValidate(4532015112830366)); // true
30console.log(luhnValidate(4532015112830367)); // false
31console.log(generateValidNumber(16)); // માન્ય 16-ડિજિટ નંબર જનરેટ કરે છે
321import java.util.Random;
2
3public class LuhnValidator {
4 public static boolean luhnValidate(long number) {
5 String digits = String.valueOf(number);
6 int checksum = 0;
7 boolean isEven = true;
8 for (int i = digits.length() - 1; i >= 0; i--) {
9 int digit = Character.getNumericValue(digits.charAt(i));
10 if (isEven) {
11 digit *= 2;
12 if (digit > 9) digit -= 9;
13 }
14 checksum += digit;
15 isEven = !isEven;
16 }
17 return checksum % 10 == 0;
18 }
19
20 public static long generateValidNumber(int length) {
21 Random random = new Random();
22 long[] digits = new long[length - 1];
23 for (int i = 0; i < length - 1; i++) {
24 digits[i] = random.nextInt(10);
25 }
26 long checksum = 0;
27 for (int i = digits.length - 1; i >= 0; i--) {
28 long digit = digits[i];
29 if ((length - 1 - i) % 2 == 0) {
30 digit *= 2;
31 if (digit > 9) digit -= 9;
32 }
33 checksum += digit;
34 }
35 long checkDigit = (10 - (checksum % 10)) % 10;
36 long result = 0;
37 for (long digit : digits) {
38 result = result * 10 + digit;
39 }
40 return result * 10 + checkDigit;
41 }
42
43 public static void main(String[] args) {
44 System.out.println(luhnValidate(4532015112830366L)); // true
45 System.out.println(luhnValidate(4532015112830367L)); // false
46 System.out.println(generateValidNumber(16)); // માન્ય 16-ડિજિટ નંબર જનરેટ કરે છે
47 }
48}
49લુહ્ન અલ્ગોરિધમને અમલમાં મૂકતી વખતે, નીચેના કિનારા કેસ અને વિશેષ વિચારણાઓ પર ધ્યાન આપો:
ઇનપુટ માન્યતા: ખાતરી કરો કે ઇનપુટ માન્ય નંબર સ્ટ્રિંગ છે. નોન-ડિજિટ અક્ષરોને યોગ્ય રીતે સંભાળવું જોઈએ (કિંવાહ દૂર કરવું અથવા અમાન્ય ઇનપુટ તરીકે માનવું).
આગે વધતા ઝીરો: આ અલ્ગોરિધમ એ સંખ્યાઓ સાથે યોગ્ય રીતે કાર્ય કરવું જોઈએ જે આગે વધતા ઝીરો ધરાવે છે.
મોટા નંબર: કેટલીક પ્રોગ્રામિંગ ભાષાઓમાં માનક પૂર્ણાંક પ્રકારોની ક્ષમતા વધારી શકે છે તેવા ખૂબ લાંબા નંબરોને સંભાળવા માટે તૈયાર રહો.
ખાલી ઇનપુટ: તમારા અમલને ખાલી સ્ટ્રિંગ અથવા નલ ઇનપુટને કેવી રીતે સંભાળવું તે નિર્ધારિત કરો.
નોન-સ્ટાન્ડર્ડ અક્ષર સેટ: કેટલીક એપ્લિકેશન્સમાં, તમે માન્યતાને રજૂ કરવા માટે માન્યતાના 0-9 શ્રેણી બહારના અક્ષરોનો સામનો કરી શકો છો. આને કેવી રીતે સંભાળવું તે નિર્ધારિત કરો.
પ્રદર્શનના વિચારણા: જે એપ્લિકેશન્સને ઝડપથી ઘણાં ઇનપુટ્સને માન્ય કરવા માટે જરૂર છે, તે અલ્ગોરિધમ અમલને ઑપ્ટિમાઇઝ કરવા પર વિચાર કરો.
માન્ય ક્રેડિટ કાર્ડ નંબર:
અમાન્ય ક્રેડિટ કાર્ડ નંબર:
માન્ય કેનેડિયન સામાજિક સુરક્ષા નંબર:
અમાન્ય IMEI નંબર:
લુહ્ન અલ્ગોરિધમના અમલને માન્ય કરવા માટે, તમે નીચેના પરીક્ષણ કેસોનો ઉપયોગ કરી શકો છો:
1def test_luhn_algorithm():
2 assert luhn_validate(4532015112830366) == True
3 assert luhn_validate(4532015112830367) == False
4 assert luhn_validate(79927398713) == True
5 assert luhn_validate(79927398714) == False
6
7 # જનરેટ કરેલા નંબરોનું પરીક્ષણ
8 for _ in range(10):
9 assert luhn_validate(generate_valid_number(16)) == True
10
11 print("બધા પરીક્ષણો સફળ થયા!")
12
13test_luhn_algorithm()
14