कुछ मानों को छोड़कर यादृच्छिक संख्याएं उत्पन्न करें

Question

मैं यादृच्छिक संख्याएं उत्पन्न करना चाहता हूं, लेकिन उन्हें excludeRows सरणी से नहीं बनना चाहता। मेरा कोड यहाँ है।

public int generateRandom(int start, int end, ArrayList<Integer> excludeRows) { 
    Random rand = new Random(); 
    int range = end - start +1 - excludeRows.size(); 
    int random = rand.nextInt(range) + 1; 

    for(int i = 0; i < exclude.size(); i++) { 
     if(excludeRows.get(i) > random) { 
      return random; 
     } 
     random++; 
    } 

    return random; 
} 

मैं थोड़ी देर के पाश में इस सुविधा का उपयोग, और प्रत्येक यात्रा के दौरान मैं excludeRows के लिए एक नया मूल्य जोड़ने। कभी-कभी यह excludeRows से संबंधित संख्याएं लौटाता है। समस्या क्या है?

Answer 1

if(!exclude.contains(random)) 
    return random; 

इस हर बार यह होगा की कोशिश करो उस मूल्य को वापस करें जो बाहर नहीं है।

Answer 2

आप जांच:

for(int i = 0; i < exclude.size(); i++) { 
    if(exclude.get(i) > random) { 
     return random; 
    } 

और अगर केवल पहले बड़ा है, तो आप मान लेंगे। क्या आप वाकई exclude क्रमबद्ध हैं?

आप if(exclude.contains(random)) या निम्नलिखित कलन विधि का उपयोग कर सकते हैं:

अगर (end-start) एक उचित संख्या है, और आप लगभग सभी मूल्यों की आवश्यकता है कि तुम सब स्वीकार्य नंबरों की सूची बना सकते हैं और इस सूची आकार पर यादृच्छिक का उपयोग करें और यादृच्छिक चयन कर सकते हैं एक सूचकांक के रूप में मूल्य। फिर सूची से अवांछित संख्या को हटा दें और एक और यादृच्छिक अनुक्रमणिका प्राप्त करें।

Answer 3

मुझे लगता है कि कुछ गलतियां हैं।

1) रेंज अंत होनी चाहिए - +1 शुरू करें, क्योंकि यह रेंज चाहता था।
2) यदि आप वास्तव में यादृच्छिक संख्या चाहते हैं (कंप्यूटर पर जितना संभव हो उतना "यादृच्छिक") तो आपको केवल अगले उपलब्ध नंबर नहीं मिलना चाहिए। क्योंकि इस मामले में आपका यादृच्छिक संख्या बहिष्कृत संख्या घनत्व/आवृत्ति की विशेषताओं को सहन करेगा।

public int generateRandom(int start, int end, ArrayList<Integer> excludeRows) { 
    Random rand = new Random(); 
    int range = end - start + 1; 
    int random; 

    boolean success = false; 
    while(!success) { 
     random = rand.nextInt(range) + 1; 
     for(Integer i: excludeRows) { 
      if(i == random) { 
       break; 
      } else if (i > random) { 
       success = true; 
       break; 
      } 
     } 
    } 
    return random; 
} 

अद्यतन

Achintya झा के जवाब के साथ मेरी कोड सुधार किया जा सकता (लेकिन ध्यान दें साथ ही कुछ टिप्पणी कर रहे हैं):

public int generateRandom(int start, int end, ArrayList<Integer> excludeRows) { 
    Random rand = new Random(); 
    int range = end - start + 1; 

    int random = rand.nextInt(range) + 1; 
    while(excludeRows.contains(random)) { 
     random = rand.nextInt(range) + 1; 
    } 

    return random; 
} 

Answer 4

दरअसल, हमें थोड़ी देर के साथ contains(random) का उपयोग करने की आवश्यकता नहीं है।

प्रश्न को सरल बनाने के लिए, देखते हैं कि क्या होता है यदि हमारे पास केवल मूल्य को छोड़कर कोई होता है। हम परिणाम को 2 भागों में विभाजित कर सकते हैं। फिर संभावित मानों की संख्या range-1 है। यदि यादृच्छिक संख्या बहिष्कृत मूल्य से कम है, तो बस इसे वापस करें। अन्यथा, हम 1 जोड़ सकते हैं।

मूल्यों को छोड़कर एकाधिक के लिए, हम परिणाम सेट को size+1 भागों में विभाजित कर सकते हैं, जहां size का अर्थ मानों को छोड़ने की संख्या है। फिर संभावित मानों की संख्या range-size है। फिर हम आरोही क्रम में मूल्यों को छोड़कर सॉर्ट करते हैं। यदि यादृच्छिक संख्या को छोड़कर मान कम से कम i से कम है, तो हम केवल यादृच्छिक संख्या i जोड़ें, जहां i बहिष्करण मूल्य का सूचकांक है।

public int generateRandomNumberWithExcepts(int start, int end, List<Integer> excepts) { 
    int size = excepts.size(); 
    int range = end - start + 1 - size; 
    int randNum = random.nextInt(range) + start; 
    excepts.sort(null); // sort excluding values in ascending order 
    int i=0; 
    for(int except : excepts) { 
     if(randNum < except-i){ 
      return randNum + i; 
     } 
     i++; 
    } 
    return randNum + i; 
}