Kreditkartennummer in c überprüfen

Z

zuBlöd

Grünschnabel
Hallo,

ich soll ein Programm in c schreiben welches Kreditkartennummern überprüft und ein Kreditinstitut zuweist.
Hier der Prüfalgorithmus:
Schritt 1: Verdoppeln Sie den Wert jeder geraden Stelle, beginnen Sie von rechts.
Schritt 2: Ergibt das Produkt einen Wert größer 9 , dann
addieren Sie die Ziffern (Bsp. aus 18 wird1+8 =9) zu einem neuen Wert.
Schritt 3: Die Kartennummer ist plausibel, wenn die Quersumme aller neuen Ziffernwerte
10,20,30,40,50,….. ergibt!

So weit zum ersten teil der Aufgabe. Bitte versteht mich nicht falsch ich möchte nicht das einer für mich die ganze Programmierung übernimmt sondern Hilfestellungen bei der schrittweisen Vorgehensweise gibt sodass ich es auch verstehe( habe leider bei einigen Vorlesungen gefehlt).

Um die Nummer zu Speichern benutze ich ein String.
.
Code: 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
  char Z[19], A[19];    //A[] ist für die eingabe; Z[) zum normieren auf 20Stellen
  int i ;
  
  gets (A);
  
  Z[19-strlen(A)]='\0';          // versuch der normierung auf 20Stellen 
  strcat(Z,A);

  for (i=0; i<=19;i++){  //überprüfung der eingabe
 printf ("%c",A[i]);}


  system("PAUSE");	
  return 0;
}
Solange ich alle 20 Stellen fülle klappt es auch. Da es unterschiedliche längen von nummern gibt muss ich die eingegebene Nummer auf 20 Stellen normieren um von rechts anfangen zu können in gerade und ungerade Stellen zu unterscheiden. Aber genau das funktioniert nicht so wie ich es will. Da ich neu bin hoffe ich das alles soweit verständlich ist.

Hoffe jemand möchte mir helfen.
Gruß zuBlöd

edit:

OK hab die Lösung erstmal selber gefunden :
Code: 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
  char Z[]="00000000000000000000", A[20];    //A[] ist für die eingabe; Z[) zum normieren auf 20Stellen
  int i,j ;
  
  gets (A);
  
  Z[20-strlen(A)]='\0';          //  normierung auf 20Stellen 
  strcat(Z,A);
  

  for (i=0; i<=20;i++){  //überprüfung der eingabe
 printf ("%c",Z[i]);}


  system("PAUSE");	
  return 0;
}
Das Programm ist noch lange nicht fertig. Werde aber erstmal selber weiter machen bei Problemen melde ich mich wieder.
 
Problem !

So habe jetzt den Prüfalgoritmus zum Teil programmiert. Jetzt sollte das Programm eine Zahl(q) ausgeben welche, bei einer gültigen Kreditkartennummer(kurz: KKN), eine vielfache von 10 ist. Macht es aber nicht immer nur 0.
Code: 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
  char Z[]="00000000000000000000", A[20];    //A[] ist für die eingabe; Z[) zum normieren auf 20Stellen
  int i,q=0 ;
  
  gets (A);
  
  Z[20-strlen(A)]='\0';               //  normierung auf 20Stellen 
  strcat(Z,A);
  
  for (i=20; i=0;i--)
  {
      if (0 == i % 2)                     //gerade Stelle?
      {
          Z[i]=Z[i];                      //wenn ja dann unverändert 
      }
          else 
         {
           Z[i]= Z[i] *2;                 //ungerade stelle werden verdoppelt
             if (Z[i]>9)                  //ist sie dann größer 9 ?
             {
               Z[i]=Z[i]-9;                //wenn ja Quersumme
             }
                else                       //sonst unverändert
                {
                  Z[i]=Z[i];
                 }   
                    
         }
         q = q + Z[i];                      //ergebnis der Schleife
     }
          
  printf ("%d",q);                //überprüfung der eingabe


  system("PAUSE");	
  return 0;
}
Eine gultige KKN : ist z.B.:4111111111111111 dann sollte q=30 sein
Ich vermute meine Initialisierung(ist dieses Fachwort an dieser Stelle richtig?) von q in der Zeile 34 ist nicht richtig.
hoffe jemand kann mir helfen
Gruß
zuBlöd
 
Hi und Willkommen bei tutorials.de,

A[20] sollte A[21] sein, wenn du 20 Stellen und die Endnull speichern willst.

Bei der Schleife auf Zeile 15 wird die Bedingung i=0 nicht viel bringen.
Das wäre erstens eine Zuweisung vom Wert 0 (also Änderung der Variable statt Vergleich,
Vergleich ist ==) und zweitens wird die Schleife ausgeführt, "solange" die Bedingung wahr ist.
Wenn die Variable am Anfang 20 ist wird sie nicht gleich 0 sein.
Nimm >= statt == bzw. =

Folgender Teil (Zeilen 17-21):
C++: 
if (0 == i % 2)                     //gerade Stelle?
{
    Z[i]=Z[i];                      //wenn ja dann unverändert 
}
else
ist sinnlos, es wird ja eigentlich nichts gemacht.
Warum nicht einfach
C++: 
if (1 == i % 2)
bzw. geht auch einfach
C++: 
if (i % 2)
(Wenn kein konkreter Vergleich irgendeiner Art dasteht
wird der Code im if (etc.) dann ausgeführt, wenn der Wert der "Bedingung" nicht 0 ist)

Zeilen 28-31
C++: 
else                       //sonst unverändert
{
    Z[i]=Z[i];
}
kannst du komplett weglassen.
"Wenn das if nciht zutreffend war änder den Wert nicht"
Gut, aber das machts auf nicht, wenn du einfach kein else machst.

Und noch etwas Größeres zum Inneren der Schleife im Gesamten:
Schau dir die Tabelle hier mal an: http://www.asciitable.com/
Vor allem die Spalten Dec und Chr.
So,wie du mit Z umgehst wäre es für Nummern (int...) in Ordnung.
Z ist aber ein String. =Array aus char, welche eigentlich auch nur Nummern sind, ja.
Aber: Die Buchstaben etc., die man auf der Konsole anzeigen kann,
haben alle "ihre" spezielle Nummer zugeordnet, zu sehen in der Tabelle,
und für einen Buchstaben Chr ist die Nummer Dec drin gespeichert.
Wenn man schaut, wo die Ziffern sind...genau 0 ist 48, 1=49...
0 als Wert wäre das String-End-zeichen, 0 zum Anzeigen ist 48. Usw.
Du hast die Ziffern in ihrer Anzeigbar-Variante,
zum Rechnen damit musst du also aufpassen, dass du statt 0-9 48-57 hast.
An den passenden Stellen 48 abziehen bzw. addieren hilft...

Die Stelle, wo du nach Initialisierung fragst:
Eher nur eine (Wert-) Zuweisung.
Initialisierung wäre die Erstzuweisung einer Variable am Anfang,
zB. das "00000000000000000000" bei Z

Was dir jetzt noch fehlt ist die Prüfung, ob q am Schluss ein Vielfaches von 10 ist
Sonst...fertig, denke ich :)
 
OT:
Hab mal in einem video gesehen wie jemand sein programm schritt für schritt durchgehen konnten und dabei konnte er sehen wie die Variablen sich verändern(weiß jetzt nicht wie ich es besser beschreiben soll). 1. finde ich das video nicht mehr 2. glaub ich er hat gesagt er benutzt apple

Gibt es denn eine Programmieroberfläche(glaube das Fachwort ist anders) für windows die das kann.
Ich benutze dev c++ und habe auch visual studio 2012 (glaube Professionell oder so) ist mir aber zu kompliziert(oder ich bin [siehe Nickname]).
THX
 
Das Hilfsprogramm dafür nennt ich Debugger, gibts natürlich auch für Windows und Linux.
Visual Studio hat das Ganze schon drin:

(Die folgenden Sachen gibts auch alle als Symbole in der Symbolleiste,
nur weiß ich die Tastenkürzel besser, als ich die Bilder beschreiben kann)

Wenn du dein fertig kompiliertes Programm direkt aus VS heraus startest
(mit dem Grünen-Pfeil-Symbol oder der Taste F5)
bist du eigentlich schon automatisch im Debugging-Modus,
nur ohne dass du alles schrittweise durchgehst.

Wenn dich eine bestimmte Codestelle interessiert:
Setzt bei der ersten Zeile dieses Codeteils (oder etas davor) einen "Haltepunkt":
Mit dem Cursor in der Zeile drückst du F9, dann sollte links daneben
ein roter Punkt aufscheinen (nochmal F9 dort löscht ihn wieder).
(Du kannst beliebig viele Haltepunkte setzten, nicht nur einen.)
Wenn du das Programm jetzt mit F5 startest wird es normal ausgeführt,
bis es das erste Mal zu einem Haltepuntkt kommt.
Dort steckts dann erstmal.

Am unteren Fensterrand hast du Infos über die Variablen etc.,
es gibt auch noch mehr Zeug, dass man sich aus Platzgründen
am Bildschirm aber extra hin/wegschalten kann/muss.

Mit F10 oder F11 gehst du dann Zeile für Zeile durch,
kannst dabei die Variablenwerte beobachten usw.
(Haltepunkte ändern geht auch).
Der Unterschied zwischen F10 und F11:
Wenn ein Funktionsaufruf kommt: Will man die Funktion auch schrittweise durchgehen oder nicht.

Wenn man mit dem schrittweisen durchgehen fertig ist nochmal F5, damit alles wieder
zur Normalgeschwindigkeit geht (bis zum nächsten Haltepunkt oder zum Programmende).

Man muss übrigens keine Haltepunkte haben, man kann auch einfach mit F10/F11
direkt von der ersten Zeile weg schrittweise beginnen.
 
wow dickes THX an sheel

so eins nach dem anderen

wieso sollte A[20] denn A[21] sein um 20 Stellen abzulegen ich dachte es wird mit null angefangen zu zählen also A[19] beinhaltet die 20.Stelle und A[20] die Endnull oder habe ich das falsch verstanden

deine anderen Anregungen/Vorschläge versuche ich noch umzusetzen(wenn Probleme auftauchen melde ich mich nochmal)

zu OT.: doppel wow. ja super. also sollte ich mich doch noch mit VS anfreunden/beschäftigen (aber erst wenn ich mit diesem Projekt fertig bin). Behalte deinen Post aber im Hinterkopf
 
Wenn du ein A[4] machst hat das 4 Elemente:
A[0], A[1], A[2], A[3]

Der längstmögliche String hat Buchstaben in A[0],A[1],A[2] und das Endzeichen in A[3]
3 Buchstaben und das Endzeichen in einem A[4]
...also 19 Buchstaben + Endzeichen in einem A[20]

Wenn du wirklich 20 Buchstaben willst brauchst du ein A[21]
 
Und siehe da es funktioniert:
Code: 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
  char Z[]="000000000000000000000", A[21];    //A[] ist für die eingabe; Z[) zum normieren auf 20Stellen
  int i,q=0,h ;
  
  gets (A);
  
  Z[21-strlen(A)]='\0';               //  normierung auf 20Stellen 
  strcat(Z,A);
  
  for (i=20; i>=0;i--)       // gruss Sheel kleiner Fehler grosse wirkung!
  {
      if (0 == i % 2)                     //gerade Stelle?
      {
        Z[i]=Z[i]-48 ;
      }
          else 
         {
           Z[i]= (Z[i]-48) *2;            //ungerade stelle werden verdoppelt
             if (Z[i]>9)                  //ist sie dann größer 9 ?
             {
               Z[i]=Z[i]-9;                //wenn ja Quersumme
             }               
                    
          }
         q = q + Z[i];                      //ergebnis der Schleife
    }
    
    if (0 == q % 10)
    {
             printf ("gueltig\n");
     }
            else
            {
              printf ("ungueltig\n");                  
            }   

  system("PAUSE");	
  return 0;
}
Damit ist der erste Schritt geschafft, die Gültigkeit einer KKN kann überprüft werden.
D.h. es regnet Dankeschön für sheel ! !
Als nächstes müssen die KKN noch einem Kreditinstitut zugewiesen werden.
Aber wie gehabt probiere ich erstmal selber und Frage dann wenns Probleme gibt.
Gruß
zuBlöd
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück