בדיקת תקינות מספרי אשראי

[אליהו פריד]

מישהו מכם מכיר נוסחאות לבדיקת תקינות מספרי אשראי??

 

[דאלארס]

תמקד את השאלה, אולי נוכל לעזור.

 

[אליהו פריד]

בא ניקח מספרי זהות, ח.פ וכו', כתבתי קוד שבודק האם המספר תקין.
הנוסחאה היא קלה
עושים כך
121212121
031790496
מכפילים כל ספרה עם הספרה מעל ומצמצמים (צימצום הכוונה שערך 15 = 6....1+5=6
כעת מחברים את כל הספרות יחד, אם התוצאה חלקי 10 משאיר שארית של 0 אז המספר תקין, ואם לאו אז לא.
אני צריך כנ"ל למספרי אשראי.

 

[דאלארס]

יש כאן
וגם כאן

 

[אריה123]

מישהו יודע על נוסחה לבדיקה של ישראכרט מקומי ?

 

[אריה123]

הסתדרתי.

ואם זה מעניין מישהו, אז:
http://halemo.net/info/isracard/index.html

 

[3 פינות]

תגיד לי אליהו פריד איך פתחת דיון בתור אורח?!
פעם ראשונה שאני רואה כזה דבר.

 

[eliezer]

בא ניקח מספרי זהות, ח.פ וכו', כתבתי קוד שבודק האם המספר תקין.
הנוסחאה היא קלה
עושים כך
121212121
031790496
מכפילים כל ספרה עם הספרה מעל ומצמצמים (צימצום הכוונה שערך 15 = 6....1+5=6
כעת מחברים את כל הספרות יחד, אם התוצאה חלקי 10 משאיר שארית של 0 אז המספר תקין, ואם לאו אז לא.
אני צריך כנ"ל למספרי אשראי.

אולי יועיל:
http://www.sqlserver.co.il/?p=5728

או זה:
http://halemo.net/info/creditcard/index.html

 

[עיטורים פלוס]

ראה כאן...

הקישור תוקן...
סליחה

 

[עיטורים פלוס]

מקווה שהנתונים דלהלן אכן מעודכנים...
מהקישור דלעיל

צפה בקובץ המצורף 230789
צפה בקובץ המצורף 230790
צפה בקובץ המצורף 230791

 

[עיטורים פלוס]

תיקון טעות:
שימו לב: ויזה וישראכרט זה לא אותו חוק אימות!
מה נכון?

 

[אליהו פריד]

Function Zimzum( V:Byte) : Byte;
Var
 S : String;
 V1,V2 : Byte;
Begin
  S := IntToStr(V);
  If Length(S) = 1 Then Begin Result := V;Exit;End;
  V1 := StrToInt(S[1]);
  V2 := StrToInt(S[2]);
  Result := V1+V2;
End;
Function IsZehutValid (S:shortString) : Boolean;
Const
 CS : Array[1..9] Of Byte = (1,2,1,2,1,2,1,2,1);
Var
 Mult : Array[1..9] Of Byte;
 Sum : Byte;
 Tot : Byte;
 X : Byte;
Begin
 FillChar (Mult,SizeOf(Mult),#0);
 If Length(S) <> 9 Then Begin Result := False;Exit;End;
 For X := 1 To 9 Do Mult[X] := Zimzum(StrToInt(S[X])*CS[X]);
 Tot := 0;
 For X := 1 To 9 Do Tot := Tot + Mult[X];
 Result := Tot Mod 10 = 0;
End;
 
Function CardMiskal (N : String) : TCType;
Var
 X : Byte;
 S : String;
 vType : Byte;
 Len : Byte;
Begin
 FillChar (Result,SizeOf(Result),#0);
 If N='' Then Exit ;
 vType := 0;
 If Length(N)=8  Then vType := 1;
 If Length(N)=9  Then vType := 1;
 If VType=1 Then Len:=9;

   IF N[1] = '4' Then Begin vType := 3;Len:=16;End;
   If N[2] In ['1'..'5'] = True Then
   If N[1] = '5' Then Begin vType := 2;Len := 16;End;
   If (N[1]='3')And(N[2] In['0','6','8']) Then Begin vType := 4;Len:=14;End;
   If (N[1]='3')Or(N[1]='2') Then
   If (N[2]='7') Then Begin vType := 5; Len :=15;End;
   Result.vType := VType;
   Result.Len := Length(N);
   Result.IsOk := vType <> 0;
   Result.Divition := 10;
   Result.Len := Len;
   S := '';
   For X := 1 To Length(N) Do
    If Odd(X) Then S := S +'2' Else S := S + '1';
    If Length(N) In [8,9] Then
    Begin
    S := '';
    For X := 9 DownTo 1 Do S := S + IntToStr(X);
    Result.Divition := 11;
    End;
   Result.Miskal := S;
End;

Function IsCreditValid (S:shortString;Len:Byte) : Boolean;
Const
 AL : Array[1..16] Of Byte = (2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1);
 AE : Array[1..15] Of Byte = (1,2,1,2,1,2,1,2,1,2,1,2,1,2,1);
Var
 Mult : Array[1..16] Of Byte;
 Sum : Byte;
 Tot : Byte;
 X : Byte;
Begin
 FillChar (Mult,SizeOf(Mult),#0);
 If Length(S) > 16 Then Begin Result := False;Exit;End;
 If Len In [14,16] Then
 For X := 1 To Length(S) Do Mult[X] := Zimzum(StrToInt(S[X])*AL[X]);
 If Len = 15 Then
 For X := 1 To Length(S) Do Mult[X] := Zimzum(StrToInt(S[X])*AE[X]);
 Tot := 0;
 For X := 1 To Length(S) Do Tot := Tot + Mult[X];
 Result := Tot Mod 10 = 0;
End;

Function IsIsraCardValid (S:String) : Boolean;
Const
 CS : Array[1..9] Of Byte = (9,8,7,6,5,4,3,2,1);
Var
 Mult : Array[1..9] Of Byte;
 Sum : Byte;
 Tot : Byte;
 X : Byte;
Begin
 If Length(S)=8 Then S := '0'+S;
 FillChar (Mult,SizeOf(Mult),#0);
 If Length(S) <> 9 Then Begin Result := False;Exit; End;
 For X := 1 To 9 Do
 Begin
 Tot := StrToInt(S[X]);
 Mult[X] := Tot*CS[X];
 End;
 Tot := 0;
 For X := 1 To 9 Do Tot := Tot + Mult[X];
 Result := Tot Mod 11 = 0;
End;