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 hänge mich gerade an einem Problem auf und komme nicht mehr weiter.
zahlenk = (int) ((Math.pow(v, 23))%(187));
In dieser Zeile muss ein Fehler sein, ich finde ihn aber nicht. Es soll bedeuten, dass in der Schleife das i-te Element im Array Zahlenk wie folgt berechnet werden soll:
(v^23) modulo 187
Es kommt aber immer das falsche Ergebnis raus. An v kann es nicht liegen, dass habe ich bereits überprüft.
Ich würde mich sehr über Hilfe freuen und wünsche noch einen schönen Tag
ublic void entschluesseln(String inhalt) throws IOException
{
String[] splitted = inhalt.split(" ");
System.out.println(Arrays.toString(splitted));
int[] zahlenv = new int[splitted.length];
for (int i = 0; i < splitted.length; i++)
{
try
{
zahlenv[i] = Integer.parseInt(splitted[i]);
}
catch (Exception e)
{
System.out.println("Fehler");
}
}
int[] zahlenk = new int[zahlenv.length];
for(int i = 0; i < zahlenk.length; i++)
{
int v = zahlenv[i];
System.out.println(zahlenv[0]);
zahlenk[i] = (int) ((Math.pow(v, 23)) % 187);
System.out.println(Arrays.toString(zahlenk));
}
}
Mein v ist jeweils ein Element für ein Array. Um es mal zu erklären, ich muss einen Text ver- und entschlüsseln mit einem privaten und öffentlichen Schlüssel.
In einer anderen Klasse habe ich den Text eingelesen und da bei der Entschlüsslung nur Zahlen dastehen, splitte ich den String erst auf und wandle es dann in das Array Zahlenv um. Dort stehen dann die verschlüsselten Zahlen. Und jetzt kommt mein Problem: Ich möchte jetzt mit einer Schleife alle Werte in diesem Array mithilfe der bereits angesprochenen Formel (v^23 mod187) berechnen.
Theoretisch rechne ich anstatt der 23 und 187 mit dem privaten und dem öffentlichen Schlüssel, aber die Aufgabe ist aufgeteilt und die Schlüsselgenerierung macht meine Partnerin.
Es ist bisschen viel, das tut mir leid - aber ich finde selber keine Lösung
Stimmt, sie wurde außerhalb von Code-Tags gepostet.
Zum Thema: pow() liefert ein double und das hat nun einmal nur eine begrenzte Genauigkeit, so dass der Remainder-Operator ggf. ein falsches Ergebnis liefert. Hier musst Du entweder statt double einen anderen Typ (z. B. BigInteger) wählen oder die Berechnung ändern.
Ja, das tut mir leid - das habe ich erst danach gesehen... Das hatte ich mir auch schon überlget, aber ich hole mir ja meinen Wert aus einem int-Array. powerFunction funktioniert bei mir irgendwie auch nicht. Mich wundert ja vorallem, dass nicht nichts rauskommt, sondern falsche Werte. Ich weiß aber ehrlich gesagt nicht, wie ich die Berechnung verändern müsste, um das Problem zu umgehen.
v^23 ist so gross, dass es nicht mehr genau darstellbar ist.
Ich würde die Berechnung vornehmen, indem ich in einer for-Schleife die Potenzierung vornehme und jedesmal % 187 rechne.
public class Test {
public static void main(String[] args) {
System.out.println(potenzModulo(30, 23, 187));
}
public static int potenzModulo(int basis, int exponent, int modulo) {
int result = 1;
for (int i = 0; i < exponent; ++i) {
result *= basis;
result %= modulo;
}
return result;
}
}
public class Test {
public static void main(String[] args) {
System.out.println(potenzModulo(30, 23, 187));
}
public static int potenzModulo(int basis, int exponent, int modulo) {
int result = 1;
for (int i = 0; i < exponent; ++i) {
result *= basis;
result %= modulo;
}
return result;
}
}
Beim Schreiben wurde ich vor dem Abschicken durch eine Telko aufgehalten, daher konnte ich jetzt vor dem Abschicken einfach mal den meisten Text löschen. Aber die Darstellung des Problems ist evtl. immer noch interessant, denn ich denke, dass es sehr anschaulich ist, wie sich da die Potenz entwickelt. Eine Möglichkeit, auch mit sehr großen Zahlen zu rechnen, bietet BigDecimal - das ist die Klasse, auf die ich dann in dem folgenden Test zurück greife. (Die eigentliche Lösung wurde schon von @fhoffmann gezeigt)
Java:
package forum;
import org.junit.jupiter.api.Test;
import java.math.BigDecimal;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class MathTest {
@Test
public void testMathPow23() {
for (int i = 1; i < 10; i++) {
BigDecimal intCalcResult = new BigDecimal(calc1(i));
BigDecimal correctResult = calc2(i);
System.out.println("i := " + i + " : " + correctResult + " vs. " + intCalcResult);
assertEquals(correctResult, intCalcResult);
}
}
public int calc1(int v) {
return (int) ((Math.pow(v, 23)) % (187));
}
public BigDecimal calc2(int v) {
BigDecimal m = new BigDecimal(v).pow(23);
System.out.println("Wert vor Modulo: " + m);
return m.remainder(new BigDecimal(187));
}
}
Die Ausgabe:
Code:
Wert vor Modulo: 1
i := 1 : 1 vs. 1
Wert vor Modulo: 8388608
i := 2 : 162 vs. 162
Wert vor Modulo: 94143178827
i := 3 : 181 vs. 181
Wert vor Modulo: 70368744177664
i := 4 : 64 vs. 64
Wert vor Modulo: 11920928955078125
i := 5 : 180 vs. 179
Also schon bei i muss es abweichen, weil der Wert einfach viel zu groß ist um von einem double genau dargestellt werden zu können.
Ach ja - Genauigkeit eines double ist 15(-16) Stellen. Die Zahl bei v=5, die bei der Potenz heraus kommt, hat schon 17 Stellen und ist damit nicht mehr genau abzubilden.
