जावा जनरेटिंग गैर-दोहराव यादृच्छिक संख्या

Question

मैं जावा में डुप्लीकेट के बिना यादृच्छिक संख्याओं का एक सेट बनाना चाहता हूं।

उदाहरण के लिए मैं 9999

यहाँ करने के लिए 0 से 10,000 यादृच्छिक पूर्णांकों स्टोर करने के लिए एक सरणी है क्या मैं अब तक है:

import java.util.Random; 
public class Sort{ 

    public static void main(String[] args){ 

     int[] nums = new int[10000]; 

     Random randomGenerator = new Random(); 

     for (int i = 0; i < nums.length; ++i){ 
      nums[i] = randomGenerator.nextInt(10000); 
     } 
    } 
} 

लेकिन इसके बाद के संस्करण कोड डुप्लिकेट पैदा करता है। मैं कैसे सुनिश्चित कर सकता हूं कि यादृच्छिक संख्या दोहराना नहीं है?

Answer 1

Integer[] arr = {...}; 
Collections.shuffle(Arrays.asList(arr)); 

उदाहरण के लिए:

public static void main(String[] args) { 
    Integer[] arr = new Integer[1000]; 
    for (int i = 0; i < arr.length; i++) { 
     arr[i] = i; 
    } 
    Collections.shuffle(Arrays.asList(arr)); 
    System.out.println(Arrays.toString(arr)); 

} 

Answer 2

Achintya झा यहाँ सही विचार है। डुप्लिकेट को हटाने के तरीके के बारे में सोचने के बजाय, आप डुप्लिकेट को पहली जगह बनाने की क्षमता को हटा देते हैं।

यदि आप इनट्स की एक सरणी के साथ रहना चाहते हैं और अपने ऑर्डर को यादृच्छिक बनाना चाहते हैं (मैन्युअल रूप से, जो काफी सरल है) इन चरणों का पालन करें।

1. आकार एन की सरणी बनाएं।
2. लूप के माध्यम से इंडेक्स पर प्रत्येक मान को प्रारंभ करें और प्रारंभ करें I (या i + 1 यदि आप संख्या 1 से n के बजाय 0 से n होना चाहते हैं)।
3. आखिरकार, सरणी के माध्यम से लूप को एक मान के लिए प्रत्येक मान को एक यादृच्छिक अनुक्रमणिका पर दोबारा बदलना।

आपका कोड ऐसा दिखाई करने के लिए संशोधित किया जा सकता है:

import java.util.Random; 

public class Sort 
{ 
    // use a constant rather than having the "magic number" 10000 scattered about 
    public static final int N = 10000; 

    public static void main(String[] args) 
    { 
     //array to store N random integers (0 - N-1) 
     int[] nums = new int[N]; 

     // initialize each value at index i to the value i 
     for (int i = 0; i < nums.length; ++i) 
     { 
      nums[i] = i; 
     } 

     Random randomGenerator = new Random(); 
     int randomIndex; // the randomly selected index each time through the loop 
     int randomValue; // the value at nums[randomIndex] each time through the loop 

     // randomize order of values 
     for(int i = 0; i < nums.length; ++i) 
     { 
      // select a random index 
      randomIndex = randomGenerator.nextInt(nums.length); 

      // swap values 
      randomValue = nums[randomIndex]; 
      nums[randomIndex] = nums[i]; 
      nums[i] = randomValue; 
     } 
    } 
} 

और अगर मैं तुम्हें थे मैं संभावना नहीं बल्कि एक बड़े मुख्य विधि की तुलना में अलग है, छोटे तरीकों में इन ब्लॉकों में से प्रत्येक के टूट जाएगा।

उम्मीद है कि इससे मदद मिलती है।

Answer 3

public class Randoms { 

static int z, a = 1111, b = 9999, r; 

public static void main(String ... args[]) 
{ 
     rand(); 
} 

    public static void rand() { 

    Random ran = new Random(); 
    for (int i = 1; i == 1; i++) { 
     z = ran.nextInt(b - a + 1) + a; 
     System.out.println(z); 
     randcheck(); 
    } 
} 

private static void randcheck() { 

    for (int i = 3; i >= 0; i--) { 
     if (z != 0) { 
      r = z % 10; 
      arr[i] = r; 
      z = z/10; 
     } 
    } 
    for (int i = 0; i <= 3; i++) { 
     for (int j = i + 1; j <= 3; j++) { 
      if (arr[i] == arr[j]) { 
       rand(); 
      } 
     } 

    } 
} 
} 

Answer 4

एक साधारण एल्गोरिथ्म है कि आप डुप्लिकेट के बिना यादृच्छिक संख्या देता है पुस्तक Programming Pearls पी में पाया जा सकता। 127.

ध्यान: परिणामस्वरूप सरणी क्रम में संख्याएं शामिल हैं! यदि आप उन्हें यादृच्छिक क्रम में चाहते हैं, तो आपको Fisher–Yates shuffle के साथ या किसी सूची का उपयोग करके और Collections.shuffle() पर कॉल करके सरणी को घुमाएं।

इस एल्गोरिदम का लाभ यह है कि आपको सभी संभावित संख्याओं के साथ एक सरणी बनाने की आवश्यकता नहीं है और रनटाइम जटिलता अभी भी रैखिक O(n) है।

public static int[] sampleRandomNumbersWithoutRepetition(int start, int end, int count) { 
    Random rng = new Random(); 

    int[] result = new int[count]; 
    int cur = 0; 
    int remaining = end - start; 
    for (int i = start; i < end && count > 0; i++) { 
     double probability = rng.nextDouble(); 
     if (probability < ((double) count)/(double) remaining) { 
      count--; 
      result[cur++] = i; 
     } 
     remaining--; 
    } 
    return result; 
} 

Answer 5

इस बारे में कैसे?

LinkedHashSet<Integer> test = new LinkedHashSet<Integer>(); 
Random random = new Random(); 
do{ 
    test.add(random.nextInt(1000) + 1); 
}while(test.size() != 1000); 

उपयोगकर्ता तो पाश के लिए एक का उपयोग कर Set के माध्यम से पुनरावृति कर सकते हैं।

Answer 6

आप अंतराल के साथ नंबर जेनरेट जरूरत है, यह बस ऐसे ही हो सकता है:

Integer[] arr = new Integer[((int) (Math.random() * (16 - 30) + 30))]; 
for (int i = 0; i < arr.length; i++) { 
arr[i] = i; 
} 
Collections.shuffle(Arrays.asList(arr)); 
System.out.println(Arrays.toString(arr));` 

परिणाम:

[1, 10, 2, 4, 9, 8, 7, 13, 18, 17, 5, 21, 12, 16, 23, 20, 6, 0, 22, 14, 24, 15, 3, 11, 19]

नोट:

आप शून्य है कि जरूरत है छोड़ नहीं देता है आप एक "अगर"