प्रदत्त श्रेणी में केवल एक यादृच्छिक प्राइम नंबर बनाना

Question

मैं किसी भी प्रदान की गई सीमा में केवल एक यादृच्छिक प्राइम नंबर बनाना चाहता हूं। मेरे पास यह कोड है:

print [x for x in range(5000, 5200) 
    if not [t for t in range(2, x) 
    if not x % t]] 

लेकिन मेरा कार्यक्रम प्रमुख संख्याओं का एक सेट प्रदान करता है। मैं अपने कोड को संशोधित करना चाहता हूं और किसी भी प्रदान की गई सीमा में केवल एक यादृच्छिक संख्या बनाना चाहता हूं लेकिन मुझे यह नहीं पता कि यह कैसे किया जाए। कृपया मदद करें।

Answer 1

आपका कार्यक्रम लगभग सही है, तो सिर्फ एक यादृच्छिक विकल्प देने के लिए और यह किया जाता है। लेकिन क्या मैं इसे बहुत समय बर्बाद कर सकता हूं। मैं एक कारगर तरीका

import random 
from math import sqrt 

def prime(x): 
    if x%2==0:return False 
    elif any(x%i==0 for i in xrange(3,int(sqrt(x))+1,2)):return False 
    else:return True 

prime_list=[x for x in xrange(5000,5200) if prime(x)] 

print random.choice(prime_list) 

Answer 2

विधि 1:

नहीं तो आप permutation करने के लिए उपयोग कर सकते हैं:

import random 
random.choice([x for x in range(5000, 5200) if not [t for t in range(2, x) if not x % t]]) 

वास्तव में आप लगभग देखते हैं, तो आप सिर्फ उपयोग करने की आवश्यकता random.choice()

---

विधि 2

यादृच्छिक रूप से अपने प्राइम नंबर रेंज परमिट करें और फिर चुनें पहला तत्व:

import numpy as np 
np.random.permutation([x for x in range(5000, 5200) if not [t for t in range(2, x) if not x % t]])[0] 

Answer 3

मेरे mathmax समाधान के साथ मुद्दा यह है कि यह 5000 और 5200 के बीच का अभाज्य लगाने के लिए सिर्फ एक लेने और बाकी टॉस करने सब काम करता है।

import random 

minimum = 5000 
maximum = 5200 

next((x for x in random.sample(range(minimum, maximum), maximum - minimum) if not [t for t in range(2, x) if not x % t]), None) 

यह 18x के बारे में तेजी से होता है: यह अधिक बेतरतीब ढंग से 5000 और 5200 के बीच अद्वितीय संख्या लेने के लिए कुशल जब तक आप पहले एक एक प्रमुख बात यह है कि लगता है हो सकता है। हम अपने primality परीक्षण के बारे में एक छोटे से होशियार होने से इस पर एक और 18x सुधार प्राप्त कर सकते हैं: के रूप में यह एक परिणाम के random.shuffle() के विपरीत उस जगह में सूची पर चल रही रिटर्न

next((x for x in random.sample(range(minimum, maximum), maximum - minimum) if not [t for t in [2] + list(range(3, int(x**0.5) + 1, 2)) if not x % t]), None) 

ध्यान दें कि random.sample() प्रयोग किया जाता है।

next((x for x in (lambda y: random.shuffle(y) or y)(list(range(5000, 5200))) if not [t for t in range(2, x) if not x % t]), None) 

Answer 4

यहाँ एक अधिक कुशल समाधान की दिशा में एक कदम है: आप random.shuffle(), और नहीं दो बार करना चाहते हैं तो अभिव्यक्ति में नंबर सहित, आप के बजाय की तरह कुछ कर सकते हैं। सभी संभावित divisors के आधार पर प्रत्येक संख्या की प्राथमिकता का परीक्षण करने के बजाय, पूर्व-उत्पन्न प्राइम की एक सूची रखें।

अगला, जब हम रेंज में यादृच्छिक प्राइम चुनने के लिए तैयार होते हैं, तो हम सभी मान्य उत्तरों की सूची को कुशलतापूर्वक खोजने और यादृच्छिक रूप से एक को चुनने के लिए बाइसक्शन का उपयोग करते हैं। यदि ऐसी सूची खाली है, तो None लौटाएं।

from __future__ import print_function 
import bisect 
import random 
from itertools import takewhile 


class Primes(object): 
    def __init__(self): 
     self.primes = [2, 3] 
     self.candidate = 5 

    def process_candidate(self): 
     if all(self.candidate % p != 0 for p in takewhile(
      lambda x: x * x <= self.candidate, self.primes)): 
      self.primes.append(self.candidate) 
     self.candidate += 2 

    def maybe_random_prime_from_range(self, a, b): 
     if b < a: 
      return None 

     while self.candidate < b: 
      self.process_candidate() 

     ai = bisect.bisect(self.primes, a) 
     bi = bisect.bisect(self.primes[ai:], b) 

     try: 
      return random.choice(self.primes[ai:ai+bi]) 
     except: 
      return None 

ps = Primes() 

print(ps.maybe_random_prime_from_range(4000, 4200))