import javax.swing.JOptionPane;
public class Würfel implements Codec {
private String codeword;
/** Die Losung, die zur Ent- bzw Verschluesselung verwendet wird */
String losung;
/** Die aequivalenten ASCII Werte der Losung */
int[] charWerteDerLosung;
/** Die alphabetische Reihenfolge der Buchstaben der Losung, beginnend ab null */
int[] losungStrukturiert;
/*
* Methode zur Permutationsrechnung
* @return Gibt die Permutation aus
*
*/
public int [] Losung(String codeword){
codeword = codeword.toLowerCase();
int zaehler = 1;
int[] zahlenlosung = new int[codeword.length()];
//Durchläuft den String von a bis z
for (int i = 'a'; i <= 'z'; i++) {
/*Überprüfung ob der Inhalt (a bis z) an der entsprechenden
Stelle des Strings vorliegt +*/
for (int n = 0; n < codeword.length(); n++) {
if(codeword.charAt(n) == i){
zahlenlosung[n] = zaehler;
zaehler++;
}
}
}
return zahlenlosung;
}
@Override
/*
* Verschlüsselt den Klartext mit der Permutation des Codewortes
*
* @pre Klartext liegt als String vor
* @param klartext: Der Klartext der als String vorliegt
* @return Liefert den Text als koodierten Text
*/
public String kodiere(String klartext) {
int [] zahlenlosg = Losung(klartext);
int laengeLosung = zahlenlosg.length;
//Neuer Stringarray mit Länge der Länge des Schlüsselwortes
String[] verTeil = new String[laengeLosung];
for (int i = 0; i < verTeil.length; i++) {
verTeil[i] = "";
}
for (int i = 0; i < klartext.length(); i++) {
//TeilString wird mit neuer Chiffe zusätzlich belegt
verTeil[zahlenlosg[i%laengeLosung]-1] = verTeil[zahlenlosg[i%laengeLosung]-1]+klartext.charAt(i);
}
String verText = "";
for (String s : verTeil) {
verText = verText+s;
}
return verText;
}
@Override
/*
*
* Dekodiert den Geheimtext mit dem Schlüsselwort
* @pre Geheimtext liegt als String vor
* @param geheimtext: Geheimtext als String
* @return Den Dekodierten Text
*
*/
public String dekodiere(String geheimtext) {
StringBuilder klartext = new StringBuilder();
nummeriereLosungAlphabetisch();
int losungslaenge = losung.length();
int geheimtextLaenge = geheimtext.length();
int zeilen = (int) Math.floor(geheimtextLaenge / losungslaenge);
int letzterIndex = zeilen * losungslaenge;
int pos = 0;
int anzahlChars = 0;
int[] nullBasierteZuordnungGeheimText = new int[geheimtextLaenge];
strukturiereNummerierteLosungNullbasiert();
//berechne Zeilenposition der einzelnen Buchstaben
for(int i=0;i<losungslaenge;i++){ //Iteriere ueber das geheimtext Array bis zum aktuellen Wert des permutationsIndex Arrays
for(int j=0;j<zeilen;j++){ //Iteriere jeweils nur %zeilen% Stellen des geheimtext Arrays weit und fuege nullbasierte Wertzuordnungen ein
nullBasierteZuordnungGeheimText[pos] = i;
pos++;
}
}
if(geheimtextLaenge > letzterIndex){
pos = 0;
//Füge Indizes der nächsten Zeile hinzu
for(int i=letzterIndex; i<nullBasierteZuordnungGeheimText.length;i++){
nullBasierteZuordnungGeheimText[i] = losungStrukturiert[pos]; //position in geheimTextArray, die ersetzt werden muss
pos++;
}
sortierePermutation(nullBasierteZuordnungGeheimText);
}
if(geheimtextLaenge-letzterIndex > 0 ) zeilen++;
int[][] altevsneuePos = new int[geheimtextLaenge][3];
int position=0;
int zusatz=0;
//Schreibe geheimtext zeilenweise auf
for(int k=0;k<zeilen;k++){
for(int j=0;j<losungStrukturiert.length;j++){
if(anzahlChars>=geheimtextLaenge){ //Abfrage, ob das Ende des Geheimtextes erreicht ist, wenn ja, dann abbruch
j=losungslaenge;
}else{
altevsneuePos[position][2] = zusatz;
pos = ((zeilen-1)*losungStrukturiert[j])+zusatz; //Ungefaehre Position des naechsten Zeichens
altevsneuePos[position][0] = pos;
while(nullBasierteZuordnungGeheimText[pos]!=losungStrukturiert[j]&&pos<geheimtextLaenge)pos++; //Exakte Position des naechsten Zeichens
altevsneuePos[position][1] = pos;
int noetigeSchritte = (altevsneuePos[position][1]-altevsneuePos[position][0]);
if(noetigeSchritte>=500)zusatz=zusatz+480;
position++;
klartext.append(geheimtext.charAt(pos));
anzahlChars++;
nullBasierteZuordnungGeheimText[pos] = -1; //Zeichen auf -1 setzen, damit er beim naechsten Durchlauf uebersprungen wird
}
}
}
return klartext.toString();
}
@Override
/*
* Holt die Zahlenlosung
*
* @pre Codewort muss als String vorliegen
* @param codeword: Codewort als String
* @return Liefert die Permutation als Zahlenlosung
*/
public String gibLosung() {
int[] Losung = this.Losung(codeword);
//Rückgabe der Zahlenlosung
return Losung.toString();
}
@Override
/*
* Methode zum setzen der Losung/Codeworts
* @pre Codeword muss als String vorliegen
* @param schlüssel: Das entsprechende Codeword als Schlüsse
* @throws eine IllegalArgumentException wenn das Codeworlänger als 26 Zeichen ist
* @return Setzen des Codewords
*
*/
public void setzeLosung(String schlüssel) throws IllegalArgumentException {
try {
if (schlüssel.length()>26 || schlüssel.length()==0){
throw new IllegalArgumentException("e");
}
} catch (Exception e) {
JOptionPane.showMessageDialog(null,"Fehler: Codeword zu lang oder 0", "Fehler", JOptionPane.ERROR_MESSAGE);
}
this.codeword=schlüssel;
}
/**
* Implementiert einen InsertionSort zur numerischen Sortierung eines Integer Arrays.
*
* @param a Ein beliebig langes Integer Array, welches sortiert werden soll.
*/
private void sortierePermutation(int[] a){
int i = 0, j = 0, t = 0;
for (i=1; i<a.length; i++)
{
j=i;
t=a[j];
while (j>0 && a[j-1]>t)
{
a[j]=a[j-1];
j--;
}
a[j]=t;
}
}
/**
* Nummeriert die Losung abhaengig von ihrer alphabetischen Position und speichert ihre char-Werte.
*/
private void nummeriereLosungAlphabetisch(){
charWerteDerLosung = new int[losung.length()];
int j = 0;
for(char c='a';c<='z';c++){
for(int i=0;i<losung.length();i++){
if (c == losung.charAt(i)){
charWerteDerLosung[j++] = c;
}
}
}
}
/**
* Verwendet die char Werte aus nummeriereLosung() und vergibt die Werte nullbasiert neu.
*/
private void strukturiereNummerierteLosungNullbasiert(){
losungStrukturiert = new int[losung.length()];
for(int i=0;i<losung.length();i++){
for(int k=0;k<charWerteDerLosung.length;k++){
if(losung.charAt(i) == charWerteDerLosung[k]){
losungStrukturiert[i] = k;
charWerteDerLosung[k] = 0;
k = charWerteDerLosung.length;
}
}
}
}
}
