একটি সংখ্যার বৃহত্তমতম মৌলিক ফ্যাক্টরটি খুঁজতে অ্যালগরিদম

183

কোন সংখ্যার বৃহত্তম প্রাইম ফ্যাক্টর গণনা করার জন্য সেরা পন্থাটি কী?

আমি ভাবছি সবচেয়ে দক্ষ নিম্নলিখিত হবে:

  1. পরিষ্কারভাবে বিভাজিত সর্বনিম্ন মৌলিক সংখ্যাটি সন্ধান করুন
  2. বিভাগের ফলাফলটি প্রধান কিনা তা পরীক্ষা করে দেখুন
  3. যদি না হয় তবে পরবর্তী সর্বনিম্ন সন্ধান করুন
  4. 2 এ যান।

আমি ক্ষুদ্র প্রাথমিক কারণগুলি গণনা করা সহজ হওয়ায় এ ধারণাটি বেস করছি। এটা কি ঠিক? আমার আর কোন পদ্ধতির দিকে নজর দেওয়া উচিত?

সম্পাদনা: আমি এখন বুঝতে পেরেছি যে খেলায় 2 টিরও বেশি মৌলিক উপাদান থাকলে আমার পদ্ধতিটি নিরর্থক, যেহেতু দ্বিতীয় ধাপের ফলাফল যখন ফলাফল দুটি অন্য প্রাইমের ফলস্বরূপ হয় তখন দ্বিতীয় ধাপে ব্যর্থ হয়, সুতরাং পুনরাবৃত্তির একটি অ্যালগরিদম প্রয়োজন।

আবার সম্পাদনা করুন: এবং এখন আমি বুঝতে পেরেছি যে এটি এখনও কাজ করে, কারণ সর্বশেষ পাওয়া প্রাথমিক সংখ্যাটি সর্বাধিক এক হতে হবে, সুতরাং পদক্ষেপ 2 থেকে অ-মৌলিক ফলাফলের আরও কোনও পরীক্ষার ফলস্বরূপ ছোট প্রাইম হবে in

algorithm  math  prime-factoring 
— mercutio
সূত্র
আমার পন্থাটি ছিল: (1) বৃহত্তর, সম্ভাব্য সংখ্যাকে 2 দ্বারা ভাগ করুন; (২) চেক করুন যে বড় সংখ্যা এটিতে সমানভাবে বিভক্ত হয়েছে; (3) যদি তাই হয় তবে 2 সংখ্যায় বিভাজিত প্রধান কিনা তা পরীক্ষা করে দেখুন। যদি তা হয় তবে তা ফিরিয়ে দিন। (4) অন্যথায়, 2 টি সংখ্যা দ্বারা বিভক্ত 1 টি থেকে প্রথম পদক্ষেপটি 3 নম্বরে ফিরে
— কেভিন মেরেডিথ
1.স্পষ্টভাবে বিভক্ত যে কোনও সংখ্যা সন্ধান করুন (i = 2 to int (sqr (num)) এর জন্য 2.number সংখ্যাটি দিয়ে ভাগ করুন (num = num / i) এবং পুনরায় পুনরুক্ত করুন যতক্ষণ না 1 পাওয়া যায় । 'এর ব্যবধান 3. সংখ্যা বৃহত্তম ফ্যাক্টর
— ব্যবহারকারী 3819867
1
আমরা ছোট ছোট প্রাইমগুলির সাথে ভাগ করতে পারি এবং অবশেষে যেটি বাকী থাকে তা

উত্তর:

134

আসলে বড় সংখ্যার কারণগুলি খুঁজে বের করার আরও বেশ কয়েকটি কার্যকর উপায় রয়েছে (ছোটদের জন্য ট্রায়াল বিভাগ যুক্তিসঙ্গতভাবে ভাল কাজ করে)।

একটি পদ্ধতি যা খুব দ্রুত হয় যদি ইনপুট সংখ্যাটির বর্গমূলের খুব কাছাকাছি দুটি কারণ থাকে তবে এটি ফর্ম্যাট ফ্যাক্টরিজেশন হিসাবে পরিচিত । এটি পরিচয় N = (a + b) (a - b) = a ^ 2 - b ^ 2 ব্যবহার করে এবং এটি বোঝা এবং বাস্তবায়ন করা সহজ। দুর্ভাগ্যক্রমে এটি সাধারণভাবে খুব দ্রুত হয় না।

100 ডিজিট দৈর্ঘ্যের ফ্যাক্টরিংয়ের জন্য সর্বাধিক পরিচিত পদ্ধতি হ'ল চতুর্ভুজীয় চালনী । বোনাস হিসাবে, অ্যালগরিদমের কিছু অংশ সহজেই সমান্তরাল প্রসেসিংয়ের মাধ্যমে সম্পন্ন হয়।

তবুও আমি শুনেছি আরেকটি অ্যালগরিদম হ'ল পোলার্ডের রোহ আলগোরিদিম । এটি সাধারণভাবে চতুষ্কোণ চালনার মতো দক্ষ নয় তবে এটি কার্যকর করা সহজ বলে মনে হচ্ছে।

একবার আপনি কীভাবে কোনও সংখ্যাকে দুটি কারণে বিভক্ত করবেন তা স্থির করে নিলে, এখানে একটি দ্রুততম অ্যালগরিদম আমি সংখ্যার বৃহত্তম প্রাইম ফ্যাক্টরটি সন্ধান করার জন্য ভাবতে পারি:

একটি অগ্রাধিকার সারি তৈরি করুন যা প্রাথমিকভাবে নম্বরটি সঞ্চয় করে। প্রতিটি পুনরাবৃত্তি, আপনি সারি থেকে সর্বাধিক সংখ্যা সরিয়ে ফেলুন এবং এটিকে দুটি কারণে বিভক্ত করার চেষ্টা করেছেন (অবশ্যই 1টিকে অবশ্যই সেই কারণগুলির মধ্যে একটি হতে দেয় না)। যদি এই পদক্ষেপটি ব্যর্থ হয়, সংখ্যাটি প্রধান এবং আপনার উত্তর আছে! অন্যথায় আপনি দুটি কারণকে সারিতে যুক্ত করুন এবং পুনরাবৃত্তি করুন।

— Artelius
সূত্র
3
চৌম্বক চালুনির তুলনায় পোলার্ড আরএ এবং এলিপটিক কার্ভ পদ্ধতিটি আপনার সংখ্যার ছোট ছোট মৌলিক কারণগুলি থেকে মুক্তি পাওয়ার পক্ষে আরও ভাল। কিউএস-তে একই রানটাইম সম্পর্কে সংখ্যা নির্বিশেষে রয়েছে। কোন পদ্ধতির দ্রুত আপনার নম্বরটি নির্ভর করে; কিউএস হার্ড-টু-ফ্যাক্টর সংখ্যার দ্রুত ক্র্যাক করবে যখন আরএইচও এবং ইসিএম সহজেই-ফ্যাক্টর সংখ্যাগুলি ক্র্যাক করবে।
— tmyklebu
চতুষ্কোণ প্রকরণের পরামর্শের জন্য আপনাকে ধন্যবাদ। আমার এক ক্লায়েন্টের জন্য এটি বাস্তবায়ন করা আমার দরকার ছিল, আমি যে প্রাথমিক সংস্করণটি এলাম তা হ'ল @ মির্কুটিও তার প্রশ্নের পরামর্শ অনুসারে কিছু ছিল। চতুর্ভুজ সমাধানটি হ'ল এখনই আমার ক্লায়েন্টের সরঞ্জামটি math.tools/calculator/prime-factors- এ শক্তি সরবরাহ করছে ।
— dors
যদি এই সমস্যাটি সমাধানের কার্যকর উপায় থাকে তবে এর অর্থ এই নয় যে ওয়েব এনক্রিপশনটি সুরক্ষিত নয়?
— বিকেএসপুরজন
141

আমি জানি যে সেরা অ্যালগরিদম এখানে রয়েছে (পাইথনে)

def prime_factors(n):
    """Returns all the prime factors of a positive integer"""
    factors = []
    d = 2
    while n > 1:
        while n % d == 0:
            factors.append(d)
            n /= d
        d = d + 1

    return factors


pfs = prime_factors(1000)
largest_prime_factor = max(pfs) # The largest element in the prime factor list

উপরের পদ্ধতিটি O(n)সবচেয়ে খারাপ অবস্থায় চলেছে (যখন ইনপুটটি প্রাথমিক সংখ্যা হয়)।

সম্পাদনা: মন্তব্যের পরামর্শ অনুযায়ী
নীচে O(sqrt(n))সংস্করণটি দেওয়া হল । এখানে আরও একবার কোড দেওয়া হয়েছে।

def prime_factors(n):
    """Returns all the prime factors of a positive integer"""
    factors = []
    d = 2
    while n > 1:
        while n % d == 0:
            factors.append(d)
            n /= d
        d = d + 1
        if d*d > n:
            if n > 1: factors.append(n)
            break
    return factors


pfs = prime_factors(1000)
largest_prime_factor = max(pfs) # The largest element in the prime factor list
— পাশাপাশি আটকান তিন তক্তার উপর অংকিত ছবি
সূত্র
11
এই কোডটি ভোট দেওয়ার আগে দয়া করে পড়ুন এবং / অথবা চালান or এটা ঠিক কাজ করে। শুধু কপি এবং পেস্ট করুন। লিখিত প্রাইম_ফ্যাক্টর হিসাবে (1000) ফিরে আসবে [2,2,2,5,5,5], যা 2 ^ 3 * 5 ^ 3 হিসাবে ব্যাখ্যা করা উচিত, যার প্রধান গুণনীয়ক।
— ট্রিপটিচ
11
" O(sqrt(n))সবচেয়ে খারাপ অবস্থায় চলে" - না, এটি O(n)সবচেয়ে খারাপ ক্ষেত্রে চলে (যেমন যখন nপ্রধান হয়।)
— শেল্ডন এল কুপার
16
এটিকে ও (স্কয়ার্ট (এন)) তৈরি করা সহজ, আপনি ড * ডি> এন করার সময় লুপটি থামিয়ে দিন এবং যদি n> 1 এই মুহুর্তে তবে এর মানটি মূল কারণগুলির তালিকায় যুক্ত করা উচিত।
— সুমুডু ফার্নান্দো
5
এর নাম আছে কি?
— ফোরথিংকার
11
যেহেতু 2 হ'ল একমাত্র মৌলিক সংখ্যা, তাই প্রতিবার 1 যোগ করার পরিবর্তে, আপনি ডি = 2 এর জন্য পৃথকভাবে পুনরাবৃত্তি করতে পারেন এবং তারপরে এটি 1 দ্বারা বৃদ্ধি করতে পারেন এবং তারপরে ডি = 3 থেকে আপনি 2 বৃদ্ধি করতে পারবেন তাই এটি সংখ্যা হ্রাস পাবে পুনরাবৃত্তির ... :)
— দর্জি_রাজ
18

আমার উত্তর ট্রিপটিচের উপর ভিত্তি করে , তবে এতে অনেক উন্নতি হয়েছে। এটি 2 এবং 3 এর বাইরে সমস্ত মৌলিক সংখ্যা 6n-1 বা 6n + 1 ফর্মের ভিত্তিতে তৈরি।

var largestPrimeFactor;
if(n mod 2 == 0)
{
    largestPrimeFactor = 2;
    n = n / 2 while(n mod 2 == 0);
}
if(n mod 3 == 0)
{
    largestPrimeFactor = 3;
    n = n / 3 while(n mod 3 == 0);
}

multOfSix = 6;
while(multOfSix - 1 <= n)
{
    if(n mod (multOfSix - 1) == 0)
    {
        largestPrimeFactor = multOfSix - 1;
        n = n / largestPrimeFactor while(n mod largestPrimeFactor == 0);
    }

    if(n mod (multOfSix + 1) == 0)
    {
        largestPrimeFactor = multOfSix + 1;
        n = n / largestPrimeFactor while(n mod largestPrimeFactor == 0);
    }
    multOfSix += 6;
}

এই অ্যালগোরিদম কীভাবে কাজ করে তা ব্যাখ্যা করে আমি সম্প্রতি একটি ব্লগ নিবন্ধ লিখেছিলাম ।

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

— সূন্দর - মনিকা পুনরায় স্থাপন করুন
সূত্র
12
আপনি আসলে এই ধারণাটি আরও এগিয়ে নিতে পারেন, উদাহরণস্বরূপ ২,৩,৫ এর বাইরে সমস্ত প্রাইম 30n + কে (এন> = 0) ফর্মের যেখানে K কেবল সেই মানগুলি 1 এবং 29 এর মধ্যে নেয় যা 2,3 দ্বারা বিভাজ্য নয় বা 5, অর্থাৎ 7,11,13,17,19,23,29। এমনকি এ পর্যন্ত আপনি যে কয়েকটি প্রাইম পেয়েছেন তার পরে আপনি এই গতিশীলভাবে মানিয়ে নিতে পারেন 2 * 3 * 5 * 7 * ... * এন + কে যেখানে এই প্রাইমগুলির দ্বারা কে বিভাজনীয় হওয়া উচিত নয় (দ্রষ্টব্য যে সমস্ত সম্ভাব্য কে প্রয়োজন হয় না প্রধানমন্ত্রী হয়ে উঠুন, যেমন 210n + কে এর জন্য আপনাকে 121 অন্তর্ভুক্ত করতে হবে, অন্যথায় আপনি 331 মিস করবেন )
— টোবিয়াস কেইনজলার
2
আমার ধারণা এটি হওয়া উচিতwhile (multOfSix - 1 <= n)
— নাদের ঘানবাড়ি
8

জাভাস্ক্রিপ্ট কোড:

'option strict';

function largestPrimeFactor(val, divisor = 2) { 
    let square = (val) => Math.pow(val, 2);

    while ((val % divisor) != 0 && square(divisor) <= val) {
        divisor++;
    }

    return square(divisor) <= val
        ? largestPrimeFactor(val / divisor, divisor)
        : val;
}

ব্যবহারের উদাহরণ:

let result = largestPrimeFactor(600851475143);

কোডের উদাহরণ এখানে :

— ভ্লাদ বেজডেন
সূত্র
7

@ ট্রিপটাইচ উত্তরের মতো তবে ভিন্ন different এই উদাহরণে তালিকা বা অভিধান ব্যবহার করা হয় না। কোড লিখেছেন রুবিতে

def largest_prime_factor(number)
  i = 2
  while number > 1
    if number % i == 0
      number /= i;
    else
      i += 1
    end
  end
  return i
end

largest_prime_factor(600851475143)
# => 6857
— ইউজনিয়াস মালেকাস
সূত্র
শেষ অবধি পাঠযোগ্য এবং তাত্ক্ষণিকভাবে (জেএসে) একই সময়ে নির্বাহযোগ্য আমি অসীম প্রধান তালিকাটি ব্যবহার করার চেষ্টা করছিলাম এবং এটি ইতিমধ্যে 1 মিলিয়নে খুব ধীর ছিল।
— Ebuall
4

সমস্ত সংখ্যা প্রাইমের পণ্য হিসাবে প্রকাশ করা যেতে পারে, যেমন:

102 = 2 x 3 x 17
712 = 2 x 2 x 2 x 89

এগুলি আপনি কেবল 2 থেকে শুরু করে এবং ফলাফলটি আপনার সংখ্যার একাধিক না হওয়া পর্যন্ত কেবল বিভাজন অবিরত করে এটিগুলি সন্ধান করতে পারেন:

712 / 2 = 356 .. 356 / 2 = 178 .. 178 / 2 = 89 .. 89 / 89 = 1

এই পদ্ধতিটি ব্যবহার করে আপনাকে আসলে কোনও প্রাইমগুলি গণনা করতে হবে না: এগুলি সমস্ত প্রাইম হয়ে যাবে, আপনি ইতিপূর্বে সমস্ত সংখ্যার সাথে সংখ্যাটি যতটা সম্ভব ফ্যাক্টরিজ করেছেন তা ভিত্তিতে।

number = 712;
currNum = number;    // the value we'll actually be working with
for (currFactor in 2 .. number) {
    while (currNum % currFactor == 0) {
        // keep on dividing by this number until we can divide no more!
        currNum = currNum / currFactor     // reduce the currNum
    }
    if (currNum == 1) return currFactor;    // once it hits 1, we're done.
}
— nickf
সূত্র
হ্যাঁ, তবে এটি মারাত্মকভাবে অদক্ষ। একবার আপনি সমস্ত 2 টি ভাগ করে নিলে, আপনার সত্যিই 4 বা 6 দ্বারা ভাগ করার চেষ্টা করা উচিত নয় বা ...; এটি কেবলমাত্র প্রাইমগুলি পরীক্ষা করতে, বা কিছু টোয়ার অ্যালগরিদম ব্যবহার করার সীমাতে এটি আরও বেশি দক্ষ।
— Wnoise
6
Wnoise অফসেট করতে +1, আমি কাকে ভুল বলে মনে করি। 4 দ্বারা ভাগ করার চেষ্টা কেবল একবার ঘটবে এবং অবিলম্বে ব্যর্থ হবে। আমি মনে করি না যে প্রার্থীদের কয়েকটি তালিকা থেকে 4 অপসারণের চেয়ে খারাপ এটি ইতিমধ্যে সমস্ত প্রাইম খুঁজে পাওয়ার চেয়ে দ্রুত faster
— ট্রিপটিচ
2
@Beowulf। ভোট দেওয়ার আগে এই কোডটি চালানোর চেষ্টা করুন। এটি প্রধান কারণগুলি ফেরত দেয়; আপনি শুধু অ্যালগরিদম বুঝতে পারবেন না।
— ট্রিপটিচ
3
কোডটি ঠিকঠাক কাজ করে, তবে আগত সংখ্যাটি যদি প্রধান হয় তবে ধীর হয় is আমি কেবল স্কোয়ার পর্যন্ত দৌড়াব এবং 2 দ্বারা বৃদ্ধি পাব যদিও এটি খুব বড় সংখ্যার জন্য খুব ধীর হতে পারে।
— blabla999
4
blabla999 ঠিক ঠিক। উদাহরণটি হল 1234567898766700 = 2 * 2 * 5 * 5 * 12345678987667। যখন আমরা পৌঁছে গেছি currFactor = 3513642, আমরা জানি যে 12345678987667 প্রধান, এবং এটি উত্তর হিসাবে ফিরে দেওয়া উচিত। পরিবর্তে, এই কোড 12345678987667 নিজেই গণনা চালিয়ে যাবে। এটি প্রয়োজনের তুলনায় 3,513,642x কম।
— নেস
4 
    //this method skips unnecessary trial divisions and makes 
    //trial division more feasible for finding large primes

    public static void main(String[] args) 
    {
        long n= 1000000000039L; //this is a large prime number 
        long i = 2L;
        int test = 0;

        while (n > 1)
        {
            while (n % i == 0)
            {
                n /= i;     
            }

            i++;

            if(i*i > n && n > 1) 
            {
                System.out.println(n); //prints n if it's prime
                test = 1;
                break;
            }
        }

        if (test == 0)  
            System.out.println(i-1); //prints n if it's the largest prime factor
    }
— the_prole
সূত্র
1
আপনি কি 1,000,000,000,039 দিয়ে আপনার কোড চেষ্টা করেছেন? এটি চোখের পলকেও চালানো উচিত। এটা কি পারে?
— নেস
2
আপনি এটি চেষ্টা না করে আগেই জানতে পারতেন। 10 ^ 12 = (2 * 5) ^ 12 = 2 ^ 12 * 5 ^ 12। সুতরাং আপনার whileলুপটি iমানগুলির মধ্য দিয়ে যাবে 2,2,2,2,2,2,2,2,2,2,2,2, 2,3,4,5, 2,3,4,5, 2,3,4,5, 2,3,4,5, 2,3,4,5, 2,3,4,5, 2,3,4,5, 2,3,4,5, 2,3,4,5, 2,3,4,5, 2,3,4,5, 2,3,4,5। 60 টি পুনরাবৃত্তি সমস্ত। তবে (10 ^ 12 + 39) এর জন্য (10 ^ 12 + 38) পুনরাবৃত্তি হবে i=2,3,4,5,6,...,10^12+39,। এমনকি যদি 10 ^ 10 অপ্স এক সেকেন্ড সময় নেয় তবে 10 ^ 12 100 সেকেন্ড সময় নেয়। তবে কেবলমাত্র 10 ^ 6 পুনরাবৃত্তিগুলি সত্যই প্রয়োজন, এবং যদি 10 ^ 10 অপস এক সেকেন্ড নেয়, 10 ^ 6 এক সেকেন্ডের 1 / 10,000 তম সময় নেয়।
— নেস
1
কারণ আমি বুঝতে পারি নি (10 ^ 12 + 39) একটি প্রধান সংখ্যা যা আমি এখন করি। আপনি যা বলছেন ঠিক তা পেয়েছি।
— the_prole
1
ঠিক আছে, সুতরাং আপনি আপনার কোডটি পরিবর্তন করতে পারেন যাতে প্রাইমগুলির পক্ষে এত বড় ধীরগতি না ঘটে: যদি এন = বি বি এবং একটি <= বি হয়, তবে একটি <= বি এ = এন, অর্থাৎ একটি <= এন । এবং যদি আমরা একটি + 1 এ পৌঁছে যাই, তবে এন অবশ্যই একটি প্রাথমিক। (আপনি যদি এই উত্তর অন্তর্ভুক্ত করতে আপনার উত্তর সম্পাদনা করেন তবে আমাকে পিং করুন)।
— নেস
1
কি হবে যখন long n = 2*1000000000039L? এটি করা উচিত হিসাবে দ্রুত কাজ করে? (এছাড়াও, আপনি একটি return;বিবৃতি ব্যবহার করে আপনার কোড সহজ করতে পারবেন ?) (আপনি যদি চান যে আমি আপনাকে ঠাট্টা করা বন্ধ করব, কেবল তাই বলুন;))
— নেস
4

সবচেয়ে সহজ সমাধান পারস্পরিক পুনরাবৃত্তি ফাংশনগুলির একটি জুড়ি ।

প্রথম ফাংশনটি সমস্ত মৌলিক সংখ্যা উত্পন্ন করে:

  1. 1 এর চেয়ে বেশি প্রাকৃতিক সংখ্যার একটি তালিকা দিয়ে শুরু করুন।
  2. সমস্ত নম্বর মুছে ফেলুন যা প্রাথমিক নয়। এটি হ'ল সংখ্যার কোনও প্রধান কারণ নেই (নিজেরাই ব্যতীত)। নিচে দেখ.

দ্বিতীয় ক্রমটি nক্রমবর্ধমান ক্রমে প্রদত্ত সংখ্যার মূল কারণগুলি প্রদান করে ।

  1. সমস্ত প্রাইমগুলির একটি তালিকা নিন (উপরে দেখুন)।
  2. সমস্ত নম্বরগুলি মুছুন যা এর কারণ নয় n।

এর বৃহত্তম প্রাইম ফ্যাক্টর nদ্বিতীয় ফাংশন দ্বারা প্রদত্ত সর্বশেষ সংখ্যা number

এই অ্যালগরিদমের জন্য একটি অলস তালিকা বা একটি ভাষা (বা ডেটা স্ট্রাকচার) কল-বাই-প্রয়োজন শব্দার্থবিজ্ঞানের প্রয়োজন ।

স্পষ্টতার জন্য, এখানে হাস্কেলের উপরেরগুলির একটি (অদক্ষ) বাস্তবায়ন:

import Control.Monad

-- All the primes
primes = 2 : filter (ap (<=) (head . primeFactors)) [3,5..]

-- Gives the prime factors of its argument
primeFactors = factor primes
  where factor [] n = []
        factor xs@(p:ps) n =
          if p*p > n then [n]
          else let (d,r) = divMod n p in
            if r == 0 then p : factor xs d
            else factor ps n

-- Gives the largest prime factor of its argument
largestFactor = last . primeFactors

এই সংখ্যাটি দ্রুত করা কেবল কোন সংখ্যাটি প্রধান এবং / অথবা এর কারণগুলির সনাক্তকরণ সম্পর্কে আরও চতুর হওয়ার বিষয় n, তবে অ্যালগরিদম একই থাকে।

— Apocalisp
সূত্র
2 
n = abs(number);
result = 1;
if (n mod 2 == 0) {
  result = 2;
  while (n mod 2 = 0) n /= 2;
}
for(i=3; i<sqrt(n); i+=2) {
  if (n mod i == 0) {
    result = i;
    while (n mod i = 0)  n /= i;
  }
}
return max(n,result)

কিছু মডুলো পরীক্ষা রয়েছে যা অতিমাত্রায় ব্যবহারযোগ্য, কারণ n এবং কখনই 2 দ্বারা ভাগ করা যায় না যদি সমস্ত কারণ 2 এবং 3 সরানো হয়। আপনি কেবলমাত্র আমার জন্য প্রাইমসকে অনুমতি দিতে পারবেন, যা এখানে বেশ কয়েকটি অন্যান্য উত্তরে দেখানো হয়েছে।

আপনি এখানে ইরাটোস্থেনেসের চালনিটি জড়িয়ে রাখতে পারেন:

  • প্রথমে sqrt (n) পর্যন্ত পূর্ণসংখ্যার তালিকা তৈরি করুন।
  • লুপের জন্য i এর সমস্ত গুণককে নতুন স্কয়ার্ট (এন) পর্যন্ত প্রধান হিসাবে চিহ্নিত করবেন না এবং তার পরিবর্তে কিছুক্ষণ লুপ ব্যবহার করুন।
  • তালিকার পরবর্তী মূল নম্বরটিতে আমি সেট করে।

আরো দেখুন এই প্রশ্নের ।

— র‌্যাল্ফ এম রিকেনবাচ
সূত্র
2

আমি সচেতন এটি একটি দ্রুত সমাধান নয়। আশ্বাস হিসাবে ধীর সমাধান বুঝতে সহজ হিসাবে পোস্ট করা।

 public static long largestPrimeFactor(long n) {

        // largest composite factor must be smaller than sqrt
        long sqrt = (long)Math.ceil(Math.sqrt((double)n));

        long largest = -1;

        for(long i = 2; i <= sqrt; i++) {
            if(n % i == 0) {
                long test = largestPrimeFactor(n/i);
                if(test > largest) {
                    largest = test;
                }
            }
        }

        if(largest != -1) {
            return largest;
        }

        // number is prime
        return n;
    }
— thejosh
সূত্র
1

সংখ্যা থেকে সমস্ত মৌলিক উপাদানগুলি সরিয়ে পাইথন আইট্রেটিভ পদ্ধতি

def primef(n):
    if n <= 3:
        return n
    if n % 2 == 0:
        return primef(n/2)
    elif n % 3 ==0:
        return primef(n/3)
    else:
        for i in range(5, int((n)**0.5) + 1, 6):
            #print i
            if n % i == 0:
                return primef(n/i)
            if n % (i + 2) == 0:
                return primef(n/(i+2))
    return n
— জ্যোতির আদিত্য সিং
সূত্র
1

আমি অ্যালগরিদম ব্যবহার করছি যা বর্তমানেকার প্রাইম ফ্যাক্টরের দ্বারা সংখ্যাটি বিভাজন অব্যাহত রেখেছে।

অজগর 3 এ আমার সমাধান:

def PrimeFactor(n):
    m = n
    while n%2==0:
        n = n//2
    if n == 1:         # check if only 2 is largest Prime Factor 
        return 2
    i = 3
    sqrt = int(m**(0.5))  # loop till square root of number
    last = 0              # to store last prime Factor i.e. Largest Prime Factor
    while i <= sqrt :
        while n%i == 0:
            n = n//i       # reduce the number by dividing it by it's Prime Factor
            last = i
        i+=2
    if n> last:            # the remaining number(n) is also Factor of number 
        return n
    else:
        return last
print(PrimeFactor(int(input())))

ইনপুট: 10 আউটপুট:5

ইনপুট: 600851475143 আউটপুট:6857

— কল্পেশ দুসনে
সূত্র
0

এখানে সি # তে আমার প্রচেষ্টা। সর্বশেষ প্রিন্ট আউট হ'ল সংখ্যার বৃহত্তম প্রধান উপাদান। আমি পরীক্ষা করেছিলাম এবং এটি কাজ করে।

namespace Problem_Prime
{
  class Program
  {
    static void Main(string[] args)
    {
      /*
       The prime factors of 13195 are 5, 7, 13 and 29.

      What is the largest prime factor of the number 600851475143 ?
       */
      long x = 600851475143;
      long y = 2;
      while (y < x)
      {
        if (x % y == 0)
        {
          // y is a factor of x, but is it prime
          if (IsPrime(y))
          {
            Console.WriteLine(y);
          }
          x /= y;
        }

        y++;

      }
      Console.WriteLine(y);
      Console.ReadLine();
    }
    static bool IsPrime(long number)
    {
      //check for evenness
      if (number % 2 == 0)
      {
        if (number == 2)
        {
          return true;
        }
        return false;
      }
      //don't need to check past the square root
      long max = (long)Math.Sqrt(number);
      for (int i = 3; i <= max; i += 2)
      {
        if ((number % i) == 0)
        {
          return false;
        }
      }
      return true;
    }

  }
}
— সিমাস ব্যারেট
সূত্র
0 
#python implementation
import math
n = 600851475143
i = 2
factors=set([])
while i<math.sqrt(n):
   while n%i==0:
       n=n/i
       factors.add(i)
   i+=1
factors.add(n)
largest=max(factors)
print factors
print largest
— Habষভ প্রসাদ
সূত্র
1
25 25 সবচেয়ে বড় মৌলিক ফ্যাক্টর?
— নেস
0

সি ++ এ পুনরাবৃত্তি ব্যবহার করে কোনও সংখ্যার বৃহত্তম প্রাইম ফ্যাক্টর গণনা করে। কোডটির কার্যকারিতা নীচে ব্যাখ্যা করা হয়েছে:

int getLargestPrime(int number) {
    int factor = number; // assumes that the largest prime factor is the number itself
    for (int i = 2; (i*i) <= number; i++) { // iterates to the square root of the number till it finds the first(smallest) factor
        if (number % i == 0) { // checks if the current number(i) is a factor
            factor = max(i, number / i); // stores the larger number among the factors
            break; // breaks the loop on when a factor is found
        }
    }
    if (factor == number) // base case of recursion
        return number;
    return getLargestPrime(factor); // recursively calls itself
}
— 4aRk Kn1gh7
সূত্র
0

এখানে বৃহত্তম প্রাইম ফ্যাক্টরটি দ্রুত গণনা করার জন্য আমার পদ্ধতিটি। এটি পরিবর্তিত xকোনও অ-প্রধান উপাদান থাকে না এমন তথ্যের ভিত্তিতে তৈরি is এটি অর্জনের জন্য, xকোনও ফ্যাক্টর পাওয়া মাত্র আমরা ভাগ করে নিই । তারপরে, কেবলমাত্র বৃহত্তম জিনিসটি ফিরে আসা। এটি ইতিমধ্যে প্রধান হবে।

কোড (হাস্কেল):

f max' x i | i > x = max'
           | x `rem` i == 0 = f i (x `div` i) i  -- Divide x by its factor
           | otherwise = f max' x (i + 1)  -- Check for the next possible factor

g x = f 2 x 2
— penkovsky
সূত্র
কিন্তু এটি কি সমস্ত এমনকি সংখ্যার সাথে ভাগ করার চেষ্টা করবে না?
— জানুস ট্রোলসেন
0

নিম্নলিখিত সি ++ অ্যালগরিদম সেরা নয়, তবে এটি এক বিলিয়ন এর নিচে সংখ্যার জন্য কাজ করে এবং এটি বেশ দ্রুত

#include <iostream>
using namespace std;

// ------ is_prime ------
// Determines if the integer accepted is prime or not
bool is_prime(int n){
    int i,count=0;
    if(n==1 || n==2)
      return true;
    if(n%2==0)
      return false;
    for(i=1;i<=n;i++){
    if(n%i==0)
        count++;
    }
    if(count==2)
      return true;
    else
      return false;
 }
 // ------ nextPrime -------
 // Finds and returns the next prime number
 int nextPrime(int prime){
     bool a = false;
     while (a == false){
         prime++;
         if (is_prime(prime))
            a = true;
     }
  return prime;
 }
 // ----- M A I N ------
 int main(){

      int value = 13195;
      int prime = 2;
      bool done = false;

      while (done == false){
          if (value%prime == 0){
             value = value/prime;
             if (is_prime(value)){
                 done = true;
             }
          } else {
             prime = nextPrime(prime);
          }
      }
        cout << "Largest prime factor: " << value << endl;
 }
— SN
সূত্র
0

ওয়েবে এই সমাধানটি "জেমস ওয়াং" দ্বারা পেয়েছেন

public static int getLargestPrime( int number) {

    if (number <= 1) return -1;

    for (int i = number - 1; i > 1; i--) {
        if (number % i == 0) {
            number = i;
        }
    }
    return number;
}
— BabarBaig
সূত্র
0

চালনী ব্যবহার করে প্রধান উপাদান: 

#include <bits/stdc++.h>
using namespace std;
#define N 10001  
typedef long long ll;
bool visit[N];
vector<int> prime;

void sieve()
{
            memset( visit , 0 , sizeof(visit));
            for( int i=2;i<N;i++ )
            {
                if( visit[i] == 0)
                {
                    prime.push_back(i);
                    for( int j=i*2; j<N; j=j+i )
                    {
                        visit[j] = 1;
                    }
                }
            }   
}
void sol(long long n, vector<int>&prime)
{
            ll ans = n;
            for(int i=0; i<prime.size() || prime[i]>n; i++)
            {
                while(n%prime[i]==0)
                {
                    n=n/prime[i];
                    ans = prime[i];
                }
            }
            ans = max(ans, n);
            cout<<ans<<endl;
}
int main() 
{
           ll tc, n;
           sieve();

           cin>>n;
           sol(n, prime);

           return 0;
}
— rashedcs
সূত্র
-1

এটি আমার কাছে মনে হয় যে দেওয়া অ্যালগরিদমের # 2 পদক্ষেপটি সেই সমস্ত দক্ষ একটি দৃষ্টিভঙ্গি হতে পারে না। আপনার কাছে কোন যুক্তিসঙ্গত প্রত্যাশা নেই যে এটি প্রধান।

এছাড়াও, পূর্ববর্তী উত্তর ইরোটোস্টিনিসকে চালিত করার প্রস্তাবটি সম্পূর্ণ ভুল। আমি মাত্র 123456789 ফ্যাক্টরটিতে দুটি প্রোগ্রাম লিখেছি One

1)  Test = 2 
2)  Current = Number to test 
3)  If Current Mod Test = 0 then  
3a)     Current = Current Div Test 
3b)     Largest = Test
3c)     Goto 3. 
4)  Inc(Test) 
5)  If Current < Test goto 4
6)  Return Largest

এই সংস্করণটি চালকের চেয়ে 90x দ্রুত ছিল।

কথাটি হ'ল, আধুনিক প্রসেসরগুলিতে অপারেশনের ধরণ অপারেশনের সংখ্যার চেয়ে অনেক কম, উপরের অ্যালগরিদমটি ক্যাশে চালাতে পারে তা উল্লেখ করা উচিত নয়, চালক পারে না। চালনাটি সমস্ত সংমিশ্রণ সংখ্যা প্রকাশ করে প্রচুর অপারেশন ব্যবহার করে।

দ্রষ্টব্য, এছাড়াও, যেগুলি চিহ্নিত করার সাথে সাথে আমার বিভাজক কারণগুলি পরীক্ষা করতে হবে এমন স্থান হ্রাস করে।

— লরেন পেচটেল
সূত্র
এটাই আমি বলেছিলাম, তবে ভোট দিয়েছি :( আমার ধারণা সমস্যাটি হ'ল যদি এই সংখ্যাটির যদি সত্যিই বড় একটি মৌলিক উপাদান থাকে (যেমন নিজেই হয়) তবে এই পদ্ধতিটি অবশ্যই সেই সংখ্যা পর্যন্ত পুরোপুরি লুপ করবে a প্রচুর ক্ষেত্রে তবে এই পদ্ধতিটি বেশ কার্যকর
— নিকফ
আপনার মাধ্যমে ফিরে পড়া এটি একই তবে আপনার প্রথম অংশটি বিভ্রান্তিকর।
— লরেন পেচটেল
এই নম্বরে 14381678998850404453640235273819513786365643939 চেষ্টা করুন, আমাকে জানাতে এটি কতটা দক্ষ ...
— মাইকেলিসিস
-1

প্রথমে প্রাথমিক সংখ্যা সংরক্ষণের জন্য একটি তালিকা গণনা করুন, উদাহরণস্বরূপ 2 3 5 7 11 13 ...

প্রতিবার যখন আপনি কোনও সংখ্যাকে প্রধান করে তোলেন, ট্রিপটাইচের দ্বারা প্রয়োগটি ব্যবহার করুন তবে প্রাকৃতিক সংখ্যার চেয়ে প্রধান সংখ্যাগুলির এই তালিকাটি পুনরাবৃত্তি করুন।

— guoger
সূত্র
-1

জাভা সহ:

জন্য intমান:

public static int[] primeFactors(int value) {
    int[] a = new int[31];
    int i = 0, j;
    int num = value;
    while (num % 2 == 0) {
        a[i++] = 2;
        num /= 2;
    }
    j = 3;
    while (j <= Math.sqrt(num) + 1) {
        if (num % j == 0) {
            a[i++] = j;
            num /= j;
        } else {
            j += 2;
        }
    }
    if (num > 1) {
        a[i++] = num;
    }
    int[] b = Arrays.copyOf(a, i);
    return b;
}

জন্য longমান:

static long[] getFactors(long value) {
    long[] a = new long[63];
    int i = 0;
    long num = value;
    while (num % 2 == 0) {
        a[i++] = 2;
        num /= 2;
    }
    long j = 3;
    while (j <= Math.sqrt(num) + 1) {
        if (num % j == 0) {
            a[i++] = j;
            num /= j;
        } else {
            j += 2;
        }
    }
    if (num > 1) {
        a[i++] = num;
    }
    long[] b = Arrays.copyOf(a, i);
    return b;
}
— পল ভার্গাস
সূত্র
-2

এটি সম্ভবত সর্বদা দ্রুত নয় তবে আপনি একটি বড় প্রধান বিভাজক এটি সম্পর্কে আরও আশাবাদী:

  1. N আপনার নম্বর
  2. এটি যদি প্রধান হয় return(N)
  3. অবধি প্রাইমস গণনা করুন Sqrt(N)
  4. অবতরণ ক্রমে প্রাইমগুলির মধ্য দিয়ে যান (বৃহত্তম বৃহত্তম)
    • তাহলে N is divisible by PrimeতারপরReturn(Prime)

সম্পাদনা: ৩ য় ধাপে আপনি এরিটোস্থেনিজের চালনা বা অ্যাটকিন্সের চালুনি বা আপনার পছন্দসই যা ব্যবহার করতে পারেন, তবে নিজেই চালনী আপনাকে সবচেয়ে বড় মৌলিক উপাদানটি খুঁজে পাবে না। (আমি কেন এসকিউএল মেনেসের পোস্টটিকে অফিসিয়াল উত্তর হিসাবে বেছে নেব না তা ঠিক ...)

— palotasb
সূত্র
1
এটি একটি মৌলিক সংখ্যা (পদক্ষেপ 2) কিনা তা নির্ধারণ করার জন্য আপনার ট্রায়াল ফ্যাক্টরিং করার দরকার নেই? এছাড়াও, 15 এর বৃহত্তম প্রধান ফ্যাক্টরটি সন্ধান করুন s স্কয়ার্ট (15) পর্যন্ত প্রাইমগুলি 2 এবং 3 হয়; তবে বৃহত্তম প্রাইম ফ্যাক্টর 5, তাই না? একইভাবে 20.
— জোনাথন লেফলার
-3

আমি মনে করি যে কোথাও সমস্ত সম্ভব ছোট ছোট ছোট ছোট ছোট ছোট ছোট ছোট স্টোর সংরক্ষণ করা ভাল এবং সবচেয়ে বড় বিভাজন খুঁজতে তাদের মাধ্যমে পুনরাবৃত্তি করা ভাল হবে। আপনি prime-numbers.org থেকে প্রাইম পেতে পারেন ।

অবশ্যই আমি ধরে নিচ্ছি যে আপনার সংখ্যাটি খুব বেশি নয় :)

— Klesk
সূত্র
-3

দ্রুত নয় তবে এটি কাজ করে!

    static bool IsPrime(long num)
    {
        long checkUpTo = (long)Math.Ceiling(Math.Sqrt(num));
        for (long i = 2; i <= checkUpTo; i++)
        {
            if (num % i == 0)
                return false;
        }
        return true;
    }
— শুভক্ষণ
সূত্র
এটি প্রশ্নের উত্তর নয়। ;-) প্রশ্নটি ছিল সবচেয়ে বড় মৌলিক ফ্যাক্টর সন্ধানের বিষয়ে, প্রাথমিকতার জন্য যাচাই করা হয়নি not
— হ্যান্স-পিটার স্টার
আপনার লুপটিকে আরম্ভ করার জন্য এটি আরও দক্ষ (দীর্ঘ i = 3; i <চেকআপ; i + = 2)
— সিজেকে
-3

এখানে জেনারেটর হিসাবে প্রদত্ত @ ট্রিপ্টিচ একই ফাংশনটি দেওয়া হয়েছে, যা কিছুটা সরলও করা হয়েছে। 

def primes(n):
    d = 2
    while (n > 1):
        while (n%d==0):
            yield d
            n /= d
        d += 1

সর্বাধিক প্রাইমটি তখন ব্যবহার করে পাওয়া যাবে:

n= 373764623
max(primes(n))

এবং ব্যবহার করে খুঁজে পাওয়া উপাদানগুলির একটি তালিকা:

list(primes(n))
— pedram
সূত্র
-6 
#include<stdio.h>
#include<conio.h>
#include<math.h>
#include <time.h>

factor(long int n)
{
long int i,j;
while(n>=4)
 {
if(n%2==0) {  n=n/2;   i=2;   }

 else
 { i=3;
j=0;
  while(j==0)
  {
   if(n%i==0)
   {j=1;
   n=n/i;
   }
   i=i+2;
  }
 i-=2;
 }
 }
return i;
 }

 void main()
 { 
  clock_t start = clock();
  long int n,sp;
  clrscr();
  printf("enter value of n");
  scanf("%ld",&n);
  sp=factor(n);
  printf("largest prime factor is %ld",sp);

  printf("Time elapsed: %f\n", ((double)clock() - start) / CLOCKS_PER_SEC);
  getch();
 }
— Chitransh
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.