GGT - Codeerklärung gesucht

Status
Nicht offen für weitere Antworten.
D

dehlen

Bekanntes Mitglied
Hallo ich brauch mal wieder eure Hilfe =)

Habe hier folgenden Codeschnipsel:
Java: 
private int ggt() 
        { 
                int a = zähler; 
                int b = nenner; 
                int rest; 

                while(b!=0) 
                { 
                        rest = a%b; 
                        a = b; 
                        b = rest; 
            } 

           return a;

verstehe obigen Code nicht so ganz könntet ihr mir vielleicht helfen und mir das ganze mal erläutern.. ?
Danke!


Also ich verstehe es im Moment so :
es werden 3 ints deklariert
so
dann kommt die while schleife also
solange b nicht 0 ist
soll er der variablen rest den Wert von a Rest b zu teilen
a soll den wert von b annehmen
und
b soll den Wert von Rest annehmen
sodass sozusagen a = der rest ist und somit a der gekürzte Bruch ist
wenn das dann abgeschlossen wurde soll er a zurückgeben, sodass man den gekürzten Bruch erhält..
ist das soweit richtig ?
also das ist eine Methode zum kürzen von Brüchen mithilfe des GGT .. danke für die Antworten =)
 
Zuletzt bearbeitet von einem Moderator:
> Never argue with ..

ok, sagen wir einfach: ja, alles richtig
(sorry 😉 )

edit:
wobei..
> sodass man den gekürzten Bruch erhält..
man erhält a = der GGT zweier Zahlen, das ist nicht der Bruch
 
wie du das im Moment verstehst, ist schon soweit richtig. Der letzte Satz geht nicht ganz hervor:
> sodass sozusagen a = der rest ist und somit a der gekürzte Bruch ist

Also ein Bruch hat für mich immernoch einen Zähler und Nenner (ausser Nenner = 1). Somit kann a alleine ja nicht der gekürtze Bruch sein. Ausserdem ist hier auch nicht a der Rest sondern b.

Aber mal davon abgesehen, ist der Code imho totaler schmarrn... Das hat nichts mit Kürzen von Brüchen zu tun. (nimmt man z.b. 6/3, was 2 Ganze wären, kommt 3/0 raus)
 
Vielleicht ist hier eine "rekursive" Erklärung verständlicher:

1) Gegeben sei ein a und ein b mit a >= b.
2) Falls a ohne Rest durch b teilbar ist, ist b der gesuchte ggT. Fertig.
3) Falls ein Rest bei der Division von a und b bleibt, ist der ggT von a und b gleich dem ggT von b und Rest (*). Benenne b in a um und Rest in b und beginne bei 1)

(*) Warum das funktioniert, ist nicht ganz trivial und hat mit Idealen und Ringen sowie der Eindeutigkeit der Primzerlegung zu tun.

Der obige Algorithmus macht im Prinzip das gleiche, nur mit einer Schleife statt mit Rekursion. Obwohl das Prinzip einfach ist, scheint besonders der "Umbenennen"-Teil vielen Einsteigern Probleme zu machen.

Ab besten vollziehst du das mal mit Papier und Bleistift an ein paar Beispielen durch

a = 24, b = 15
24 / 15 = 1, Rest 9.
Also "altes b" = "neues a" = 15, Rest = "neues b" = 9
15 / 9 = 1, Rest 6
Also "altes b" = "neues a" = 9, Rest = "neues b" = 6
9 / 6 = 1, Rest 3
Also "altes b" = "neues a" = 6, Rest = "neues b" = 3
6 / 3 = 2, Rest 0.
Das letzte b = 3 ist der gesuchte ggT.
 
Zuletzt bearbeitet:
man sollte noch erwähnen, daß "zähler, nenner" als bezeichnung falsch verstanden werden kann, besser wäre groessereZahl und kleinereZahl. dann erkennt man eher, daß hier ein GGT berechnet wird, statt eines Bruches (zähler, nenner).
 
das schon eher (edit @Andi_CH). einen Bruch kürzen ist in einer methode imho eh blöd darstellbar (ausser man liefert einen String oder ein int-Array). Aber dafür hat man ja Klassen (langeweile auf der Arbeit):
Java: 
public class FractionReducer {
	
	private int numerator, denominator;
	
	public FractionReducer(int numerator, int denominator) {
		this.numerator = numerator;
		this.denominator = denominator;
	}
	
	public int getNumerator() {
		return numerator;
	}
	
	public int getDenominator() {
		return denominator;
	}
	
	public void reduce() {
		for (int i = Math.min(numerator, denominator); i > 1; i--) {
			if (numerator % i == 0 && denominator % i == 0) {
				numerator /= i;
				denominator /= i;
				break; // auf Wunsch von Landei
			}
		}
	}
	
	public static void main(String[] args) {
		FractionReducer fr = new FractionReducer(10, 15);
		fr.reduce();
		System.out.println(fr.getNumerator() + "/" + fr.getDenominator());
	}
}
 
Zuletzt bearbeitet:
@nrg: Dein reduce() ist so ziemlich die verschwenderischste Implementierung, die man finden kann. Die Berechnung des ggT ist wesentlich effizienter.
 
oh man wie kleinlich. dann macht man in die for-schleife im if halt noch ein break....

edit: was vllt aber noch hinzuzufügen ist: ich hab zu meiner Schande gar nicht gecheckt, dass der Code ansich wohl doch nicht so ein Schmarrn ist. war viel zu sehr bei dem Bruch als Ganzes und hab das mitm ggt erst nach deinem Post gemerkt (meinen letzten Post hatte ich nach Andi_CH Post angefangen zu schreiben)
 
Zuletzt bearbeitet:
ok danke für eure antworten... also
zusammenfassung für mich ... meine erklärung war fast richtig... 😀

aber der Code ist nicht zum kuerzen geeignet ?!... wenn ja verbesserungsvorschläge?

Danke
 
sinnvollerweise kürzt man ja mit dem ggT... insofern kannst du dir deine (saudumme) Frage hoffentlich selbst beantworten :lol:
 
dehlen hat gesagt.:
ok danke für eure antworten... also
zusammenfassung für mich ... meine erklärung war fast richtig... 😀

aber der Code ist nicht zum kuerzen geeignet ?!... wenn ja verbesserungsvorschläge?

Danke
Zum Vergrößern anklicken....

Hm - also nach der chaotischen, kreativen Phase ein Neustart?

Möchtest du eine Klasse Bruch mit Zähler und Nenner und einer Operation "kürzen" die den Bruch optimal kürzt?
Darin kann dein Ansatz einen GGT zu finden möglicherweise vewendet werden.
 
ja genau das meinte ich .. wich wollte keine vorschläge wie ich den ggt verwenden kann sondern wie ich meine fassung verbessern kann...

Wäre sowas hier besser ?

Java: 
 private static int ggt(int zahl1, int zahl2) {
   while (zahl2 != 0) {
     if (zahl1 > zahl2) {
       zahl1 = zahl1 - zahl2;
     } else {
       zahl2 = zahl2 - zahl1;
     }
   }
   return zahl1;
 }

Was haltet ihr von der Fassung
 
ok habe es nun rekursiv mit modulo gelöst... denke ich 😀
Java: 
 public static int ggT (int x, int y) {
	    if(y != 0) return ggT(y, x % y);
	    return x;
	}
}

Ist das nun eine bessere Methode?

Also wenn ich das ausführe bekomme ich zumindest keinen syntax error.... hätte nur gern gewusst ob diese Methode nun effizienter ist als meine erste ?!
 
Zuletzt bearbeitet:
Oh ok... Naja auch egal sie funktioniert ja und von daher.. :d
Muss noch für ne Arbeit lernen deswegen sollte ich mich eigentlich nicht von diesem Problem aufhalten lassen... Wollte ja eigentlich nur den Code verstehen und das habe ich ja jetzt 🙂
Die Verbesserung ist ja einfach nur noch ne "Schönheitsoperation"
Also vielen dank für die antworten
 
Hallo,
hab das bisher mitverfolgt und hätte noch so ne kleine Bitte wenn es geht.
Ich schreibe morgen eine Info Klausur und habe immer noch keine zusammenfassung über Sinn und Verwendung von Java.
Also wann man String nimmt, was void/main heißt, wann private/public...usw.
Unser Lehrer hat das offensichtlich nicht für so wichtig gehalten bzw nur ganz kurz am Rande erklärt.
Wäre wirklich nett wenn mir einer kurz mal ne Erklärung für die verschiedenen Sachen schreiben könnte.
LG
Laura
schonmal DANKE im voraus
 
hm, das sind alles Grundlegende Elemente vom Java.
Das soll man dir bis morgen erklären? Behaupte mal zu sagen dass das nichts wird.

Hast du irgendwelche vorkenntnisse in java?
 
Ja also klar ich hab ein halbes jahr lang info unterricht
und programmieren klappt ja auch
aber halt so alles ma generell...der hat uns das immer nur für die aufgabe erklärt und nich allgemein das is ja mein problem...
-.-
 
Status
Nicht offen für weitere Antworten.

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Codeerklärung Memory
Antworten: 12
Codeerklärung benötigt
Antworten: 12
GGT
Antworten: 15
Brüche kürzen mittels Methoden und ggT
Antworten: 15
ggT
Antworten: 3

Zurück
Oben