Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Ich sitze gerade an einer Informatikhausaufgabe, bei der wir die binäre Exponentiation implementieren sollen. Das Programm steht soweit und sollte, glaub ich auch funktionieren.
Exponent und Mantisse werden als Kommandozeilenparameter eingelesen und in integer gespeichert.
Nun brauche ich eine Funktion, die mir jedes einzelne Bit vom integer Exponent auf 1 oder 0 prüft. Das ist das einzige was mir fehlt und ich verzweifel dran...
public static boolean testBit(int n, int pos) {
return (n & 1 << pos) != 0;
}
???:L
Ansonsten könnte man sich auch den Binärstring holen und mit charAt schauen ob '0' oder '1' an dem gegeben char steht. Oder habe ich dich gänzlich falsch verstanden?
Ich füg mal meinen bisherigen Programmcode mit ein. Knackpunkt an der Sache ist, dass wir innerhalb der Methode potenzieren, keine anderen Methoden aufrufen dürfen. Wir sollen stattdessen mit Shift-Operatoren und Booleschen Operatoren arbeiten. In der momentanen Version (mit testBit) schimpft der Compiler "cannot find symbol" in Zeile 11 (die Zeile mit testBit, das t ist als falsch markiert)...
Java:
public class Potenzieren {
public static long potenziere(int x, int n, int k) {
long result = x; // entspricht zu diesem Zeitpunkt dem x_0 (siehe Angabe)
for (int i = k; i <= k; i--) { // i entspricht der aktuellen position des bits
if () {
result = result * (x * (x * x));
//n = n << p;
} else {
result = result * (x * x);
//n = n << p;
}
}
return result; // soll hier dem Endergebnis x_k (siehe Angabe) entsprechen
}
public static void main(String[] args) {
int x = Integer.parseInt(args[0]); // x = Mantisse
int n = Integer.parseInt(args[1]); // n = Exponent
int k = Integer.SIZE - Integer.numberOfLeadingZeros(n) - 1; // k = Anzahl benötigter Bits zur Darstellung von n ohne führende 0en und vorzeichen
System.out.println(x + " hoch " + n + " ergibt " + potenziere(x, n, k));
}
}
Hab grad gemerkt, dass ich den falschen code kopiert hab:
Java:
public class Potenzieren {
public static long potenziere(int x, int n, int k) {
long result = x; // entspricht zu diesem Zeitpunkt dem x_0 (siehe Angabe)
for (int i = k; i <= k; i--) { // i entspricht der aktuellen position des bits
if (testBit(n,i) == true) {
result = result * (x * (x * x));
//n = n << p;
} else {
result = result * (x * x);
//n = n << p;
}
}
return result; // soll hier dem Endergebnis x_k (siehe Angabe) entsprechen
}
public static void main(String[] args) {
int x = Integer.parseInt(args[0]); // x = Mantisse
int n = Integer.parseInt(args[1]); // n = Exponent
int k = Integer.SIZE - Integer.numberOfLeadingZeros(n) - 1; // k = Anzahl benötigter Bits zur Darstellung von n ohne führende 0en und vorzeichen
System.out.println(x + " hoch " + n + " ergibt " + potenziere(x, n, k));
}
}
Achso, das muss man erst definieren? Ich dachte, das wäre ne Funktion wie z.B. Math.round oder sowas... hmm, dann hat sich das ja eh erledigt, da ich ja keine Methodenaufrufe machen darf. Ich brauch irgendwie etwas, das mir die Bits nacheinander durchprüft, nur unter Verwendung von Shift- und Booleschen Operatoren. Ansonsten rechne ich die Zahl in Binär um, speicher das Ergebnis als String und prüfe dann nacheinander die Charaktere. Hatte nur gehofft, es gäbe da eine "elegantere" Lösung...
Hä? Hast du meinen Post mit der testBit-Methode übersehen? ;(
Musst ja nicht die Methode kopieren und aufrufen ---> (n & 1 << pos) != 0; und gut ist! Aber ich glaube es wäre besser wenn du dich selbst ein wenig mit der Materie beschäftigst, denn so wie es aussieht hast du großen Nachholbedarf (nicht böse gemeint, mir war aber selbst nicht klar, dass ich hier bei Hausaufgaben helfen würde in meinem ersten Post(habs überlesen ))
Nein, nein aber da es in der Methode drin war, dachte ich irgendwie automatisch, dass ich des net so hernehmen kann.. hm
Das stimmt natürlich, ich hab noch nicht so wahnsinnig viel Ahnung von diesen Booleschen/Shift-Operatoren... aber ich versteh einfach nicht wie mir diese Boole-Dinger wirklich helfen sollen, bei der Anweisung "Wenn an Bitstelle x von Exponent n eine 1 steht, dann mach das". Würdest du mir vielleicht "übersetzen" was (n & 1 << pos) != 0.
Das << steht ja für Linksverschiebung des linken teils (n & 1) um pos-Stellen, was wiederrum auf ungleich 0 geprüft wird, oder ? aber ich versteh das n & 1 noch nicht so ganz ("Exponent n UND 1" ??)
