Warum druckt dieser Code mit zufälligen Zeichenfolgen "Hallo Welt"?

Die folgende Druckanweisung würde "Hallo Welt" drucken. Könnte jemand das erklären?

System.out.println(randomString(-229985452) + " " + randomString(-147909649));

Und randomString()sieht so aus:

public static String randomString(int i)
{
    Random ran = new Random(i);
    StringBuilder sb = new StringBuilder();
    while (true)
    {
        int k = ran.nextInt(27);
        if (k == 0)
            break;

        sb.append((char)('`' + k));
    }

    return sb.toString();
}

Wenn eine Instanz von java.util.Randommit einem bestimmten Startparameter (in diesem Fall -229985452oder -147909649) erstellt wird, folgt sie dem Zufallszahlengenerierungsalgorithmus, der mit diesem Startwert beginnt .

Jeder, Randomder mit demselben Samen konstruiert wurde, erzeugt jedes Mal das gleiche Zahlenmuster.

Die anderen Antworten erklären warum, aber hier ist wie.

Gegeben eine Instanz von Random:

Random r = new Random(-229985452)

Die ersten 6 Zahlen, die r.nextInt(27)generiert werden , sind:

8
5
12
12
15
0

und die ersten 6 Zahlen, r.nextInt(27)die gegeben werden, Random r = new Random(-147909649)sind:

23
15
18
12
4
0

Fügen Sie dann einfach diese Zahlen zur ganzzahligen Darstellung des Zeichens hinzu `(96):

8  + 96 = 104 --> h
5  + 96 = 101 --> e
12 + 96 = 108 --> l
12 + 96 = 108 --> l
15 + 96 = 111 --> o

23 + 96 = 119 --> w
15 + 96 = 111 --> o
18 + 96 = 114 --> r
12 + 96 = 108 --> l
4  + 96 = 100 --> d

Ich lasse es einfach hier. Wer viel (CPU-) Zeit übrig hat, kann gerne experimentieren :) Wenn Sie einige Fork-Join-Fu beherrschen, damit dieses Ding alle CPU-Kerne verbrennt (nur Threads sind langweilig, oder?), Teilen Sie dies bitte mit dein Code. Ich würde es sehr begrüßen.

public static void main(String[] args) {
    long time = System.currentTimeMillis();
    generate("stack");
    generate("over");
    generate("flow");
    generate("rulez");

    System.out.println("Took " + (System.currentTimeMillis() - time) + " ms");
}

private static void generate(String goal) {
    long[] seed = generateSeed(goal, Long.MIN_VALUE, Long.MAX_VALUE);
    System.out.println(seed[0]);
    System.out.println(randomString(seed[0], (char) seed[1]));
}

public static long[] generateSeed(String goal, long start, long finish) {
    char[] input = goal.toCharArray();
    char[] pool = new char[input.length];
    label:
    for (long seed = start; seed < finish; seed++) {
        Random random = new Random(seed);

        for (int i = 0; i < input.length; i++)
            pool[i] = (char) random.nextInt(27);

        if (random.nextInt(27) == 0) {
            int base = input[0] - pool[0];
            for (int i = 1; i < input.length; i++) {
                if (input[i] - pool[i] != base)
                    continue label;
            }
            return new long[]{seed, base};
        }

    }

    throw new NoSuchElementException("Sorry :/");
}

public static String randomString(long i, char base) {
    System.out.println("Using base: '" + base + "'");
    Random ran = new Random(i);
    StringBuilder sb = new StringBuilder();
    for (int n = 0; ; n++) {
        int k = ran.nextInt(27);
        if (k == 0)
            break;

        sb.append((char) (base + k));
    }

    return sb.toString();
}

Ausgabe:

-9223372036808280701
Using base: 'Z'
stack
-9223372036853943469
Using base: 'b'
over
-9223372036852834412
Using base: 'e'
flow
-9223372036838149518
Using base: 'd'
rulez
Took 7087 ms

Alle hier haben großartige Arbeit geleistet, um zu erklären, wie der Code funktioniert, und um zu zeigen, wie Sie Ihre eigenen Beispiele erstellen können. Hier ist jedoch eine informationstheoretische Antwort, die zeigt, warum wir vernünftigerweise erwarten können, dass es eine Lösung gibt, die die Brute-Force-Suche irgendwann finden wird.

Die 26 verschiedenen Kleinbuchstaben bilden unser Alphabet Σ. Um Wörter unterschiedlicher Länge zu generieren, fügen wir ein Terminatorsymbol hinzu ⊥, um ein erweitertes Alphabet zu erhalten Σ' := Σ ∪ {⊥}.

Sei αein Symbol und X eine gleichmäßig verteilte Zufallsvariable über Σ'. Die Wahrscheinlichkeit, dieses Symbol zu erhalten, P(X = α)und sein Informationsgehalt I(α)sind gegeben durch:

P (X = α) = 1 / | Σ '| = 1/27

I (α) = -log₂ [P (X = α)] = -log₂ (1/27) = log₂ (27)

Für ein Wort ω ∈ Σ*und sein ⊥-terminiertes Gegenstück ω' := ω · ⊥ ∈ (Σ')*haben wir

I (ω): = I (ω ') = | ω' | * log₂ (27) = (| ω | + 1) * log₂ (27)

Da der Pseudozufallszahlengenerator (PRNG) mit einem 32-Bit-Startwert initialisiert wird, können wir die meisten Wörter mit einer Länge von bis zu erwarten

λ = Boden [32 / log₂ (27)] - 1 = 5

von mindestens einem Samen erzeugt werden. Selbst wenn wir nach einem 6-stelligen Wort suchen würden, wären wir in 41,06% der Fälle immer noch erfolgreich. Nicht zu schäbig.

Bei 7 Buchstaben sehen wir näher an 1,52%, aber ich hatte das nicht bemerkt, bevor ich es ausprobiert habe:

#include <iostream>
#include <random>

int main()
{
    std::mt19937 rng(631647094);
    std::uniform_int_distribution<char> dist('a', 'z' + 1);

    char alpha;
    while ((alpha = dist(rng)) != 'z' + 1)
    {
        std::cout << alpha;
    }
}

Siehe die Ausgabe: http://ideone.com/JRGb3l

Ich habe ein schnelles Programm geschrieben, um diese Samen zu finden:

import java.lang.*;
import java.util.*;
import java.io.*;

public class RandomWords {
    public static void main (String[] args) {
        Set<String> wordSet = new HashSet<String>();
        String fileName = (args.length > 0 ? args[0] : "/usr/share/dict/words");
        readWordMap(wordSet, fileName);
        System.err.println(wordSet.size() + " words read.");
        findRandomWords(wordSet);
    }

    private static void readWordMap (Set<String> wordSet, String fileName) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader(fileName));
            String line;
            while ((line = reader.readLine()) != null) {
                line = line.trim().toLowerCase();
                if (isLowerAlpha(line)) wordSet.add(line);
            }
        }
        catch (IOException e) {
            System.err.println("Error reading from " + fileName + ": " + e);
        }
    }

    private static boolean isLowerAlpha (String word) {
        char[] c = word.toCharArray();
        for (int i = 0; i < c.length; i++) {
            if (c[i] < 'a' || c[i] > 'z') return false;
        }
        return true;
    }

    private static void findRandomWords (Set<String> wordSet) {
        char[] c = new char[256];
        Random r = new Random();
        for (long seed0 = 0; seed0 >= 0; seed0++) {
            for (int sign = -1; sign <= 1; sign += 2) {
                long seed = seed0 * sign;
                r.setSeed(seed);
                int i;
                for (i = 0; i < c.length; i++) {
                    int n = r.nextInt(27);
                    if (n == 0) break;
                    c[i] = (char)((int)'a' + n - 1);
                }
                String s = new String(c, 0, i);
                if (wordSet.contains(s)) {
                    System.out.println(s + ": " + seed);
                    wordSet.remove(s);
                }
            }
        }
    }
}

Ich habe es jetzt im Hintergrund laufen lassen, aber es hat bereits genug Wörter für ein klassisches Pangram gefunden:

import java.lang.*;
import java.util.*;

public class RandomWordsTest {
    public static void main (String[] args) {
        long[] a = {-73, -157512326, -112386651, 71425, -104434815,
                    -128911, -88019, -7691161, 1115727};
        for (int i = 0; i < a.length; i++) {
            Random r = new Random(a[i]);
            StringBuilder sb = new StringBuilder();
            int n;
            while ((n = r.nextInt(27)) > 0) sb.append((char)('`' + n));
            System.out.println(sb);
        }
    }
}

( Demo auf ideone. )

Ps. -727295876, -128911, -1611659, -235516779.

Ich war fasziniert davon, ich habe diesen Zufallswortgenerator auf einer Wörterbuchwortliste ausgeführt. Bereich: Integer.MIN_VALUE bis Integer.MAX_VALUE

Ich habe 15131 Treffer.

int[] arrInt = {-2146926310, -1885533740, -274140519, 
                -2145247212, -1845077092, -2143584283,
                -2147483454, -2138225126, -2147375969};

for(int seed : arrInt){
    System.out.print(randomString(seed) + " ");
}

Druckt

the quick browny fox jumps over a lazy dog 

Die meisten Zufallszahlengeneratoren sind tatsächlich "pseudozufällig". Sie sind lineare kongruente Generatoren oder LCGs ( http://en.wikipedia.org/wiki/Linear_congruential_generator )

LCGs sind bei einem festen Startwert ziemlich vorhersehbar. Verwenden Sie grundsätzlich einen Startwert, der Ihnen Ihren ersten Buchstaben gibt, und schreiben Sie dann eine App, die weiterhin das nächste int (char) generiert, bis Sie den nächsten Buchstaben in Ihrer Zielzeichenfolge treffen, und notieren Sie, wie oft Sie die LCG aufrufen mussten. Fahren Sie fort, bis Sie jeden einzelnen Buchstaben generiert haben.

Da Multithreading mit Java sehr einfach ist, finden Sie hier eine Variante, die mit allen verfügbaren Kernen nach einem Startwert sucht: http://ideone.com/ROhmTA

import java.util.ArrayList;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

public class SeedFinder {

  static class SearchTask implements Callable<Long> {

    private final char[] goal;
    private final long start, step;

    public SearchTask(final String goal, final long offset, final long step) {
      final char[] goalAsArray = goal.toCharArray();
      this.goal = new char[goalAsArray.length + 1];
      System.arraycopy(goalAsArray, 0, this.goal, 0, goalAsArray.length);
      this.start = Long.MIN_VALUE + offset;
      this.step = step;
    }

    @Override
    public Long call() throws Exception {
      final long LIMIT = Long.MAX_VALUE - this.step;
      final Random random = new Random();
      int position, rnd;
      long seed = this.start;

      while ((Thread.interrupted() == false) && (seed < LIMIT)) {
        random.setSeed(seed);
        position = 0;
        rnd = random.nextInt(27);
        while (((rnd == 0) && (this.goal[position] == 0))
                || ((char) ('`' + rnd) == this.goal[position])) {
          ++position;
          if (position == this.goal.length) {
            return seed;
          }
          rnd = random.nextInt(27);
        }
        seed += this.step;
      }

      throw new Exception("No match found");
    }
  }

  public static void main(String[] args) {
    final String GOAL = "hello".toLowerCase();
    final int NUM_CORES = Runtime.getRuntime().availableProcessors();

    final ArrayList<SearchTask> tasks = new ArrayList<>(NUM_CORES);
    for (int i = 0; i < NUM_CORES; ++i) {
      tasks.add(new SearchTask(GOAL, i, NUM_CORES));
    }

    final ExecutorService executor = Executors.newFixedThreadPool(NUM_CORES, new ThreadFactory() {

      @Override
      public Thread newThread(Runnable r) {
        final Thread result = new Thread(r);
        result.setPriority(Thread.MIN_PRIORITY); // make sure we do not block more important tasks
        result.setDaemon(false);
        return result;
      }
    });
    try {
      final Long result = executor.invokeAny(tasks);
      System.out.println("Seed for \"" + GOAL + "\" found: " + result);
    } catch (Exception ex) {
      System.err.println("Calculation failed: " + ex);
    } finally {
      executor.shutdownNow();
    }
  }
}

Random gibt immer die gleiche Sequenz zurück. Es wird zum Mischen von Arrays und anderen Operationen als Permutationen verwendet.

Um verschiedene Sequenzen zu erhalten, muss die Sequenz an einer Position initialisiert werden, die als "Startwert" bezeichnet wird.

Das randomSting erhält die Zufallszahl an der i-Position (seed = -229985452) der "zufälligen" Sequenz. Verwendet dann den ASCII- Code für die nächsten 27 Zeichen in der Sequenz nach der Startposition, bis dieser Wert gleich 0 ist. Dies gibt das "Hallo" zurück. Die gleiche Operation wird für "Welt" durchgeführt.

Ich denke, dass der Code für keine anderen Wörter funktioniert hat. Der Typ, der programmiert hat und die zufällige Reihenfolge sehr gut kennt.

Es ist sehr toller Geek-Code!

Das Prinzip ist, dass die Zufallsklasse, die mit demselben Startwert erstellt wurde, jedes Mal dasselbe Zahlenmuster generiert.

Aus der Antwort von Denis Tulskiy abgeleitet , erzeugt diese Methode den Samen.

public static long generateSeed(String goal, long start, long finish) {
    char[] input = goal.toCharArray();
    char[] pool = new char[input.length];
    label:
        for (long seed = start; seed < finish; seed++) {
            Random random = new Random(seed);

            for (int i = 0; i < input.length; i++)
                pool[i] = (char) (random.nextInt(27)+'`');

            if (random.nextInt(27) == 0) {
                for (int i = 0; i < input.length; i++) {
                    if (input[i] != pool[i])
                        continue label;
                }
                return seed;
            }

        }

    throw new NoSuchElementException("Sorry :/");
}

In den Java-Dokumenten ist dies eine beabsichtigte Funktion, wenn ein Startwert für die Random-Klasse angegeben wird.

Wenn zwei Instanzen von Random mit demselben Startwert erstellt werden und für jeden dieselbe Sequenz von Methodenaufrufen ausgeführt wird, werden identische Zahlenfolgen generiert und zurückgegeben. Um diese Eigenschaft zu gewährleisten, werden bestimmte Algorithmen für die Klasse Random angegeben. Java-Implementierungen müssen alle hier gezeigten Algorithmen für die Klasse Random verwenden, um die absolute Portabilität von Java-Code zu gewährleisten.

http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Random.html

Seltsamerweise würden Sie denken, dass es implizite Sicherheitsprobleme gibt, wenn vorhersehbare Zufallszahlen vorliegen.

Es geht um "Samen". Gleiche Samen ergeben das gleiche Ergebnis.

Hier ist eine kleine Verbesserung für Denis Tulskiy Antwort . Es halbiert die Zeit

public static long[] generateSeed(String goal, long start, long finish) {
    char[] input = goal.toCharArray();

    int[] dif = new int[input.length - 1];
    for (int i = 1; i < input.length; i++) {
        dif[i - 1] = input[i] - input[i - 1];
    }

    mainLoop:
    for (long seed = start; seed < finish; seed++) {
        Random random = new Random(seed);
        int lastChar = random.nextInt(27);
        int base = input[0] - lastChar;
        for (int d : dif) {
            int nextChar = random.nextInt(27);
            if (nextChar - lastChar != d) {
                continue mainLoop;
            }
            lastChar = nextChar;
        }
        if(random.nextInt(27) == 0){
            return new long[]{seed, base};
        }
    }

    throw new NoSuchElementException("Sorry :/");
}

Es geht nur um den Input Seed . Gleicher Samen liefert immer die gleichen Ergebnisse. Auch wenn Sie Ihr Programm immer wieder neu ausführen, ist es die gleiche Ausgabe.

public static void main(String[] args) {

    randomString(-229985452);
    System.out.println("------------");
    randomString(-229985452);

}

private static void randomString(int i) {
    Random ran = new Random(i);
    System.out.println(ran.nextInt());
    System.out.println(ran.nextInt());
    System.out.println(ran.nextInt());
    System.out.println(ran.nextInt());
    System.out.println(ran.nextInt());

}

Ausgabe

-755142161
-1073255141
-369383326
1592674620
-1524828502
------------
-755142161
-1073255141
-369383326
1592674620
-1524828502