# Eingabe umgedreht ausgeben



## Tombery (30. Nov 2009)

Hallo,

die nächste Aufgabe besteht jetzt darin, einen eingebenen Satz umgekehrt wieder auszugeben. Die Kleinbuchstaben werden zu Grossbuchstaben und umgekehrt.

Beispiel:

Eingabe => Diese Aufgabe hat es in sich
Ausgabe => HCIS NI SE TAH EBAGFUa ESEId

Erlaubt sind nur Buchstaben (a-z und A-Z und die leerstelle). die sollen wir in char-arrays reintun. und für die eingabe sollen wir die Scanner-Klasse verwenden. 

Ich sitze jetzt schon länger dran...aber es will einfach nicht funktionieren:


```
import java.util.Scanner;

public class Revert {
	 
	public static void main (String[]args){
		
		//Einlesen des Satzes
		
		Scanner in = new Scanner(System.in);
		String satz = in.nextLine();
		
		//Satz in einen Char-Array speichern
		char satzzeichen[] = satz.toCharArray();
		
		//Kleinbuchstaben (char-array)
		char[] klein = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 
				        'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', ' '};
		
		//Grossbuchstaben (char-array)
		char[] groß = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 
				       'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
		
		String invSatz = "";
		
		//Überprüfen ob Eingabe(Satz) in den Arrays enthalten ist
		for(int i = 0; i <= satzzeichen.length; i++){
			
			if(satzzeichen[i] == klein[i] || satzzeichen[i] == groß[i]){
				
				//Satz-Array wird rückwärts durchlaufen
				for (int j = satzzeichen.length-1; j >= 0; j--) { 
					
					    //Wenn Satzzeichen Kleinbuchstabe ist, wird es in ein Großbuchstabe umgewandelt
		                if (Character.isLowerCase(satzzeichen[j])) { 
		                	
		                        invSatz += Character.toUpperCase(satzzeichen[j]); 
		                } 
		                //Wenn Satzzeichen Großbuchstabe ist, wird es in ein Kleinbuchstabe umgewandelt
		                else if (Character.isUpperCase(satzzeichen[j])) { 
		                	
		                        invSatz += Character.toLowerCase(satzzeichen[j]); 
		                } 
		                else //Wenn Satzzeichen eine Leerstelle ist
		                { 
		                        invSatz += satzzeichen[j]; 
		                   
		                } 
		                //Satzzeichen in umgekehrter Reihenfolge ausgeben
		        	    
		                for ( int k = satzzeichen.length-1; k >= 0; k-- ){
		        		
		            	System.out.println(k);
		            	
		        	    }
		        } 
				
			}else{

				System.out.println("Es sind nur Buchstaben von a-z bzw. A-Z zugelassen");
				
			}
		}
	   
	}
}
```


----------



## eRaaaa (30. Nov 2009)

also ich habs mir jetzt nicht komplett angeschaut, aber was versuchst du mit dieser abfrage [c] if(satzzeichen_ == klein || satzzeichen == groß){[/c] zu erreichen? 

das würde ja nur stimmen, wenn dein satz abc... wäre  und selbst dann, was ist, wenn der satz länger als 26 zeichen ist? 
also diese abfrage solltest du nochmal überdenken !_


----------



## javimka (30. Nov 2009)

Könnte es daran liegen, dass deine for-Schleife zum ausgeben der Buchstaben innerhalb der for-Schleife zum durchiterieren liegt? Ausserdem verwendest du println(), es gibt also eine neue Zeile für jeden Buchstaben. Falls du das nicht willst, musst du print() verwenden.


----------



## Tombery (1. Dez 2009)

@eraaaa

genau DAS ist der knackpunkt  der kasus knackpunkt 
(glaub ich hat ein lehrer von mir immer gesagt XD)
ich weiß nicht wie ich das sonst vergleichen kann...
die eingabe soll ja nur buchstaben (und leerstelle) aus den beiden arrays enthalten...wenn nicht soll eine fehlermeldung ausgegeben werden. 

wie kann man ein character-zeichen mit einem character-array vergleichen? also ob das character-zeichen in dem char-array enthalten ist? kann man das überhaupt? XD

@javimka

stimmt, println müsste print sein. 
das mit der schleife...hm...es gibt doch verschachtelte schleifen, also müsste es gehen. wobei...vielleicht sollte ich die beiden schleifen doch eher separieren. erst überprüfen ob die zeichen überhaupt in den arrays enthalten ist, sonst fehlermeldung. und dann erst die zweite forschleife mit den klein- und großbuchstaben. ist besser.


----------



## javimka (1. Dez 2009)

Um zu prüfen, ob ein Char in einem Char-Array ist, kannst du ja einfach durchiterieren und das einzelne Char mit jedem Element aus dem Array vergleichen. Ein String ist ja im Grunde genommen auch ein char-Array, wenn du dein Char-Array als String hast, dann kannst du mit der Methode indexOf(char) den Index des ersten Auftretens von diesem char finden. Falls das Char nicht im String ist, wird -1 zurückgegeben.


----------



## Tombery (1. Dez 2009)

```
//Array in String umwandeln
		String s;
		s = new String(satzzeichen);


int IndexOf (String s){
			    
				char groß;
				
		}
```

fehleranzeige....außerdem müsste ich ja den IndexOf zweimal machen..einmal für groß und einmal für char-array klein....

oder...ich lasse den vergleich ganz gleich weg, aber wofür dann die arrays? kann man das auch irgendwie anders machen mit den buchstaben a-z und A-Z? *zeit läuft langsam davon*

wenn ich das ganze vergleichen weglasse, kommt das hier als ausgabe:

Das ist ein Satz (<= Eingabe)

ZZTZTAZTAsZTAs ZTAs NZTAs NIZTAs NIEZTAs NIE ZTAs NIE TZTAs NIE TSZTAs NIE TSIZTAs NIE TSI ZTAs NIE TSI SZTAs NIE TSI SAZTAs NIE TSI SAd (<= Ausgabe)


----------



## javimka (1. Dez 2009)

Ich habe eigentlich gedacht, du könntest den Satz ganz am Anfang gleich verwenden, ist ja ein String.
Teil dir die Arbeit doch in zwei Schritte auf. Erstens den Satz umdrehen, zweitens Gross/Kleinschreibung umkehren.

Ein anderer Ansatz: Darfst du StringBuffer verwenden? Dann könntest du einen neuen StrinBuffer erstellen mit deinem Satz als Argument und dann kannst du ihn mit reverse() einfach umkehren. Ansonsten machst du ein Char-Array und speicherst doch deine Chars aus dem Satz rein. Die kannst du finden mit charAt(i). Dann machst du wieder ein neues Array und speicherst sie dort in umgekehrter Reihenfolge rein.

Dann musst du nur noch durchiterieren und mit jedem Char einen Vergleich machen, ob es Gross- oder Kleinschreibung ist, dann einfach umdrehen und ausgeben.


----------



## Tombery (1. Dez 2009)

hm...wie speichert man einen Char-Array umgekehrt in einen neuen Char-Array?


```
//Satz in einen Char-Array speichern
		char buchstaben[] = satz.toCharArray();
		
		//Buchstaben in einem neuen Char-Array umgekehrt speichern
		
		//Satz-Array wird rückwärts durchlaufen
		for (int j = buchstaben.length-1; j >= 0; j--) { 
			
			buchstaben[j] = ???;
			
			char satz_umgekehrt[] = ???;
			
		}
```


----------



## javimka (1. Dez 2009)

was solls 


```
String satz = "Diese Aufgabe hat es in sich";
int n = satz.length();

// String in ein Array kopieren
char[] array = new char[n];
for (int i=0;i<n;i++) {
	array[i] = satz.charAt(i);
}

// Array umkehren
char[] reverse = new char[n];
for (int i=0;i<n;i++) {
	reverse[i] = array[n-1-i]; // -1, weil das letzte Element das n-1. ist
}

// Gross-/Kleinschreibung umkeren
char[] invert = new char[n];
for (int i=0;i<n;i++) {
	if (Character.isLowerCase(reverse[i]))
		invert[i] = Character.toUpperCase(reverse[i]);
	else
		invert[i] = Character.toLowerCase(reverse[i]);
}

// Ausgabe
for (int i=0;i<n;i++) {
	System.out.print(invert[i]);
}
```


----------



## Tombery (1. Dez 2009)

danke :toll:

habe das reserve mal genommen, wobei aber des eigentlich keinen unterschied macht XDDD da ich ja schon unten bei der if-anweisung den satz ja umgedreht habe.....und die fehlerausgabe war fehlerhaft, weil ich das system.out.println an der falschen stelle hatte XDDDD stimmt also jetzt!

das einzige problem war das mit dem array.....dass ich den nicht benutzen kann, um zu überprüfen ob die eingabezeichen (satz) in dem array liegt XD""


----------



## Tombery (1. Dez 2009)

gut erste aufgabe soweit gelöst ^^ 

und schon geht die quälerei weiter XDDD

Aufgabe 2:

Cäsar-Verschiebung 

man muss doch...das normale alphabet in ein array packen? und dann das verschobene alphabet in ein neues array, nicht? und dann...muss man mit der eingabe vergleichen und ausgeben...denk ich mir mal.
klingt einfach. aber das ist es garantiert nicht XD

hier alle methoden, die wir verwenden MÜSSEN:


```
import java.util.Scanner;

public class Caesar {

	
	public Caesar (int shift){
		
		//Klartextalphabet (char-array)
		
		char[] klar = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 
				        'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 
				        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 
					    'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
		
		//Verschiebung

		//Verschiebung nur wenn shift kleiner als Anzahl der Buchstaben vom Klartext
		if(shift < klar.length){
			
			//Buchstaben-array wird durchlaufen
			for( int i = 0; i < buchstaben.length(); i++ ){
				
				//zeichen = einzelnes Zeichen von Buchstaben-array
				int zeichen = buchstaben.charAt(i);
				
				//wenn zeichen im char-arry(klar) enthalten
				if ( (zeichen >= 'a') && (zeichen <= 'Z') ) {
				
					//wird Zeichen verschoben
					zeichen = zeichen + shift;
				}
				else{
					
					System.out.println("Satzzeichen nicht zugelassen");
					
				}
			}
        }
		else{
			
			System.out.println("Verschiebung ungültig");
			
		}
	}
	
	//Methode verschlüsselt eingebenen Text
	
	public String encrypt(String s){
		
		//neues char-array
		char[] verschoben = new char[buchstaben.length()];
		
		//array durchlaufen
		for( int j = 0; j < buchstaben.length(); j++ ){
			
		//verschobene elemente von buchstaben ins neue array übertragen
	               verschoben[i] = buchstaben[i + shift];
		
		}
	}
	
	//Methode entschlüsselt eingegebenen Text
	
	public String decrypt(String s){
		
		//Eingabetext durchlaufen
		for (int k = 0 ; k < buchstaben.length() ; k++) {
			
			//Text ausgeben
			System.out.print(leer);
		}
	}
	
	//main-Methode
	
	public static void main (String[]args){
		
    //Einlesen des Satzes
		
		Scanner in = new Scanner(System.in);
		String satz = in.nextLine();
		
		//Satz in einen Char-Array speichern
		char buchstaben[] = satz.toCharArray();
		
		//Initialisieren der Verschiebung shift
		int shift = 3;
		
		//Ausgabe 
		
		System.out.println("Originaltext: ");
		System.out.println("Verschlüsselter Text: ");
		System.out.println("Entschlüsselter Text: ");
		
		
	}
}
```


----------



## Tombery (3. Dez 2009)

aktueller stand:

da kommt eine sehr verwirrende ausgabe, wenn man ein wort eingibt...und ich weiß nicht weshalb??


```
//Verwenden der Bibliotheksklasse java.util.Scanner
import java.util.Scanner;

public class Caesar {

	//char-arrays (Datenelemente)
	
	//Klartextalphabet
	
	char[] klar = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 
	        'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 
	        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 
		    'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
	
	//Geheimtextalphabet
	
	char[] geheim = new char[klar.length];
	
	
	//-Custom-Konstruktor für Verschiebung-
	
	
	public Caesar (int shift){

		//Verschiebung nur wenn shift kleiner als Anzahl der Buchstaben vom Klartext
		if(shift < klar.length){
			
			//Klar-array wird durchlaufen
			for( int i = 0; i < klar.length; i++ ){
				
				//zeichen = einzelnes Zeichen für das Auffüllen von dem char-arry (geheim)
				int zeichen = klar[i];
				
					//wird Zeichen verschoben
					zeichen = zeichen + shift;
					
					//wenn die Verschiebung über die char-array(klar)-Grenze hinaus geht
					if(i > klar.length-shift){
						
						//dann muss der char-array über die Grenze hinaus zum Anfang zurück und weiterlaufen
						
					}
					
					//geheim-Array mit zeichen füllen
					geheim[i] = (char)zeichen;
			}
					
		}else{
			
			System.out.println("Verschiebung ungültig");
			
		}
	}
	
	
	//-Methode verschlüsselt eingebenen Text-
	
	
	public String encrypt(String s){
		
		//Eingabetext in einen Char-Array speichern
		char text[] = s.toCharArray();
		
		//String s zu einem Array umwandeln
		//String[]text2 = new String[s.length()];
		
		//leerer String zum Auffüllen des verschlüsselten Textes (Ausgabe)
		String verschlüsselt = "";
		
		//Eingabetext durchlaufen
		for( int j = 0; j < s.length(); j++ ){
			
        //Überprüfen ob Satzzeichen des Eingabetextes gültig
			
			//ASCII-Code für Grossbuchstaben: 65-90, für Kleinbuchstaben: 97-122, für Leerzeichen: 32
			if((text[j] >= 65 && text[j] <= 90) || (text[j] == 32)){ 
				
				//Zeichen von dem Eingabetext durch Geheimtextalphabet ersetzen
				text[j] = geheim[j];
				
				verschlüsselt = verschlüsselt + text[j];
				
			}else{
				
				//Fehlermeldung ausgeben
				System.out.println("Satzzeichen ungültig");
				
				break;
				
			}
		
		}
		
		//verschlüsselten Text ausgeben
		System.out.println("Verschlüsselter Text: " + verschlüsselt);
		
		return verschlüsselt;
		
	}
	
	
	//-Methode entschlüsselt eingegebenen Text-
	
	
	public String decrypt(String s){
		
		//Eingabetext in einen Char-Array speichern
		char text[] = s.toCharArray();
		
		//leerer String zum Auffüllen des entschlüsselten Textes (Ausgabe)
		String entschlüsselt = "";
		
		//Eingabetext durchlaufen
		for (int k = 0 ; k < s.length() ; k++) {
			
			//Überprüfen ob Satzzeichen des Eingabetextes gültig
			
			//ASCII-Code für Grossbuchstaben: 65-90, für Kleinbuchstaben: 97-122, für Leerzeichen: 32
			if((text[k] >= 65 && text[k] <= 90) || (text[k] == 32)){
				
				//leeren String füllen
				entschlüsselt = entschlüsselt + text[k];
				
			}else{
				
				//Fehlermeldung ausgeben
				System.out.println("Satzzeichen ungültig");
				
				break;
				
			}
			
		}
		
		//entschlüsselten Text (aufgefüllten String) ausgeben
		System.out.println("Entschlüsselter Text: " + entschlüsselt);
		
		return entschlüsselt;
		
	}
	
	
	//-main-Methode-
	
	
	public static void main (String[]args){
		
    //Einlesen des Satzes
		
		Scanner in = new Scanner(System.in);
		String satz = in.nextLine();
		
		//Satz in einen Char-Array speichern
		//char buchstaben[] = satz.toCharArray();
		
		//Initialisieren der Verschiebung shift
		int shift = 3;
		
		//den Caesar-Konstruktor füllen
		Caesar c = new Caesar(shift);
		
		//Methoden füllen
		c.encrypt(satz);
		c.decrypt(satz);
		
		//Ausgabe des eingegebenen Satzes
		System.out.println("Originaltext: " + satz);
		
	}
}
```

bei eingabe "Hallo" kam:

Satzzeichen ungültig
Verschlüsselter Text: d
Satzzeichen ungültig
Entschlüsselter Text: H
Originaltext: Hallo


----------

