# Entschlüsselungsproblem (Caesar)



## Moonflyer (25. Nov 2006)

Hey Leute,

im Studium programmieren wir gerade eine Caesar Verschlüsselung.

Hier nochmal kurz die Aufgabe:


> Das Verfahren:
> Ein Zeichen des Klartexts wird durch Verschieben um einen Wert a im Alphabet verschlüsselt. Das
> Verschieben der Buchstaben erfolgt dabei zyklisch.
> Beispiel:
> ...



Das Verschlüsseln klappt prima, auch über die "Grenzen" hinaus. (Z wird zu C, Y zu B...).
Ich betrachte dabei quasi erst einmal die Zeichen, die simpel zu verschieben sind und dann die Zeichen am Ende des Alphabets, die gesondert betrachtet werden müssen.

```
public String verschluessele(String s){

   s = s.toUpperCase();                                    // UPPERCASE
   char[] k = s.toCharArray();                             // Umwandeln in char-Array

   for (int i=0; i<s.length(); i++) {
     char c = s.charAt(i);                                 // Jedes einzelnes char-Element wird angewählt

     if(((int)(c) >= 65) && ((int)(c) <= (90-a))){         // "Normale" Erhöhung des ASCII-Wertes um a
       c = (char)((int)(c) + a);
       k[i] = c;
     }
     else if (((int)(c) >(90-a)) && ((int)(c) <=90)){      // Sonderregel für das Überschreiten der Grenze
       c = (char)(a-(90-(int)(c))+64);
       k[i] = c;
     }
   }
   s = new String(k);
   return s;
 }
```

Die Entschlüsselung müsste ja eigentlich genauso nur andersrum funktionieren.
Jedoch hab ich ein Problem mit dem "über die Grenze verschieben".

```
public String entschluessele(String s){

   s = s.toUpperCase();                                    // UPPERCASE
   char[] k = s.toCharArray();                             // Umwandeln in char-Array

   for (int i=0; i<s.length(); i++) {
     char c = s.charAt(i);                                 // Jedes einzelnes char-Element wird angewählt

     if(((int)(c) >= (65+a)) && ((int)(c) <= (90))){         // "Normale" Erniedrigung des ASCII-Wertes um a
       c = (char)((int)(c) - a);
       k[i] = c;
     }
     else if (((int)(c) >= 65) && ((int)(c) <(65+a))){      // Sonderregel für das Überschreiten der Grenze
       
>>   c = (char)(a-(65-(int)(c))+90); << HIER KOMM ICH NICHT ZURECHT

       k[i] = c;
     }
   }
   s = new String(k);
   return s;
 }
```

Ich hab die Stelle markiert, die nicht funktioniert. Irgendwie versagt mein Verstand dabei. Kann sich das bitte einer anschauen ?

Danke


----------



## SlaterB (25. Nov 2006)

zunächst mal: kannst du nicht c statt (int) (c) schreiben? scheint mir syntaktisch erlaubt,
wenn nicht, dann definiere dir doch eine Hilfsvariable
int cc = (int) c;

im Moment ist dein Code ja unlesbar..

-----------

Verchlüsseln:
c = (char)((int)(c) + a);
also
c = (char)(c + a);

beim Überlauf:
c = (char)(a-(90-(int)(c))+64); 
also
c = (char)(a-(90-c)+64); 

das ist unnötig kompliziert geschrieben, mache es lieber so wie oben und subtrahiere 26 für den Überlauf
c = (char)(c + a - 26);

---------

mit diesen Vereinfachungen fällt dir vielleicht auch das Entschlüsseln leichter,

ansonsten: Code weiter vereinfachen,
verschlüssle doch erstmal ein Zeichen statt so vieler auf einmal (for-Schleife fällt weg),
dann nimm für a einen festen Wert, a = 10,

und dann male dir notfalls per Hand auf, was für a, b, c usw. rauskommen soll,
wenn du dann immer noch nicht die Formel siehst, dann kannst du ja fragen,
aber so? versuche es doch lieber selber, sei froh, so ein extrem einfaches Problem zu haben


----------



## Moonflyer (25. Nov 2006)

Danke Slater.

Ich habs dann selbst hingekriegt. Ich war wohl etwas übereifrig in Sachen klammern und Castings


----------



## Gelöschtes Mitglied 5909 (26. Nov 2006)

man sollte doch auch mit a-z rechnen können?
oder geht des in java nich? in c++ gehts, macht die sache noch ein wenig einfacher und auch lesbarer wie ich finde


----------

