# Betrag in Münzen aufteilen



## MikeP (23. Nov 2008)

Hallo,

ich brauch dringend Hilfe. Bin ganz "frisch" auf den Java gebiet.

Hab eine Aufgaben, in der ich einen Betrag ( in Cent, also maximal 99 Cent) in so wenig wie 
möglich Münzen aufteilen muss.

Aufg.:
Schreiben Sie zur Klasse ”zaehler” 


eine Methode ”wechseln()”, um die dem Wert von stand (in Cent) entsprechende Anzahl von Münzen am Bildschirm auszugeben (wie muss der Wertebereich beschränkt werden?).
Schreiben Sie ein geeignetes Hauptprogramm, das einen gültigen Währungsbetrag in „stand“ ablegt und anschließend „wechseln()“ ausführt.

Hinweis:	Am einfachsten ist die Ermittlung der minimalen Anzahl von Münzen!

Versuchen Sie, möglichst wenig Anweisungen zu verwenden.


----------



## Marco13 (23. Nov 2008)

Aha. Na, dann viel Erfolg  :toll:


----------



## NoX (23. Nov 2008)

Wo genau liegt dein Problem? Hast du denn überhaupt schon mit der Aufgabe angefangen?


----------



## MikeP (23. Nov 2008)

Hier mal meine ersten Versuche, die aber alle nicht zum richtigen Ergebnis führen:

1.

public class Zaehler {

	 int stand;

	public Zaehler()
	{
		stand = 0;
	}



	public void wechseln()
	{
		if(stand < 100)
		{ if(stand%50 >= 1)
			{ System.out.println(stand/50); }

			if(stand%70 >= 1)
			{ System.out.println(stand/20); }

			if(stand%10 >= 1)
			{ System.out.println(stand/10); }

			if(stand%5 >= 1)
			{ System.out.println(stand/5); }

			if(stand%2 >= 1)
			{ System.out.println(stand/2); }

			if(stand%1 >= 1)
			{ System.out.println(stand/1); }

		}

		else {System.out.println("Der Cent-Betrag darf max. 99 sein.");}





	}
}



2.

public void wechseln()
{

if(stand-50 > 0) {
		System.out.println("Anzahl 50 Cent Münzen: " + (stand/50));
		stand = stand - 50; }

		if(stand-40 > 0) { 
		System.out.println("Anzahl 20 Cent Münzen: " + (stand/20));
		stand = stand-40; }

		if(stand-20 > 0) { 
		System.out.println("Anzahl 10 Cent Münzen: " + (stand/10));
		stand = stand-20;}

		if(stand-10 > 0) {  
		System.out.println("Anzahl  5 Cent Münzen: " + (stand/5));
		stand = stand-10;}


		if(stand-4 > 0) {  
		System.out.println("Anzahl  2 Cent Münzen: " + (stand/2));
		stand = stand-4;}

		if(stand-2 > 0) { 
		System.out.println("Anzahl  1 Cent Münzen: " + (stand/1));
		stand = stand-2;}
}		


3.

public void wechseln()


{

		stand = stand/50;
		System.out.println(" Anzahl 50 Cent Münzen: " + stand);
			stand = stand/5;
		System.out.println(" Anzahl 20 Cent Münzen: " + stand);
		  	stand = stand/10;
		System.out.println(" Anzahl 10 Cent Münzen: " + stand);
		  	stand = stand/20;
		System.out.println(" Anzahl  5 Cent Münzen: " + stand);
		  	stand = stand/50;
		System.out.println(" Anzahl  2 Cent Münzen: " + stand);
		  	stand = stand/100;
		System.out.println(" Anzahl  1 Cent Münzen: " + stand);

}




Meine main sieht dann so aus:

public class Startklasse {

	public static void main(String[] args) {

		Zaehler z1 = new Zaehler ();

		z1.stand = 99;   //z.B.
		z1.wechseln();
	}

}			



Ich weiß nämlich auch nicht genau wie die Rechnung in Detail geht. 
Zunächst muss ich doch die Zahl (stand) durch 50 Teilen, denn das 50 Cent stück ist
ja bekanntlich das kleinste unter dem Euro.
Dann das 20 Cent Stück..usw.

Einen Betrag (stand) in die jeweiligen Münzen aufzuteilen ist ja kein Problem.
Ist ja immer stand/50, stand/20 usw.

Aber ich muss den Betrag in die kleinstmögliche Anzahl an Münzen aufteilen.
Wollt es erst mit einer for-Schleife probieren, aber ich muss ja jedes mal 
eine andere Rechnung machen. Deshalb kam ich da auch nicht weiter.


----------



## Landei (23. Nov 2008)

Die Grundidee (mit dem größten Stüch anfangen) ist schon halbwegs erkennbar, aber es geht viel einfacher:


```
int stand = ...;

int fuffziger = 0;
while(stand > 50) {
  fuffziger ++; //anzahl fuffziger hoch
  stand -= 50; //betrag entsprechend reduzieren
}

int zwanziger = 0;
while(stand > 20) {
   zwanziger ++;
   stand -= 20;
}

//usw.
```

Übrigens: [code] -Tags machen den Code hübscher (im Forum)


----------



## MikeP (23. Nov 2008)

Hab jetzt mal ne Lösung gefunden, nach langem probieren.
Aber ist glaub nicht wirklich elegant.

Hier also nur die methode:

public void wechseln()

if(stand > 50) {
		System.out.println("Anzahl 50 Cent Münzen: " + (stand/50));
		stand = stand - 50; }

		if(stand >= 40) { 
		System.out.println("Anzahl 20 Cent Münzen: " + (stand/20));
		stand = stand-40; }



		if(stand >= 10) { 
		System.out.println("Anzahl 10 Cent Münzen: " + (stand/10));
		stand = stand-10;}

		if(stand >= 5) {  
		System.out.println("Anzahl  5 Cent Münzen: " + (stand/5));
		stand = stand-5;}


		if(stand >= 4) {  
		System.out.println("Anzahl  2 Cent Münzen: " + (stand/2));
		stand = stand-4;}

		if(stand >= 1) { 
		System.out.println("Anzahl  1 Cent Münzen: " + (stand/1));
		stand = stand-1;}
}


MFG


----------



## MikeP (23. Nov 2008)

Sorry...die letzten zwei Anweisungen müssen so aussehen:

                if(stand >= 2) {  
		System.out.println("Anzahl  2 Cent Münzen: " + (stand/2));
		stand = stand-2;}

		if(stand == 1) { 
		System.out.println("Anzahl  1 Cent Münzen: " + (stand/1));
		stand = stand-1;}


----------



## Marco13 (23. Nov 2008)

Teste das mal mit 70 cent. (Tipp: While statt if ...).

Eleganter machen könnte man es auch, ja...


----------



## MikeP (24. Nov 2008)

Vielen Dank. Jetzt hab ich nur ein Problem.
Er subtrahiert zwar aber auf der Console wird nichts ausgegeben.


```
int fuffziger = 0;
while(stand > 50) {
	System.out.println("Anzahl Fünfziger: " + (fuffziger++)); 
  stand -= 50;
```



Console

Anzahl Fünfziger : 0


(Bei einem stand = 89; der eingegeben wurde)


----------



## SlaterB (24. Nov 2008)

warum solche Experimente mit der Auswertungsreihenfolge?
schreibe

fuffziger++;
System.out.println("Anzahl Fünfziger: " + fuffziger); 

und nichts kann schiefgehen

------

ansonsten wäre hier
System.out.println("Anzahl Fünfziger: " + (++fuffziger));
angebracht


----------



## mahe (24. Nov 2008)

In der Schleife ist das auch ziemlich blöd. Man sollte in der Schleife nur fuffziger++; stehen haben und die Ausgabe nach der Schleife machen.

Oder natürlich statt der Schleife das Problem einfach mit dem Modulo-Operator lösen ...


----------



## MikeP (24. Nov 2008)

Jep, hab ich beim Testen auch gemerkt.
Thx.
So passt alles:


```
public class Zaehler {

	 int stand;
	
	public Zaehler()
	{
		stand = 0;
	}
		
	public void wechseln()
	{
		if(stand < 100)
		{ 
       int fuffziger = 0 ;
	while(stand >= 50) {
	fuffziger++;
	System.out.println("Anzahl Fünfziger: " + fuffziger); //anzahl fuffziger hoch
	stand -= 50;} //betrag entsprechend reduzieren
  
	int zwanziger = 0;
	while(stand >= 20) {
	zwanziger++;
	stand -= 20;}
	System.out.println("Anzahl Zwanziger: " + zwanziger);
   
	int zehner = 0;
	while(stand >= 10) {
	zehner++;
	stand -= 10;}
	System.out.println("Anzahl Zehner: " + zehner);
	
	int funfer = 0;
	while(stand >= 5) {
     funfer++; 
       stand -= 5;}
	System.out.println("Anzahl Fünfer: " + funfer);
         
	int zweier = 0;
    while(stand >= 2) {
     zweier++; 
      stand -= 2;}
    System.out.println("Anzahl Zweier: " + zweier);
	
	
      int einer = 0;
      while(stand >= 1) {
       einer++;
        stand -= 1;}
      System.out.println("Anzahl Einer: " + einer);

                   }
       }
}


und noch die main:

public class Startklasse {

	public static void main(String[] args) {

		Zaehler z1 = new Zaehler ();
		
		z1.stand = 91; //z.B.	
		z1.wechseln();
	}

}
```

thx @ all


----------



## ARadauer (25. Nov 2008)

ich würd das so machen....

```
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test{
   
   public static int[] muenzen = {50, 20, 10, 5, 2 ,1};
   public static int[] anzahl = new int[muenzen.length];

   public static void main(String[] args) throws NumberFormatException, IOException {
     BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
     int wert = Integer.valueOf(r.readLine());
     int pos = 0;
     while(wert>0){
        if(wert<muenzen[pos]){
           pos++;
        }else{
           anzahl[pos]++;
           wert = wert - muenzen[pos];
        }
     }     
     for(int i =0; i <muenzen.length; i++){
        System.out.println(muenzen[i]+" "+anzahl[i]);       
     } 
   }
}
```


----------



## André Uhres (25. Nov 2008)

Oder so:

```
int[] muenzen = {50, 20, 20, 10, 5, 2, 2, 1};
for (int muenze : muenzen) {
    if (stand >= muenze) {
        System.out.println(muenze);
        stand -= muenze;
    }
}
```


----------



## Marco13 (25. Nov 2008)

Wobei letzteres mit 90 Cent doch auch nicht die richtige Ausgabe liefert, oder  ???:L (Auch hier müßte doch while stattt if stehen?!)


----------



## SlaterB (25. Nov 2008)

die 20 und die 2 sind doch doppelt in der Liste


----------

