View Full Version : [Frage] Hilfe beim Programm
Hallo!
Ich versuche eigentlich die 1.Runde in Eprog zu lösen, aber zuerst wollte ich ein Programm schreiben, das nur einen Teil macht von dem was sie in der 1.Runde verlangen und das klappt nicht so 100% wie ichs gern hätte...
Und zwar will ich, dass das Programm einen String einliest, der eine bestimmte Länge haben soll. Wenn es passt "OK" ausgeben, wenn nicht "FALSCHE EINGABE".
klappt soweit, dass das OK kommt, wenn die länge stimmt, aber bei falscher länge kommt auch das OK. und ich komm aus dem ganzen erst raus, wenn ich Ctrl+Z drücke.. das will ich eigentlich auch nicht..
import java.util.*;
public class Ascii {
public static void main(String[] args) {
String zeile = " ";
boolean status = true;
Scanner einlesen = new Scanner(System.in);
while (einlesen.hasNext()) {
zeile = einlesen.next();
if (zeile.length() != 7) {
status = false;
}
if (status = false) {
System.out.println("FALSCHE EINGABE");
} else {
System.out.println("OK");
}
}
}
}
Paulchen
23-10-2007, 15:05
Wenn du
if (status = false)
schreibst, dann ist das eine Zuweisung. Der Variablen status wird der Wert false zugewiesen, und das ist dann der Wert des Ausdrucks. Daher steht da mehr oder weniger
if (false)
Dass das nicht wie gewünscht funktioniert, sollte klar sein.
Was du haben willst, ist ein Vergleich, da brauchst du == statt ==:
if (status == false)
Die beiden if-Statements kannst du übrigens zusammenziehen:
if (zeile.length() != 7) {
System.out.println("FALSCHE EINGABE");
} else {
System.out.println("OK");
}
oh mann...ja stimmt..das hab ich ganz übersehen..danke!!
und wie mach ich jetzt dass das programm nach einem OK oder FALSCHE EINGABE selbst endet?
Horrendus
23-10-2007, 15:24
Indem du es als letzte Anweisung ins Programm schreibst ... wenn danach nichtsmehr kommt ist das Programm fertig und beendet sich selbst.
lg Stefan
oke sehr gut ^^ funktioniert.
jetzt überleg ich wie eine bestimmte anzahl der zeilen verlangen kann.. kann mir jemand einen tipp geben?
nachdem du ohnehin schon zeilenweise einliest is es nicht allzu schwer....
in der einleseschleife eine countvariable haben die die zeilen brav mitzählt, wäre vielleicht nicht schlecht.
nachdem mitzählen allein nicht reicht , sondern das programm auch noch was tun soll:
ebenfalls in der einleseschleife oder in einer extra-schleife ausenrum
die zeilenzählvariable dann abfragen, und je nach wert der zählvariable dann abbrechen oder nicht ...oder sonstwas tun..
ich hab das jetzt so probiert..
for (int zeilen=0; zeilen<3; zeilen++) {
zeile = einlesen.next();
if (zeile.length() != 3) {
status = false;
}
}
if (status == false) {
System.out.println("FALSCHE EINGABE");
} else {
System.out.println("OK");
}
aber irgendwas klappt da nicht...?!
also wenn ich 3 zeilen eingebe mit je 3 zeichen kommt sofort FALSCHE EINGABE und gebe ich zu wenige zeilen ein kommt sowas:
Exception in thread "main" java.util.NoSuchElementException
at java.util.Scanner.throwFor(Scanner.java:838)
at java.util.Scanner.next(Scanner.java:1347)
at Ascii.main(Ascii.java:13)
du hast oben eine eine schleife die fix 3 mal durchlaufen wird.
und in der schleife liest du ein.
und beim dritten mal gibts aber nix mehr zum einlesen, also:
exception
bzw ein bisschen mehr hilfestellung: du hast da ja die überprüfung rausgeworfen.. while (einlesen.hasnext()) .. die kannst du nicht weglassen.
also musst du sie da noch irgendwo IN die schleife oder innerhalb der schleife einbauen.
und zum andern fall:
schreib vor dem if bitte mal das ergebnis von zeile.length auf die konsole raus mit system.out usw.. bzw schau dir an was da wirklich drin steht und überleg dir dann warum das so sein könnte. ;)
versuch generell dir das programm erstmal in ruhe zeile für zeile durchzudenken , wenn mal was nicht geht.
so eine art schreibtischtest machen... bzw schrittweise die paar zeilen durchgehen und debugging informationen ausgeben (variablen-inhalte usw)
das hilft oft weiter...
"Wah - geht nicht .. Falsche Ausgabe, Exception" und dann wie gebannt auf den Code starren und rumexperimentieren hilft nicht soviel weiter.. bzw kommt man damit selten auf Fehler drauf, weil man den Baum vor lauter Wald nicht mehr sieht .. ;) ... und ins Forum laufen und andere Debuggen lassen , klappt zwar, weil wir alle nett sind und hier auch schon oft Hilfe bekommen haben. Aber wenn du Programmieren lernen willst , wirst du auch Fehlersuchen und Debuggen lernen müssen, damit du nicht immer gleich beim ersten Fehler anstehst und hilflos bist. :)
kann ich das irgendwie umgehen, oder muss ich das mit try..catch lösen?
sollte ja nach den 3 zeilen ein OK kommen...
kann ich das irgendwie umgehen, oder muss ich das mit try..catch lösen?
sollte ja nach den 3 zeilen ein OK kommen...
hiermit:
bzw ein bisschen mehr hilfestellung: du hast da ja die überprüfung rausgeworfen.. while (einlesen.hasnext()) .. die kannst du nicht weglassen.
also musst du sie da noch irgendwo IN die schleife oder innerhalb der schleife einbauen.
danke dir wirklich.
ich weiß.. ich renn eigentlich ungern sofort ins forum .. ich will den code ja nicht von wem bekommen, sondern es wirklich selbst machen und verstehen.. aber ich sitz echt schon seit dienstag an dem bsp und hab schon viel versucht, komme eh zwar langsam (aber doch) irgendwie weiter..
kommt jetzt zwar keine exception..dafür immer nur falsche eingabe..
und zu deinem zweiten.. dass ich vor dem if zeile.length rausschreiben soll.. meinst du ich soll mit system.out.print die anzahl der eingegeben zeichen ausgeben lassen?
und zu deinem zweiten.. dass ich vor dem if zeile.length rausschreiben soll.. meinst du ich soll mit system.out.print die anzahl der eingegeben zeichen ausgeben lassen?
Du sollst dir den Inhalt von zeile.length anzeigen lassen.
Die If-Bedingung überprüft ob Zeile.lenth ungleich 3 ist,
wenn ja wird falsche Eingabe ausgegeben (besser gesagt Variable status gesetzt , später Variable status überprüft , da status false ist Ausgabe von Eingabe falsch.)
Also solltest du dir anschaun , was in der Bedingungsvariable zum Zeitpunkt der Überprüfung bzw unmittelbar vorher oder nachher drinnen steht.
Eine Möglichkeit das zu tun wäre einfach zeile.length vor oder nach der If-Anweisung auf die Konsole rauszuschreiben.
Folgende Dinge solltest du checken / dir überlegen:
(einfach das Programm durchgehen und überlegen an welchen Stellen es zur falschen Eingabe überall abzweigen könnte)
Als erstes Mal die If-Bedingung eben:
Steht da wirklich ein Wert ungleich 3 drin? ...
Wenn aber ja: warum könnte das so sein? (Doku der Einlesefunktion checken!, mal mit 2 oder 4 Zeichen pro Zeilen probieren und schaun was dann in der Bedingungsvariable zeile.length steht)
Wenn nein: wo könnte der Fehler noch liegen , wenn nicht in der Bedingung? Vielleicht bei der Statusvariable? Was hat Einfluss auf die Statusvariable? Wo würde die Statusvariable noch verändert usw..
Aus welchen Gründen könnte das Programm noch zur Anweisung "gebe falsche Eingabe aus" springen?
Spiel dich einfach mal bisschen mit dem Programm und test mehrere Fälle durch bzw überlege dir wo der Grund liegen könnte, dass das Programm nun in den Zweig falsche Eingabe springt.
Soviele Möglichkeiten gibts ja nicht bei einem 5-Zeiler. ;)
soo...jetzt hab ich echt viel herumprobiert und mir genau das angeschaut was du gesagt hast. hat schon ziemlich geholfen, ich versteh jetzt mehr.
und das prog funkt wies sollte ^^ juhuu
grml.. doch nicht...
ich hab jetzt
for .. {
while .. {
...
}
}
es kommt auch ein OK wenn ich zu viele zeilen hab.. und wenn ich das while weglasse kommt nach den 5 zeilen ganz allein ein OK..bei der abgabe steht dann dass bei mehr zeilen auch ein OK kommt.. wie wenn man gar nicht mehr zeilen eingeben kann...
Hm, .. du hast es ja schon fast. ;)
Nur hast du ein kleines bisschen zu kompliziert gedacht.
Für das was du machen möchtest brauchst du nicht unbedingt 2 Schleifen.
Zwei Schleifen würdest du NUR brauchen, zb:
Schleife eins ist die Leseschleife und Schleife 2 eine aussenherum (so wie deine For-Schleife).
Wenn die Leseschleife fertig ist, willst du das noch 5x etwas gemacht wird.
Das würdest du aussen in eine zweite For-schleife schreiben.
Aber nachdem du in deiner zweiten Schleife garnix machst...
Sondern du im Prinzip nur etwas überprüfen möchtest , was in der ersten Schleife gemacht wird,
solltest du das besser auch in der ersten Schleife machen, und nicht was Kompliziertes aussen rum baun. ;)
Du willst beim Einlesevorgang mitzählen und abbrechen wenn deine bestimmte Zeilenanzahl erreicht ist.
Bau das in deine Einlese-Schleife ein.
in zeilencount = 0;
while (einlesen.hasNext() && zeilencount <= 10) {
zeile = einlesen.next();
zeilencount ++;
}
Zum das Problem es kommt ein Ok, auch wenn zuviele Zeilen eingegeben werden, folgendes:
Wo wird die Status-Variable verändert und warum?
Laut Codelistings oben setzt du das Status-Flag , wenn die Zeile zu klein ist.
Was müsstest du machen , damit es ein False ausgibt , wenn zuviele Zeilen eingegeben werden?
Hinweis:
Ich habe das jetzt oben etwas brutal gelöst, dh man kann garnicht mehr Zeilen eingeben als erlaubt.
Also kann auch niemals ein OK trotz zuvieler Zeichen auftauchen.
Man kann das aber auch so lösen wie du es dir vorgestellt hast.
Einfach oben die Abbruchbedingung weglassen.... und dann musst du aber klarerweise noch etwas machen.
Und zwar:
Du hast dann zwei Fehlerfälle für die er in den False-Zweig gehen muss.
Fehlerfall 1 (mit der Zeilenlänge) hast du gelöst mit einer IF-Abfrage.
Fehlerfall 2 kannst du auf dieselbe Art lösen, nur statt Zeilenlänge müsstest du die Variable abfragen, die die Zeilen zählt. ;)
if (zeile.length() != 7) {
status = false;
else if (zeilencount >= wasweissich)
status ist auch falsch... ;)
}
}
Du kannst nicht erwarten , dass dein Programm etwas tut , an das du garnicht gedacht hast. ;)
das mit dem status hab ich eh schon lange aus der schleife raus getan..
ich hab das jetzt so gemacht wie dus geschrieben hast, aber das funktioniert auch nicht... ich kann wiedr so viele zeilen wie ich will einlesen und es is immer ein OK...
sehr seltsam...
oje oje..du hast echt geduld ^^
import java.util.*;
public class Ascii {
public static void main(String[] args) {
String zeile = " ";
boolean status = true;
int zeilen=0;
Scanner einlesen = new Scanner(System.in);
while (einlesen.hasNext() && zeilen <= 5){
zeile = einlesen.next();
zeilen ++;
if (zeile.length() != 3) {
status = false;
break;
}
}
if (status) {
System.out.println("OK");
} else {
System.out.println("FALSCHE EINGABE");
}
}
}
Paulchen
25-10-2007, 21:54
Was mir mal als erstes einfällt: Du liest sechs Zeilen, die Variable "zeile" zählt von 0 bis 5, erst, wenn sie den Wert 6 annimmt, wird die Schleife abgebrochen. Trotzdem mag es etwas verwundern, dass ein "OK" erst nach sieben (!) Eingaben, wobei jede Eingabe die Länge 3 hat, kommt.
Woran liegt das?
Der Scanner wartet auf die Eingabe nicht in einlesen.next(), wo man es erwarten würde, sondern schon in einlesen.hasNext(). Das hat den Sinn, dass diese Methode nur dann true zurückgibt, wenn auch tatsächlich was gelesen wird. Kommt keine Eingabe mehr (wenn beispielsweise mit Strg+Z oder Strg+D ein EOF erzeugt wurde), dann muss das schon einlesen.hasNext() erkennen. einlesen.hasNext() gibt dann schon false zurück, der Programmierer kann dann darauf reagieren und weiß, es kommt keine Eingabe mehr. Würde erst einlesen.next() erkennen, dass die Eingabe zu Ende ist, hättest du das Problem, dass du die Schleife nicht mehr rechtzeitig abbrechen kannst.
Nun hast du einlesen.hasNext() in die Schleifenbedingung verpackt, und die wird von links nach rechts ausgewertet. Irgendwann hat die Variable zeilen den Wert 6 (dann wurden bereits sechs Werte gelesen, wie oben erläutert). Dann hat zwar der Ausdruck "zeilen<=5" den Wert false, es wird aber dennoch der Ausdruck auf der linken Seite des "&&" zuerst ausgewertet, und das ist einlesen.hasNext(). Diese Methode wartet auf eine Eingabe, wie oben beschrieben. Das ist somit die siebente Eingabe. Erst wenn du etwas eingibst, wird der Ausdruck "einlesen.hasNext() && zeilen <= 5" ausgewertet, der nun insgesamt false ergibt, da "zeilen <= 5" false ist. Nun wird die Schleife verlassen, das Ergebnis wird ausgegeben. Ingesamt wurden aber sieben Werte eingelesen.
Resümee: Ersetze
while (einlesen.hasNext() && zeilen <= 5)
durch
while (zeilen < 5 && einlesen.hasNext())
Dann wird einerseits ein Wert weniger eingelesen, da "zeilen < 5" schon false wird, wenn die Variable zeilen den Wert 5 annimmt. Andererseits wird noch ein Wert weniger eingelesen, da Java erkennt, dass die Bedingung "zeilen < 5 && einlesen.hasNext()" nur false sein kann, sobald "zeilen < 5" false ist. einlesen.hasNext() wird dann gar nicht mehr aufgerufen, was zur Folge hat, dass nicht auf noch eine Eingabe gewartet wird. 7-1-1=5, also sollten es nun fünf Werte sein, die eingelesen und verarbeitet werden.
So, ich hoffe, ich hab dich jetzt nicht noch mehr verwirrt als du ohnehin schon bist. ;)
Das hier stimmt im Grunde schon.
Vielleicht ist die Obergrenze nicht die , die du erwartet hast. :(
Paulchen hats eh erklärt.
Am besten also du tauscht die beiden Bedingungen und
nimmst das <= weg und schreibst nur < in der Bedingung oder initialisierst mit zeilen mit eins und lässt <= ...
Dann ist die gewollte Zeilenanzahl-Grenze bisschen offensichtlicher. :wave2:
Das hier ist noch eine Möglichkeit wie es gehen würde, ....
Hier stoppt die Schleife nicht , .. sondern es wird eben wie bei der Zeilenlänge die Variable status gesetzt , aus der Schleife gehüpft
und eine Fehlermeldung ausgegeben.
import java.util.*;
public class Ascii {
public static void main(String[] args) {
String zeile = " ";
boolean status = true;
int zeilen=1;
Scanner einlesen = new Scanner(System.in);
while (einlesen.hasNext()) {
zeile = einlesen.next();
zeilen ++;
if (zeile.length() != 3) {
status = false;
break;
}else if {zeilen > 5}
status = false;
break;
}
}
if (status) {
System.out.println("OK");
} else {
System.out.println("FALSCHE EINGABE");
}
}
}
sorry war das wochenende nicht da..
so funktionierts jetzt ..für mehr zeilen als 5 kommt falsche eingabe..
aber für weniger ein ok.. deswegen hab ich mir gedacht, es müsste auch funktionieren wenn ich schreib:
else if (zeilen != 5) {
status = false;
break;
}
nach einer zeile bricht er aber schon ab und gibt eine falsche eingabe aus.. oder dem break kommt immer falsche eingabe, egal wie viele zeilen ich einlesen...
Naja.. überleg dir doch mal was die 3 Zeilen machen :lauscher:
WENN zeile ungleich 5
setze status auf falsch
break
und wenn du trotz überlegen nicht weiterkommst, würde ich dir einen schreibtischtest nahelegen. ;)
dafür machst du eine tabelle mit allen wichtigen variablen ( zeilen , zeile.length ,status, ausgabe )
gehst das programm schritt für schritt durch.. und schreibst für jeden durchlauf die werte mit die die variablen annehmen ..
ich hab irgendwie das gefühl dass du dir zu wenig überlegst was dein programm eigentlich tut.. ;)
hmm.. ich denk mir mal er prüft schon nach der ersten zeile und weil die nicht gleich 5 ist, bricht er ab.. versteh aber nicht wieso er mir nicht die chance gibt mehr einzugeben ...
hmm.. ich denk mir mal er prüft schon nach der ersten zeile und weil die nicht gleich 5 ist, bricht er ab.. versteh aber nicht wieso er mir nicht die chance gibt mehr einzugeben ...
natürlich prüft er nach der ersten zeile.
die if-überprüfung findet INNERHALB der schleife statt ..., nicht danach.
(und der scanner liest zeilenweise ein , jeden schleifendurchlauf eine zeile.
weisst du wie eine while schleife bzw schleifen generell funktionieren bzw abgearbeitet werden? :engel:
da solltest du dich mal bisschen mehr schlau machen..
wo fängt deine schleife an .. und wo ist sie zuende... und wie wird die schleife vom prinzip her ausgeführt?
in welcher reihenfolge und wie oft werden die anweisungen in der schleife ausgeführt,..
wann wird die schleife abgebrochen, .. wann wird die schleifenbedingung überprüft... wann werden schleifenzählvariablen erhöht sofern vorhanden....??
ja anscheinend denk ich falsch.. grml..
wie schleifen allg funktioniert versteh ich eigentlich schon.
wenn es klappt dass wenn ich frage ob mehr zeilen als 5 da sind, falsche eingabe ausgegeben wird, sobald 6 zeilen dastehn.. wieso klappt es dann nicht wenn ich abfrage ob 5 zeilen da sind.. ?! es funktioniert ja auch vorher mit der zeilenlänge
ja anscheinend denk ich falsch.. grml..
wie schleifen allg funktioniert versteh ich eigentlich schon.
wenn es klappt dass wenn ich frage ob mehr zeilen als 5 da sind, falsche eingabe ausgegeben wird, sobald 6 zeilen dastehn.. wieso klappt es dann nicht wenn ich abfrage ob 5 zeilen da sind.. ?! es funktioniert ja auch vorher mit der zeilenlänge
tust du ja nicht.
du fragst nicht ab "ob 5 zeilen da sind"
du fragst "sind ungleich 5 zeilen da"
ungleich 5 heisst aber mehr oder weniger als 5... :wave:
wenn du auf "sind 5 zeilen da bzw hat zeilen den wert 5" abfragen würdest ,.. würde es natürlich genauso klappen.
das problem ist aber das dein programm nicht das tut , was du dir vorstellst, dass es tun müsste..
vielleicht hilft ein schreibtischtest.. oder auch nur mal versuchen den programmcode in pseudocode oder ein struktogramm zurückzuverwandeln.
weiss nicht mit was du dir leichter tust.
/edit:
zu dem "es funktioniert ja auch mit der zeilenlänge":
bist du dir da 100% ig sicher? ;)
Ich glaube nicht , dass das Programm funktioniert, bzw besser die Anweisung mit der Zeilenlänge tut zwar etwas, aber nicht das was du möchtest.
Ich würde dir - nochmal - dazu raten dein Programm ausführlich zu testen.
Versuche nicht nur bei der Zeilenlänge zb .. 3 Zeichen einzugeben und zu sagen "Juhuuu funkt.."
Sondern gib 2 Zeichen ein,... notier dir was passiert, dann gib 3 Zeichen ein ... , dann gib 4 Zeichen ein, und schau was passiert ...
und dann gib mal eine zufällige Zahl von Zeichen ein. ... und schau immer was das Programm in den Testfällen macht... und ob es so reagiert wie "erwartet".
ja bei der zeilenlänge bin ich mir 100% sicher. da kommt NUR bei 3 zeichen OK.
bin jetzt wieder einmal alles der reihe nach durchgegangen.. hab die if-abfrage (zeilen != 5) außerhalb der schleife hingeschrieben und jetzt funktionierts. :)
Danke für die ewige Geduld und Hilfe =)
ja bei der zeilenlänge bin ich mir 100% sicher. da kommt NUR bei 3 zeichen OK.
bin jetzt wieder einmal alles der reihe nach durchgegangen.. hab die if-abfrage (zeilen != 5) außerhalb der schleife hingeschrieben und jetzt funktionierts. :)
ja wenn das so gewollt ist , passt dafür auch !=3
(dachte du wolltest weniger als 3 zeilen oder genau 3 zeilen)
aber bei der zeilenanzahl-abfrage war das sicherlich nicht so gewollt, dass es immer wenn die zeilenanzahl ungleich 5 ist abbricht...
ausserhalb der schleife die zeilenanzahl abfrage:
heisst das er solange einliest solange du was eingibst ( könnten auch 100 zeilen sein).. und wenn nichts mehr kommt geht er aus der schleife und überprüft dann ...
naja.. selbst wenns funktioniert keine ideale lösung .. , weil du theoretisch eine abbruchbedingung zusätzlich in der schleife brauchst.. oder es aber möglich wäre 10000 zeilen einzugeben bevor es überprüft wird ...
warum schreibst du nicht einfach in der schleife if (zeilen == 5) status = false; break; ???
denkst wohl zu kompliziert........
das hab ich schon am anfang probiert..
if (zeilen == 5) {
status = true;
break;
}
das funktioniert aber nicht.
Paulchen
29-10-2007, 17:14
warum schreibst du nicht einfach in der schleife if (zeilen = 5) status = false; break; ??? Das würde dann bedeuten, dass, sobald die fünfte Zeile eingelesen wird, die Eingabe automatisch als falsch bewertet wird. Und wo überprüfst du dann überhaupt, ob weniger als fünf Zeilen eingegeben wurden?
so jetzt hab ichs nochmal umgeschrieben.. jetzt müssten alle zufrieden sein..hoff ich ;)
also zuerst hab ich das mit dem
if (zeilen == 5) {
status = true;
break;
} else {
status = false;
}
ohne die zeilenLÄNGE abzufragen hingeschrieben.. hat funktioniert. also hab ich dann die zeilenlänge-abfrage nach der zeilenanzahl-abfrage hingeschrieben... jetzt funktionierts. und alles innerhalb der schleife ^^
Das würde dann bedeuten, dass, sobald die fünfte Zeile eingelesen wird, die Eingabe automatisch als falsch bewertet wird.
ja würde es bedeuten.
Und wo überprüfst du dann überhaupt, ob weniger als fünf Zeilen eingegeben wurden?
garnicht. hat allerdings ihre erste lösungsvariante mit der überprüfung im schleifenkopf auch noch nicht gemacht, soweit ich das in erinnerung hab.
wenn sie das möchte, dann (zusätzlich) eine zweite if abfrage nach der schleife die untergrenze abfragen lassen .....
oder den benutzer nicht aus dem programm lassen bevor er nicht genug zeilen eingegeben hat... :devil:
vBulletin® v3.7.1, Copyright ©2000-2008, Jelsoft Enterprises Ltd.