Neden rastgele dizeler kullanan bu kod "merhaba dünya" yazdırıyor?

Aşağıdaki basılı açıklama "merhaba dünya" yazdıracaktır. Herkes bunu açıklayabilir mi?

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

Ve randomString()şöyle görünüyor:

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.RandomBelirli bir tohum parametresiyle (bu örnekte -229985452veya -147909649) bir örneği oluşturulduğunda , o tohum değeriyle başlayan rastgele sayı oluşturma algoritmasını izler .

Her RandomAynı tohum inşa numaraların aynı desene her zaman üretecektir.

Diğer cevaplar nedenini açıklıyor, ama işte nasıl.

Bir örneği verildiğinde Random:

Random r = new Random(-229985452)

Üreten ilk 6 sayı r.nextInt(27):

8
5
12
12
15
0

ve ilk 6 numaraları r.nextInt(27)verilmiştir oluşturur Random r = new Random(-147909649)gibidir:

23
15
18
12
4
0

Sonra bu sayıları karakterin tamsayı gösterimine ekleyin `(96'dır):

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

Sadece burada bırakacağım. Kimin (CPU) yedeklemesi için çok fazla zamanı varsa, denemekten çekinmeyin :) Ayrıca, bu şeyin tüm CPU çekirdeklerini yakmasını sağlamak için bazı fork-join-fu konusunda uzmanlaştıysanız (sadece iş parçacıkları sıkıcı, değil mi?) senin kodun. Çok makbule geçer.

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();
}

Çıktı:

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

Buradaki herkes, kodun nasıl çalıştığını açıklamak ve kendi örneklerinizi nasıl oluşturabileceğinizi göstermek için harika bir iş çıkardı, ancak işte kaba kuvvet aramasının nihayetinde bulacağını bir çözümün var olmasını neden makul bir şekilde beklediğimizi gösteren bir bilgi teorik cevabı.

26 farklı küçük harf alfabemizi oluşturur Σ. Farklı uzunluklarda kelimeler üretilmesine izin vermek için, ⊥genişletilmiş bir alfabe elde etmek için bir sonlandırıcı sembolü ekliyoruz Σ' := Σ ∪ {⊥}.

Izin αvermek bir sembol ve X eşit dağılmış rastgele değişken üzerinde Σ'. Bu simgeyi elde etme olasılığı P(X = α)ve bilgi içeriği I(α)aşağıdakiler tarafından verilir:

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

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

Bir kelime ω ∈ Σ*ve ⊥-sonlandırılan karşılığı için ω' := ω · ⊥ ∈ (Σ')*,

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

Pseudorandom Number Generator (PRNG) 32 bitlik bir tohumla başlatıldığından, çoğu uzun kelimeyi

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

en az bir tohum tarafından üretilir. 6 karakterlik bir kelime arayacak olsak bile, zamanın yaklaşık% 41.06'sında başarılı olurduk. O kadar da eski püskü değil.

7 harf için% 1.52'ye daha yakından bakıyoruz, ancak denemeden önce bunu fark etmemiştim:

#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;
    }
}

Çıktıya bakın: http://ideone.com/JRGb3l

Bu tohumları bulmak için hızlı bir program yazdım:

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);
                }
            }
        }
    }
}

Şimdi arka planda çalışıyor, ama zaten klasik bir pangram için yeterli kelime bulundu:

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);
        }
    }
}

( İdeone hakkında demo. )

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

Bu ilgimi çekti, bu rastgele kelime oluşturucuyu sözlük kelime listesinde çalıştırdım. Aralık: Tamsayı.MIN_VALUE - Tamsayı.MAX_VALUE

15131 sonuç aldım.

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

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

Baskılar

the quick browny fox jumps over a lazy dog 

Çoğu rasgele sayı üreteci aslında "sahte rasgele" dir. Bunlar Doğrusal Konjügasyon Jeneratörleri veya LCG'lerdir ( http://en.wikipedia.org/wiki/Linear_congruential_generator )

LCG'ler sabit bir tohum göz önüne alındığında oldukça öngörülebilirdir. Temel olarak, ilk mektubunuzu veren bir tohum kullanın, ardından hedef dizenizdeki bir sonraki mektubu vuruncaya kadar bir sonraki int (char) oluşturmaya devam eden bir uygulama yazın ve LCG'yi kaç kez çağırmanız gerektiğini yazın. Her harfi üretene kadar devam edin.

Java ile çoklu iş parçacığı kullanımı çok kolay olduğu için, mevcut tüm çekirdekleri kullanarak bir tohum arayan bir varyant var: 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();
    }
  }
}

Rastgele daima aynı sırayı döndürür. Dizileri karıştırmak ve permütasyon olarak diğer işlemleri yapmak için kullanılır.

Farklı sekanslar elde etmek için sekansı "tohum" adı verilen bir pozisyonda başlatmak gerekir.

RandomSting, rastgele sayıyı "rastgele" dizinin i konumunda (tohum = -229985452) alır. Daha sonra bu değer 0'a eşit olana kadar tohum pozisyonundan sonraki dizide sonraki 27 karakter için ASCII kodunu kullanır. Bu "merhaba" döndürür. Aynı işlem "dünya" için de yapılır.

Kodun başka kelimeler için işe yaramadığını düşünüyorum. Programlanan adam rastgele diziyi çok iyi biliyor.

Çok büyük bir geek kodu!

Temel, aynı tohumla inşa edilen Rastgele Sınıf olup, her seferinde aynı sayı desenini üretecektir.

Denis Tulskiy'nin cevabından türetilen bu yöntem tohumu üretir.

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 belgelerinden, bu Random sınıfı için bir tohum değeri belirtilirken kasıtlı bir özelliktir.

Aynı tohumla iki Rastgele örnek oluşturulursa ve her biri için aynı yöntem çağrıları dizisi yapılırsa, aynı sayı dizilerini oluşturur ve döndürürler. Bu özelliği garanti etmek için Random sınıfı için belirli algoritmalar belirtilir. Java uygulamaları, Java kodunun mutlak taşınabilirliği uğruna, Random sınıfı için burada gösterilen tüm algoritmaları kullanmalıdır.

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

Tuhaf, tahmin edilebilir 'rastgele' sayılara sahip olmanın örtük güvenlik sorunları olduğunu düşünürdünüz.

"Tohum" ile ilgili. Aynı tohumlar aynı sonucu verir.

İşte Denis Tulskiy'nin cevabı için küçük bir gelişme . Zamanı yarıya indirir

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 :/");
}

Her şey girdi tohumuyla ilgili . Aynı tohum her zaman aynı sonuçları verir. Programınızı tekrar tekrar çalıştırsanız bile bu aynı çıktıdır.

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());

}

Çıktı

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