String text = "DieserTextsollchiffriertwerden";
String chiffriert = caesarVer(text, 3);
println(chiffriert);
public String caesarVer(String s, int k) {
String klartext = s.toUpperCase(); // Alles in Grossbuchstaben umwandeln
String geheimtext = "";
int key = k % 26; // Schluessel ueber 25 sind nicht noetig
int ktzeichen;
int gtzeichen;
for (int i = 0; i < klartext.length(); i++) {
ktzeichen = (int) klartext.charAt(i);
if(ktzeichen + key <= 90) {
gtzeichen = ktzeichen + key;
} else {
gtzeichen = ktzeichen + key - 26;
}
geheimtext = geheimtext + (char) gtzeichen; // ASCII in char umwandeln
}
return geheimtext;
}
// Hier caesarEnt ergaenzen
// Hier vigenereVer ergaenzen
// public String vigenereVer(String s, String k) {
// s in Grossbuchstaben umwandeln
// Zeichenketten für den Geheimtext und den key speichern
// Mit einer Schleife zeichenweise die Zeichenkette durchlaufen
// Variable fuer das aktuelle KT-Zeichen initialisieren
// Variable fuer das aktuelle Schluesselzeichen initialisieren, wobei man den Index mit % anpasst
// Umwandeln in die ASCII-Werte dieser beiden Zeichen und speichern
// Verschiebung durchführen
// Pruefen, ob man ueber das Z hinausgeht und gegebenenfalls zuruecksetzen
// Rückgabe des Ergebnisses
//}
// Hier vigenereEnt ergaenzen
// Hier kasiskiTeilen ergaenzen
// public String[] kasiskiTeilen(String s, int k) {
// Umwandeln von s in Großbuchstaben
// Schlüssellänge speichern
// String-Array "block" mit so vielen Plaetzen, wie es Teilstrings gibt, erstellen
// Fuellen eines Arrays mit leeren Strings, damit man spaeter etwas anhaengen kann
// Mit einer Schleife die Anzahl der Blöcke oft durchlaufen (index i)
// Mit einer inneren Schleife beim Index der äußerden starten,
// den Geheimtext durchlaufen und nach jedem Durchlauf den Index so erhöhen,
// dass man eine Schlüssellänge weitergeht.
// In jedem Schritt der inneren Schleife das aktuelle Zeichen an den i-ten Block
// der Reihung "block" anhängen.
// Ergebnis zurückgeben
//}
// Bestimmt aus den durch kasiskiTeilen erzeugten Teilstrings (je Position des Schlüssels)
// mittels Häufigkeitsanalyse das jeweilige Schlüsselzeichen (Annahme: häufigstes Klartextzeichen = 'E').
// Liefert den kompletten Schlüssel als String zurück.
// public String kasiskiKey(String[] s) {
// leeren String für key setzen und anschließend alle Zeichen in S zu Großbuchstaben konvertieren
// leeres 2d-int-Array "anzahl" zum Zaehlen der Haeufigkeiten mit "Anzahl der Blöcke" Zeilen und 26 Spalten anlegen.
// Index (Zeile 0,Spalte 0) fuer A des 1. Blocks, (1,0) fuer A des 2. Blocks, (0,1) fuer B des 1. Blocks,...
// In den Zeilen sollen die Haeufigkeiten von A bis Z fuer die Strings in s stehen
// "anzahl" mit 0en füllen
// Mit einer Schleife die s durchlaufen (Index i)
// Mit einer inneren Schleife die Spalten von s durchlaufen (Index j)
// ((int)(s[i].charAt(j))) ist der ASCII-Wert des aktuellenZeichens
// der aktuellen Spalte. Subtrahiere 65 und der Wert passt genau zum
// Spaltenindex für das jeweilige Zeichen in anzahl.
// Erhöhe damit an der i-ten Stelle die Zeichenhäufigkeit in anzahl.
// Jetzt wird der häufigste Buchstabe in jedem Block ermittelt
// Mit einer Schleife die Zeilen von anzahl durchgehen (Index i)
// Setze in jedem Schritt die Häufigkeit anzahl[i][0] als Maxmimum
// Ermittle den (char)(max + 65) den ASCII-Wert des aktuellen Maximums und speichere diesen
// Mit einer inneren Schleife die 26 Spalten der i-ten Zeile durchgehen (Index j)
// Prüfe in jedem Schritt, ob anzahl[i][j] > max.
// Wenn ja, setzte das max auf den neuen Wert.
// if(j >= 5) {
// keypart = (char)((j - 5) + 65); // Schluesselzeichen berechnen
// }
// else {
// keypart = (char)(28 - j + 65); // Schluesselzeichen berechnen, wenn es ueber das z hinausgeht
// }
//}
//}
// Hänge keypart an key an
//}
// Rückgabe von key
//}
// public String kasiskiKey(String[] s) {
// String key = "";
// int blocks = s.length;
// for (int i = 0; i < blocks; i = i + 1) {
// String block = s[i];
// if(block == null) {
// block = "";
// } else {
// block = block.toUpperCase();
// }
// // Häufigkeiten der Buchstaben A..Z ermitteln
// int[] freq = new int[26];
// for (int j = 0; j < 26; j = j + 1) {
// freq[j] = 0;
// }
// for (int j = 0; j < block.length(); j = j + 1) {
// char c = block.charAt(j);
// if((int) c >= 65 && (int) c <= 90) {
// int idx = c - 65;
// int tmp = freq[idx];
// tmp = tmp + 1;
// freq[idx] = tmp;
// } else {
// // andere Zeichen ignorieren
// }
// }
// // Index des häufigsten Buchstabens finden
// int maxIndex = 0;
// int maxCount = freq[0];
// for (int j = 1; j < 26; j = j + 1) {
// if(freq[j] > maxCount) {
// maxCount = freq[j];
// maxIndex = j;
// } else {
// // nichts tun, nur verschachtelte if-Struktur verwenden
// if(freq[j] == maxCount) {
// // bei Gleichstand belassen wir den ersten (stabil)
// }
// }
// }
// // Falls kein Buchstabe vorhanden ist (maxCount == 0), setze Schlüsselzeichen auf 'A' (kein Shift)
// if(maxCount == 0) {
// key = key + (char) 65;
// } else {
// // Annahme: am wahrscheinlichsten ist im Klartext 'E' (Index 4)
// int plainIndex = 4;
// int keyIndex = maxIndex - plainIndex;
// if(keyIndex < 0) {
// keyIndex = keyIndex + 26;
// } else {
// // verschachtelter else-Block: nichts weiter nötig
// }
// int charCode = 65 + keyIndex;
// key = key + (char) charCode;
// }
// }
// return key;
// }
// public String xor(String s, String k) {
// Leere Zeichenketten geheim und key initialisieren
// Wenn der Schlüssel größer als der Klartext ist, mit einer Schleife den
// Schlüssel so ändern, dass nur die Zeichen bis zur Länge von s bleiben,
// Sonst: Mit einer Schleife die Schlüsselzeichen ans Ende des Schlüssels
// wieder anhängen. Hierfür wird k.charAt(i % k.length()) hilfreich sein.
//
// Mit einer Schleife s durchlaufen.
// Die aktuellen Zeichen von s und key speichern.
// Die ASCII-Werte von diesen Zeichen speichern
// int und = x1 & x2; // gemeinsame Einsen ermitteln
// int x = x1 + x2 - 2 * und; // XOR berechnen (Identität: x1 + x2 = (x1 ^ x2) + 2*(x1 & x2))
// String s1 = Integer.toBinary(x); // Zeichenkette mit der Dualdarstellung des aktuellen Geheimzeichens erstellen
//
// Da alle ASCII-Dualzahlen 8-stellig sind aber bei Integer.toBinary fuehrende Nullen nicht vorhanden sind,
// gegebenenfalls mit so vielen Nullen vorne auffuellen, wie zur Länge 8 fehlen.
// Dafür mit einer Schleife 8-s1.length() mal an den bisherigen Geheimtext eine 0 hängen.
// Anschließend mit einer weiteren Schleife die Einsen von s1 anhängen.
// Abschließend ein Leerzeichen an geheim anhängen, für bessere Lesbarkeit.
// Rückgabe des Ergebnisses;
// }
// public int[] permutationErstellen(int n) {
// Neue Ganzzahlreihung per der Groesse n deklarieren
// Dynamische Reihung d1 initialisieren.
// Mit einer Schleife die Zahlen von 1 bis n in d1 eintragen (Index i).
// Mit einer weiteren Schleife n-mal eine Zufallszahl zwischen 1 und der aktuellen
// Länge von d1 erzeugen.
// An die i-te Stelle von per den Inhalt der j-ten Stell von d1 stecken.
// Das j-te Element aus d1 entfernen.
// Rückgabe von per
// }
// public String permutationVer(String s, int[] p) {
// Leere Zeichenkette fuer Geheimtext initialisieren
// Mit einer Schleife s blockweises durchlaufen in p.length() Schritten (Index i)
// Mit einer inneren Schleife p durchlaufen (Index j)
// Index fuer das Zeichen (p[j] -1), welches an die aktuelle Position soll, unter einer Variablen speichern
// Zeichen an die Zeichenkette anhaengen
// Rückgabe der Zeichenkette
// }
// public String permutationEnt(String s, int[] p) {
// // int-Array fuer die inverse Permutation initialisieren
// // for-Schleife zum Fuellen des Arrays mit der inversen Permutation
// // Variable fuer die innere Schleife
// // index fuer die innere Schleife
// //index zum Durchlaufen der Permutation p
// // while-Schleife zum Suchen aller Zahlen, beginnend bei 1, dann 2 usw.
// // Suche nach zunaechst 1, dann 2 usw.
// // Wenn die gesuchte Stelle gefunden wurde, in die inverse Permutation eintragen
// // Abbruch und naechste Zahl suchen (Man sucht erst die 1, dann die 2 usw.)
// // Naechstes Zeichen der Permutation im naechsten while-Schleifendurchlauf betrachten
// // permutationver mit dem Geheimtext und der inversen Permutation ausfuehren
// }
// public String desVer(String s, String k, int[] p) {
// Zeichenketten fuer den linken und den rechten Teil des Klartextes deklarieren und leer initialisieren.
// Zeichenketten fuer die neue linke und neue rechten Haefte deklarieren und leer initialisieren.
// Zeichenkette fuer den Geheimtext deklarieren und leer initialisieren.
// Zeichenketten fuer die beiden Schluessel deklarieren und leer initialisieren.
// Wir durchlaufen mit einer Schleife s und bearbeiten in jedem Durchlauf die
// aktuellen acht Zeichen.
// Mit einer Schleife den linken Teil des Klartextes aufbauen.
// Mit einer Schleife den rechten Teil des Klartextes aufbauen.
// Mit einer oder zwei Schleife die beiden Schlüsselhälften aufbauen.
// Permutation auf die rechte Klartexthaelfte anwenden.
// XOR auf das Ergebnis von oben anwenden.
// Die neue rechte Haelfte mit einer weiteren XOR-Verschluesselung erzeugen.
// Die neue linke Haefte erzeugen.
// Die obigen Schritte ein zweites Mal mit dem anderen Schluesselteil durchfuehren.
// den neuen Geheimtext für die nächste Runde zusammensetzen.
// Rückgabe des Ergebnisses
// }