ทำไมรหัสนี้โดยใช้สตริงสุ่มพิมพ์“ สวัสดีโลก”

คำสั่งพิมพ์ต่อไปนี้จะพิมพ์ "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) มันจะติดตามอัลกอริทึมการสร้างหมายเลขสุ่มที่เริ่มต้นด้วยค่าเมล็ดนั้น

ทุกสิ่งที่Randomสร้างด้วยเมล็ดเดียวกันจะสร้างรูปแบบของตัวเลขที่เหมือนกันทุกครั้ง

คำตอบอื่น ๆ อธิบายว่าทำไม แต่นี่คือวิธี

รับตัวอย่างของRandom:

Random r = new Random(-229985452)

ตัวเลข 6 ตัวแรกที่r.nextInt(27)สร้างคือ:

8
5
12
12
15
0

และตัวเลข 6 ตัวแรกที่r.nextInt(27)สร้างขึ้นมาRandom r = new Random(-147909649)คือ:

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) ในการทดลองอย่าลังเลที่จะทดลอง :) นอกจากนี้หากคุณมีความเชี่ยวชาญในการแยก fork-join-fu เพื่อทำให้สิ่งนี้เผาไหม้แกน CPU ทั้งหมด (เพียงแค่เธรดน่าเบื่อใช่ไหม) โปรดแบ่งปัน รหัสของคุณ ฉันจะขอบคุณมันมาก

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 Σตัวอักษรกรณีที่ต่ำกว่าที่แตกต่างกันในรูปแบบตัวอักษรของเรา ในการอนุญาตให้สร้างคำของความยาวที่แตกต่างกันเรายังเพิ่มสัญลักษณ์ตัว Terminator ให้ผลผลิตขยายตัวอักษร⊥Σ' := Σ ∪ {⊥}

อนุญาตαเป็นสัญลักษณ์และ X Σ'ตัวแปรสุ่มกระจายอย่างสม่ำเสมอมากกว่า ความน่าจะเป็นที่ได้รับสัญลักษณ์นั้นP(X = α)และเนื้อหาข้อมูลI(α)นั้นได้รับจาก:

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

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

สำหรับคำω ∈ Σ*และ⊥-คู่ที่ถูกยกเลิกω' := ω · ⊥ ∈ (Σ')*เรามี

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

เนื่องจาก Pseudorandom Number Generator (PRNG) เริ่มต้นด้วยเมล็ดพันธุ์แบบ 32 บิตเราจึงสามารถคาดหวังคำที่มีความยาวสูงสุดได้

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

ที่จะสร้างโดยอย่างน้อยหนึ่งเมล็ด แม้ว่าเราจะต้องค้นหาคำที่มีความยาว 6 ตัวอักษรเราก็ยังคงประสบความสำเร็จประมาณ 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);
                }
            }
        }
    }
}

ฉันให้มันทำงานในพื้นหลังตอนนี้ แต่มันก็พบคำที่เพียงพอสำหรับ pangram คลาสสิก:

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.

ฉันรู้สึกทึ่งกับสิ่งนี้ฉันจึงใช้เครื่องมือสร้างคำแบบสุ่มนี้ในรายการคำศัพท์ในพจนานุกรม ช่วง: 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();
    }
  }
}

สุ่มกลับลำดับเดียวกันเสมอ มันใช้สำหรับการสับอาร์เรย์และการดำเนินการอื่น ๆ เป็นวิธีเรียงสับเปลี่ยน

ในการรับลำดับที่แตกต่างกันจำเป็นต้องเริ่มต้นลำดับในบางตำแหน่งที่เรียกว่า "seed"

RandomSting รับตัวเลขสุ่มในตำแหน่ง i (seed = -229985452) ของลำดับ "สุ่ม" จากนั้นใช้รหัสASCIIสำหรับอักขระ 27 ตัวถัดไปในลำดับหลังตำแหน่งเมล็ดจนกระทั่งค่านี้เท่ากับ 0 ซึ่งส่งคืน "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 การใช้งาน Java จะต้องใช้อัลกอริทึมทั้งหมดที่แสดงที่นี่สำหรับคลาส Random เพื่อประโยชน์ในการพกพาได้อย่างสมบูรณ์ของโค้ด Java

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

แม้ว่าแปลกคุณจะคิดว่ามีปัญหาด้านความปลอดภัยโดยนัยในการมีตัวเลข 'สุ่ม' ที่คาดการณ์ได้

มันเกี่ยวกับ "เมล็ดพันธุ์" เมล็ดเดียวกันให้ผลเหมือนกัน

นี่คือการปรับปรุงเล็กน้อยสำหรับ Denis Tulskiy คำตอบ มันลดเวลาลงครึ่งหนึ่ง

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