सवाल यादृच्छिक तारों का उपयोग करके यह कोड "हैलो वर्ल्ड" प्रिंट क्यों करता है?


निम्नलिखित प्रिंट स्टेटमेंट "हैलो वर्ल्ड" प्रिंट करेगा। क्या कोई इसे समझा सकता है?

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

1591
2018-03-03 04:38


मूल


खैर, उन विशेष बीजों को पूरी तरह से काम करने के लिए बस इतना ही होता है। यादृच्छिक वास्तव में यादृच्छिक नहीं है, यह छद्म यादृच्छिक है। - Doorknob
यह काम करता है, जैसा कि अन्य ने कहा है, क्योंकि यादृच्छिक नहीं है। मेरे लिए, उस व्यक्ति को एक और दिलचस्प सवाल किया जाएगा जिसने लिखा है, इसे बलपूर्वक बल दें, या किसी दिए गए बीज के लिए अगले एन मानों के लिए यादृच्छिक उत्पन्न करने का एक आसान तरीका है। ब्रूट फोर्सिंग आसान है और आधुनिक हार्डवेयर के साथ बहुत लंबा समय नहीं लेना चाहिए, इसलिए यह करने का एक व्यवहार्य तरीका था। यह देखते हुए कि यह स्थैतिक है, आप आसानी से नेटवर्क पर खोज वितरित कर सकते हैं। - jmoreno
मुझे इसका उद्देश्य आश्चर्य है n में for (int n = 0; ; n++)। वे उपयोग कर सकते थे for(;;) या while(true) बजाय! - Eng.Fouad
वास्तव में यादृच्छिक अनुक्रम में अंततः प्रत्येक संभावित स्ट्रिंग दिखाई देगी। एक उच्च गुणवत्ता वाले छद्म यादृच्छिक क्रम में उचित लंबाई की लंबाई (लॉग_एस (एन) - एन) बिट्स (जहां एन पीआरएनजी आंतरिक स्थिति में बिट्स की संख्या है और एन एक छोटी संख्या है, उम्मीद कर सकते हैं, सुविधा के लिए 8 चुनें ) चक्र में दिखाई देने के लिए। इस कोड को एक स्वतंत्र रूप से चुने गए हार्डकोडेड स्टार्ट पॉइंट (चरित्र बैकटिक का मान) के उपयोग से कुछ मदद मिलती है जो लगभग 8 बिट्स को वापस ले जाती है। - dmckee
"हैलो वर्ल्ड" प्रिंट करने के अजीब तरीके से विजेता - osdamv


जवाब:


जब एक उदाहरण java.util.Random एक विशिष्ट बीज पैरामीटर के साथ बनाया गया है (इस मामले में -229985452 या -147909649), यह यादृच्छिक संख्या पीढ़ी एल्गोरिदम का पालन करता है शुरू उस बीज मूल्य के साथ।

प्रत्येक Random उसी बीज के साथ निर्मित हर बार संख्याओं के समान पैटर्न उत्पन्न करेगा।


846
2018-03-03 04:40



@ वल्कन - जावाडोक कहता है कि बीज 48 बिट्स है। docs.oracle.com/javase/7/docs/api/java/util/Random.html। और इसके अलावा, वास्तविक बीज 32 बिट मान हैं। - Stephen C
यादृच्छिक संख्या अनुक्रम के प्रत्येक तत्व को मॉड्यूलो 27 लिया जाता है, और प्रत्येक में 6 तत्व होते हैं "hello\0"तथा "world\0"। यदि आप वास्तव में यादृच्छिक जनरेटर मानते हैं, तो आप जिस अनुक्रम की तलाश में थे, उसे पाने के लिए बाधा 27 ^ 6 (387,420,48 9) में 1 होगी - इसलिए यह बहुत प्रभावशाली है लेकिन काफी दिमागी बहती नहीं है! - Russell Borogove
@RussellBorogove: लेकिन उन बाधाओं के साथ, और 2 ^ 64 संभावित बीज, 47.6 बिलियन बीज मूल्यों की उम्मीद है जो अनुक्रम देते हैं। यह सिर्फ एक खोजने का मामला है। - dan04
@ dan04 - मैं उस अनुमान को तैयार करने के लिए तैयार नहीं था; पीआरएनजी के कार्यान्वयन के आधार पर, बीज शब्द का आकार राज्य के आकार के बराबर नहीं हो सकता है, और अनुक्रम पथ समान रूप से वितरित नहीं किए जा सकते हैं। लेकिन फिर भी, बाधाएं निश्चित रूप से अच्छी हैं, और यदि आप एक जोड़ी नहीं पा रहे हैं तो आप अलग आवरण के साथ फिर कोशिश कर सकते हैं ("Hello"  "World"), या उपयोग कर रहे हैं 122-k के बजाय 96+k, या ... - Russell Borogove
@ ThorbjørnRavnAndersen जावाडोक निर्दिष्ट करता है कि "विशेष एल्गोरिदम क्लास रैंडम के लिए निर्दिष्ट हैं। जावा कार्यान्वयन को जावा कोड की पूर्ण पोर्टेबिलिटी के लिए क्लास रैंडम के लिए यहां दिखाए गए सभी एल्गोरिदम का उपयोग करना चाहिए।" - Vulcan


अन्य उत्तरों बताते हैं क्यों, लेकिन यहां कैसे है।

एक उदाहरण दिया गया 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

फिर बस उन संख्याओं को चरित्र के पूर्णांक प्रतिनिधित्व में जोड़ें ` (जो 9 6 है):

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

1086
2018-03-03 04:55



pedantically, new Random(-229985452).nextInt(27) हमेशा 8 लौटाता है। - immibis
@immibis क्यों? मेरा मतलब है कि यादृच्छिक () को हर बार यादृच्छिक संख्या वापस करनी चाहिए, फिक्स ऑर्डर नंबर सेट नहीं? - roottraveller
@rootTraveller एक शुरुआत के लिए, new Random() एक नंबर वापस नहीं करता है। - immibis
@immibis 4 साल और एक महीने देर हो चुकी है, लेकिन फिर के लिए तय है। ; D - jpmc26


मैं इसे यहाँ छोड़ दूंगा। जिनके पास बहुत कुछ (सीपीयू) समय है, वे प्रयोग करने के लिए स्वतंत्र महसूस करते हैं :) इसके अलावा, अगर आपने कुछ फोर्क-जॉइन-फू को महारत हासिल कर लिया है ताकि यह सब कुछ सीपीयू कोर जलाए जा सके (केवल थ्रेड उबाऊ हो, है ना?), कृपया साझा करें तुम्हारा कोड। मुझे इसकी तारीफ़ करने में गर्व है।

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

263
2018-03-03 15:03



@एक दो तीन nextInt(27) सीमा के भीतर मतलब है [0, 26]। - Eng.Fouad
@ वल्कन अधिकांश बीज अधिकतम मूल्य के बहुत करीब होते हैं, जैसे कि यदि आप 1 और 1000 के बीच यादृच्छिक संख्या चुनते हैं, तो आपके द्वारा उठाए जाने वाले अधिकांश नंबरों में तीन अंक होंगे। यह आश्चर्य की बात नहीं है, जब आप इसके बारे में सोचते हैं :) - Thomas
@ वल्कन वास्तव में यदि आप गणित करते हैं तो आप देखेंगे कि वे शून्य के रूप में अधिकतम मूल्य के करीब हैं (मुझे लगता है कि बीज को पीढ़ी कोड में हस्ताक्षरित के रूप में व्याख्या किया जा रहा है)। लेकिन क्योंकि अंकों की संख्या वास्तविक मूल्य के साथ केवल लॉगरिदमिक रूप से बढ़ती है, वास्तव में यह संख्या वास्तव में बंद होने पर वास्तव में बंद दिखती है। - Thomas
एक दिलचस्प और संबंधित नियम है बेनफोर्ड का कानून, यह बताते हुए कि कई प्राकृतिक डेटा स्रोतों में, प्रमुख संख्या "1" और "2" अधिक बार दिखाई देती हैं, इसी कारण से: 9 से 10 तक जाने के लिए 10 से 20 की तुलना में बहुत छोटा कारक लगता है। इस मामले में, से जाने के लिए 0 सेवा मेरे int.max/10 से जाने से बहुत कम लेता है int.max/10 सेवा मेरे int.max। - FeepingCreature
@ मरेक: मुझे नहीं लगता कि छद्म यादृच्छिक देवताओं के इस तरह के व्यवहार की मंजूरी होगी। - Denis Tulskiy


यहां हर किसी ने यह बताने का एक अच्छा काम किया है कि कोड कैसे काम करता है और दिखाता है कि आप अपने उदाहरण कैसे बना सकते हैं, लेकिन यहां एक सूचना सैद्धांतिक उत्तर दिखा रहा है कि क्यों हम उचित रूप से समाधान की उम्मीद कर सकते हैं कि ब्रूट फोर्स सर्च अंततः मिल जाएगी।

26 अलग-अलग निचले केस अक्षर हमारे वर्णमाला बनाते हैं Σ। विभिन्न लंबाई के शब्दों को उत्पन्न करने की अनुमति देने के लिए, हम आगे टर्मिनेटर प्रतीक जोड़ते हैं  एक विस्तारित वर्णमाला पैदा करने के लिए Σ' := Σ ∪ {⊥}

चलो α एक प्रतीक और एक्स एक समान रूप से वितरित यादृच्छिक चर हो Σ'। उस प्रतीक को प्राप्त करने की संभावना, P(X = α), और इसकी सूचना सामग्री, I(α)द्वारा दिए गए हैं:

पी (एक्स = α) = 1 / | Σ '| = 1/27

मैं (α) = -log₂ [पी (एक्स = α)] = -log₂ (1/27) = log₂ (27)

एक शब्द के लिए ω ∈ Σ* और उसका ⊥-समकक्ष समकक्ष ω' := ω · ⊥ ∈ (Σ')*, हमारे पास है

मैं (ω): = मैं (ω ') = | ω' | * log₂ (27) = (| ω | + 1) * log₂ (27)

चूंकि छद्म यादृच्छिक संख्या जेनरेटर (पीआरएनजी) 32-बिट बीज के साथ शुरू किया गया है, इसलिए हम लंबाई के अधिकांश शब्दों की अपेक्षा कर सकते हैं

λ = मंजिल [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


248
2018-03-04 09:49



मेरा सूचना सिद्धांत कमजोर है लेकिन मुझे यह सबूत पसंद है। क्या कोई मुझे लैम्ब्डा लाइन समझा सकता है, स्पष्ट रूप से हम एक दूसरे के साथ सूचना सामग्री को विभाजित कर रहे हैं, लेकिन यह हमें हमारी शब्द-लंबाई क्यों देता है? जैसा कि मैंने कहा था कि मैं थोड़ी सी जंगली हूं इसलिए स्पष्ट पूछने के लिए क्षमा चाहता हूं (एनबी यह शैनन सीमा से कुछ करने के लिए है - कोड आउटपुट से) - Mike H-R
@ माइकएच-आर लैम्ब्डा लाइन है I(⍵) समीकरण पुनर्व्यवस्थित।I(⍵) 32 (बिट्स) और है |⍵| 5 (प्रतीकों) के रूप में बाहर निकला। - iceman


मैंने इन बीजों को खोजने के लिए एक त्वरित कार्यक्रम लिखा:

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

(विचारधारा पर डेमो।)

Ps। -727295876, -128911, -1611659, -235516779


65
2018-03-03 18:33



class R{ public static void main(String[] a) { System.out.println("-229985452, -147909649"); } नौकरी भी करता है। - djechlin


मैं इससे चिंतित था, मैंने एक शब्दकोष शब्द सूची पर इस यादृच्छिक शब्द जनरेटर को चलाया। रेंज: 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 

31
2018-04-13 22:47



आपने अपना दिन आदमी बनाया: डी ने इसे लंबे समय से कोशिश की। मेरा / अधिकतम और मेरे सहयोगियों के नामों की खोज करें और केवल पीटर मिला: (पीटर 4611686018451441623 पीटर 24053719 पीटर -4611686018403334185 पीटर -9223372036830722089 पीटर -4611686017906248127 पीटर 521139777 पीटर 4611686018948527681 पीटर -9223372036333636031 पीटर - 4611686017645756173 पीटर 781631731 पीटर 4611686019209019635 पीटर -9223372036073144077 पीटर -4611686017420317288 पीटर 1007070616 पीटर -9223372035847705192) - Marcel


सबसे यादृच्छिक संख्या जनरेटर वास्तव में, "छद्म यादृच्छिक" हैं। वे रैखिक संगठनात्मक जेनरेटर हैं, या एलसीजी (http://en.wikipedia.org/wiki/Linear_congruential_generator)

एलसीजी एक निश्चित बीज के बाद काफी अनुमानित हैं। असल में, एक बीज का उपयोग करें जो आपको अपना पहला अक्षर देता है, फिर एक ऐप लिखें जो अगली int (char) उत्पन्न करता है जब तक कि आप अपनी लक्ष्य स्ट्रिंग में अगला अक्षर नहीं दबाते और लिखते हैं कि आपको एलसीजी कितनी बार आमंत्रित करना था। तब तक जारी रखें जब तक आप प्रत्येक अक्षर उत्पन्न नहीं कर लेते।


26
2018-03-04 10:59



एक गैर छद्म यादृच्छिक संख्या जेनरेटर का एक उदाहरण क्या है - chiliNUT
@chiliNUT ऐसे जेनरेटर बाहरी गैजेट हैं। कुछ इलेक्ट्रॉनिक दीपक। या बुरी तरह लिखित बिट जो 0 या 1 पढ़ी जाती है। आप यादृच्छिक संख्याओं के शुद्ध डिजिटल जनरेटर नहीं कर सकते हैं, डिजिटल एल्गोरिदम यादृच्छिक नहीं हैं, वे बिल्कुल सटीक हैं। - Gangnus
@chiliNUT कई ऑपरेटिंग सिस्टम इकट्ठा करते हैं एन्ट्रापी। जैसे लिनक्स में आप इसका उपयोग कर सकते हैं /dev/urandom यादृच्छिक डेटा पढ़ने के लिए डिवाइस। हालांकि, यह एक दुर्लभ संसाधन है। इसलिए, इस तरह के यादृच्छिक डेटा आमतौर पर बीज पीआरएनजी के लिए प्रयोग किया जाता है। - Adrian W
@AdrianW विकिपीडिया कहते हैं urandom अभी भी छद्म यादृच्छिक है en.wikipedia.org/wiki//dev/random - chiliNUT
हां, लेकिन यह क्रिप्टोग्राफिक रूप से सुरक्षित है, जिसका अर्थ है कि कोई भी क्रूर बल हमले नहीं कर सकता है (जैसे "यादृच्छिक" अनुक्रम "हैलो वर्ल्ड" के लिए बीज ढूंढना) /dev/random। लेख मैंने उपरोक्त उद्धृत किया है लिनक्स कर्नेल कुंजीपटल समय, माउस आंदोलनों और आईडीई समय से एंट्रॉपी उत्पन्न करता है और विशेष फ़ाइलों / dev / random / / dev / urandom के माध्यम से अन्य ऑपरेटिंग सिस्टम प्रक्रियाओं के लिए यादृच्छिक वर्ण डेटा उपलब्ध कराता है। मुझे विश्वास है कि यह वास्तव में यादृच्छिक है। हो सकता है कि यह पूरी तरह से सही नहीं है। परंतु /dev/random कम से कम शामिल कुछ एन्ट्रॉपी - Adrian W


यादृच्छिक हमेशा एक ही अनुक्रम लौटते हैं। इसका उपयोग क्रमिकरण के रूप में सरणी और अन्य परिचालनों को घुमाने के लिए किया जाता है।

विभिन्न अनुक्रम प्राप्त करने के लिए, "बीज" नामक कुछ स्थिति में अनुक्रम प्रारंभ करना आवश्यक है।

यादृच्छिक सेटिंग को "यादृच्छिक" क्रम के i स्थिति (बीज = -229985452) में यादृच्छिक संख्या मिलती है। फिर इसका उपयोग करता है ASCII बीज की स्थिति के अनुक्रम में अगले 27 वर्ण के लिए कोड जब तक यह मान 0 के बराबर न हो। यह "हैलो" लौटाता है। "दुनिया" के लिए एक ही ऑपरेशन किया जाता है।

मुझे लगता है कि कोड किसी अन्य शब्द के लिए काम नहीं करता था। वह व्यक्ति जो प्रोग्राम किया गया है जो यादृच्छिक अनुक्रम को बहुत अच्छी तरह से जानता है।

यह बहुत अच्छा गीक कोड है!


22
2018-03-03 04:54



मुझे संदेह है कि क्या वह "यादृच्छिक क्रम बहुत अच्छी तरह से जानता है"। अधिक संभावना है कि उसने काम करने वाले एक को खोजने तक अरबों संभावित बीजों की कोशिश की। - dan04
@ dan04 असली प्रोग्रामर केवल पीआरएनजी का उपयोग नहीं करते हैं, वे पूरे अवधि को दिल और मूल्यवान मूल्यों के अनुसार याद करते हैं। - Thomas
"रैंडम हमेशा एक ही अनुक्रम लौटाता है" - रैंडम के बाद रखें () या इसे कोड के रूप में दिखाएं। इसके अलावा वाक्य गलत है। - Gangnus


चूंकि जावा के साथ बहु-थ्रेडिंग बहुत आसान है, यहां एक ऐसा संस्करण है जो उपलब्ध सभी कोरों का उपयोग करके बीज की खोज करता है: 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();
    }
  }
}

22
2017-10-04 23:13



मेरे जैसे जावा नोब के लिए, आपको आउटपुट नंबर को प्रत्यय करने की आवश्यकता है L और तर्क प्रकार को बदलें long, अर्थात। randomString(long i) चारों ओर खेलने के लिए। :) - 林果皞


से व्युत्पन्न डेनिस तुलस्कीजवाब, यह विधि बीज उत्पन्न करता है।

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

13
2018-03-07 13:26





प्रिंसिपल एक ही बीज के साथ निर्मित रैंडम क्लास हर बार संख्याओं का एक ही पैटर्न उत्पन्न करेगा।


13
2018-06-13 20:36