जावा में अद्वितीय रैंडम नंबर उत्पन्न करना

Question 1

मैं 0 और 100 के बीच यादृच्छिक संख्याओं को प्राप्त करने की कोशिश कर रहा हूं। लेकिन मैं चाहता हूं कि वे अद्वितीय हों, एक क्रम में दोहराए नहीं। उदाहरण के लिए यदि मुझे 5 नंबर मिले हैं, तो उन्हें 82,12,53,64,32 होना चाहिए और न कि 82,12,53,12,32 मैंने इसे इस्तेमाल किया है, लेकिन यह एक क्रम में समान संख्याएं उत्पन्न करता है।

Random rand = new Random();
selected = rand.nextInt(100);

Question 2

सीमा में प्रत्येक संख्या को क्रमिक रूप से सूची संरचना में जोड़ें।
इसे शफल करें ।
पहले 'एन' को लें।

यहाँ एक सरल कार्यान्वयन है। यह 1-10 रेंज से 3 अद्वितीय यादृच्छिक संख्याओं को प्रिंट करेगा।

import java.util.ArrayList;
import java.util.Collections;

public class UniqueRandomNumbers {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        for (int i=1; i<11; i++) {
            list.add(new Integer(i));
        }
        Collections.shuffle(list);
        for (int i=0; i<3; i++) {
            System.out.println(list.get(i));
        }
    }
}

मूल दृष्टिकोण के साथ फिक्स का पहला भाग, जैसा कि मार्क बायर्स ने अब डिलीट किए गए उत्तर में बताया है, केवल एक Randomउदाहरण का उपयोग करना है ।

यही कारण है कि संख्या समान होने का कारण बन रही है। एक Randomउदाहरण मिलीसेकंड में वर्तमान समय के आधार पर होता है। एक विशेष बीज मूल्य के लिए, 'यादृच्छिक' उदाहरण छद्म यादृच्छिक संख्याओं के ठीक उसी क्रम को वापस कर देगा ।

ध्यान दें कि public Integer(int value)कंस्ट्रक्टर deprecatedजावा 9 के बाद से है।

लूप के लिए पहले बस इसे बदला जा सकता है:

for (int i = 1; i < 11; i++) {
  list.add(i);
}

Question 3

जावा 8+ के साथ आप तब यादृच्छिक मानों को प्राप्त करने के लिए और अद्वितीय यादृच्छिक मानों की धारा को कम करने के लिए intsविधि का उपयोग कर सकते हैं ।RandomIntStreamdistinctlimit

ThreadLocalRandom.current().ints(0, 100).distinct().limit(5).forEach(System.out::println);

Randomअगर आपके पास इसके बजाय जरूरत है, तो LongStreamएस और DoubleStreamएस बनाने के तरीके भी हैं ।

यदि आप एक क्रम में सभी (या बड़ी मात्रा में) संख्याओं को एक यादृच्छिक क्रम में चाहते हैं, तो सभी संख्याओं को एक सूची में जोड़ने के लिए अधिक कुशल हो सकता है, इसे फेरबदल करें, और पहला n ले लें क्योंकि उपरोक्त उदाहरण वर्तमान में लागू किया गया है अनुरोध की गई सीमा में यादृच्छिक संख्या उत्पन्न करके और उन्हें एक सेट के माध्यम से पारित करने के लिए (इसी तरह रोब केल्टी के उत्तर के लिए ), जिसे सीमा से पारित राशि से कई गुना अधिक उत्पादन की आवश्यकता हो सकती है क्योंकि एक नई अनूठी संख्या उत्पन्न करने की संभावना प्रत्येक के साथ कम हो जाती है। यहाँ दूसरे तरीके का एक उदाहरण है:

List<Integer> range = IntStream.range(0, 100).boxed()
        .collect(Collectors.toCollection(ArrayList::new));
Collections.shuffle(range);
range.subList(0, 99).forEach(System.out::println);

Question 4

100 नंबर की एक सरणी बनाएं, फिर उनके क्रम को यादृच्छिक करें।
एक छद्म यादृच्छिक संख्या जनरेटर को तैयार करें जिसमें 100 की सीमा हो।
100 तत्वों का बूलियन एरे बनाएं, फिर उस नंबर को चुनने पर एक एलीमेंट सेट करें। जब आप ऐरे के विरूद्ध अगली संख्या की जाँच करें और ऐरे तत्व को सेट करने पर फिर से प्रयास करें। ( longजहाँ आप स्थानांतरित करते हैं और जहाँ आप व्यक्तिगत रूप से बिट एक्सेस करने के लिए मास्क लगाते हैं, तो आप आसानी से स्पष्ट बूलियन सरणी बना सकते हैं ।)

Question 5

Collections.shuffle()सभी 100 नंबरों पर उपयोग करें और पहले पांच का चयन करें, जैसा कि यहां दिखाया गया है ।

Question 6

मुझे ऐसा लगता है कि यह तरीका ध्यान देने योग्य है।

   private static final Random RANDOM = new Random();    
   /**
     * Pick n numbers between 0 (inclusive) and k (inclusive)
     * While there are very deterministic ways to do this,
     * for large k and small n, this could be easier than creating
     * an large array and sorting, i.e. k = 10,000
     */
    public Set<Integer> pickRandom(int n, int k) {
        final Set<Integer> picked = new HashSet<>();
        while (picked.size() < n) {
            picked.add(RANDOM.nextInt(k + 1));
        }
        return picked;
    }

Question 7

मैंने आनंद के जवाब को सेट के अनूठे गुणों का न केवल उपयोग करने के लिए फिर से उकसाया, बल्कि set.add()सेट में विफल होने पर वापस किए गए बूलियन झूठ का भी उपयोग करता है।

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

public class randomUniqueNumberGenerator {

    public static final int SET_SIZE_REQUIRED = 10;
    public static final int NUMBER_RANGE = 100;

    public static void main(String[] args) {
        Random random = new Random();

        Set set = new HashSet<Integer>(SET_SIZE_REQUIRED);

        while(set.size()< SET_SIZE_REQUIRED) {
            while (set.add(random.nextInt(NUMBER_RANGE)) != true)
                ;
        }
        assert set.size() == SET_SIZE_REQUIRED;
        System.out.println(set);
    }
}

Question 8

मैंने इसे ऐसे ही बनाया है।

    Random random = new Random();
    ArrayList<Integer> arrayList = new ArrayList<Integer>();

    while (arrayList.size() < 6) { // how many numbers u need - it will 6
        int a = random.nextInt(49)+1; // this will give numbers between 1 and 50.

        if (!arrayList.contains(a)) {
            arrayList.add(a);
        }
    }

Question 9

यह अद्वितीय यादृच्छिक संख्या उत्पन्न करने के लिए काम करेगा ................

import java.util.HashSet;
import java.util.Random;

public class RandomExample {

    public static void main(String[] args) {
        Random rand = new Random();
        int e;
        int i;
        int g = 10;
        HashSet<Integer> randomNumbers = new HashSet<Integer>();

        for (i = 0; i < g; i++) {
            e = rand.nextInt(20);
            randomNumbers.add(e);
            if (randomNumbers.size() <= 10) {
                if (randomNumbers.size() == 10) {
                    g = 10;
                }
                g++;
                randomNumbers.add(e);
            }
        }
        System.out.println("Ten Unique random numbers from 1 to 20 are  : " + randomNumbers);
    }
}

Question 10

ऐसा करने का एक चतुर तरीका मापांक में एक आदिम तत्व के प्रतिपादकों का उपयोग करना है।

उदाहरण के लिए, 2 एक आदिम रूट मॉड 101 है, जिसका अर्थ है कि 2 मॉड 101 की शक्तियां आपको एक गैर-दोहराव अनुक्रम देती हैं जो 1 से 100 तक हर संख्या को देखता है:

2^0 mod 101 = 1
2^1 mod 101 = 2
2^2 mod 101 = 4
...
2^50 mod 101 = 100
2^51 mod 101 = 99
2^52 mod 101 = 97
...
2^100 mod 101 = 1

जावा कोड में, आप लिखेंगे:

void randInts() {
int num=1;
for (int ii=0; ii<101; ii++) {
    System.out.println(num);
    num= (num*2) % 101;
    }
}

एक विशिष्ट मापांक के लिए एक आदिम मूल खोजना मुश्किल हो सकता है, लेकिन मेपल का "प्रिमोट" फ़ंक्शन यह आपके लिए करेगा।

Question 11

मैं यहाँ एक और प्रश्न से आया हूँ, जो इस प्रश्न का डुप्लिकेट है ( जावा में अद्वितीय यादृच्छिक संख्या उत्पन्न करना )

एक ऐरे में 1 से 100 नंबर स्टोर करें।
मान प्राप्त करने के लिए 1 से 100 के बीच यादृच्छिक संख्या को स्थिति और रिटर्न ऐरे [स्थिति -1] के बीच उत्पन्न करें
एक बार जब आप सरणी में किसी संख्या का उपयोग करते हैं, तो मान को -1 के रूप में चिह्नित करें (यह संख्या पहले से ही उपयोग की गई है या नहीं यह जांचने के लिए किसी अन्य सरणी को बनाए रखने की आवश्यकता नहीं है)
यदि सरणी में मान -1 है, तो सरणी में नया स्थान लाने के लिए फिर से यादृच्छिक संख्या प्राप्त करें।

Question 12

मेरे पास इस समस्या का आसान समाधान है, इसके साथ हम आसानी से अनूठे यादृच्छिक संख्याओं की संख्या उत्पन्न कर सकते हैं, इसका सिर्फ तर्क कोई भी किसी भी भाषा में इसका उपयोग कर सकता है।

for(int i=0;i<4;i++)
        {
            rn[i]= GenerateRandomNumber();
            for (int j=0;j<i;j++)
            {
                if (rn[i] == rn[j])
                {
                    i--;
                }
            }
        }

Question 13

हालांकि यह एक पुराना धागा है, लेकिन दूसरा विकल्प जोड़ने से नुकसान नहीं हो सकता है। (JDK 1.8 लंबो कार्यों को आसान बनाने के लिए लगता है);

समस्या को निम्न चरणों में तोड़ा जा सकता है;

पूर्णांक की प्रदान की गई सूची के लिए एक न्यूनतम मूल्य प्राप्त करें (जिसके लिए अद्वितीय यादृच्छिक संख्या उत्पन्न करें)
पूर्णांकों की प्रदान की गई सूची के लिए अधिकतम मूल्य प्राप्त करें
पहले पाए गए न्यूनतम और अधिकतम पूर्णांक मानों के विरुद्ध यादृच्छिक पूर्णांक मान उत्पन्न करने के लिए थ्रेडलोकल्रैंडगैम क्लास (JDK 1.8 से) का उपयोग करें और फिर यह सुनिश्चित करने के लिए फ़िल्टर करें कि मान वास्तव में मूल रूप से प्रदान की गई सूची द्वारा निहित हैं। अंत में, यह सुनिश्चित करने के लिए कि विशिष्ट संख्याएँ विशिष्ट हैं, इन्ट्रोस्ट्रीम पर लागू होते हैं।

यहाँ कुछ विवरण के साथ समारोह है:

/**
 * Provided an unsequenced / sequenced list of integers, the function returns unique random IDs as defined by the parameter
 * @param numberToGenerate
 * @param idList
 * @return List of unique random integer values from the provided list
 */
private List<Integer> getUniqueRandomInts(List<Integer> idList, Integer numberToGenerate) {

    List<Integer> generatedUniqueIds = new ArrayList<>();

    Integer minId = idList.stream().mapToInt (v->v).min().orElseThrow(NoSuchElementException::new);
    Integer maxId = idList.stream().mapToInt (v->v).max().orElseThrow(NoSuchElementException::new);

            ThreadLocalRandom.current().ints(minId,maxId)
            .filter(e->idList.contains(e))
            .distinct()
            .limit(numberToGenerate)
            .forEach(generatedUniqueIds:: add);

    return generatedUniqueIds;

}

ताकि, 'allIntegers' सूची ऑब्जेक्ट के लिए 11 अद्वितीय यादृच्छिक संख्या प्राप्त कर सकें, हम फ़ंक्शन को कॉल करेंगे;

    List<Integer> ids = getUniqueRandomInts(allIntegers,11);

फ़ंक्शन नई सरणीवादी 'जनरलाइक्स' की घोषणा करता है और लौटने से पहले आवश्यक संख्या तक प्रत्येक अद्वितीय यादृच्छिक पूर्णांक के साथ पॉप्युलेट करता है।

पीएस थ्रेडलोकलेंगलर क्लास समवर्ती धागे के मामले में सामान्य बीज मूल्य से बचता है।

Question 14

इसे आज़माएं

public class RandomValueGenerator {
    /**
     * 
     */
    private volatile List<Double> previousGenValues = new ArrayList<Double>();

    public void init() {
        previousGenValues.add(Double.valueOf(0));
    }

    public String getNextValue() {
        Random random = new Random();
        double nextValue=0;
        while(previousGenValues.contains(Double.valueOf(nextValue))) {
            nextValue = random.nextDouble();
        }
        previousGenValues.add(Double.valueOf(nextValue));
        return String.valueOf(nextValue);
    }
}

Question 15

यह अन्य उत्तरों से काफी अलग नहीं है, लेकिन मैं अंत में पूर्णांकों की सरणी चाहता था:

    Integer[] indices = new Integer[n];
    Arrays.setAll(indices, i -> i);
    Collections.shuffle(Arrays.asList(indices));
    return Arrays.stream(indices).mapToInt(Integer::intValue).toArray();

Question 16

यदि आप नीचे दिए गए अनुसार मान प्राप्त करने के लिए बूलियन सरणी के माध्यम से नेविगेट करें, तो सही को भरने के लिए आप बूलियन सरणी का उपयोग कर सकते हैं

package study;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/*
Created By Sachin  Rane on Jul 18, 2018
*/
public class UniqueRandomNumber {
    static Boolean[] boolArray;
    public static void main(String s[]){
        List<Integer> integers = new ArrayList<>();


        for (int i = 0; i < 10; i++) {
            integers.add(i);
        }


        //get unique random numbers
        boolArray = new Boolean[integers.size()+1];
        Arrays.fill(boolArray, false);
        for (int i = 0; i < 10; i++) {
            System.out.print(getUniqueRandomNumber(integers) + " ");

        }

    }

    private static int  getUniqueRandomNumber(List<Integer> integers) {
        int randNum =(int) (Math.random()*integers.size());
        if(boolArray[randNum]){
            while(boolArray[randNum]){
                randNum++;
                if(randNum>boolArray.length){
                    randNum=0;
                }
            }
            boolArray[randNum]=true;
            return randNum;
        }else {
            boolArray[randNum]=true;
            return randNum;
        }

    }

}

Question 17

0 से m-1 तक n अद्वितीय यादृच्छिक संख्या चुनें।

int[] uniqueRand(int n, int m){
    Random rand = new Random();
    int[] r = new int[n];
    int[] result = new int[n];
    for(int i = 0; i < n; i++){
        r[i] = rand.nextInt(m-i);
        result[i] = r[i];
        for(int j = i-1; j >= 0; j--){
            if(result[i] >= r[j])
                result[i]++;
        }
    }
    return result;
}

एक सूची की कल्पना कीजिए जिसमें 0 से एम -1 तक की संख्या है। पहला नंबर चुनने के लिए, हम बस उपयोग करते हैं rand.nextInt(m)। फिर सूची से नंबर हटा दें। अब m-1 नंबर रहता है, इसलिए हम कॉल करते हैं rand.nextInt(m-1)। हमें जो संख्या मिलती है, वह सूची में स्थिति का प्रतिनिधित्व करती है। यदि यह पहली संख्या से कम है, तो यह दूसरा नंबर है, क्योंकि पहले नंबर से पहले सूची का हिस्सा पहले नंबर को हटाने से नहीं बदला गया था। यदि स्थिति पहली संख्या से अधिक या उसके बराबर है, तो दूसरी संख्या स्थिति + 1 है। कुछ और व्युत्पत्ति करें, आप इस एल्गोरिथ्म को प्राप्त कर सकते हैं।

व्याख्या

इस एल्गोरिथ्म में O (n ^ 2) जटिलता है। तो यह एक बड़े सेट से छोटी संख्या में अद्वितीय संख्या उत्पन्न करने के लिए अच्छा है। जबकि फेरबदल आधारित एल्गोरिथ्म को फेरबदल करने के लिए कम से कम O (m) की आवश्यकता होती है।

इसके अलावा फेरबदल आधारित एल्गोरिथ्म को फेरबदल करने के लिए हर संभव परिणाम को स्टोर करने के लिए मेमोरी की आवश्यकता होती है, इस एल्गोरिथ्म की आवश्यकता नहीं है।

Question 18

आप संग्रह वर्ग का उपयोग कर सकते हैं।

संग्रह नामक एक उपयोगिता वर्ग विभिन्न क्रियाएं प्रदान करता है जो एक संग्रह पर किया जा सकता है जैसे कि ArrayList (उदाहरण के लिए, तत्वों को खोजें, अधिकतम या न्यूनतम तत्व ढूंढें, तत्वों के क्रम को उल्टा करें, और इसी तरह)। तत्वों को फेरबदल करने के लिए यह क्रिया कर सकता है। फेरबदल सूची में हर तत्व को अलग स्थिति में ले जाएगा। यह एक यादृच्छिक वस्तु का उपयोग करके ऐसा करता है। इसका मतलब यह निर्धारक यादृच्छिकता है, लेकिन यह ज्यादातर स्थितियों में करेगा।

ArrayList को फेरबदल करने के लिए, कार्यक्रम के शीर्ष पर संग्रह आयात जोड़ें और फिर फेरबदल स्थिर विधि का उपयोग करें। यह ArrayList को एक पैरामीटर के रूप में फेरबदल करने के लिए लेता है:

import java.util.Collections;
import java.util.ArrayList;
public class Lottery {
public static void main(String[] args) {
//define ArrayList to hold Integer objects
ArrayList numbers = new ArrayList();
for(int i = 0; i < 100; i++)
{
numbers.add(i+1);
}
Collections.shuffle(numbers);
System.out.println(numbers);
}
}

Question 19

किसी श्रेणी या सरणी में अद्वितीय यादृच्छिक मान उत्पन्न करने के लिए यह सबसे सरल विधि है ।

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

एक यादृच्छिक संख्या उत्पन्न करें और इसे नए सरणी में जोड़ें।
एक और यादृच्छिक संख्या उत्पन्न करें और जांचें कि क्या यह नए सरणी में पहले से संग्रहीत है।
यदि नहीं तो इसे जोड़ें और जारी रखें
और कदम को दोहराएं।

ArrayList<Integer> sampleList = new ArrayList<>();
sampleList.add(1);
sampleList.add(2);
sampleList.add(3);
sampleList.add(4);
sampleList.add(5);
sampleList.add(6);
sampleList.add(7);
sampleList.add(8);

अब sampleListहम पांच यादृच्छिक संख्याओं का उत्पादन करेंगे जो अद्वितीय हैं।

int n;
randomList = new ArrayList<>();
for(int  i=0;i<5;i++){
    Random random = new Random();
    n=random.nextInt(8);     //Generate a random index between 0-7

    if(!randomList.contains(sampleList.get(n)))
    randomList.add(sampleList.get(n));
    else
        i--;    //reiterating the step
}

यह वैचारिक रूप से बहुत सरल है। यदि पहले से उत्पन्न रैंडम वैल्यू मौजूद है तो हम स्टेप को दोहराएंगे। यह तब तक जारी रहेगा जब तक उत्पन्न सभी मूल्य अद्वितीय नहीं होते।

यदि आपको यह उत्तर उपयोगी लगता है तो आप इसे वोट कर सकते हैं क्योंकि यह अन्य उत्तरों की तुलना में अवधारणा में बहुत सरल है ।

Question 20

आप जावा में 0 से n-1 के बीच n अद्वितीय यादृच्छिक संख्या उत्पन्न कर सकते हैं

public static void RandomGenerate(int n)
{
     Set<Integer> st=new HashSet<Integer>();
     Random r=new Random();
     while(st.size()<n)
     {
        st.add(r.nextInt(n));
     }

}

Question 21

इसे देखो

public class RandomNumbers {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int n = 5;
        int A[] = uniqueRandomArray(n);
        for(int i = 0; i<n; i++){
            System.out.println(A[i]);
        }
    }
    public static int[] uniqueRandomArray(int n){
        int [] A = new int[n];
        for(int i = 0; i< A.length; ){
            if(i == A.length){
                break;
            }
            int b = (int)(Math.random() *n) + 1;
            if(f(A,b) == false){
                A[i++] = b;
            } 
        }
        return A;
    }
    public static boolean f(int[] A, int n){
        for(int i=0; i<A.length; i++){
            if(A[i] == n){
                return true;
            }
        }
        return false;
    }
}

Question 22

नीचे एक तरीका है, जिसका इस्तेमाल मैं हमेशा यूनिक नंबर जेनरेट करने के लिए करता हूं। रैंडम फ़ंक्शन नंबर उत्पन्न करता है और इसे टेक्स्टफाइल में संग्रहीत करता है, फिर अगली बार यह फ़ाइल में इसकी तुलना करता है और नई अनूठी संख्या उत्पन्न करता है इसलिए इस तरह से हमेशा एक नया अद्वितीय नंबर होता है।

public int GenerateRandomNo()
{
    int _min = 0000;
    int _max = 9999;
    Random _rdm = new Random();
    return _rdm.Next(_min, _max);
}
public int rand_num()
{
    randnum = GenerateRandomNo();
    string createText = randnum.ToString() + Environment.NewLine;
    string file_path = System.IO.Path.GetDirectoryName(System.Windows.Forms.Application.ExecutablePath) + @"\Invoices\numbers.txt";
    File.AppendAllText(file_path, createText);
    int number = File.ReadLines(file_path).Count(); //count number of lines in file
    System.IO.StreamReader file = new System.IO.StreamReader(file_path);
    do
    {
        randnum = GenerateRandomNo();
    }
    while ((file.ReadLine()) == randnum.ToString());
    file.Close();
    return randnum;

}