# n hoch n ausgeben mit for schleife



## gast (8. Nov 2003)

hallo ich will mir ein java programm schreiben, das nach eingabe von zeichen, also buchstaben und zahlen, die funktion n hoch n ausrechnet und ausgibt. aber es soll maximal bis n=15 eingelesen werden. eingaben außerhalb des bereiches zb größer 15, buchstaben und brüche sollen abgefangen werden. wie kann man von einem string die zahlen auslesen lassen und nur die erlaubten zahlen verwenden also ganze zahlen kleiner 16. das muss doch irgendwie mit der charAt methode gehen.


```
import java.io.*;

public class test{
    public static void main(String[] args)
    throws IOException
    {String x; long n;
     BufferedReader din = new BufferedReader(new InputStreamReader(System.in)); 
     System.out.print( "Wert eingeben:" );
     x = din.readLine();
     
for (  ;  ;  ) { 

}
     if (n > 15 || n < 0 );
    System.out.println("Zu hohe n Werte"); 
    System.out.println("n");
    }
}
```
das war mein erster versuch aber es beinhaltet nicht alles so wie ich es will wer kann mir helfen???


----------



## jptc.org (9. Nov 2003)

Ich weiss zwar nicht ob ich das problem vollends verstanden haben, aber eigentlich willst du nur aus einem String eine Zahl machen, oder? Versuch doch einfach mal das folgende:


```
String str = // von irgendwo eingelesen
Integer zahl;
try {
   zahl = Integer.parseInt(str).intValue();
} catch (NumberFormatException nfex) {
   System.out.println("Schöner Versuch aber nur Zahlen sind erlaubt!");
}

if (zahl != null && zahl.getIntValue() > 15) {
   System.out.println("Mir ist die zahl zu groß");
}
```

Ich hoffe das konnte helfen.

Karsten Voigt
http://www.java-performance-portal.org


----------



## gast (9. Nov 2003)

danke das hat mich schon ein stück weiter gebracht aber ich habe immer noch ein großes problem, weil ich nicht weiß wie ich dem programm klar mache das es n hoch n ausrechnet. man muss das doch mit einer for schleife ausdrücken und igendwie mit i. ist daba das i der exponent?
wie macht man so eine for schleife?

ps
danke für die nette hilfe im forum, das bringt einem wirklich weiter
mfg


----------



## jptc.org (9. Nov 2003)

ist es wichtig, dass du diese funktion selbst nachprogrammierst? java.util.Math bietet schon eine schöne statische methode die das macht was du möchtest: java.util.Math.pow(a, n). diese methode rechnet dann a hoch n aus.

Karsten Voigt
http://www.java-performance-portal.org


----------



## Guest (9. Nov 2003)

Ja ist wichtig! Weil wir die Funktion n hoch n in einer "for" Schleife berechnen sollen und nicht gültige Eingaben in den String mit Hilfe der Methode "charAt" aussortieren sollen .... :?:  :!: 



```
import java.io.*;

public class test{
    public static void main(String[] args)
    throws IOException
    {String x; int n;
     BufferedReader din = new BufferedReader(new InputStreamReader(System.in)); 
     System.out.print( "Wert eingeben:" );
     x = din.readLine();
     if (( n = x.charAt(n)>='0') && ( n = x.charAt(n)>='15')) {
        for ( ; ; ; )
        System.out.println("Ergenis ist:" + n);  }
     else  System.out.println("falscher Werte eingegeben! ");
    
    }
}
```



ich denke mal es sollte in die Richtung gehen wenn es möglich ist, weil mehr als if/else und for Schleifen wir noch nicht mal hatten....  :roll:


----------



## Bladerunner (9. Nov 2003)

ich bin es nochmal. vielleicht kann mir jemand mit einem beispiel helfen, was mir die for schleife besser erläutert. bei vollgendem programm wird 1 bis 15 ausgegeben

```
public class SchleifeF {            
 public static void main(String args[])  
   {

   int i=0; 
   
    for(i=0;i<=15;i++)
        {
        System.out.println(i);
        }

   }
}
```
jetzt müsste ich es doch nur so modifiziern das ich ein n eingeben lasse und dann die for schleife in

```
for(i=0;i<=n;i++)
```
ändere. jetzt wiederholt er die schleife n mal, wenn ich das richtig verstehe. wie kann ich das programmieren das der n hoch n ausrechnet? wie sieht eine for schleife für n hoch n aus?


----------



## schalentier (9. Nov 2003)

ähm..

also erstmal, weist du was ein char ist?
ein char ist ein 1byte großer datentyp, der werte zwischen -127 und 128 annehmen kann. normalerweise werden chars benutzt, um ASCII zeichen darzustellen. so is '1' ein char und 'A' auch.  '15' dagegen ist kein char, sondern eine zeichenkette, genauer 2 chars '1' und '5'. für zeichenketten verwendet man Strings.

Also versteh ich deine aufgabe nicht. (ich glaub keiner hier versteht sie)

erklär noch mal ganz genau, was du machen willst.

 :?:


----------



## Bladerunner (9. Nov 2003)

"Schreiben Sie ein Java-Programm, das die Funktion f(n)=n hoch n für natürliche Zahlen n = 1,....,15 berechnet. Eingaben außerhalb dieses Bereiches sollen zu einer Meldung an den Benutzer führen und nich weiter verarbeitet werde. Das Program soll außerdem alle Eingaben, die keine ganzen Zahlne sind, mit einer solchen Meldung abfangen."

Hinweise: Eingabe als String (Zeichenkette) -> Mehtode zum Auslesen von Zahlen (bsp. s.charAt(i)=='0')

Bsp zum Auslesen ((s.charAt(i)>='0')&&(s.charAt(i)>='9'))


----------



## Nobody (9. Nov 2003)

also die berechnung in der for schleife ist absolut simpel. ich schreib dir nur die for schleife an:


```
//einlesen erfolgte schon, genauso wie die überprüfung
int erg=n;
for(int i=1;i<n;i++){
  erg=erg*n;
}
System.out.println(erg);
```

sollte gehen oder?


----------



## Jiriki (9. Nov 2003)

schalentier hat gesagt.:
			
		

> also erstmal, weist du was ein char ist?
> ein char ist ein 1byte großer datentyp, der werte zwischen -127 und 128 annehmen kann. normalerweise werden chars benutzt, um ASCII zeichen darzustellen. so is '1' ein char und 'A' auch.  '15' dagegen ist kein char, sondern eine zeichenkette, genauer 2 chars '1' und '5'. für zeichenketten verwendet man Strings.
> :?:




FALSCH  :!: 

zitat von krüger:

"Konsequenterweise wurde der Typ char in Java daher bereits von Anfang an 2 Byte groß gemacht und speichert seine Zeichen auf der Basis des Unicode-Zeichensatzes."

das ein String in java aus mehreren aufeinanderfolgenden chars besteht stimmt aber nur sind es keine ascii zeichen sondern unicode zeichen!!! (wobei der unicode den ascii code enthält...)


----------



## Jiriki (9. Nov 2003)

Bladerunner hat gesagt.:
			
		

> Bsp zum Auslesen ((s.charAt(i)>='0')&&(s.charAt(i)>='9'))



sollte bestimmt so heissen

( s.charAt(i) >= '0' && s.charAt(i) <= '9' )

die zahl soll ja grösser/gleich null und KLEINER/gleich 9 sein und nicht grösser/gleich 9


----------



## Jiriki (9. Nov 2003)

```
import java.io.*;

class Test
{
	public static void main(String [] arg)
	{
		macheWas();
	}
	
	public static void macheWas()
	{
		try
		{
			BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
			System.out.print("Bitte Zahl zwischen 1-15 eingeben: ");
			
			String eingabe = in.readLine();
			
			int zahl = Integer.parseInt(eingabe);
			
			if(zahl>=1 && zahl <=15)
			{
				System.out.println(zahl + " hoch " + zahl + " = " + (long) Math.pow(zahl, zahl));
			}
			else
			{
				//throw new NumberFormatException();		//Exception werfen
				System.out.println("Fehlerhafte Eingabe");	//oder fehler selbst behandeln
				macheWas();									//ganz nach belieben
			}
		}
		
		catch (NumberFormatException e)
		{
			System.out.println("Fehlerhafte Eingabe");
			macheWas();
		}
		
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}
}
```

ist zwar nicht 100% nach der aufgabe aber....


----------



## schalentier (9. Nov 2003)

Jiriki hat gesagt.:
			
		

> schalentier hat gesagt.:
> 
> 
> 
> ...



hast natürlich recht.   

hab nich nachgedacht, es ging mir mehr ums prinzip.


----------



## Bladerunner (9. Nov 2003)

Also lasst mich mal raten mit der "charAt" Methode kann man gar nicht ganze Zahlen aus einer Zeichenkette rausfiltern und ungügltige Eingaben abfangen  :?: 

Tja frage mich nur dann was wir damit sonst machen sollten  :roll:


----------



## Nobody (9. Nov 2003)

schonmal was von indexOf gehört? soll ganz brauchbar sein 
also so sieht das dann aus:

```
//leider musst du alle nicht erlaubten zeichen abfragen, daher hier nicht sehr geschickt.
//ich schreibs hier nur mal am beispiel von a und A, du könntest das ganze auch in eine schleife packen und mit einem array arbeiten

boolean korrekt=true;
if(eingabe.indexOf("a")!=-1  || eingabe.indexOf("A")!=-1){
  korrekt=false;
}
```

geschickter wäre hier eine try catch methode:


```
try{
  int i=Integer.parseInt(eingabe);
}
catch(NumberFormatException e){
  //fehlerausgabe
}
```


----------



## Bladerunner (9. Nov 2003)

So hab jetzt das Programm fertig, macht genau das was es soll. Bin zwar mal gespannt was er sagt aber soll er es mir mal mit seinem charAt() zeigen  :twisted:   :twisted:   :twisted:


----------



## gustav (11. Nov 2003)

Wahrscheinlich solltst Du den Eingabestring selbst parsen ! Oder ?
Habe mal versucht eine Heuristik zusammenzustellen. Wichtig ist doch nur das Deine Eingabe aus 1 oder 2 Zeichen besteht. Dabei darf das 1. Zeichen zwischen 0 und 9 liegen, das 2. aber nur zwischen 0 und 5.  Alle anderen Eingaben verwirfst du einfach. Der Sonderfall mit nur einer Ziffer macht die ganze Sache allerdings wieder ein wenig unübersichtlich. 

```
public class pow1
{
    public static void main(String[] args) 
    {
     String x=""; 
     long n;
     BufferedReader din = new BufferedReader(new InputStreamReader(System.in));
     System.out.print( "Wert eingeben:" );
     try
     {
       x = din.readLine();
     }
     catch (Exception e) {} 
     
     
     int zahl = -1 ; // Initialisierung mit ungültigen Wert
     int len = x.length() ;

        // 1. zeichen
     if (len > 0) // || (len > 2)
     {
       if ( (x.charAt(0)>='0') && (x.charAt(0)<='9')) 
       {
         zahl = (int) (x.charAt(0) - '0') ;
         
          // 2. Zeichen
         if (len > 1)
         {
           if ( (x.charAt(1)>='0') && (x.charAt(1)<'6')) 
           {
             zahl = zahl * 10 ;
             zahl = zahl + (int) (x.charAt(1) - '0') ;
           } 
           else // 2. Zeichen nicht zulässig => 1.Zeichen ungültig machen
           {
             System.out.println("2. Zeichen nicht zulässig") ;
             zahl = -1 ;
           }
         }
         
           // längere Eingaben
         if (len > 2)
         {
           System.out.println("Eingabe zu lang") ;         
         } 
         else
         {
            for (int i = 0 ; i < zahl ; i++)      
            {
              System.out.println(i) ;
              // hier muss dann das Potenzieren rein :-)
              // Vorschlag :  pow(n, n) = pow(n*n, n/2) !!!
            }
         }
         
       } else System.out.println("erstes Zeichen keine Zahl") ;
       
       System.out.println("\nZahl =" +zahl) ;
     }
     else System.out.println("keine Eingabe") ; ;
    }
}
```


----------



## Bladerunner (11. Nov 2003)

Oh wow  :shock: .... erstmal thx für die Mühe !

Ob ich die Eingabe selber "parsen" sollte kann ich dir nicht sagen da ich nicht mal weiß was das bedeutet  :wink: , der einzige Hinweis war ja das charAt aber darauf konnte ich mir nicht wirklich nen reim drauf bilden. Zumal auch überall steht das man damit nur ein Zeichen an einer gewissen Stelle zurückgeliefert bekommt. Naja mal schauen so hab ich es jetzt jedenfalls gelöst....



```
import java.io.*;

public class Aufgabe1{
    public static void main(String[] args)
    throws IOException
    {String x; int n , n1;
     BufferedReader din = new BufferedReader(new InputStreamReader(System.in)); 
     System.out.print( "Wert eingeben:" );
     x = din.readLine();
     try {
         n = Integer.parseInt(x); 
         if (n>=0 && n <=15)
            { n1=n; 
            for(int i=1;i<n;i++)
            { n1=n1*n; } 
            System.out.print("Ergebnis ist:" + n1);} 
         else System.out.print("Schöner Versuch aber nur Zahlen von 0 - 15 sind erlaubt ");  }
     catch (NumberFormatException e) 
    { System.out.println("Schöner Versuch aber nur Zahlen von 0 - 15 sind erlaubt "); }
    }
}
```


----------

