Programmieraufgabe Java (10$) inside

Original von MisterJ
Du hast keine Ahnung wie du die Aufgabe lösen sollst und hast dafür bisher exakt was probiert? Gar nichts?
Dem Forum, wo dir Leute helfen könnten/würden, enthältst du erstmal die Aufgabe vor und machst jetzt noch ein Geheimnis darum, was man verwenden darf. Ist dein Ziel, dass dir nicht geholfen wird die Aufgabe selbst zu lösen? So liest sich der ganze Thread nämlich.
Hier Geld, du mach für mich.

Wenn man mal irgendeine Java Aufgabe gelöst hat, kann man hier schonmal mit irgendwas anfangen und dann sagen, wo es nicht weitergeht. Wenn die Aufgabe z.b. heißt "Klasse RationaleZahl" kann man wohl zumindest mal die Klasse anlegen. Die zwei Attribute da rein schreiben kann auch kein Problem sein und Getter/Setter sind in Eclipse zwei Mausklicks.

Sorry für den Rant, aber offensichtlich (s.o.) gibt es hier genug Leute, die dir helfen würden, die Aufgabe selbst zu lösen und wenn du mal damit rüber gekommen wärst, hättest du das ganze evtl. schon und wüsstest wie das funktioniert.

Dazu nochmal: Wenn du die Aufgabe der Dozentin erklären musst, hast du eh verloren, wenn du es nicht selber machst - du wirst ihr wohl kaum deine Lösung erklären können....

Weil ich kein Unmensch bin, schreib ich hier mal kurz was :-)

public class rationaleZahl{

int zaehler;
int nenner;

public rationaleZahl()
{zaehler=0;
nenner=1;}

public rationaleZahl(int parazaehler, int paranenner)
{zaehler=parazaehler;
nenner=paranenner;}
}

public void kuerzen()
{}
}

So würde die rationale Zahl aussehen, Berechnungen gehörten imo in ne eigene Klasse oder in die Main.

bezüglich der Listen:
Fürs Verständnis wäre es am besten, wenn du 4 Listen hättest:
a) erste rationale Zahl
b) zweite rationale Zahl
c) Operationszeichen
d) Ergebnis

=> Vorteil ist, dass eine rechnung immer an einem Index in allen Listen steht.

Original von MisterJ
Du hast keine Ahnung wie du die Aufgabe lösen sollst und hast dafür bisher exakt was probiert? Gar nichts?
Dem Forum, wo dir Leute helfen könnten/würden, enthältst du erstmal die Aufgabe vor und machst jetzt noch ein Geheimnis darum, was man verwenden darf. Ist dein Ziel, dass dir nicht geholfen wird die Aufgabe selbst zu lösen? So liest sich der ganze Thread nämlich.
Hier Geld, du mach für mich.

Wenn man mal irgendeine Java Aufgabe gelöst hat, kann man hier schonmal mit irgendwas anfangen und dann sagen, wo es nicht weitergeht. Wenn die Aufgabe z.b. heißt "Klasse RationaleZahl" kann man wohl zumindest mal die Klasse anlegen. Die zwei Attribute da rein schreiben kann auch kein Problem sein und Getter/Setter sind in Eclipse zwei Mausklicks.

Sorry für den Rant, aber offensichtlich (s.o.) gibt es hier genug Leute, die dir helfen würden, die Aufgabe selbst zu lösen und wenn du mal damit rüber gekommen wärst, hättest du das ganze evtl. schon und wüsstest wie das funktioniert.

Nimm doch den 10er oder lass es sein (is doch n faires Angebot). Deine Erziehungshilfe in allen Ehren aber ich glaube er weiß genau was er hier will und DAS ist es eher nicht.

ich wusste nicht was dieser thread für hohe wellen schlagen würde ♦

@ FiftyBlume: Danke, das hatte ich bisher aber auch. Steht ja da ist ja nich so das ich bei der Aufgabe noch 0 gemacht hab, ich komme einfach nur nicht weiter und habe keine Zeit (ok vll hätte ich die Zeit und bin dann halt zu faul) die zuende zu lösen. Wenn jemand n 10er haben will und die mir macht soll er sich melden und nich so dumme kommentare abgeben.

Bei mir hakt es vorallem daran, wie ich die Methoden aufbauen soll und wie ich diese in verschiedenen Klassen miteinandfer verknüpfe...

Erziehung muss aber sein, sonst lernt man das nie... Und wenn er genau weiß, was er will, muss er mehr als nen 10er bieten...

Will zwar keiner hören, aber: Ich helf auch gern, erwarte dabei dann aber auch, dass derjenige dabei was lernt. Das funktioniert nicht, wenn man einfach nur Lösungen postet. Gleichzeitig sollen auch andere was lernen, das setzt aber voraus, dass Aufgabe und Tipps öffentlich sind. Wenn jemand mit solchen Infos nur privat rausrücken will und dann auch die Lösung privat verschickt wird, ist das eine Dienstleistung, die entsprechend entlohnt gehört. Andernfalls ist es ein Gefallen, und ich sehe nicht, warum man solch einen wildfremden Menschein im Internet tun sollte.

@FiftyBlume: So perfekt ist das jetzt aber nicht... Erst mal sollten die Attribute da private werden, und wenn man dann die Signaturen der Rechenmethoden anschaut ist auch klar, dass die in RationaleZahl rein müssen (weil immer nur eine Zahl übergeben wird). Selbst wenn das nicht so ist sehe ich nicht, warum man vom Design die Rechenmethoden auslagern sollte. Tests und Beispiele natürlich schon.

@OP: Fang doch einfach mal mit der RationaZahl Klasse an, die ist wirklich sehr einfach. Da ist effektiv auch schon alles gegeben was du brauchst. Gibt es Teil 2 (die Rechnungen) auch so in der Aufgabenstellung? Denn das ist vom Niveau her schon n ganzes Stück drüber (nicht unbedingt von der Komplexität, aber man muss halt ein paar Sachen kennen). Habt ihr euch mit dem Einlesen von Eingaben überhaupt schon mal beschäftigt?

Bei mir hakt es vorallem daran, wie ich die Methoden aufbauen soll und wie ich diese in verschiedenen Klassen miteinandfer verknüpfe...

Also doch der zweite Teil auch? Brauchst du auch ne Prüfung der Eingabe, ob sie sinnvoll ist? Also soll das Programm auch vernünftig laufen, wenn jemand "3 / arsch" eingibt? Oder darfst du das voraussetzen, dass das passt? Übrigens brauchst du an der Stelle keine Listen oder so was, du musst einfach nur Zahlen und das Rechensymbol einlesen können.

Wenn jemand n 10er haben will und die mir macht soll er sich melden und nich so dumme kommentare abgeben.

Bitte sieh das von dem Standpunkt: Keiner wird dir die Aufgabe machen, weil er den 10er so nötig hat. Man wird es nur machen, weil man grad nix besseres zu tun / Lust drauf / was auch immer hat. Das setzt aber voraus, dass man dir wirklich helfen will, was am besten funktioniert, wenn du entsprechend sympathisch rüberkommst. Wenn du über die Hälfte der (mMn durchaus Berechtigten) Kommentare meckerst wird das schwierig...

Aber das willst du natürlich auch nicht hören.

Ok , da könntest du recht haben

Also meine Klasse RationaleZahl sieht bisher so aus:

import java.util.Scanner;

class RationaleZahl{
private int zaehler;
private int nenner;
Scanner sc = new Scanner (System.in);

RationaleZahl(){
zaehler=0;
nenner =1;
}
public rationaleZahl(int parazaehler, int paranenner)
{zaehler=parazaehler;
nenner=paranenner;}

int getNenner(){
return nenner;
}
void setNenner(String Text) {

nenner =Integer.parseInt(Text); }

int getZaehler(){
return zaehler;
}

void setZaehler(String Text) {
zaehler =Integer.parseInt(Text);
}

void ausgabe(){
System.out.println(((double)zaehler/(double)nenner));
}
}

Die Prüfung ob die Zahl sinnvoll ist muss auch rein. Die Rechnungen gibt es nicht in der Aufgabenstellung.
Bei der Klasse RationaleZahl hakt es bei mir also an folgenden Dingen:

--> Bei den Rechnungsmehtoden kommen ja auch x und y vor, wo initialisier ich die?
--> Wie baue ich die Rechnungsmethoden auf? Was gaben Sie zurück? ein ergebnis also
ergebnis = xcsdsdsdsd
return ergebnis=
--> was bringen mir die beiden Kontruktoren, wo is der Unterschied

Wir haben ganz neu mit bilden vbon Methoden angefangen. Die letze Aufgabe war eine NimmSpielaufgabe- die ging noch. Aber bei dieser Aufgabe verzweifelt der ganze Kurs. Da wir in der Vorlesung leider nichts mitnehmen ist eig alles Selbststudium und ich verzweifle gerade ein wenig.
Wenn ich die Klasse RationaleZahl fertig habe, wage ich zu behaupten die Klasse Start alleine hinzubekommen.

Achso: Wieso braucht man keine Listen? Am Ende sollen ja alle Ergebnisse ausgegeben werden. Nicht nur das letzt genannte Ergebnis/rechnung

Achso und hier meine Start-Klasse..
Für eine Zahl klappt es einigermaßen (natürlich nicht schön aber geht erstmal ums Prinzip). Jetz brauche ich halt die Berechnungsmethoden um die eingegeben Zahlen miteinander zu verrechnen + Irg ein Speicher um am Ende alle Zahlen auszugeben...:

import java.util.Scanner;

public class Start {
static Scanner sc = new Scanner(System.in);
static RationaleZahl hugo = new RationaleZahl();

public static void main (String []args){
String condition;
do{
hugo.setZaehler(sc.nextLine());
hugo.setNenner(sc.nextLine());
hugo.ausgabe();

System.out.println("erneute Berechnung? (j/n)");
condition = sc.next();
} while (!condition.equalsIgnoreCase("n"));
System.out.println();
System.out.println("~~~~~~~~~~~~~~~~");
System.out.println("Auf Wiedersehen");

}
}

Edit: da passiert aber irg wie nix :/

Damit kann man doch besser arbeiten.

Zur RationaleZahl: Den Scanner brauchst du da drin nicht. Oder? Und ich würd bei den Settern keine Strings annehmen, sondern ints. Dann musst halt beim Aufruf der Methoden vorher konvertieren und nicht in RationalZahl selber, das ist schöner.

Bei der Ausgabe... Warum nicht die Zahl selber ausgeben lassen, also zaehler + " / " + nenner? Und wenn der Name dieser Methode nicht vorgegeben ist: Für so was gibt es in Java die Standardmethode toString, die man da überschreiben sollte. Sähe dann so aus:

public String toString() {
return "" + zaehler + " / " + nenner;
}

Dann funktioniert es, wenn du an beliebiger Stelle einfach das Objekt ausgibst:

RationaleZahl q = new RationaleZahl(2,4);
System.out.println(q);

Für die Rechnung übergibst du den Rechenmethoden einfach ein RationaleZahl Objekt und rechnest dann damit. Ich geb dir mal n Beispiel für die Multiplikation:

void mult(RationaleZahl q) {
zaehler *= q.zaehler;
nenner *= q.nenner;
}

Zwei Anmerkungen: Java lässt es zu, dass du so auf die privaten Attribute von q zugreifst, ob das gut oder schlecht ist kann man drüber streiten. Da du auch getter hast, könntest du an dieser Stelle auch q.getZaehler() verwenden, was auf jeden Fall schöner ist (ich war nur faul... ;)).
Zweitens: Diese Methode verändert eine der Zahlen direkt. Das ist auch nicht schön, aber nachdem es ja setter geben soll (was ich persönlich bei rationalen Zahlen nicht machen würd, aber die Aufgabe ist halt so...) kann man das so machen. Schau aber mal in der Aufgabenstellung, ob das Ergebnis nicht stattdessen ne neue Zahl sein soll, dann musst du den Code entsprechend anpassen.

Was heißt, bei dir passiert nix? Was gibst du ein, was kommt raus? Auf die schnelle sehe ich keinen Fehler (eventuell aber ein nextLine statt next bei der Condition, aber das ist nur geraten).

Was am Ende alles ausgegeben werden soll kann ich nur raten. In der Aufgabenstellung, die du verlinkt hast, hat der jeweils immer nur eine Berechnung reingeschrieben. Vielleicht stand es aber hier, vielleicht hab ichs überlesen...

Danke schonmal...

1) Das soll ausgegeben werdn:
Beendet der Benutzer das Programm, werden alle im Array abgespeicherten rationalen Zahlen mitsamt ihren mathematischen Operationen ausgegeben:

Ausgabe: “Berechnet wurden:”
Ausgabe: “3 / 4 + 7 / 8 Ergebnis: 13 / 8”
Ausgabe: “2 / 3 - 3 / 2 Ergebnis: -5 / 6”
2) passiert nix heißt es passiert nix ♦
ich führe das Programm aus aber es öffnet sich die Console nicht, es passiert buchstaeblich nichts
3) aber die mult methode:

void mult(RationaleZahl q) {
zaehler *= q.zaehler;
nenner *= q.nenner;
}

sorgt doch nur dafür, das zaehler*zaehler gerechnet wird oder? dann muesste man doch erstmal die zahl (zaehler/nenner) als zaehler einleen ?!?!

4.) die toString methode:

Die rechnet doch eig nichs aus, sondern gibt nur die Zahl aus. Aber ich will ja das Ergebnis haben also bspw:

Eingabe: 3 / 4
Eingabe: +
Eingabe: 7 / 8

Ausgabe: “3 / 4 + 7 / 8 = 13 / 8”
Ausgabe: “erneute Berechnung? (j/n)”

sprich mit nenner erweitern das der selber nenner hat ect.

1) Ok, also ham sie das dazugebastelt, damit man was mit Listen zu tun hat. Selten dämliche Aufgabenstellung...

Da steht alles, was du brauchst: http://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html (Und noch viel mehr... ;)) Allerdings brauchst du mMn für ne vernünftige Benutzung von ArrayList einiges an Kenntnissen (zum Beispiel Generics), so dass ich nicht sehe, wie man das an der Stelle vernünftig nutzen soll. Oder soll man einfach nur ein Array mit vorgegebener Länge nehmen (dann wärs aber noch bekloppter...)?

2) Wenn du das in Eclipse startest, öffnet der keine Konsole. Die wird auf das Konsolenfenster in Eclipse umgebogen (standardmäßig glaub ich unter dem Quellcode).

3) Nein, sie berechnet zaehler * q.zaehler. q ist die zweite Zahl, mit der gerechnet werden soll. Das heißt, die zweite Zahl musst du erzeugen, ja. Der erste zaehler ist direkt das Attribut zaehler der Klasse. Die mult-Methode muss dazu natürlich in der Klasse RationaleZahl stehen.

Aufgerufen würde das zum Beispiel so:

RationaleZahl zahl = new RationaleZahl(3, 4);
Rationale Zahl nochnezahl = new RationaleZahl(7, 8);
zahl.mult(nochnezahl);

Wenn du dann zahl ausgeben lässt, steht da 13 / 8 drin. Das was hier nochnezahl heißt ist innerhalb der Methode mult von zahl unter dem Namen q ansprechbar.

4) Die soll ja auch nix ausrechnen. Ausrechnen tust du mit add, mult usw. Diese Ergebnisse sind dann in einem bestimmten Objekt der Klasse RationaleZahl gespeichert. Beim Beispiel oben gäbe es also eine RationaleZahl mit zaehler = 13 und nenner = 8 (in dem Fall zahl, aber je länger ich drüber nachdenke, desto besser ist es, für das Ergebnis ne neue RationaleZahl zu erzeugen). Wenn du für diese dann die toString-Methode aufrust, willst du ja schon nix rechnen, sondern nur diese Zahl ausgeben können.

puh vielen Dank muss das erstmal alles verarbeiten ♦
Gehe jetz gleich ins Tutorium vielleicht besprechen wuir da die Aufgabe.

Ich meld mich heut Abend nochmal.

Ich finds übrigens echt Klasse das es hier so mviele Hilfsbereite Leute gibt. Vielen Dank an sarc!

StackOverflow für die Zukunft

btw: gibt es kein Programmierer-Unterforum?

Hallo noldini,

ich habe den Thread mal in das dafür vorgesehene Forum verschoben. Bitte achte darauf, dass du Hilfestellungen hier nachfragst. Danke für dein Verständnis.

Gruß,
michimanni

also das Thema mit den 10$ hat sich erledigt.. es hat sich diesbezüglich keiner gemeldet und wir haben die Lösung jetzt zusammen im Tutorium gemacht.
Der Haken ist nur, dass unsere Dozentin alle Quellcodes durch ein Prgramm namens Jpleg jagt, um so Plagiate herauszufinden. Zu meiner ehrenrettung muss ich sagen, dass ich es versucht habe, allerdings im Tutorium gemerkt habe, dass ich auf dem falschen Weg war. Und das waren ALLE. Keiner von uns hätte diese Aufgabe lösen können. wir waren zu 8. und nicht nur die die eh nix checken sondern schon mit die besten im Kurs. Nunja jetzt habe ich das Programm hier,m allerdings muss ich es so umformen, dass das Programm keine Strukturgleichheit feststellt. Es bringt nix die Variablem umzubennen oder Zeilen zu vertauschen, das Programm achtet einzig und alleine auf die Struktur. Kann mir vielleicht jemand helfen wie ich cie Struktur verändern kann???

Hier meine Lösung:

import java.util.Scanner;

public class RationaleZahl{
private int zaehler;
private int nenner;
Scanner sc = new Scanner (System.in);

public RationaleZahl(){
zaehler=0;
nenner =1;
}
public RationaleZahl(int zaehler, int nenner)
{this.zaehler=zaehler;
this.nenner=nenner;
}

public int getZaehler() {
return zaehler;
}

public void setZaehler(int zaehler) {
this.zaehler = zaehler;
}

public int getNenner() {
return nenner;
}

public void setNenner(int nenner) {
this.nenner = nenner;
}

public RationaleZahl addiere (RationaleZahl z){
int x;
x= zaehler*z.getNenner()+nenner*z.getZaehler();
int y;
y= nenner*z.getNenner();
return new RationaleZahl (x,y);
}

public RationaleZahl subtrahieren (RationaleZahl z){
int x;
x= zaehler*z.getNenner()-nenner*z.getZaehler();
int y;
y= nenner*z.getNenner();
return new RationaleZahl (x,y);
}

public RationaleZahl multiplizieren (RationaleZahl z){
int x;
x= zaehler*z.getZaehler();
int y;
y= nenner*z.getNenner();
return new RationaleZahl (x,y);
}

public RationaleZahl dividieren (RationaleZahl z){
int x;
x= zaehler*z.getNenner();
int y;
y= nenner*z.getZaehler();
return new RationaleZahl (x,y);
}

public String ausgeben (){
return zaehler + " / "+ nenner;
}

public void kuerzen() {
int i,
n= Math.abs(nenner),
z= Math.abs(zaehler);
while (z > 0){
if( z < n ){
i= n;
n= z;
z= i;
}
z= z - n;
}
nenner= nenner / n;
zaehler= zaehler / n;
}
}

UND

import java.util.ArrayList;
import java.util.Scanner;

public class Start {
static Scanner sc = new Scanner(System.in);

public static void main (String []args){
ArrayList <String> ergebnisse =new ArrayList<String>();
String condition;

do{
System.out.print("Bitte geben Sie nun einen Bruch ein: ");
RationaleZahl rz1 = einleseBruch();
System.out.print("Bitte geben Sie nun den Operator an: ");
String op = einlesenOp();
System.out.print("Bitte geben Sie erneut einen Bruch ein: ");
RationaleZahl rz2 = einleseBruch();
RationaleZahl rzE = null;
switch (op){
case "+": rzE = rz1.addiere(rz2);break;
case "-": rzE = rz1.subtrahieren(rz2);break;
case "*": rzE = rz1.multiplizieren(rz2);break;
case "/": rzE = rz1.dividieren(rz2);break;
}
rzE.kuerzen();
System.out.println(rz1.ausgeben()+" "+op+" "+rz2.ausgeben()+" = "+rzE.ausgeben());
ergebnisse.add(rz1.ausgeben()+" "+op+" "+rz2.ausgeben()+" = "+rzE.ausgeben());

System.out.print("erneute Berechnung? (j/n): ");
condition = sc.next();

}while (!condition.equalsIgnoreCase("n"));
System.out.println();
System.out.println("~~~~~~~~~~~~~~~~");
System.out.println("Berechnet wurden: ");
for (String out : ergebnisse) {
System.out.println(out);
}
System.out.println();
System.out.println("Auf Wiedersehen!");
}

public static RationaleZahl einleseBruch(){
Scanner sc = new Scanner(System.in);
String eingabe=sc.nextLine();;
String[] bla = eingabe.split("/");
bla[0]=bla[0].trim();//selbe für bla 1
bla[1]=bla[1].trim();
return new RationaleZahl(Integer.valueOf(bla[0]),Integer.valueOf(bla[1]));
}

public static String einlesenOp(){
Scanner sc = new Scanner (System.in);
return sc.nextLine();
}
}

Bitte helft mir das Programm umzustrukturieren. Hab das selber noch nich ganz gecheckt deshalbe tue ich mir da schwer :/

push

1. Warum willst du das umstrukturieren? Ihr habt doch jetzt die Lösung, da muss man es doch nicht nochmal abgeben. Ich verstehe den Sinn des Vorhabens nicht. Schau dir lieber die Struktur an und versuche es nachvollziehen.

2. Das Programm, gerade die Klasse RationaleZahl ist so trivial, dass ich sagen muss, das die meisten Programmierer hier wohl mit der gleichen Struktur, wenn nicht sogar mit dem gleichen Code ankommen.

Dinge, die man ändern sollte wären Zeilen wie:
int x;
x = ...;
->
int x = ...;

Allerdings nicht, um die "Struktur" zu ändern, sondern weil es einfach besserer code ist.

Original von noldini
Der Haken ist nur, dass unsere Dozentin alle Quellcodes durch ein Prgramm namens Jpleg jagt, um so Plagiate herauszufinden. [...] Es bringt nix die Variablem umzubennen oder Zeilen zu vertauschen, das Programm achtet einzig und alleine auf die Struktur. Kann mir vielleicht jemand helfen wie ich cie Struktur verändern kann???

Dieses Programm durchsucht das gesamte Web und analysiert dabei noch die Struktur der Quellcodes? Würd mich mal interessieren... "Jpleg" heißt das?

Original von 4ultima

Original von noldini
Der Haken ist nur, dass unsere Dozentin alle Quellcodes durch ein Prgramm namens Jpleg jagt, um so Plagiate herauszufinden. [...] Es bringt nix die Variablem umzubennen oder Zeilen zu vertauschen, das Programm achtet einzig und alleine auf die Struktur. Kann mir vielleicht jemand helfen wie ich cie Struktur verändern kann???

Dieses Programm durchsucht das gesamte Web und analysiert dabei noch die Struktur der Quellcodes? Würd mich mal interessieren... "Jpleg" heißt das?

Heißt JPlag(ist auch i-wie logischer)...

Wenn man was umstrukturieren will, dann sollte man den Source einfach verständlich und gleichmäßig aufbauen - mein Stil wäre z.B. alle lokalen Variablen zu Beginn einer Methode zu definieren, Parameter namentlich von Variablen abzugrenzen(pZaehler z.B.) und auch Rückgabewerte schon zu Beginn der Methode zu initialisieren.

public RationaleZahl subtrahieren (RationaleZahl z){
int x;
x= zaehler*z.getNenner()-nenner*z.getZaehler();
int y;
y= nenner*z.getNenner();
return new RationaleZahl (x,y);
}

zu

public RationaleZahl subtrahieren (RationaleZahl z){
RationaleZahl ret= new RationaleZahl();
ret.setZaehler(zaehler*z.getNenner()-nenner*z.getZaehler());
ret.setNenner( nenner*z.getNenner())
return ret;
}

oder zu:
public RationaleZahl subtrahieren (RationaleZahl z){
return new RationaleZahl (zaehler*z.getNenner()-nenner*z.getZaehler(),nenner*z.getNenner());
}

Allerdings dann bitte drauf achten, dass man im gesamten Sourcecode den gleichen Stil hat...also nicht eine Rechenart als superkurze Variante und eine mit x,y und eine mit return-Variable, sondern schon alle gleich.

btw wird deine Dozentin das Programm höchstwahrscheinlich benutzen, um rauszufinden, ob jemand innerhalb des Kurses abgeschrieben hab, das web zu durchsuchen ist ein riesenaufwand.

Viel mehr kannst du eigentlcih nicht machen, ein großteil der Klasse ist ja schon vorgegeben(insbesondere Syntax der Methoden, etc.) - es gibt einfach kaum Spielraum und die Anfängerlösung sieht shcon überall gleich aus.