# Zeichen aus Strings auslesen und in zweidimensionalen Reihungen positionieren



## Samara84 (5. Jan 2017)

Hallo,
ich sitze seit Tagen an einer Hausaufgabe und komme bei einem Schritt nicht weiter. Vielleicht kann mir ja hier jemand ein Denkanstoß geben. (Es gab hier schon ähnliche Fragen, allerdings habe ich noch nichts gefunden, was mein Problem lösen könnte.)
Aufgabe ist folgende:
Benutzer soll ein Wort/Satz über die Eingabe eingeben. Dieser Satz soll in einer zweidimensionalen Reihung wiedergegeben werden. Die Matrix für das Array bestimmt der Benutzer über Schlüssel 1 und Schlüssel zwei. So weit habe ich das hinbekommen. 
Der Satz soll über Schlüssel1 (Zeilen) und Schlüssel2 (Spalten) in eine Matrix aufgeteilt werden.

Ich kriege den Satz nicht so angeordnet, wie auf dem Bild.





Hier meine Klasse:

```
public class Codierung {
   
    private int zeilen;
    private int spalten;
   
    public Codierung(int pZeilen, int pSpalten) {
       
        zeilen = pZeilen;
        spalten = pSpalten;
       
    }
   
    private void codierteMatrixAusgeben(char[][] pCodierteMatrix) {

        System.out.println("Die codierte Matrix:");
       
        for (int i = 0; i < zeilen; i++)
        {
            for (int j = 0; j < spalten; j++)
            {
                System.out.print(pCodierteMatrix[i][j]);
            }
        }

    }
   
    private char[][] nachrichtInReihungSpeichern(String pNachricht) {
       
        char[][] text = new char[zeilen][spalten];
        int index = 0;
        if (pNachricht.length() < (zeilen * spalten)) {
            Random rnd = new Random();
            for (int i = pNachricht.length(); i < (zeilen * spalten); i++) {
               
                pNachricht += (char) (48 + rnd.nextInt(122-48));
            }
        }
        for (int i = 0; i < zeilen; i++) {
            for (int j = 0; j < spalten; j++) {

                text[i][j] = pNachricht.charAt(index);
                index++;
            }
        }
        return text;
    }
       
   
   
    public String verschluessleText(String klarText) throws IllegalArgumentException{
       
       
        if ((zeilen * spalten) < klarText.length())
            throw new IllegalArgumentException("Zu viele Zeichen. Bitte die Zeichen reduzieren.");
       
        char[][] text = nachrichtInReihungSpeichern(klarText);
        codierteMatrixAusgeben(text);
        String codierterText = verschluesseltenTextAuslesen(text);

        return codierterText;
    }
   
    private String verschluesseltenTextAuslesen(char[][] pCodierteMatrix) {
       
        String codierterText = "";

        for (int i = 0; i < zeilen; i++)
        {
            for (int j = 0; j < spalten; j++)
            {
                codierterText += pCodierteMatrix[i][j];
            }
        }

        return codierterText;
       
    }
   
}
```

und hier meine Testklasse:


```
public class CodierungTest {

    public static void main(String[] args) throws IOException{
           
       
             String codierteNachricht;
           
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
           
            System.out.println("Geben Sie den zu verschlüsselnden Text ein:");
            String nachricht = br.readLine();
            System.out.println();
           
            System.out.println("Schlüssel 1 (Zeilen) : ");
            String zeilen = br.readLine();
            int schluessel1 = Integer.parseInt(zeilen);
            System.out.println();
           
            System.out.println("Schlüssel 2 (Spalten): ");
            String spalten = br.readLine();
            int schluessel2 = Integer.parseInt(spalten);
            System.out.println();
           
           
            nachricht = nachricht.replaceAll(" ", "");


            Codierung verschluesselung = new Codierung(schluessel1, schluessel2);
           
            System.out.println(codierteNachricht = verschluesselung.verschluessleText(nachricht) + "\n");
           
            System.out.println("Ihr eingegebener Text in verschlüsselter Form:");
            System.out.println(codierteNachricht);
   
    }

}
```

Das ist meine Ausgabe:


```
Geben Sie den zu verschlüsselnden Text ein:
Du hast zwei Versuche

Schlüssel 1 (Zeilen) :
5

Schlüssel 2 (Spalten):
5

Die codierte Matrix:
DuhastzweiVersuche0BHeYkZDuhastzweiVersuche0BHeYkZ

Ihr eingegebener Text in verschlüsselter Form:
DuhastzweiVersuche0BHeYkZ
```


----------



## Samara84 (5. Jan 2017)

Das (erste) Problem der kodierten Matrix liegt wohl in diesem Abschnitt:

```
private char[][] nachrichtInReihungSpeichern(String pNachricht) {
       
        char[][] text = new char[zeilen][spalten];
        int index = 0;
        if (pNachricht.length() < (zeilen * spalten)) {
            Random rnd = new Random();
            for (int i = pNachricht.length(); i < (zeilen * spalten); i++) {
               
                pNachricht += (char) (48 + rnd.nextInt(122-48));
            }
        }
       
        for (int i = 0; i < zeilen; i++) {
            for (int j = 0; j < spalten; j++) {
               
                text[i][j] = pNachricht.charAt(index);
                index++;
            }
        }
        return text;
    }
```

Wie kriegt man es hin, dass der String in die Zeilen eingeteilt wird? Das fehlt wohl noch etwas in der inneren for Schleife, oder liege ich da komplett daneben?


----------



## Libentis (5. Jan 2017)

```
public static void main(String[] args) {
        String text = "Lösung Einsendeaufgabe ZKT-E2";
        text = text.replaceAll(" ", "");
        char[][] c = new char[7][4];
        int pos = 0;
        for(int i=0; i<7; i++) {
            for(int j=0; j<4; j++) {
                if(pos >= text.length())
                    c[i][j] = '€';
                else
                    c[i][j] = text.charAt(pos++);
            }
        }
      
        for(int i=0; i<7; i++) {
            System.out.println();
            for(int j=0; j<4; j++) {
                System.out.print(c[i][j]);
            }
        }
      
    }
```
Funktioniert bei mir problemlos.
Die letzte Zahl(8) bei dir im Bild ist zufällig geniert. Bei mir ist das jetzt einfach das € Zeichen.


----------



## Samara84 (5. Jan 2017)

Ja, das läuft auch bei mir ohne Probleme .. Ich habe jetzt folgenden Abschnitt mit einem Zeilenumbruch ergänzt und die Matrix funktioniert auch wie Sie soll. Allerdings tritt jetzt das nächste Problem auf und zwar, dass unter der Matrix eine zusätzliche Ausgabe der gesamten Matrix aber eindimensional erzeugt wird..
Wie bekomme ich die eindimensionale Ausgabe weg?


```
private void codierteMatrixAusgeben(char[][] pCodierteMatrix) {

        System.out.println("Die codierte Matrix:");
        System.out.println();
       
        for (int i = 0; i < zeilen; i++)
        {
            for (int j = 0; j < spalten; j++)
            {
                System.out.print(pCodierteMatrix[i][j]);
            }
            System.out.println();
        }

    }
```

Ausgabe:


```
Geben Sie den zu verschlüsselnden Text ein:
Das ist jetzt ein neuer Versuch

Schlüssel 1 (Zeilen) :
6

Schlüssel 2 (Spalten):
6

Die codierte Matrix:

Dasist
jetzte
inneue
rVersu
chf@LA
[QWCGK
DasistjetzteinneuerVersuchf@LA[QWCGK

Ihr eingegebener Text in verschlüsselter Form:
DasistjetzteinneuerVersuchf@LA[QWCGK
```


----------



## Samara84 (5. Jan 2017)

OK. Das habe ich auch lösen können. Jetzt fehlt mir nur noch, dass die kodierte Matrix spaltenweise von oben nach unten in einem String (unter: Ihr eingegebener Text in verschlüsselter Form) ausgegeben wird.

Aufgabenstellung: Der verschlüsselte Text ergibt sich durch das spaltenweise Auslesen der gefüllten Reihung.

tja... Kann mir da mal jemand ein Denkanstoß geben bitte?


----------



## Libentis (5. Jan 2017)

Ist doch garnicht so schwer.
Nehmen wir als Beispiel mal die normale Ausgabe die ich dir vorhin geschickt habe.

```
for(int i=0; i<7; i++) {
            for(int j=0; j<4; j++) {
                System.out.print(c[i][j]);
            }
            System.out.println();
        }
```
Wir haben 2 For Schleifen. Eine für die Zeilen(die Äußere) und eine zweite für die Spalten(Innere). Wir fangen an, indem wir für die 1. Zeile alle zugehörigen Werte in der j. Spalte nacheinander ausgeben. Sprich die gesamte Zeile. Danach gehen wir eine Zeile weiter und geben diese aus. Und so weiter und so fort. Ich denke, dass du das nocht verstanden hast, oder?

Wenn ich das jetzt richtig verstanden habe wollen wir jetzt nicht die ganze Zeile, sondern immer die ganze Spalte ausgeben und anschließend eine Spalte weiter gehen. Also im Prinzip das selbe in grün. Probiers mal


----------



## Samara84 (5. Jan 2017)

Top. Ich danke dir!! Damit hats jetzt funktioniert.

```
private String verschluesseltenTextAuslesen(char[][] pCodierteMatrix) {
       
        String codierterText = "";

        for (int i = 0; i < spalten; i++){
           
            for (int j = 0; j < zeilen ; j++){
               
                codierterText += pCodierteMatrix[j][i];
               
            }
           
        }

        return codierterText;
       
    }
```

Ausgabe:

```
Geben Sie den zu verschlüsselnden Text ein:
Jetzt funktioniert alles wie es soll!

Schlüssel 1 (Zeilen) :
7

Schlüssel 2 (Spalten):
7

Die codierte Matrix:

Jetztfu
nktioni
ertalle
swieess
oll!w11
y=7iHJe
JJF8Yda

Ihr eingegebener Text in verschlüsselter Form:
JnesoyJekrwl=Jtttil7Fziae!i8tolewHYfnls1Jduies1ea
```


----------



## Libentis (5. Jan 2017)

Kein Ding


----------

