প্রধান সংখ্যা তৈরি করার সর্বাধিক মার্জিত উপায় [বন্ধ]

Question 1

বন্ধ । এই প্রশ্নটি মতামত ভিত্তিক । এটি বর্তমানে উত্তর গ্রহণ করছে না।

এই প্রশ্নটি উন্নত করতে চান? প্রশ্নটি আপডেট করুন যাতে পোস্টটি সম্পাদনা করে সত্য এবং উদ্ধৃতি দিয়ে উত্তর দেওয়া যায় ।

5 বছর আগে বন্ধ ।

এই প্রশ্নটি উন্নত করুন

এই ফাংশনটি বাস্তবায়নের সর্বাধিক মার্জিত উপায় কী:

ArrayList generatePrimes(int n)

এই ফাংশনটি প্রথম nপ্রাইমগুলি তৈরি করে (সম্পাদনা করুন: যেখানে n>1), তাই দিয়ে generatePrimes(5)ফিরে আসবে । (আমি এটি সি # তে করছি, তবে আমি জাভা বাস্তবায়নে খুশি - বা এই বিষয়ে অন্য কোনও অনুরূপ ভাষা (সুতরাং হাস্কেল নয়))।ArrayList{2, 3, 5, 7, 11}

এই ফাংশনটি কীভাবে লিখতে হয় তা আমি জানি তবে আমি যখন গতকাল রাতে এটি করেছিলাম তখন এটি আশা করে যত সুন্দর ছিল না। আমি এখানে যা এলাম:

ArrayList generatePrimes(int toGenerate)
{
    ArrayList primes = new ArrayList();
    primes.Add(2);
    primes.Add(3);
    while (primes.Count < toGenerate)
    {
        int nextPrime = (int)(primes[primes.Count - 1]) + 2;
        while (true)
        {
            bool isPrime = true;
            foreach (int n in primes)
            {
                if (nextPrime % n == 0)
                {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime)
            {
                break;
            }
            else
            {
                nextPrime += 2;
            }
        }
        primes.Add(nextPrime);
    }
    return primes;
}

আমি গতির বিষয়ে খুব বেশি উদ্বিগ্ন নই, যদিও আমি এটি স্পষ্টতই অদক্ষ হতে চাই না। কোন পদ্ধতিটি ব্যবহার করা হবে তা আমি আপত্তি করি না (নিষ্পাপ বা চালুনি বা অন্য কোনও কিছু) তবে আমি এটিটি কীভাবে কাজ করে তা মোটামুটি সংক্ষিপ্ত এবং সুস্পষ্ট হতে চাই।

সম্পাদনা করুন : যারা প্রতিক্রিয়া জানিয়েছেন তাদের সবাইকে ধন্যবাদ, যদিও অনেকেই আমার আসল প্রশ্নের উত্তর দেয়নি। পুনরাবৃত্তি করতে, আমি কোডের একটি সুন্দর পরিষ্কার টুকরা চেয়েছিলাম যা প্রাথমিক সংখ্যার একটি তালিকা তৈরি করে। আমি এটি ইতিমধ্যে বিভিন্ন উপায়ে একগুচ্ছ কীভাবে করতে হয় তা জানি, তবে আমি কোড লেখার প্রবণ যা এটি যতটা পরিষ্কার হতে পারে তেমন পরিষ্কার নয়। এই থ্রেডে কয়েকটি ভাল বিকল্প প্রস্তাব করা হয়েছে:

আমার কাছে যা ছিল তার একটি সুন্দর সংস্করণ (পিটার স্মিট, জেমভেদার এবং রেক্রিয়াটিভ)
ইরোটোথিনিস (স্টারব্লিউ) এর চালনি একটি খুব পরিষ্কার প্রয়োগ
জাভা BigIntegerএবং nextProbablePrimeখুব সাধারণ কোডের জন্য ব্যবহার করুন , যদিও আমি এটি বিশেষভাবে দক্ষ (ডিএফএ) ভাবতে পারি না
অলসভাবে প্রাইমগুলির তালিকা তৈরি করতে লাইনকিউ ব্যবহার করুন (মাগিস)
একটি পাঠ্য ফাইলে প্রচুর প্রাইম রাখুন এবং প্রয়োজনীয় হলে সেগুলি পড়ুন (ডারিন)

সম্পাদনা 2 : আমি সি # তে এখানে দেওয়া কয়েকটি পদ্ধতি প্রয়োগ করেছি এবং অন্য একটি পদ্ধতি এখানে উল্লেখ করা হয়নি। তারা সকলেই কার্যকরভাবে প্রথম এন প্রাইমগুলি সন্ধান করে (এবং আমার কাছে চালকদের সরবরাহের সীমা সন্ধান করার একটি শালীন পদ্ধতি রয়েছে)।

Question 2

অনুমানটি ব্যবহার করুন

pi(n) = n / log(n)

প্রাইমগুলির সংখ্যার জন্য এন পর্যন্ত সীমা সন্ধান করুন এবং একটি চালনী ব্যবহার করুন। অনুমানটি প্রাইমের সংখ্যাটিকে কিছুটা কম অবমূল্যায়ন করে, তাই চালুনি প্রয়োজনের তুলনায় কিছুটা বড় হবে, যা ঠিক।

এটি আমার স্ট্যান্ডার্ড জাভা চালনী, সাধারণ ল্যাপটপে প্রায় এক সেকেন্ডে প্রথম মিলিয়ন প্রাইমগুলি গণনা করে:

public static BitSet computePrimes(int limit)
{
    final BitSet primes = new BitSet();
    primes.set(0, false);
    primes.set(1, false);
    primes.set(2, limit, true);
    for (int i = 0; i * i < limit; i++)
    {
        if (primes.get(i))
        {
            for (int j = i * i; j < limit; j += i)
            {
                primes.clear(j);
            }
        }
    }
    return primes;
}

Question 3

যারা সহায়ক উত্তর দিয়েছেন তাদের সকলকে অনেক ধন্যবাদ। এখানে সি # তে প্রথম এন প্রাইমগুলি সন্ধানের কয়েকটি ভিন্ন পদ্ধতির আমার বাস্তবায়ন । প্রথম দুটি পদ্ধতি এখানে পোস্ট করা হয়েছে কি অনেক বেশি। (পোস্টারগুলির নাম শিরোনামের পাশেই রয়েছে।) আমি আটকিনের চালনা কিছু সময় করার পরিকল্পনা করছি, যদিও আমি সন্দেহ করি যে এটি বর্তমানেকার পদ্ধতির মতো এতো সহজ হবে না। যদি কেউ এই পদ্ধতির কোনও উন্নতির কোনও উপায় দেখতে পান তবে আমি জানতে আগ্রহী :-)

মানক পদ্ধতি ( পিটার স্মিট , জেমভেদার , রেক্রিয়াটিভ )

প্রথম মৌলিক সংখ্যা 2। এটি প্রাইমগুলির তালিকায় যুক্ত করুন। পরের মূলটি হ'ল পরবর্তী নম্বর যা এই তালিকার কোনও সংখ্যার দ্বারা সমানভাবে বিভাজ্য নয়।

public static List<int> GeneratePrimesNaive(int n)
{
    List<int> primes = new List<int>();
    primes.Add(2);
    int nextPrime = 3;
    while (primes.Count < n)
    {
        int sqrt = (int)Math.Sqrt(nextPrime);
        bool isPrime = true;
        for (int i = 0; (int)primes[i] <= sqrt; i++)
        {
            if (nextPrime % primes[i] == 0)
            {
                isPrime = false;
                break;
            }
        }
        if (isPrime)
        {
            primes.Add(nextPrime);
        }
        nextPrime += 2;
    }
    return primes;
}

এটি কেবল পরীক্ষা করা সংখ্যার বর্গমূল পর্যন্ত বিভাজ্যতার জন্য পরীক্ষা করে অনুকূলিত হয়েছে; এবং শুধুমাত্র বিজোড় সংখ্যা পরীক্ষা করে। এই বিষয়ে আরও ফর্মের শুধুমাত্র সংখ্যা পরীক্ষার দ্বারা অপ্টিমাইজ করা যেতে পারে 6k+[1, 5]বা, 30k+[1, 7, 11, 13, 17, 19, 23, 29]বা তাই ।

ইরোটোথিনিসের চালনী ( স্টারব্লিউ )

এই খুঁজে বের করে সব মৌলিক করার k । প্রথম এন প্রাইমগুলির একটি তালিকা তৈরি করতে, প্রথমে আমাদের n তম প্রাইমের আনুমানিক মান প্রয়োজন । এখানে বর্ণিত নিম্নলিখিত পদ্ধতিটি এটি করে।

public static int ApproximateNthPrime(int nn)
{
    double n = (double)nn;
    double p;
    if (nn >= 7022)
    {
        p = n * Math.Log(n) + n * (Math.Log(Math.Log(n)) - 0.9385);
    }
    else if (nn >= 6)
    {
        p = n * Math.Log(n) + n * Math.Log(Math.Log(n));
    }
    else if (nn > 0)
    {
        p = new int[] { 2, 3, 5, 7, 11 }[nn - 1];
    }
    else
    {
        p = 0;
    }
    return (int)p;
}

// Find all primes up to and including the limit
public static BitArray SieveOfEratosthenes(int limit)
{
    BitArray bits = new BitArray(limit + 1, true);
    bits[0] = false;
    bits[1] = false;
    for (int i = 0; i * i <= limit; i++)
    {
        if (bits[i])
        {
            for (int j = i * i; j <= limit; j += i)
            {
                bits[j] = false;
            }
        }
    }
    return bits;
}

public static List<int> GeneratePrimesSieveOfEratosthenes(int n)
{
    int limit = ApproximateNthPrime(n);
    BitArray bits = SieveOfEratosthenes(limit);
    List<int> primes = new List<int>();
    for (int i = 0, found = 0; i < limit && found < n; i++)
    {
        if (bits[i])
        {
            primes.Add(i);
            found++;
        }
    }
    return primes;
}

সুন্দরামের চালনী

আমি সম্প্রতি এই চালনিটি আবিষ্কার করেছি , তবে এটি বেশ সহজভাবে প্রয়োগ করা যেতে পারে। আমার বাস্তবায়ন ইরোটোস্টিনিসের চালনী হিসাবে তত দ্রুত নয়, তবে এটি নিষ্পাপ পদ্ধতির চেয়ে উল্লেখযোগ্যভাবে দ্রুত।

public static BitArray SieveOfSundaram(int limit)
{
    limit /= 2;
    BitArray bits = new BitArray(limit + 1, true);
    for (int i = 1; 3 * i + 1 < limit; i++)
    {
        for (int j = 1; i + j + 2 * i * j <= limit; j++)
        {
            bits[i + j + 2 * i * j] = false;
        }
    }
    return bits;
}

public static List<int> GeneratePrimesSieveOfSundaram(int n)
{
    int limit = ApproximateNthPrime(n);
    BitArray bits = SieveOfSundaram(limit);
    List<int> primes = new List<int>();
    primes.Add(2);
    for (int i = 1, found = 1; 2 * i + 1 <= limit && found < n; i++)
    {
        if (bits[i])
        {
            primes.Add(2 * i + 1);
            found++;
        }
    }
    return primes;
}

Question 4

একটি পুরানো প্রশ্নের পুনরুদ্ধার করা, তবে আমি লিনকিউয়ের সাথে খেলতে গিয়ে হোঁচট খেয়েছি।

এই কোডটির সমান্তরাল এক্সটেনশনগুলির সাথে .NET4.0 বা .NET3.5 প্রয়োজন

public List<int> GeneratePrimes(int n) {
    var r = from i in Enumerable.Range(2, n - 1).AsParallel()
            where Enumerable.Range(1, (int)Math.Sqrt(i)).All(j => j == 1 || i % j != 0)
            select i;
    return r.ToList();
}

Question 5

আপনি ভাল পথে আছেন।

কিছু মন্তব্য

primes.Add (3); এই ফাংশনটি = 1 এর জন্য কাজ করে না makes
সংখ্যার বর্গক্ষেত্রটি পরীক্ষা করার জন্য আপনাকে বড় আকারের বিভাগটি পরীক্ষা করতে হবে না।

প্রস্তাবিত কোড:

ArrayList generatePrimes(int toGenerate)
{
    ArrayList primes = new ArrayList();

    if(toGenerate > 0) primes.Add(2);

    int curTest = 3;
    while (primes.Count < toGenerate)
    {

        int sqrt = (int) Math.sqrt(curTest);

        bool isPrime = true;
        for (int i = 0; i < primes.Count && primes.get(i) <= sqrt; ++i)
        {
            if (curTest % primes.get(i) == 0)
            {
                isPrime = false;
                break;
            }
        }

        if(isPrime) primes.Add(curTest);

        curTest +=2
    }
    return primes;
}

Question 6

আপনি সম্ভাব্য প্রাইমস এক নজর করা উচিত । বিশেষ করে একটি কটাক্ষপাত এলোমেলোভাবে আলগোরিদিম এবং মিলার-রবিন primality পরীক্ষা ।

সম্পূর্ণতার জন্য আপনি কেবল java.math.BigInteger ব্যবহার করতে পারেন :

public class PrimeGenerator implements Iterator<BigInteger>, Iterable<BigInteger> {

    private BigInteger p = BigInteger.ONE;

    @Override
    public boolean hasNext() {
        return true;
    }

    @Override
    public BigInteger next() {
        p = p.nextProbablePrime();
        return p;
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException("Not supported.");
    }

    @Override
    public Iterator<BigInteger> iterator() {
        return this;
    }
}

@Test
public void printPrimes() {
    for (BigInteger p : new PrimeGenerator()) {
        System.out.println(p);
    }
}

Question 7

কোনওভাবেই দক্ষ নয়, তবে সম্ভবত সবচেয়ে পঠনযোগ্য:

public static IEnumerable<int> GeneratePrimes()
{
   return Range(2).Where(candidate => Range(2, (int)Math.Sqrt(candidate)))
                                     .All(divisor => candidate % divisor != 0));
}

সঙ্গে:

public static IEnumerable<int> Range(int from, int to = int.MaxValue)
{
   for (int i = from; i <= to; i++) yield return i;
}

প্রকৃতপক্ষে উত্তম বিন্যাসকরণের সাথে এখানে কিছু পোস্টের কেবলমাত্র একটি বৈচিত্র।

Question 8

সিসি-বিওয়াই-এসএ লাইসেন্স https://creativecommons.org/license/by-sa/3.0/ এর অধীনে সেন্টউইটাম 13189 বার্লিন জার্মানি কপিরাইটস ২০০৯

সমস্ত প্রাইমগুলি গণনা করার সহজ তবে সর্বাধিক মার্জিত উপায় এটি হ'ল তবে এই পথটি ধীরে ধীরে এবং উচ্চতর সংখ্যার জন্য মেমরির ব্যয় অনেক বেশি কারণ অনুষদ (!) ফাংশন ব্যবহার করে ... তবে এটি অ্যাপ্লিকেশনটিতে উইলসন থিওরিমের ভিন্নতা দেখায় পাইথনে প্রয়োগ করা অ্যালগরিদম দ্বারা সমস্ত প্রাইম তৈরি করুন

#!/usr/bin/python
f=1 # 0!
p=2 # 1st prime
while True:
    if f%p%2:
        print p
    p+=1
    f*=(p-2)

Question 9

Primes.txt এবং তারপরে তৈরি করতে একটি প্রধান সংখ্যা জেনারেটর ব্যবহার করুন :

class Program
{
    static void Main(string[] args)
    {
        using (StreamReader reader = new StreamReader("primes.txt"))
        {
            foreach (var prime in GetPrimes(10, reader))
            {
                Console.WriteLine(prime);
            }
        }
    }

    public static IEnumerable<short> GetPrimes(short upTo, StreamReader reader)
    {
        int count = 0;
        string line = string.Empty;
        while ((line = reader.ReadLine()) != null && count++ < upTo)
        {
            yield return short.Parse(line);
        }
    }
}

এক্ষেত্রে আমি পদ্ধতি স্বাক্ষরে ইন্টার 16 ব্যবহার করি, সুতরাং আমার প্রাইমস.টি.এস.টি. ফাইলটিতে 0 থেকে 32767 পর্যন্ত সংখ্যা রয়েছে you আপনি যদি এটি ইন্ট 32 বা ইন্ট 64 এ প্রসারিত করতে চান তবে আপনার প্রাইম.এসটিএসটি উল্লেখযোগ্য আকারে আরও বড় হতে পারে।

Question 10

আমি নিম্নলিখিত সি # সমাধান প্রস্তাব করতে পারেন। এটি কোনওভাবেই দ্রুত নয় তবে এটি কী করে সে সম্পর্কে এটি খুব স্পষ্ট।

public static List<Int32> GetPrimes(Int32 limit)
{
    List<Int32> primes = new List<Int32>() { 2 };

    for (int n = 3; n <= limit; n += 2)
    {
        Int32 sqrt = (Int32)Math.Sqrt(n);

        if (primes.TakeWhile(p => p <= sqrt).All(p => n % p != 0))
        {
            primes.Add(n);
        }
    }

    return primes;
}

আমি কোনও চেক আউট রেখেছি - যদি সীমাটি নেতিবাচক বা দুটির চেয়ে ছোট হয় তবে (এই মুহুর্তে পদ্ধতিটি সর্বনিম্ন দুটি প্রাইম হিসাবে ফিরে আসবে)। তবে এগুলি ঠিক করা সহজ।

হালনাগাদ

নিম্নলিখিত দুটি এক্সটেনশন পদ্ধতি ব্যবহার করুন

public static void Do<T>(this IEnumerable<T> collection, Action<T> action)
{
    foreach (T item in collection)
    {
        action(item);
    }
}

public static IEnumerable<Int32> Range(Int32 start, Int32 end, Int32 step)
{
    for (int i = start; i < end; i += step)
    }
        yield return i;
    }
}

আপনি নিম্নলিখিত হিসাবে এটি আবার লিখতে পারেন।

public static List<Int32> GetPrimes(Int32 limit)
{
    List<Int32> primes = new List<Int32>() { 2 };

    Range(3, limit, 2)
        .Where(n => primes
            .TakeWhile(p => p <= Math.Sqrt(n))
            .All(p => n % p != 0))
        .Do(n => primes.Add(n));

    return primes;
}

এটি কম দক্ষ (কারণ বর্গমূলটি প্রায়শই পুনরায় মূল্যায়ন করা হয়) তবে এটি এমনকি ক্লিনার কোড। অলসভাবে প্রাইমগুলি গণনা করার জন্য কোডটি পুনরায় লেখা সম্ভব, তবে এটি কোডটিকে কিছুটা বিশৃঙ্খলা করবে।

Question 11

সি # তে ইরোটোথিনিস-এর সিভির একটি বাস্তবায়ন এখানে রয়েছে :

    IEnumerable<int> GeneratePrimes(int n)
    {
        var values = new Numbers[n];

        values[0] = Numbers.Prime;
        values[1] = Numbers.Prime;

        for (int outer = 2; outer != -1; outer = FirstUnset(values, outer))
        {
            values[outer] = Numbers.Prime;

            for (int inner = outer * 2; inner < values.Length; inner += outer)
                values[inner] = Numbers.Composite;
        }

        for (int i = 2; i < values.Length; i++)
        {
            if (values[i] == Numbers.Prime)
                yield return i;
        }
    }

    int FirstUnset(Numbers[] values, int last)
    {
        for (int i = last; i < values.Length; i++)
            if (values[i] == Numbers.Unset)
                return i;

        return -1;
    }

    enum Numbers
    {
        Unset,
        Prime,
        Composite
    }

Question 12

আপনার একই অ্যালগরিদম ব্যবহার করে আপনি এটি কিছুটা ছোট করতে পারেন:

List<int> primes=new List<int>(new int[]{2,3});
for (int n = 5; primes.Count< numberToGenerate; n+=2)
{
  bool isPrime = true;
  foreach (int prime in primes)
  {
    if (n % prime == 0)
    {
      isPrime = false;
      break;
    }
  }
  if (isPrime)
    primes.Add(n);
}

Question 13

আমি জানি যে আপনি হাস্কেলবিহীন সমাধানের জন্য বলেছিলেন তবে আমি এটি এখানে যুক্ত করছি কারণ এটি প্রশ্নের সাথে সম্পর্কিত এবং হাসাকেলও এই ধরণের জিনিসটির জন্য সুন্দর beautiful

module Prime where

primes :: [Integer]
primes = 2:3:primes'
  where
    -- Every prime number other than 2 and 3 must be of the form 6k + 1 or 
    -- 6k + 5. Note we exclude 1 from the candidates and mark the next one as
    -- prime (6*0+5 == 5) to start the recursion.
    1:p:candidates = [6*k+r | k <- [0..], r <- [1,5]]
    primes'        = p : filter isPrime candidates
    isPrime n      = all (not . divides n) $ takeWhile (\p -> p*p <= n) primes'
    divides n p    = n `mod` p == 0

Question 14

আমি কিছু লিনিকিউ ব্যবহার করে সি # তে একটি সহজ ইরোটোস্টিনিস বাস্তবায়ন লিখেছি।

দুর্ভাগ্যক্রমে লিনকুই ইনটগুলির সীমাহীন ক্রম সরবরাহ করে না তাই আপনাকে ইনট্যাক্স ব্যবহার করতে হবে ax ম্যাক্সভ্যালু :(

প্রতিটি ক্যাশেড প্রাইম (এটি দেখতে কিছুটা কুৎসিত দেখায়) এর জন্য এটি গণনা করা এড়ানোর জন্য আমাকে এক বিপরীতমুখী প্রার্থী স্কয়ারটি ক্যাশে রেখেছিলেন।

আমি প্রার্থীর স্ক্র্যাটের পূর্ববর্তী প্রাইমগুলির একটি তালিকা ব্যবহার করি

cache.TakeWhile(c => c <= candidate.Sqrt)

এবং এর বিরুদ্ধে 2 থেকে শুরু করে প্রতিটি ইন্টার পরীক্ষা করুন

.Any(cachedPrime => candidate.Current % cachedPrime == 0)

কোডটি এখানে:

static IEnumerable<int> Primes(int count)
{
    return Primes().Take(count);
}

static IEnumerable<int> Primes()
{
    List<int> cache = new List<int>();

    var primes = Enumerable.Range(2, int.MaxValue - 2).Select(candidate => new 
    {
        Sqrt = (int)Math.Sqrt(candidate), // caching sqrt for performance
        Current = candidate
    }).Where(candidate => !cache.TakeWhile(c => c <= candidate.Sqrt)
            .Any(cachedPrime => candidate.Current % cachedPrime == 0))
            .Select(p => p.Current);

    foreach (var prime in primes)
    {
        cache.Add(prime);
        yield return prime;
    }
}

আরেকটি অপ্টিমাইজেশন হ'ল এমনকি সংখ্যার পরীক্ষা করা এড়ানো এবং তালিকা তৈরির আগে মাত্র 2 টি ফিরে আসা। এইভাবে যদি কলিং পদ্ধতিটি কেবলমাত্র 1 জন প্রধানের জন্য জিজ্ঞাসা করে এটি সমস্ত গোলমাল এড়াতে পারে:

static IEnumerable<int> Primes()
{
    yield return 2;
    List<int> cache = new List<int>() { 2 };

    var primes = Enumerable.Range(3, int.MaxValue - 3)
        .Where(candidate => candidate % 2 != 0)
        .Select(candidate => new
    {
        Sqrt = (int)Math.Sqrt(candidate), // caching sqrt for performance
        Current = candidate
    }).Where(candidate => !cache.TakeWhile(c => c <= candidate.Sqrt)
            .Any(cachedPrime => candidate.Current % cachedPrime == 0))
            .Select(p => p.Current);

    foreach (var prime in primes)
    {
        cache.Add(prime);
        yield return prime;
    }
}

Question 15

এটিকে আরও মার্জিত করার জন্য, আপনার ইস্প্রাইম পরীক্ষাটি আলাদা পদ্ধতিতে রিফ্যাক্টর করা উচিত এবং এর বাইরে লুপিং এবং ইনক্রিমেন্টগুলি পরিচালনা করতে হবে।

Question 16

আমি জাভাতে এটি লিখেছিলাম একটি কার্যকরী লাইব্রেরি ব্যবহার করে করেছি, তবে যেহেতু আমার পাঠাগারটি এনুমারেশনগুলির মতো একই ধারণা ব্যবহার করে, তাই আমি নিশ্চিত যে কোডটি মানিয়ে নেওয়া যায়:

Iterable<Integer> numbers = new Range(1, 100);
Iterable<Integer> primes = numbers.inject(numbers, new Functions.Injecter<Iterable<Integer>, Integer>()
{
    public Iterable<Integer> call(Iterable<Integer> numbers, final Integer number) throws Exception
    {
        // We don't test for 1 which is implicit
        if ( number <= 1 )
        {
            return numbers;
        }
        // Only keep in numbers those that do not divide by number
        return numbers.reject(new Functions.Predicate1<Integer>()
        {
            public Boolean call(Integer n) throws Exception
            {
                return n > number && n % number == 0;
            }
        });
    }
});

Question 17

এটি সংক্ষিপ্ত বিজ্ঞপ্তিতে আমি ভাবতে পারি সবচেয়ে মার্জিত।

ArrayList generatePrimes(int numberToGenerate)
{
    ArrayList rez = new ArrayList();

    rez.Add(2);
    rez.Add(3);

    for(int i = 5; rez.Count <= numberToGenerate; i+=2)
    {
        bool prime = true;
        for (int j = 2; j < Math.Sqrt(i); j++)
        {
            if (i % j == 0)
            {
                    prime = false;
                    break;
            }
        }
        if (prime) rez.Add(i);
    }

    return rez;
}

আশা করি এটি আপনাকে ধারণা দিতে সহায়তা করবে। আমি নিশ্চিত এটি অপ্টিমাইজড হতে পারে, তবে এটি আপনাকে কীভাবে আপনার সংস্করণটিকে আরও মার্জিত করা যায় তা ধারণা দেওয়া উচিত।

সম্পাদনা: মন্তব্যে উল্লিখিত হিসাবে এই অ্যালগরিদম প্রকৃতপক্ষে সংখ্যার টো জেনারেটের জন্য ভুল মানগুলি প্রদান করে <2. আমি কেবল উল্লেখ করতে চাই যে, আমি তাকে প্রধান সংখ্যা তৈরি করার জন্য একটি দুর্দান্ত পদ্ধতি পোস্ট করার চেষ্টা করছিলাম না (এর জন্য হেনরির উত্তর দেখুন), আমি কীভাবে তার পদ্ধতিটি আরও মার্জিত করে তুলতে পারি তা খুব কমই দেখিয়ে দিচ্ছিলাম।

Question 18

ফাংশনাল জাভাতে স্ট্রিম-ভিত্তিক প্রোগ্রামিং ব্যবহার করে , আমি নিম্নলিখিতগুলি নিয়ে এসেছি। প্রকারটি Naturalমূলত a BigInteger> = 0।

public static Stream<Natural> sieve(final Stream<Natural> xs)
{ return cons(xs.head(), new P1<Stream<Natural>>()
  { public Stream<Natural> _1()
    { return sieve(xs.tail()._1()
                   .filter($(naturalOrd.equal().eq(ZERO))
                           .o(mod.f(xs.head())))); }}); }

public static final Stream<Natural> primes
  = sieve(forever(naturalEnumerator, natural(2).some()));

এখন আপনার কাছে একটি মান রয়েছে যা আপনি প্রায় বহন করতে পারবেন, এটি প্রাইমগুলির অসীম প্রবাহ। আপনি এই জাতীয় জিনিসগুলি করতে পারেন:

// Take the first n primes
Stream<Natural> nprimes = primes.take(n);

// Get the millionth prime
Natural mprime = primes.index(1000000);

// Get all primes less than n
Stream<Natural> pltn = primes.takeWhile(naturalOrd.lessThan(n));

চালুনির ব্যাখ্যা:

ধরুন আর্গুমেন্ট স্ট্রিমের প্রথম সংখ্যাটি মৌলিক এবং এটিকে রিটার্নের প্রবাহের সামনের দিকে রাখুন। রিটার্নের স্ট্রিমের বাকী অংশটি কেবল তখনই জিজ্ঞাসা করা হয় যে উত্পাদন করা যায়।
যদি কেউ স্ট্রিমের বাকি অংশের জন্য জিজ্ঞাসা করে, তবে যুক্তির স্ট্রিমের বাকী অংশে চালুনি কল করুন, প্রথম সংখ্যা দ্বারা বিভাজ্য সংখ্যাগুলি ফিল্টার করে (বিভাগের বাকীটি শূন্য)।

আপনার নিম্নলিখিত আমদানি থাকা দরকার:

import fj.P1;
import static fj.FW.$;
import static fj.data.Enumerator.naturalEnumerator;
import fj.data.Natural;
import static fj.data.Natural.*;
import fj.data.Stream;
import static fj.data.Stream.*;
import static fj.pre.Ord.naturalOrd;

Question 19

আমি ব্যক্তিগতভাবে মনে করি এটি বেশ সংক্ষিপ্ত এবং পরিষ্কার (জাভা) বাস্তবায়ন:

static ArrayList<Integer> getPrimes(int numPrimes) {
    ArrayList<Integer> primes = new ArrayList<Integer>(numPrimes);
    int n = 2;
    while (primes.size() < numPrimes) {
        while (!isPrime(n)) { n++; }
        primes.add(n);
        n++;
    }
    return primes;
}

static boolean isPrime(int n) {
    if (n < 2) { return false; }
    if (n == 2) { return true; }
    if (n % 2 == 0) { return false; }
    int d = 3;
    while (d * d <= n) {
        if (n % d == 0) { return false; }
        d += 2;
    }
    return true;
}

Question 20

এই লিনকিউ ক্যোয়ারীটি চেষ্টা করে দেখুন, এটি আপনার প্রত্যাশা অনুযায়ী প্রাথমিক সংখ্যা উত্পন্ন করে

        var NoOfPrimes= 5;
        var GeneratedPrime = Enumerable.Range(1, int.MaxValue)
          .Where(x =>
            {
                 return (x==1)? false:
                        !Enumerable.Range(1, (int)Math.Sqrt(x))
                        .Any(z => (x % z == 0 && x != z && z != 1));
            }).Select(no => no).TakeWhile((val, idx) => idx <= NoOfPrimes-1).ToList();

Question 21

// Create a test range
IEnumerable<int> range = Enumerable.Range(3, 50 - 3);

// Sequential prime number generator
var primes_ = from n in range
     let w = (int)Math.Sqrt(n)
     where Enumerable.Range(2, w).All((i) => n % i > 0)
     select n;

// Note sequence of output:
// 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47,
foreach (var p in primes_)
    Trace.Write(p + ", ");
Trace.WriteLine("");

Question 22

এখানে একটি অজগর কোড উদাহরণ রয়েছে যা সমস্ত প্রাইমের যোগফলকে দুই মিলিয়নের নিচে মুদ্রণ করে:

from math import *

limit = 2000000
sievebound = (limit - 1) / 2
# sieve only odd numbers to save memory
# the ith element corresponds to the odd number 2*i+1
sieve = [False for n in xrange(1, sievebound + 1)]
crosslimit = (int(ceil(sqrt(limit))) - 1) / 2
for i in xrange(1, crosslimit):
    if not sieve[i]:
        # if p == 2*i + 1, then
        #   p**2 == 4*(i**2) + 4*i + 1
        #        == 2*i * (i + 1)
        for j in xrange(2*i * (i + 1), sievebound, 2*i + 1):
            sieve[j] = True
sum = 2
for i in xrange(1, sievebound):
    if not sieve[i]:
        sum = sum + (2*i+1)
print sum

Question 23

সবচেয়ে সহজ পদ্ধতিটি হ'ল পরীক্ষা এবং ত্রুটি: আপনি চেষ্টা করেন 2 এবং n-1 এর মধ্যে যে কোনও সংখ্যা যদি আপনার প্রার্থীকে প্রধান এন ভাগ করে।
প্রথম শর্টকাটগুলি অবশ্যই ক) আপনাকে কেবল বিজোড় সংখ্যাগুলি পরীক্ষা করতে হবে, এবং খ) আপনি কেবল স্কয়ারটি (এন) পর্যন্ত বিভাজকগুলির জন্য পরীক্ষা করতে পারেন।

আপনার ক্ষেত্রে যেখানে আপনি প্রক্রিয়াটিতে পূর্ববর্তী সমস্ত প্রাইমগুলিও উত্পন্ন করেন, কেবলমাত্র আপনার তালিকার কোনও প্রাইম, স্কয়ারটি (এন) পর্যন্ত এন ভাগ করে কিনা তা পরীক্ষা করে দেখতে হবে।
আপনার অর্থের জন্য আপনি দ্রুততম পেতে পারেন :-)

ঠিক আছে, কোড সম্পাদনা করুন , আপনি এটি চেয়েছিলেন। তবে আমি আপনাকে সতর্ক করছি :-), এটি হ'ল 5 মিনিটের দ্রুত এবং নোংরা ডেল্ফি কোড:

procedure TForm1.Button1Click(Sender: TObject);
const
  N = 100;
var
  PrimeList: TList;
  I, J, SqrtP: Integer;
  Divides: Boolean;
begin
  PrimeList := TList.Create;
  for I := 2 to N do begin
    SqrtP := Ceil(Sqrt(I));
    J := 0;
    Divides := False;
    while (not Divides) and (J < PrimeList.Count) 
                        and (Integer(PrimeList[J]) <= SqrtP) do begin
      Divides := ( I mod Integer(PrimeList[J]) = 0 );
      inc(J);
    end;
    if not Divides then
      PrimeList.Add(Pointer(I));
  end;
  // display results
  for I := 0 to PrimeList.Count - 1 do
    ListBox1.Items.Add(IntToStr(Integer(PrimeList[I])));
  PrimeList.Free;
end;

Question 24

প্রথম 100 প্রাথমিক সংখ্যাগুলি খুঁজে পেতে, নিম্নলিখিত জাভা কোডটি বিবেচনা করা যেতে পারে।

int num = 2;
int i, count;
int nPrimeCount = 0;
int primeCount = 0;

    do
    {

        for (i = 2; i <num; i++)
        {

             int n = num % i;

             if (n == 0) {

             nPrimeCount++;
         //  System.out.println(nPrimeCount + " " + "Non-Prime Number is: " + num);

             num++;
             break;

             }
       }

                if (i == num) {

                    primeCount++;

                    System.out.println(primeCount + " " + "Prime number is: " + num);
                    num++;
                }


     }while (primeCount<100);

Question 25

আমি ভিক্কিতে "চালনার অফ আতকিন" এর প্রথম পড়ার সাথে এটি পেয়েছিলাম এবং এর আগে কিছুটা চিন্তাভাবনা দিয়েছিলাম - আমি প্রচুর স্ক্র্যাচ থেকে কোডিং করতে ব্যয় করি এবং লোকেরা আমার সংকলকের মতো সমালোচিত, খুব ঘন কোডিংয়ের জন্য সম্পূর্ণরূপে শূন্য হয়ে যায় get শৈলী + আমি কোড চালানোর জন্য প্রথম চেষ্টাও করিনি ... আমি যে উদাহরণটি ব্যবহার করতে শিখেছি তা এখানে রয়েছে, কেবল পড়ুন এবং কাঁদুন, আপনি যা পারেন তা পান।

কোনও ব্যবহারের আগে এই সমস্ত কিছুর সত্যই পরীক্ষার জন্য একেবারে এবং সম্পূর্ণ নিশ্চিত হন, অবশ্যই এটি কাউকে দেখাবেন না - এটি ধারণাগুলি পড়া এবং বিবেচনার জন্য। আমার আধ্যাত্মিক সরঞ্জামটি কাজ করা দরকার তাই আমি এখানে প্রতিবারই কিছু কাজ করার জন্য শুরু করি।

একটি পরিষ্কার সংকলন পান, তারপরে যা ত্রুটিযুক্ত তা সরিয়ে নেওয়া শুরু করুন - আমার কাছে ব্যবহারযোগ্য কোডের প্রায় 108 মিলিয়ন কীস্ট্রোক এইভাবে এটি করা হচ্ছে ... আপনি যা পারেন তা ব্যবহার করুন।

আমি আগামীকাল আমার সংস্করণে কাজ করব।

package demo;
// This code is a discussion of an opinion in a technical forum.
// It's use as a basis for further work is not prohibited.
import java.util.Arrays;
import java.util.HashSet;
import java.util.ArrayList;
import java.security.GeneralSecurityException;

/**
 * May we start by ignores any numbers divisible by two, three, or five
 * and eliminate from algorithm 3, 5, 7, 11, 13, 17, 19 completely - as
 * these may be done by hand. Then, with some thought we can completely
 * prove to certainty that no number larger than square-root the number
 * can possibly be a candidate prime.
 */

public class PrimeGenerator<T>
{
    //
    Integer HOW_MANY;
    HashSet<Integer>hashSet=new HashSet<Integer>();
    static final java.lang.String LINE_SEPARATOR
       =
       new java.lang.String(java.lang.System.getProperty("line.separator"));//
    //
    PrimeGenerator(Integer howMany) throws GeneralSecurityException
    {
        if(howMany.intValue() < 20)
        {
            throw new GeneralSecurityException("I'm insecure.");
        }
        else
        {
            this.HOW_MANY=howMany;
        }
    }
    // Let us then take from the rich literature readily 
    // available on primes and discount
    // time-wasters to the extent possible, utilizing the modulo operator to obtain some
    // faster operations.
    //
    // Numbers with modulo sixty remainder in these lists are known to be composite.
    //
    final HashSet<Integer> fillArray() throws GeneralSecurityException
    {
        // All numbers with modulo-sixty remainder in this list are not prime.
        int[]list1=new int[]{0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,
        32,34,36,38,40,42,44,46,48,50,52,54,56,58};        //
        for(int nextInt:list1)
        {
            if(hashSet.add(new Integer(nextInt)))
            {
                continue;
            }
            else
            {
                throw new GeneralSecurityException("list1");//
            }
        }
        // All numbers with modulo-sixty remainder in this list are  are
        // divisible by three and not prime.
        int[]list2=new int[]{3,9,15,21,27,33,39,45,51,57};
        //
        for(int nextInt:list2)
        {
            if(hashSet.add(new Integer(nextInt)))
            {
                continue;
            }
            else
            {
                throw new GeneralSecurityException("list2");//
            }
        }
        // All numbers with modulo-sixty remainder in this list are
        // divisible by five and not prime. not prime.
        int[]list3=new int[]{5,25,35,55};
        //
        for(int nextInt:list3)
        {
            if(hashSet.add(new Integer(nextInt)))
            {
                continue;
            }
            else
            {
                throw new GeneralSecurityException("list3");//
            }
        }
        // All numbers with modulo-sixty remainder in
        // this list have a modulo-four remainder of 1.
        // What that means, I have neither clue nor guess - I got all this from
        int[]list4=new int[]{1,13,17,29,37,41,49,53};
        //
        for(int nextInt:list4)
        {
            if(hashSet.add(new Integer(nextInt)))
            {
                continue;
            }
            else
            {
                throw new GeneralSecurityException("list4");//
            }
        }
        Integer lowerBound=new Integer(19);// duh
        Double upperStartingPoint=new Double(Math.ceil(Math.sqrt(Integer.MAX_VALUE)));//
        int upperBound=upperStartingPoint.intValue();//
        HashSet<Integer> resultSet=new HashSet<Integer>();
        // use a loop.
        do
        {
            // One of those one liners, whole program here:
            int aModulo=upperBound % 60;
            if(this.hashSet.contains(new Integer(aModulo)))
            {
                continue;
            }
            else
            {
                resultSet.add(new Integer(aModulo));//
            }
        }
        while(--upperBound > 20);
        // this as an operator here is useful later in your work.
        return resultSet;
    }
    // Test harness ....
    public static void main(java.lang.String[] args)
    {
        return;
    }
}
//eof

Question 26

এই কোড ব্যবহার করে দেখুন।

protected bool isPrimeNubmer(int n)
    {
        if (n % 2 == 0)
            return false;
        else
        {
            int j = 3;
            int k = (n + 1) / 2 ;

            while (j <= k)
            {
                if (n % j == 0)
                    return false;
                j = j + 2;
            }
            return true;
        }
    }
    protected void btn_primeNumbers_Click(object sender, EventArgs e)
    {
        string time = "";
        lbl_message.Text = string.Empty;
        int num;

        StringBuilder builder = new StringBuilder();

        builder.Append("<table><tr>");
        if (int.TryParse(tb_number.Text, out num))
        {
            if (num < 0)
                lbl_message.Text = "Please enter a number greater than or equal to 0.";
            else
            {
                int count = 1;
                int number = 0;
                int cols = 11;

                var watch = Stopwatch.StartNew();

                while (count <= num)
                {
                    if (isPrimeNubmer(number))
                    {
                        if (cols > 0)
                        {
                            builder.Append("<td>" + count + " - " + number + "</td>");
                        }
                        else
                        {
                            builder.Append("</tr><tr><td>" + count + " - " + number + "</td>");
                            cols = 11;
                        }
                        count++;
                        number++;
                        cols--;
                    }
                    else
                        number++;
                }
                builder.Append("</table>");
                watch.Stop();
                var elapsedms = watch.ElapsedMilliseconds;
                double seconds = elapsedms / 1000;
                time = seconds.ToString();
                lbl_message.Text = builder.ToString();
                lbl_time.Text = time;
            }
        }
        else
            lbl_message.Text = "Please enter a numberic number.";

        lbl_time.Text = time;

        tb_number.Text = "";
        tb_number.Focus();
    }

এখানে এসপেক্স কোড।

<form id="form1" runat="server">
    <div>
        <p>Please enter a number: <asp:TextBox ID="tb_number" runat="server"></asp:TextBox></p>

        <p><asp:Button ID="btn_primeNumbers" runat="server" Text="Show Prime Numbers" OnClick="btn_primeNumbers_Click" />
        </p>
        <p><asp:Label ID="lbl_time" runat="server"></asp:Label></p>
        <p><asp:Label ID="lbl_message" runat="server"></asp:Label></p>
    </div>
</form>

ফলাফল: এক সেকেন্ডেরও কম সময়ে 10000 প্রাইম নম্বর

100000 প্রাইম নম্বর 63৩ সেকেন্ডে

প্রথম 100 প্রাইম নম্বরের স্ক্রিনশট এখানে চিত্র বর্ণনা লিখুন