# Char Feld -> "Zeilenumbruch"



## Berger345 (9. Nov 2007)

Hallo liebe Forummitglieder!

Ich zerreiße mir schon seit stunden den Kopf über meine Programmierhausübung. Folgende Lösung muss ich erstellen:
Implementieren Sie eine Methode void alignText(char[] text, int width), die den im
Parameter text enthaltenen Text linksbündig aligniert in die Konsole ausgibt, wobei
die Spaltenbreite width zu berücksichtigen ist. text enthält Wörter (Folge von
zusammenhängenden Buchstaben) und Leerzeichen, die die Wörter trennen.
Zwischen zwei Wörtern ist genau ein Leerzeichen. Jede Zeile wird bis zu width mit
ganzen Wörtern aufgefüllt. Hat ein Wort nicht mehr Platz, wird es in der nächsten
Zeile ausgedruckt. Ist ein Wort länger als width wird es ohne Trennzeichen
umgebrochen.

Nunja, ich habe schon mehrere verschiedene Versuche gestartet und die, die bisher am "besten" funktioniert hat, stelle ich hier rein:


```
public class EPRUE0603 
{
	static void alignText(char[] text, int width)
	{
		int save = width;
		
		char[] temp = new char[text.length];
		int wText = -1;
		
		while(wText < text.length)
		{
			int n = 0; 
			wText +=1;

			while(text[wText+n] != ' ' && text[wText+n] != '.')
			{
				temp[n] = text[wText+n];
				n++;
			}
			
			wText = wText + n;

			if(n <= width)
			{
				print(temp, n);
				width = width - n;
			} else {
				System.out.println(); //Umbruch
				print(temp, n);
				width = save;
			}
			
		}
	}
	
	
	static void print(char[] word, int length)
	{
		for(int i = 0; i < length; i++)
				System.out.print(word[i]);
	}
	
	public static void main(String[] args)
	{
		char[] text = { 
				'I','m','p','l','e','m','e','n','t','i','e','r','e','n',' ',
				'S','i','e',' ','e','i','n','e',' ','M','e','t','h','o','d','e','.' 
		};
		
		
		alignText(text, 6);
	}
}
```

Hier die Ausgabe der Konsole:
// Umbruch
ImplementierenSie
eine
MethodeException in thread "main" java.lang.ArrayIndexOutOfBoundsException: 32
	at EPRUE0603.make(EPRUE0603.java:16)
	at EPRUE0603.main(EPRUE0603.java:56)


Die Out of Bounce Exception bekommen ich wohl wegen dem Punkt.

Irgendwie funktionierts leider noch nicht ganz. ich wieß nicht, wie ich die Zerlegung eines Wortes, dass länger ist als width bewergstelligen soll. Ich muss ja wissen, wieviel in der nächsten Zeile dann noch übrig ist.

Oder gehe ich das komplett falsch an und sollte alles nochmal neu schreiben? und wenn ja, wie?

Danke im Vorraus!


----------



## DocRandom (10. Nov 2007)

Moin Berger!

Ich hab mir erlaubt, Deinen Code etwas umzuschleiben.
Hier das Ergebnis:

```
package berger345;

public class EPRUE0603 {
   
	static void alignText(char[] text, int width) {
	
		// Indexvariable für das Wort
		int i = 0;
		// Zaehlvariable fuer die Schleife
		int zeichen = 0;
		// Array mit der Laenge von width
		char[] word = new char[width];
		
		// solange es Zeichen gibt
		while( zeichen < text.length) {
			word[i] = text[zeichen];
			i++;
			zeichen++;
			// ist die Wortlänge erreicht?
			if (i == width) {
				i = 0;
				// Wort ausgeben
				System.out.println(word);
				// Wort löschen
				for(int x = 0; x < width; x++) {
					word[x] = ' ';
				}
			}
		}
		// das letze Wort ausgeben, falls vorhanden
		System.out.println(word);
   }
	
   
   public static void main(String[] args)
   {
      char[] text = {
            'I','m','p','l','e','m','e','n','t','i','e','r','e','n',' ',
            'S','i','e',' ','e','i','n','e',' ','M','e','t','h','o','d','e','.'
      };
      
      
      alignText(text, 5);
   }
}
```

lg
DocRandom


----------



## Berger 234 (10. Nov 2007)

Danke für deine Antwort! So eine ähnliche Grundstruktur hatte ich bei meiner ersten Lösung auch, nur darf ich Wörter, die nicht mehr in die Zeile passen, nicht einfach abschneiden, sondern muss sie in die nächste Zeile schreiben (solange das Gesamtwort die Breite (width) nicht im ganzen überschreitet.

Hier mal ein Beispiel zur Veranschaulichung: Breite der Zeile 5
TAKE THE DOG FOR A WALK.

Ausgabe:
TAKE |
THE |
DOG |
FOR A|
WALK.|

| = soll ende der Zeile signalisieren.


Hab das ganze noch einmal geschrieben, nur ein wenig abgeändert und besser kommentiert:


```
public class Main {

    static void make(char[] text, int width) {
        int save = width;

        for (int i = 0; i < text.length; i++) { // Durchlaufen des textarrays
            if (wordLength(text, i) <= width) { // Überprüfen, ob die Textlänge kleiner ist als die Zeilenbreite
                printWord(text, i, wordLength(text, i)); // ja: Wort Ausgeben
                width = width - wordLength(text, i); // Zeilenbreite akutallisieren 
                i = i + wordLength(text, i); // Durchlaufindex des textarrays hochzählen (aktueller durchlauf + die wortlänge)
            } else {
                System.out.println(); // nein: zeilenumbruch und ausgabe
                printWord(text, i, (i + wordLength(text, i)));
                width = save; // breite auf ursprüngliche breite setzen
                i = (i + wordLength(text, i)) + 1; // Durchlaufindex des textarrays hochzählen (aktueller durchlauf + die wortlänge) 
            }
        }
    }

    
    /**
     * Wort ausgeben mit Leerzeichen
     */
    static void printWord(char[] text, int idxLow, int idxHigh) {
        while (idxLow < (idxHigh + 1)) {
            System.out.print(text[idxLow]);
            idxLow++;
        }
    }
    
    
    /**
     * Länge des Wortes wird zurückgegeben. 
     */
    static int wordLength(char[] text, int idx) {
        while (text[idx] != ' ') {
            idx++;
        }

        return idx;
    }

    public static void main(String[] args) {
        char[] text = {'I', 'm', 'p', 'l', 'e', 'm', 'e', 'n', 't', 'i', 'e', 'r', 'e', 'n', ' ',
                'S', 'i', 'e', ' ', 'e', 'i', 'n', 'e', ' ', 'M', 'e', 't', 'h', 'o', 'd', 'e', '.'};
        make(text, 15);
    }
}
```


hier die ausgabe:

run:
Implementieren 
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 32
        at epr.Main.printWord(Main.java:38)
        at epr.Main.make(Main.java:28)
        at epr.Main.main(Main.java:55)
Sie eine Methode.
Java Result: 1
BUILD SUCCESSFUL (total time: 0 seconds)


Ich hoffe es ist jetzt ein wenig verständlicher. Ich frage mich jedoch, warum das Programm "Sie eine Methode" in eine Zeile ausgiebt, obwohl die Breite 15 schon längst überschritten wurde.

Danke im Vorraus!


----------



## Berger 234 (11. Nov 2007)

Ok, nach langem überlegen, bin ich draufgekommen, dass eine Abarbeitung einer Zeile von hinten viel einfacher ist.

Deswegen habe ich deinen Vorschlag noch einmal genauer durchdacht. Ich suche mir jetzt einfach das letzte leerzeichen im array word und lösche alle zeichen, die danach kommen. dabei überprüfe ich, ob das nächste zeichen, im array text auch noch ein leerzeichen ist -> wenn ja, kann ich array word einfach als ganzes ausgeben, wenn nicht, schreibe ich das abgeschnittene in die nächste zeile. (ich passe den index zeichen neu an)

ich schätze mal, dass es im Groben funktioniert, jedoch stimmt meine ausgabe noch nicht 100%. weiß jemand woran das liegen könnte, dass er mir bei "Sie", dass S schreibt, bei "eine" das E aber nicht ausgibt? Bei Methode das gleiche.

run-single:
Imple
menti
eren 
Sie  
ine  
ethod
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 32
        at epr.EPRUE0603.alignText(EPRUE0603.java:26)
        at epr.EPRUE0603.main(EPRUE0603.java:110)
Java Result: 1
BUILD SUCCESSFUL (total time: 0 seconds)

Danke für eure Hilfe!


```
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package epr;

/**
 *
 * @author Berger
 */
public class EPRUE0603 
{
    static void alignText(char[] text, int width) 
    {
        // Zaehlvariable fuer die Schleife
        int zeichen = 0;
        // Array mit der Laenge von width
        char[] word = new char[width];

        // solange es Zeichen gibt
        while (zeichen < text.length) 
        {
            for(int n = 0; n < word.length; n++) { // array word ganz auffüllen
                word[n] = text[zeichen];
                zeichen++;
            }

                if(searchLastSpace(word) != -1) // das array wird von hinten nach leerzeichen durchsucht und gibt die position des letzten leerzeichen aus
                {
                    if(text[zeichen] == ' ') // im array text, wird überprüft, ob das nächste zeichen ein leerzeichen ist
                    {
                        System.out.println(word); // wenn ja, dann kann das array word einfach im ganzen ausgegeben werden
                    } else {
                        System.out.println(deletePartsOfArray(word, searchLastSpace(word), word.length)); // wenn nein, werden die letzten zeichen bis zum leerzeichen abgeschnitten
                        zeichen = zeichen + (word.length - searchLastSpace(word)); // wieviele zeichen wurden abgehackt? idx zeichen des array text wird angepasst
                    }
                } else {
                    System.out.println(word);
                }
                
                // Wort löschen
                for (int x = 0; x < width; x++) 
                {
                    word[x] = ' ';
                }
        }
        // das letze Wort ausgeben, falls vorhanden
        System.out.println(word);
    }

    
    /**
     * looks for last space in current row. if found it returns the position of the space
     * if not it returns a negative value: -1
     * @param word saves the characters of current row int text
     * @return
     */
    static int searchLastSpace(char[] word) 
    {
        for(int i = word.length; i > 0; i--)
        {
            if(word[i-1] == ' ')
                return i;
        }
        
        return -1; // if no space found
    }
    
    
    /**
     * delets all characters after the final space
     * @param word
     * @param lowerRange
     * @param higherRange
     * @return
     */
    static char[] deletePartsOfArray(char[] word, int lowerRange, int higherRange)
    {
        while(lowerRange < higherRange)
        {
            word[higherRange-1] = ' ';
            higherRange--;
        }
        
        return word;
    }

    public static void main(String[] args) {
        char[] text = {'I', 'm', 'p', 'l', 'e', 'm', 'e', 'n', 't', 'i', 'e', 'r', 'e', 'n', ' ',
                'S', 'i', 'e', ' ', 'e', 'i', 'n', 'e', ' ', 'M', 'e', 't', 'h', 'o', 'd', 'e', '.'};

        alignText(text, 5);
    }
}
```


----------



## Gast (12. Nov 2007)

weiß keiner von euch wo der hund begraben ist? morgen wäre mein abgabetermin, also wäre ich über jede hilfe dankbar!


----------



## SlaterB (12. Nov 2007)

der Fehler ist doch einfach zu finden, du suchst dir die Zeile mit der Exception und schaust dir an was dort passiert,
ArrayIndexOutOfBoundsException verrät dir schon, dass es um einen Index geht,

schnell siehst du, dass du 5 Zeichen aus Text in Word schreibst,
aber ist doch denkbar, dass nur noch 1-4 Zeichen da sind

hier eine zumindest für dein Beispiel funktionierende Variante, an mehreren Stellen vereinfacht:


```
public class EPRUE0603
{
    static void alignText(char[] text, int width)
    {
        // Zaehlvariable fuer die Schleife
        int zeichen = 0;
        // Array mit der Laenge von width
        char[] word = new char[width];

        // solange es Zeichen gibt
        while (zeichen < text.length)
        {
            for (int n = 0; n < word.length; n++)
            {
                word[n] = ' ';
            }
            int max = Math.min(text.length - zeichen, word.length);
            for (int n = 0; n < max; n++)
            {
                word[n] = text[zeichen];
                zeichen++;
            }

            int lastSpace = searchLastSpace(word);
            if (lastSpace == -1 || zeichen == text.length || text[zeichen] == ' ')
            {
                System.out.println(word);
            }
            else
            {
                deletePartsOfArray(word, lastSpace);
                zeichen = zeichen - word.length + lastSpace;
                System.out.println(word);
            }

            // Wort löschen
            for (int x = 0; x < width; x++)
            {
                word[x] = ' ';
            }
        }
        // das letze Wort ausgeben, falls vorhanden
        System.out.println(word);
    }

    /**
     * looks for last space in current row. if found it returns the position of the space
     * if not it returns a negative value: -1
     * 
     * @param word
     *            saves the characters of current row int text
     * @return
     */
    static int searchLastSpace(char[] word)
    {
        for (int i = word.length; i > 0; i--)
        {
            if (word[i - 1] == ' ') return i;
        }

        return -1; // if no space found
    }

    static void deletePartsOfArray(char[] word, int lowerRange)
    {
        for (int i = lowerRange; i < word.length; i++)
        {
            word[lowerRange] = ' ';
        }
    }

    public static void main(String[] args)
    {
        char[] text =
            {'I', 'm', 'p', 'l', 'e', 'm', 'e', 'n', 't', 'i', 'e', 'r', 'e', 'n', ' ', 'S', 'i', 'e', ' ', 'e', 'i', 'n', 'e',
             ' ', 'M', 'e', 't', 'h', 'o', 'd', 'e', '.'};

        alignText(text, 5);
    }
}
```


----------

