Preisfrage: Wer erkennt ein Muster?

[FatBoy]

Ihr seid genial!

[FatBoy]

Ich noch einmal...

10 Zeilen? Naja, das sieht nach 'etwas' mehr Arbeit aus. :p

java.util.Random
- Random
-- AtomicLong
-- setSeed
--- set
- nextDouble
-- next
--- get
--- compareAndSet

Oder?

[Harley D.]

Nur das wichtigste reicht. Entweder so:

unsigned __int64 seed;

void   Random            (unsigned __int64 seed_in) {
 seed = ((seed_in ^ 0x00000005DEECE66Dui64) & 0x0000FFFFFFFFFFFFui64);
}

double Random_nextDouble () {
 unsigned __int64 z1;
 seed = (((seed * 0x00000005DEECE66Dui64) + 0x000000000000000Bui64) & 0x0000FFFFFFFFFFFFui64);
 z1   = (seed >> 22); z1 <<= (27);
 seed = (((seed * 0x00000005DEECE66Dui64) + 0x000000000000000Bui64) & 0x0000FFFFFFFFFFFFui64);
 z1  += (seed >> 21);
 return ((double) z1 / (double) 0x0020000000000000ui64); 
}

Oder so:

struct PRC1000 {
 struct PRC1000 *prc1000; // SELF
 unsigned __int64 seed;
};
typedef PRC1000 PRC1000;

void prc1000_rand_init       (void *inst_in, unsigned __int64 seed_in) {
 PRC1000 *prc1000 = ((PRC1000 *)(inst_in))->prc1000;
 prc1000->seed = ((seed_in ^ 0x00000005DEECE66Dui64) & 0x0000FFFFFFFFFFFFui64);
}

void prc1000_rand_getnext    (void *inst_in, void *double_out) {
 PRC1000 *prc1000 = ((PRC1000 *)(inst_in))->prc1000;
 unsigned __int64 z1;
 prc1000->seed = (((prc1000->seed * 0x00000005DEECE66Dui64) + 0x000000000000000Bui64) & 0x0000FFFFFFFFFFFFui64);
 z1  = (prc1000->seed >> 22); z1 <<= (27);
 prc1000->seed = (((prc1000->seed * 0x00000005DEECE66Dui64) + 0x000000000000000Bui64) & 0x0000FFFFFFFFFFFFui64);
 z1 += (prc1000->seed >> 21);
*(double *) double_out = ((double) z1 / (double) 0x0020000000000000ui64); 
}

[Harley D. Fan]

Danke

[Harley D. Fan]

Ich kriege auch gar nichts gebacken...

int *a(long paramLong, const int paramInt)
{
	int *arrayOfInt = new int[paramInt];
	jRandom *myRandom = new jRandom;

	myRandom->SetSeed(paramLong);
	for(int i1 = 0; i1 < paramInt; ++i1)
		arrayOfInt[i1] = (int) myRandom->NextDouble() * paramInt;

	return arrayOfInt;
}

char *jdMethod_if(long paramLong, char *paramString)
{
	int i1 = strlen(paramString);
	char *arrayOfChar = new char[strlen(paramString)];
	int *arrayOfInt = a(paramLong, i1);

	if(strlen(paramString) == 0)
		return "";

	arrayOfChar = paramString;
	int i2 = arrayOfChar[arrayOfInt[0]];

	for(int i3 = 0; i3 <= i1 - 2; ++i3) //Beim Debuggen kommt es hier zu einem Fehler...
		arrayOfChar[arrayOfInt[i3]] = arrayOfChar[arrayOfInt[(i3 + 1)]];

	arrayOfChar[arrayOfInt[(i1 - 1)]] = i2;

	return arrayOfChar;
}

[Harley D. Fan]

Hallo,
ich bins noch einmal. Leider blicke ich nun noch weniger durch, als jemals zuvor. Deine Funktionen habe ich in eine Klasse gepackt, das sieht wie folgt aus (jRandom.h):

#ifndef JRAND
#define JRAND

class jRandom
{
public:
	unsigned __int64 seed;

	void SetSeed(unsigned __int64 seed_in)
	{
		this->seed = ((seed_in ^ 0x00000005DEECE66Dui64) & 0x0000FFFFFFFFFFFFui64);
	}

	unsigned __int64 GetSeed()
	{
		return this->seed;
	}

	double NextDouble()
	{
		unsigned __int64 z1;

		this->seed = (((this->seed * 0x00000005DEECE66Dui64) + 0x000000000000000Bui64) & 0x0000FFFFFFFFFFFFui64);
		z1         = (this->seed >> 22); z1 <<= (27);
		this->seed = (((this->seed * 0x00000005DEECE66Dui64) + 0x000000000000000Bui64) & 0x0000FFFFFFFFFFFFui64);
		z1        += (this->seed >> 21);

		return ((double) z1 / (double) 0x0020000000000000ui64);
	}
};

#endif

Dann wollte ich mal schauen, ob sich der Fehler vielleicht schon in der Funktion "a" befindet (siehe vorigen Beitrag). Deswegen habe ich den Inhalt dieser Funktion einfach mal in die main.cpp eingefügt und so getestet:

#include <windows.h>
#include <iostream>
#include "jRandom.h"

using namespace std;

int main(int argc, char *argv[])
{
	long paramLong = 1147;
	int paramInt = 12;

	int *arrayOfInt = new int[paramInt];
	jRandom *myRandom = new jRandom;

	myRandom->SetSeed(paramLong);
	for(int i1 = 0; i1 < paramInt; ++i1)
		cout << (int) myRandom->NextDouble() * paramInt;

	cin.get();
	return 0;
}

Das ergibt, so wie es dort steht, 000000000000. Egal, welchen Wert paramLong hat. In Java ergibt das Gleiche 77271011105300.

Hoffe, dass Du Licht ins Dunkel bringen kannst

[Jester]

Kann es sein, dass der Cast Dir da was kaputt macht?
Benutz mal statt dem (int) nen vernünftigen static_cast, bei dem man auch sieht welcher Ausdruck nun genau gecastet wird. Ansonsten sollte es ja nicht so schwer sein nachzuvollziehen, an welcher Stelle der C++-Code anderer Ergebnisse liefert als der Java-Code.

[Harley D.]

Da fehlt noch eine Klammer :

// cout << (int) myRandom->NextDouble() * paramInt;
cout << (int) (myRandom->NextDouble() * paramInt);

Schließlich soll der Rückgabewert von "myRandom->NextDouble()" erst noch mit "paramInt" multipliziert werden bevor zu einem int (o.ä.) gecastet wird.

[Harley D. Fan]

Danke, aber ich habe immer noch zwei Probleme:

1. Es kommt zu einem Laufzeitfehler an markierter Stelle (Warum?)

char *jdMethod_if(long paramLong, char *paramString)
{
	int i1 = strlen(paramString);
	char *arrayOfChar = new char[strlen(paramString)];
	int *arrayOfInt = a(paramLong, i1);

	if(strlen(paramString) == 0)
		return "";

	arrayOfChar = paramString;
	char c1 = arrayOfChar[arrayOfInt[0]];

	for(int i3 = 0; i3 <= i1 - 2; ++i3)
		arrayOfChar[arrayOfInt[i3]] = arrayOfChar[arrayOfInt[(i3 + 1)]]; // Hier

	arrayOfChar[arrayOfInt[(i1 - 1)]] = c1;

	return arrayOfChar;
}

2. Ich habe das mal mit NetBeans getestet (Java)

package javaapplication1;

import java.util.Random;

public class Main
{
  public static void main(String[] argv)
  {
    System.out.print(jdMethod_if(1147, "NOTICE AUTH :*** Looking up your hostname..."));
  }

  private static String jdMethod_if(long paramLong, String paramString)
  {
    int i1 = paramString.length();
    char[] arrayOfChar = new char[paramString.length()];
    int[] arrayOfInt = a(paramLong, i1);
    if (paramString.length() == 0)
      return "";
    paramString.getChars(0, paramString.length(), arrayOfChar, 0);
    int i2 = arrayOfChar[arrayOfInt[0]];
    for (int i3 = 0; i3 <= i1 - 2; ++i3)
      arrayOfChar[arrayOfInt[i3]] = arrayOfChar[arrayOfInt[(i3 + 1)]];
    arrayOfChar[arrayOfInt[(i1 - 1)]] = (char) i2;
    return new String(arrayOfChar);
  }

  private static int[] a(long paramLong, int paramInt)
  {
    int[] arrayOfInt = new int[paramInt];
    Random localRandom = new Random(paramLong);
    for (int i1 = 0; i1 < paramInt; ++i1)
      arrayOfInt[i1] = (int)(localRandom.nextDouble() * paramInt);
    return arrayOfInt;
  }
}

und da kommt irgendwie nicht " OLkCE .A r y:aIh* uo.T* *upiNomg oostnnHeUT." (wie es richti wäre) sondern ".OrICNoA.TULaTo*p o**knoE H ymue h stng :ui." raus. Olles Java

[Harley D. Fan]

Ergänzung zu Problem Nr. 2:
Auch

jdMethod_if(1147, "NOTICE AUTH :*** Looking up your hostname...");
jdMethod_if(1147, "NOTICE AUTH :*** Looking up your hostname... ");
jdMethod_if(1147, "NOTICE AUTH :*** Looking up your hostname...  ");
jdMethod_if(1147, "NOTICE AUTH  :*** Looking up your hostname...");
jdMethod_if(1147, "NOTICE AUTH  :*** Looking up your hostname... ");
jdMethod_if(1147, "NOTICE AUTH  :*** Looking up your hostname...  ");

und diverse andere Variationen führen nicht zu

OLkCE .A r y:aIh* uo.T* *upiNomg oostnnHeUT.

mit der Funktion aus dem Beitrag vor diesem hier. Habe ich etwas falsch gemacht? Ich habe es, wie geschrieben, einfach mit NetBeans ausgetestet (habe also nicht meine Übersetzung oder deine Portierung benutzt)... deswegen ist mir das Problem so unerklärlich

[Harley D.]

Harley D. Fan schrieb:

Habe ich etwas falsch gemacht?

Diese Funktion aus der "a.class" entschlüsselt den String:

private String jdMethod_if(long paramLong, String paramString)

Und die folgende verschlüsselt ihn (auch in der "a.class"):

private String a(long paramLong, String paramString)

[x]

Ihr scheint ja hier nichts anderes zu tun, als eure Lebenszeit zu verschwenden. Entschuldigt meine Ausdrucksweise, aber das ist doch alles für den Katz...

[Harley D.]

x schrieb:

Ihr scheint ja hier nichts anderes zu tun, als eure Lebenszeit zu verschwenden. Entschuldigt meine Ausdrucksweise, aber das ist doch alles für den Katz...

Inwiefern jetzt, wenn ich mal fragen darf?

[Harley D. Fan]

Noch einmal Danke, aber... (Java)

package javaapplication1;

import java.util.Random;

public class Main
{
  public static void main(String[] argv)
  {
    System.out.print(jdMethod_if(1147, " OLkCE .A r y:aIh* uo.T* *upiNomg oostnnHeUT."));
    //System.out.print();
  }

  private static String jdMethod_if(long paramLong, String paramString)
  {
    int i1 = paramString.length();
    char[] arrayOfChar = new char[paramString.length()];
    int[] arrayOfInt = a(paramLong, i1);
    if (paramString.length() == 0)
      return "";
    paramString.getChars(0, paramString.length(), arrayOfChar, 0);
    int i2 = arrayOfChar[arrayOfInt[0]];
    for (int i3 = 0; i3 <= i1 - 2; ++i3)
      arrayOfChar[arrayOfInt[i3]] = arrayOfChar[arrayOfInt[(i3 + 1)]];
    arrayOfChar[arrayOfInt[(i1 - 1)]] = (char) i2;
    return new String(arrayOfChar);
  }

  private static int[] a(long paramLong, int paramInt)
  {
    int[] arrayOfInt = new int[paramInt];
    Random localRandom = new Random(paramLong);
    for (int i1 = 0; i1 < paramInt; ++i1)
      arrayOfInt[i1] = (int)(localRandom.nextDouble() * paramInt);
    return arrayOfInt;
  }
}

ergibt

init:
deps-jar:
Compiling 1 source file to D:\NetBeansProjects\JavaApplication1\build\classes
compile:
run:
TOgkC  NU A n:Lor* aIoT*uEu*iHome.o stn pyh..
BUILD SUCCESSFUL (total time: 0 seconds)

und...

jdMethod_if(1147, " OLkCE .A r y:aIh* uo.T* *upiNomg oostnnHeUT. "); -> .O.kC  oTu  H:Lhio*NaI.*o ErupemgUo stnn *yAT 
jdMethod_if(1147, "OLkCE .A r y:aIh* uo.T* *upiNomg oostnnHeUT. "); -> .L CEO.oTr uHaks uoIh.* o p NemgUAoytnn*i:*T 
jdMethod_if(1147, "OLkCE .A r y:aIh* uo.T* *upiNomg oostnnHeUT."); -> TLgCEOoAUr  nkohp uaI.*o * *NHme.oystn i:uT.

Weder entschlüsseln noch verschlüsseln klappt mit dieser Funktion korrekt

[Harley D. Fan]

Ganz nebenbei sollte es doch jedem selbst überlassen sein, womit man denn seine Lebenszeit verschwendet.
Ich für meinen Teil freue mich sehr! über Antworten auf meine Fragen und Hilfestellungen!

[Harley D.]

Du hast in der "private int[] a(long paramLong, int paramInt)" eine elementar wichtige Sache übersehen:

private int[] a(long paramLong, int paramInt)
{
(...)
 for (int i1 = 0; i1 < paramInt; ++i1)
 {                          // <- Klammer beachten!
  arrayOfInt[i1] = (int)(localRandom.nextDouble() * paramInt);
  localRandom.nextDouble(); // <- der wird !zweimal! pro Durchgang aufgerufen!
 }                          // <- Klammer beachten!
(...)
}

So. Jetzt verschwende ich erstmal meine Lebenszeit wieder mit der Suche nach wirklich großen Primzahlen (und danach mit schlafen).

[Harley D. Fan]

Man, du bist eine Art Engel! Das funktioniert wunderbar!!!

(Der Decompiler wars :p)