ランダムな文字列を使用したこのコードが "hello world"を表示するのはなぜですか？
次のprint文は "hello world"を印刷します。誰もがこれを説明できますか？
System.out.println(randomString(-229985452) + " " + randomString(-147909649));
そしてrandomString()はこのようになります：
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();
}
特定のシードパラメータ（この場合はJava.util.Randomまたは-229985452）を使用して-147909649のインスタンスを構築すると、そのシード値を使用して乱数生成アルゴリズム beginning に従います。
同じシードで構築されたすべてのRandomは、毎回同じパターンの数を生成します。
他の答えはその理由を説明していますが、ここではその方法です。
Randomのインスタンスがあるとします。
Random r = new Random(-229985452)
r.nextInt(27)が生成する最初の6つの数は以下のとおりです。
8
5
12
12
15
0
そしてr.nextInt(27)が与えられたRandom r = new Random(-147909649)が生成する最初の6つの数は以下の通りです。
23
15
18
12
4
0
それから、それらの数を文字`の整数表現（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
ここに置いておきます。余計な（CPU）時間がある人は、試してみてください:)また、これですべてのCPUコアを焼き尽くすためにfork-join-fuを習得したことがある場合は（スレッドがつまらない、そうでしょ？）あなたのコードとても感謝しています。
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();
}
出力：
-9223372036808280701
Using base: 'Z'
stack
-9223372036853943469
Using base: 'b'
over
-9223372036852834412
Using base: 'e'
flow
-9223372036838149518
Using base: 'd'
rulez
Took 7087 ms
ここにいる人全員がコードのしくみを説明し、あなたがあなた自身の例をどのように構成することができるかを示すのに素晴らしい仕事をしました。
26種類の小文字でアルファベットがΣになっています。異なる長さの単語を生成することを可能にするために、我々はさらに拡張アルファベット⊥をもたらすためにターミネータシンボルΣ' := Σ ∪ {⊥}を追加する。
αをシンボル、XをΣ'上の一様分布確率変数とします。そのシンボルP(X = α)とその情報内容I(α)を取得する確率は、次の式で与えられます。
P（X =α）= 1/|Σ '| = 1/27
I(α) = -log₂[P(X = α)] = -log₂(1/27) = log₂(27)
Wordのω ∈ Σ*とその⊥-で終了する対応するω' := ω · ⊥ ∈ (Σ')*については、
I(ω) := I(ω') = |ω'| * log₂(27) = (|ω| + 1) * log₂(27)
疑似乱数生成器（PRNG）は32ビットのシードで初期化されるので、最大で長さが最大でもほとんどの単語を予測できます。
λ＝フロア［３２ ／ ｌｏｇ2（２７）］ - １ ＝ ５
少なくとも1つのシードによって生成されます。 6文字のWordを検索したとしても、約41.06％の確率で成功します。汚すぎる格好はやめて。
7文字の場合、1.52％近くを見ていますが、試してみる前に気づいていませんでした。
#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;
}
}
出力を参照してください： http://ideone.com/JRGb3l
私はこれらの種を見つけるための簡単なプログラムを書きました：
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);
}
}
}
}
}
私は今それをバックグラウンドで実行しています、しかしそれはすでに古典的なパングラムのために十分な単語を見つけました：
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);
}
}
}
（ ideoneに関するデモ ）
Ps。 -727295876, -128911, -1611659, -235516779。
私はこれに興味をそそられた、私は辞書の単語リストにこのランダムなWordジェネレータを走らせた。範囲：Integer.MIN_VALUEからInteger.MAX_VALUE
15131件ヒットしました。
int[] arrInt = {-2146926310, -1885533740, -274140519,
-2145247212, -1845077092, -2143584283,
-2147483454, -2138225126, -2147375969};
for(int seed : arrInt){
System.out.print(randomString(seed) + " ");
}
版画
the quick browny fox jumps over a lazy dog
ほとんどの乱数ジェネレータは、実際には「疑似乱数」です。それらは線形合同生成器、またはLCGです（ http://en.wikipedia.org/wiki/Linear_congruential_generator ）
LCGは、種が固定されていればかなり予測可能です。基本的には、あなたの最初の文字を与えるシードを使って、あなたがあなたのターゲット文字列の次の文字に当たるまで次のint（char）を生成し続け、LCGを呼び出す必要があった回数を書き留めます。すべての文字が生成されるまで続けます。
マルチスレッドはJavaでは非常に簡単なので、利用可能なすべてのコアを使用してシードを検索する方法があります。 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();
}
}
}
ランダムは常に同じシーケンスを返します。これは、並べ替えとして配列や他の操作をシャッフルするために使用されます。
異なるシーケンスを取得するには、「シード」と呼ばれるある位置でシーケンスを初期化する必要があります。
RandomStingは、 "ランダム"シーケンスのi位置（seed = -229985452）にある乱数を取得します。次に、この値が0になるまで、シード位置の後のシーケンスの次の27文字に _ ascii _ コードを使用します。これにより、 "hello"が返されます。同じことが "世界"についても行われます。
そのコードは他の言葉ではうまく機能しなかったと思います。それをプログラムした人は、ランダムシーケンスを非常によく知っています。
非常に素晴らしいオタクコードです。
原則は、同じシードで構築されたランダムクラスが毎回同じパターンの数を生成することです。
Denis Tulskiy の答えから派生した、このメソッドはシードを生成します。
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 :/");
}
Javaのドキュメントによると、これはRandomクラスのシード値を指定するときの意図的な機能です。
Randomの2つのインスタンスが同じシードで作成され、それぞれに対して同じ一連のメソッド呼び出しが行われた場合、それらは同じ数列を生成して返します。この性質を保証するために、クラスRandomに対して特定のアルゴリズムが指定されています。 Javaコードの絶対的な移植性のために、Java実装はクラスRandomのためにここに示されたすべてのアルゴリズムを使わなければなりません。
http://docs.Oracle.com/javase/1.4.2/docs/api/Java/util/Random.html
奇妙なことに、予測可能な「乱数」を持つことには暗黙のセキュリティ問題があると思うでしょう。
それは「種」についてです。同じ種は同じ結果を与えます。
これはDenis Tulskiy answer のマイナーな改良です。それは時間を半分にします
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 :/");
}
入力シードがすべてです。同じシードは常に同じ結果をもたらします。プログラムを何度も再実行しても、同じ出力になります。
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());
}
出力
-755142161
-1073255141
-369383326
1592674620
-1524828502
------------
-755142161
-1073255141
-369383326
1592674620
-1524828502