"Miep"-Spiel

M4veR1ck

M4veR1ck

Mitglied
Hey,
Wir haben von unserer Lehrerin die Aufgabe bekommen das *Miep* spiel zu programmieren...
Dieses Miep spiel geht so das zB die Mitschüler immer eine Zahl sagen (zB. 1,2,3,4... etc), nur das immer wenn eine Zahl durch 3 teilbar ist und es keinen Rest gibt halt, der Mitschüler Miep sagt...
Allerdings soll der Mitschüler auch Miep sagen sobald eine 3 drin vorkommt... also anstatt 23 nen Miep...
Das sollten wir in ein lauffähiges Java-Programm umsetzten...
Ich hab nur keinen Plan wie man das mit der 3 hinkriegt... Das mit dem Miep wenn es eine durch 3 teilbare Zahl ist, ist leicht nur das zweite krieg ich net hin... Wär nett wenn mir dort jemand bei helfen könnt...

Code: 
package miep_spiel;

import java.io.*;

public class Miep_Spiel {

	public static void main(String[] args) throws IOException{
		
		BufferedReader eingabe = new BufferedReader(new InputStreamReader(System.in));
		
		int zahlen, zahlEnde;
		String tastatur;
		
		System.out.println("Geben sie bitte an, wie bis wan das Programm laufen soll!");
		tastatur = eingabe.readLine();
		zahlEnde = Integer.parseInt(tastatur);
		
		for(zahlen = 1; zahlen <= zahlEnde; zahlen++){
			if(zahlen%3 == 0){
				System.out.print(" Miep");
			}
			else{
				System.out.print(" " + zahlen);
			}
		}

	}

}

Bildschirmausgabe folgt:

Code: 
Geben sie bitte an, wie bis wan das Programm laufen soll!
26
 1 2 Miep 4 5 Miep 7 8 Miep 10 11 Miep 13 14 Miep 16 17 Miep 19 20 Miep 22 23 Miep 25 26

Nur soll da jetzt noch die 13 und die 23 raus...
 
Zuletzt bearbeitet:
Mit dieser kleinen Schleife kannst du testen, ob eine 3 in der Zahl enthalten ist. Dabei wird immer durch 10 geteilt und geprüft, ob die letzte Ziffer eine 3 ist.
Java: 
for ( int z = zahlen; z > 0; z/=10 )
{
  if ( z%10 == 3 )
  { System.out.print(" Miep"); break; }
}
 
Alternativ kannst du aber auch einen String mit deiner Zahl erzeugen und prüfen, ob dieser die Zahl enthält,.

Etwa so:

Code: 
            if (("" + i).contains("3")) {
                System.out.println("MIEP");
            } else {
                System.out.println(i);
            }

Oder in ganz kurz:

Code: 
System.out.println(("" + i).contains("3") ? "MIEP" : i);

Weil mir gerade langweilig ist, hier die gesamte Abfrage mit ternären Operatoren:
Code: 
            System.out.println((i % 3 == 0) ? "MIEP"
                    : ("" + i).contains("3") ? "MIEP" : i);
 
Zuletzt bearbeitet:
(""+i)
damit erzeugst du aus dem i (ich denke es war der datentyp integer gemeint), in dem deine zu überprüfende zahl steckt, einen string und kannst diesen mit ".contains"3""
vergleichen ob eine 3 darin vorkommt.

glg
 
aja die idee mit dem durch 10 teilen würde funktionieren wenn du die zahl durch 10 teilst und das ergebnis und den rest überprüfst ob 3 herauskommt.
ABER: geht nur bis 100

glg
 
Hi!

Da muss ich Vereth's Ansatz aber verteidigen. Die Schleife gibt genau dann ein MIEP aus, wenn die Zahl eine 3 enthält.
Als Beispiel spielen wir das mal mit 31 durch:

1. Durchlauf: z=31;
z%10 ist 1, also ungleich drei, also passiert nix!

vor dem 2. Durchlauf wird z = z/10, also (bei int-Division wird abgerundet)
2.Durchlauf: z= 3;
z%10 ist 3, also => MIEP

das funktioniert genauso mit 131, 113, 111453222 oder jeder anderen beliebigen Zahl, die eine 3 enthält.

Problem dabei ist natürlich, dass du, wenn ein MIEP ausgegeben wurde, die Zahl nicht mehr ausgeben sollst. Du schreibst dir also am besten eine Funktion

boolean contains3(int zahl)
die zunächst nur prüft. Die Ausgabe erfolgt dann außerhalb dieser Methode je nach Resultat.

Aber der Ansatz ist durchaus richtig.

mfg,

RoCMe
 
Wäre es nicht sauberer statische Methoden wie String.valueOf(i) oder Integer.toString(i) statt (""+i) zu benutzen?
Meiner Meinung nach liest sich das auch weitaus besser und ist für Änfänger besser verständlich.

Edit: Ansonsten, wer mich kennt, weiß, dass ich gerne bei solchen Aufgaben mit Rekursion arbeite. Daher werde ich auch hier einen Vorschlag mit Rekursion bringen, wodurch du keineString-Methoden zur Bearbeitung von "enthaeltDrei" benötigst...

Java: 
public boolean enthaeltDrei(int n) {
	if(n%10==3) return true;
	else if(n>=10) return enthaeltDrei(n/10);
	else return false;
}

//[...]

//Fall 1: Zahl ist durch 3 teilbar
if(zahl%3==0) System.out.println("Miep");

//Fall 2: Zahl enthält 3
else if(enthaeltDrei(zahl)==true) System.out.println("Miep");

//Fall 3: Zahl enthält keine 3 und ist nicht durch 3 teilbar
else System.out.println(zahl);

//[...]
 
Zuletzt bearbeitet:
Auch die Lösung mit ""+i ist 'sauber', weil sie sie sich nicht auf unzulässige Voraussetzungen stützt, sondern nur definiertest Verhalten nutzt; durch die Verkettung von String mit int wird die toString()-Methode automatisch zur Konvertierung aufgerufen. Es ist ganz nützlich, sich mit solchen verkürzten Formulierungen vertraut zu machen, weil sie helfen, den Code zu straffen und übersichtlicher zu halten. Es erinnert mich ein wenig an die Frage ob man zusammengesetzte Operatoren wie z.B. += anwenden soll: wenn man erst verstanden hat, was der Ausdruck macht (und das geht schnell), ist es nicht viel schwerer zu lesen als der explizite Aufruf der toString()-Methode. Manche empfinden es sogar als eleganter.

Ich verwende auch manchmal Rekursion, weil es manchmal ein natürliches Verfahren ist, Berechnungen in einer knappen und überschaubaren Weise zu implementieren. Jede Rekursion kann aber durch Iteration ersetzt werden, und in diesem Fall empfinde ich die Realisierung mit einer Schleife als angemessener und intuitiver.
Dennoch: hübsche Idee :)
 
Zuletzt bearbeitet:
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück