কৃপণতম প্রধানমন্ত্রীটি সন্ধান করুন


9

ইন্ট্রো

কিছু ধনাত্মক পূর্ণসংখ্যা গ্রহণের প্রক্রিয়া বিবেচনা এন কিছু বেস এবং ডানে অঙ্ক বেস তার উপস্থাপনা সঙ্গে প্রতিটি অঙ্ক প্রতিস্থাপন।

  • ডানদিকে অঙ্কটি 0 হলে বেস বি ব্যবহার করুন ।
  • ডানদিকে অঙ্কটি যদি 1 হয় তবে 0 এর সাথে টালি চিহ্ন হিসাবে অ্যানারি ব্যবহার করুন ।
  • ডানদিকে কোনও অঙ্ক না থাকলে (যেমন আপনি সেই স্থানে রয়েছেন), সর্বাধিক উল্লেখযোগ্য অঙ্কের কাছাকাছি লুপ করুন।

উদাহরণ হিসাবে এন = 160 এবং = 10 আসুন প্রক্রিয়াটি চালানোয় এমন দেখাচ্ছে:

The first digit is 1, the digit to the right is 6, 1 in base 6 is 1.
The next digit is 6, the digit to the right is 0, 0 is not a base so use b, 6 in base b is 6.
The last digit is 0, the digit to the right (looping around) is 1, 0 in base 1 is the empty string (but that's ok).

Concatenating '1', '6', and '' together gives 16, which is read in the original base b = 10.

ঠিক একই পদ্ধতি তবে ডানের পরিবর্তে বাম দিকে সরানোও করা যেতে পারে:

The first digit is 1, the digit to the left (looping around) is 0, 0 is not a base so use b, 1 in base b is 1.
The next digit is 6, the digit to the left is 1, 6 in base 1 is 000000.
The last digit is 0, the digit to the left is 6, 0 in base 6 is 0.

Concatenating '1', '000000', and '0' together gives 10000000, which is read in the original base b = 10.

সুতরাং, আমরা 160 ( বি = 10 এর জন্য) সম্পর্কিত 16 টি সংখ্যা তৈরি করেছি : 16 এবং 10000000।

আমরা n কে একটি ছদ্মবেশী সংখ্যা হিসাবে সংজ্ঞায়িত করব যদি এটি সমানভাবে এই প্রক্রিয়াটিতে উত্পন্ন দুটি সংখ্যার মধ্যে একটিরও 2 বা ততোধিক অংশে বিভক্ত হয়

উদাহরণে এন ধূর্ততা কারণ 160 ভাগ 10000000 ঠিক 62500 বার।

203 ধূর্ত নয় কারণ ফলাফলসংখ্যা 2011 এবং 203 নিজেই, যা 203 2 বা ততোধিক বারে সমানভাবে মাপসই করতে পারে না।

চ্যালেঞ্জ

(বাকি সমস্যার জন্য আমরা কেবল = 10 বিবেচনা করব )

চ্যালেঞ্জটি হ'ল এমন একটি প্রোগ্রাম লিখুন যা সর্বাধিক ধূর্ত সংখ্যা খুঁজে পায় যাও প্রধান।

প্রথম 7 ধূর্ত প্রাইমস (এবং আমি এখনও অবধি যা কিছু পেয়েছি) সেগুলি হ'ল:

2
5
3449
6287
7589
9397
93557 <-- highest so far (I've searched to 100,000,000+)

আরও অস্তিত্ব আছে কিনা তা সম্পর্কে আমি আনুষ্ঠানিকভাবে নিশ্চিত নই, তবে আমি তাদের প্রত্যাশা করি। আপনি যদি প্রমাণ করতে পারেন যে চূড়ান্তভাবে অনেকগুলি রয়েছে (বা না হয়) আমি আপনাকে +200 অনুগ্রহমূলক প্রতিনিধি দেব।

বিজয়ী হবেন সেই ব্যক্তি যিনি সর্বোচ্চ ধূর্ত প্রাইম সরবরাহ করতে পারেন তবে শর্ত থাকে যে তারা অনুসন্ধানে সক্রিয় ছিল এবং ইচ্ছাকৃতভাবে অন্যের কাছ থেকে গৌরব নিচ্ছে না।

বিধি

  • আপনি যে কোনও প্রাইম সন্ধানের সরঞ্জামগুলি ব্যবহার করতে পারেন।
  • আপনি সম্ভাব্য প্রাইম টেস্টার ব্যবহার করতে পারেন।
  • আপনি অন্য ব্যক্তির কোডটি এট্রিবিউশন সহ পুনরায় ব্যবহার করতে পারেন । এটি একটি সাম্প্রদায়িক প্রচেষ্টা। কাথথ্রোট কৌশলগুলি সহ্য করা হবে না।
  • আপনার প্রোগ্রামটি অবশ্যই সক্রিয়ভাবে প্রধানের জন্য অনুসন্ধান করতে হবে। আপনি আপনার সর্বাধিক পরিচিত কারিগরী প্রাইমে শুরু করতে পারেন।
  • আপনার প্রোগ্রামটি অ্যামাজন ইসি 2 টি 2। মিডিয়াম উদাহরণগুলির 4 ঘন্টার মধ্যে (সমস্ত একবারে চারটি বা চার ঘন্টার জন্য একটির মধ্যে বা কিছু) এর মধ্যে পরিচিত সমস্ত ধূর্ত প্রাইমগুলি গণনা করতে সক্ষম হওয়া উচিত । আমি তাদের উপর এটি পরীক্ষা করব না এবং অবশ্যই আপনার প্রয়োজন হবে না। এটি কেবল একটি মানদণ্ড।

উপরের টেবিলটি তৈরি করার জন্য আমি আমার পাইথন 3 কোডটি এখানে ব্যবহার করেছি:

import pyprimes

def toBase(base, digit):
    a = [
            ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
            ['', '0', '00', '000', '0000', '00000', '000000', '0000000', '00000000', '000000000' ],
            ['0', '1', '10', '11', '100', '101', '110', '111', '1000', '1001'],
            ['0', '1', '2', '10', '11', '12', '20', '21', '22', '100'],
            ['0', '1', '2', '3', '10', '11', '12', '13', '20', '21'],
            ['0', '1', '2', '3', '4', '10', '11', '12', '13', '14'],
            ['0', '1', '2', '3', '4', '5', '10', '11', '12', '13'],
            ['0', '1', '2', '3', '4', '5', '6', '10', '11', '12'],
            ['0', '1', '2', '3', '4', '5', '6', '7', '10', '11'],
            ['0', '1', '2', '3', '4', '5', '6', '7', '8', '10']
        ]
    return a[base][digit]

def getCrafty(start=1, stop=100000):
    for p in pyprimes.primes_above(start):
        s = str(p)
        left = right = ''
        for i in range(len(s)):
            digit = int(s[i])
            left += toBase(int(s[i - 1]), digit)
            right += toBase(int(s[0 if i + 1 == len(s) else i + 1]), digit)
        left = int(left)
        right = int(right)
        if (left % p == 0 and left // p >= 2) or (right % p == 0 and right // p >= 2):
            print(p, left, right)
        if p >= stop:
            break
    print('DONE')

getCrafty()

আমি মনে করি যে খালি স্ট্রিং হতে কোনও বেস x তে 0 করা আরও গাণিতিক হবে। এছাড়াও, আমি নিশ্চিত যে এই সংস্করণটিকে প্রমাণ করা বা প্রত্যাখ্যান করা আরও সহজ হবে
গর্বিত হাসেলেলার

উত্তর:


7

ম্যাথমেটিকা, ০.৩ সেকেন্ডে (৩, 2৫7 খুঁজে পান (2 * 10 10 এর নীচে আর কোন ধূর্ত প্রাইম নেই )

এটি সমস্ত প্রাইমগুলির মধ্যে কেবল একটি নির্বোধ বিস্তৃত অনুসন্ধান। এটির সাথে শুরু করতে প্রতি 55 সেকেন্ডে প্রায় 1,000,000 প্রাইমগুলি পরীক্ষা করা হয় (যা প্রাইমগুলি আরও বড় হওয়ার সাথে সাথে ধীর হয়ে যেতে বাধ্য)।

আমি একগুচ্ছ সহায়ক ফাংশন ব্যবহার করছি:

lookup = {
  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
  {{}, 0, {0, 0}, {0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, 
   {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0}},
  {0, 1, {1, 0}, {1, 1}, {1, 0, 0}, {1, 0, 1}, {1, 1, 0}, {1, 1, 1}, {1, 0, 0, 0}, 
   {1, 0, 0, 1}},
  {0, 1, 2, {1, 0}, {1, 1}, {1, 2}, {2, 0}, {2, 1}, {2, 2}, {1, 0, 0}},
  {0, 1, 2, 3, {1, 0}, {1, 1}, {1, 2}, {1, 3}, {2, 0}, {2, 1}},
  {0, 1, 2, 3, 4, {1, 0}, {1, 1}, {1, 2}, {1, 3}, {1, 4}},
  {0, 1, 2, 3, 4, 5, {1, 0}, {1, 1}, {1, 2}, {1, 3}},
  {0, 1, 2, 3, 4, 5, 6, {1, 0}, {1, 1}, {1, 2}},
  {0, 1, 2, 3, 4, 5, 6, 7, {1, 0}, {1, 1}},
  {0, 1, 2, 3, 4, 5, 6, 7, 8, {1, 0}}
};
convertBase[d_, b_] := lookup[[b + 1, d + 1]];
related[n_] := (
   d = IntegerDigits[n];
   {FromDigits[Flatten[convertBase @@@ Transpose[{d, RotateRight@d}]]],
    FromDigits[Flatten[convertBase @@@ Transpose[{d, RotateLeft@d}]]]}
);
crafty[n_] := (
   {ql, qr} = related[n]/n;
   IntegerQ[ql] && ql > 1 || IntegerQ[qr] && qr > 1
);

এবং তারপরে এই লুপটি আসল অনুসন্ধান করে:

p = 2;
start = TimeUsed[];
i = 1;
While[True,
 If[crafty[p], Print@{"CRAFTY PRIME:", p, TimeUsed[] - start}];
 p = NextPrime@p;
 If[Mod[++i, 1000000] == 0, 
  Print[{"Last prime checked:", p, TimeUsed[] - start}]
 ]
]

আমি পোস্টটি আপডেট করে রাখব, যদি আমি কোনও প্রাইম পাই বা আশাবাদী সম্পর্কে ভাবতে পারি।

এটি বর্তমানে প্রায় 5.5 মিনিটের মধ্যে 100,000,000 অবধি সমস্ত প্রাইম পরীক্ষা করে।

সম্পাদনা: আমি ওপি'র উদাহরণ অনুসরণ করার সিদ্ধান্ত নিয়েছি এবং বেস রূপান্তরের জন্য একটি সারণিতে স্যুইচ করেছি। এটি প্রায় 30% গতিবেগ দিয়েছে।

কৌতুক নম্বর সাধারণভাবে

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

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

এখানে 2,210,000,000 অবধি সমস্ত বাম-কূটকী সংখ্যা রয়েছে:

{2, 5, 16, 28, 68, 160, 222, 280, 555, 680, 777, 1600, 2605, 2800, 
 6800, 7589, 7689, 9397, 9777, 16000, 16064, 16122, 22222, 24682, 
 26050, 28000, 55555, 68000, 75890, 76890, 93557, 160000, 160640, 
 161220, 247522, 254408, 260500, 280000, 680000, 758900, 768900, 
 949395, 1600000, 1606400, 1612200, 2222222, 2544080, 2605000, 
 2709661, 2710271, 2717529, 2800000, 3517736, 5555555, 6800000, 
 7589000, 7689000, 9754696, 11350875, 16000000, 16064000, 16122000,
 25440800, 26050000, 27175290, 28000000, 28028028, 35177360, 52623721, 
 68000000, 68654516, 75890000, 76890000, 113508750, 129129129, 160000000,
 160640000, 161220000, 222222222, 254408000, 260500000, 271752900,
 275836752, 280000000, 280280280, 333018547, 351773600, 370938016, 
 555555555, 680000000, 758900000, 768900000, 777777777, 877827179, 
 1135087500, 1291291290, 1600000000, 1606400000, 1612200000, 1944919449}

এবং এখানে এই পরিসীমাটিতে সমস্ত ডান-কৌতুকপূর্ণ নম্বর রয়েছে:

{2, 5, 16, 28, 68, 125, 128, 175, 222, 284, 555, 777, 1575, 1625, 
 1875, 3449, 5217, 6287, 9375, 14625, 16736, 19968, 22222, 52990, 
 53145, 55555, 58750, 93750, 127625, 152628, 293750, 529900, 587500, 
 593750, 683860, 937500, 1034375, 1340625, 1488736, 2158750, 2222222, 
 2863740, 2937500, 5299000, 5555555, 5875000, 5937500, 6838600, 
 7577355, 9375000, 12071125, 19325648, 21587500, 28637400, 29375000, 
 29811250, 42107160, 44888540, 52990000, 58750000, 59375000, 68386000, 
 71461386, 74709375, 75773550, 93750000, 100540625, 116382104,
 164371875, 197313776, 207144127, 215875000, 222222222, 226071269,
 227896480, 274106547, 284284284, 286374000, 287222080, 293750000, 
 298112500, 421071600, 448885400, 529900000, 555555555, 587500000, 
 593750000, 600481125, 683860000, 714613860, 747093750, 757735500, 
 769456199, 777777777, 853796995, 937500000, 1371513715, 1512715127, 
 1656354715, 1728817288, 1944919449, 2158750000}

মনে রাখবেন যে বাম-কৌতুক এবং ডান-কৃপণ সংখ্যার অসীম সংখ্যা রয়েছে কারণ বিদ্যমানগুলি থেকে এগুলি উত্পন্ন করার বিভিন্ন উপায় রয়েছে:

  • 0যে কোনও বাম-ধূর্ত নম্বরতে একটি স্বেচ্ছাসেবী সংখ্যার সংযোজন করা যেতে পারে যার ন্যূনতম তাৎপর্যপূর্ণ অঙ্ক অন্য বাম-ধূর্ত নম্বর পেতে তার সর্বাধিক উল্লেখযোগ্য অঙ্কের চেয়ে বেশি।
  • তেমনি, 0যে কোনও ডান-কৃপণ সংখ্যায় যার সর্বাধিক উল্লেখযোগ্য সংখ্যার চেয়ে কম তার মধ্যে কমপক্ষে উল্লেখযোগ্য অঙ্কের মধ্যে একটি নির্বিচার সংখ্যক সংযোজন করা যায় । এটি (এবং পূর্ববর্তী বিবৃতি) কারণ হ'ল 0কৌশলটি এবং এটি সম্পর্কিত নম্বর উভয়কে যুক্ত করা হবে, কার্যকরভাবে উভয়কে 10 দ্বারা গুণিত করে।
  • 2S বা 5s এর প্রতিটি বিজোড় সংখ্যাটি কৌতুকপূর্ণ।
  • প্রতিটি বিজোড় সংখ্যার 777ধূর্ততা।
  • এটি প্রদর্শিত হয় যে একটি বিজোড় সংখ্যার 28দ্বারা যুক্ত হয় 0, 28028028যেমন সর্বদা বাম-কৃপণ।

অন্যান্য বিষয় লক্ষণীয়:

  • কমপক্ষে চারটি দশ-অঙ্কের সংখ্যা রয়েছে যা দুটি পুনরাবৃত্ত পাঁচ-অঙ্কের সংখ্যা নিয়ে গঠিত (যা তারা নিজেরাই কৌতুকপূর্ণ নয়, তবে এখানে কিছু প্যাটার্ন থাকতে পারে)।
  • অনেকগুলি ডান-কৌতুকপূর্ণ নম্বর রয়েছে যা এর একাধিক 125। এটি অন্য উত্পাদন নিয়ম সন্ধান করতে তাদের তদন্ত করার উপযুক্ত হতে পারে।
  • আমি একটি বাম-কৃপণ নম্বর পাইনি যা 4 দিয়ে শুরু হয় বা 3 দিয়ে শেষ হয়।
  • ডান-কৌতুক নম্বরগুলি কোনও অঙ্ক দিয়ে শুরু করতে পারে তবে আমি 1 বা 3 এর সমাপ্ত কোনও ডান-কৌতুক নম্বর পাইনি।

আমি মনে করি এই তালিকাটি আরও আকর্ষণীয় হবে যদি আমি তাদের বাদ দিই যাদের অস্তিত্বটি একটি ছোট কার্পटी সংখ্যার দ্বারা নিহিত রয়েছে, বিশেষত যেহেতু এগুলি এখনও পর্যন্ত নির্মিত নির্মাণ বিধি দ্বারা প্রাইম হয় না are সুতরাং এখানে সমস্ত কৌতুকপূর্ণ প্রাইম রয়েছে যা উপরের কোনও নিয়ম দিয়ে তৈরি করা যায় না:

Left-crafty:
{16, 68, 2605, 7589, 7689, 9397, 9777, 16064, 16122, 24682, 
 93557, 247522, 254408, 949395, 2709661, 2710271, 2717529, 3517736,
 9754696, 11350875, 52623721, 68654516, 129129129, 275836752, 
 333018547, 370938016, 877827179, 1944919449}

Right-crafty:
{16, 28, 68, 125, 128, 175, 284, 1575, 1625, 1875, 3449, 5217, 
 6287, 9375, 14625, 16736, 19968, 52990, 53145, 58750, 127625, 
 152628, 293750, 593750, 683860, 1034375, 1340625, 1488736, 2158750,
 2863740, 7577355, 12071125, 19325648, 29811250, 42107160, 44888540,
 71461386, 74709375, 100540625, 116382104, 164371875, 197313776,
 207144127, 226071269, 227896480, 274106547, 284284284, 287222080, 
 600481125, 769456199, 853796995, 1371513715, 1512715127, 1656354715, 
 1728817288, 1944919449}

আরও লক্ষ করুন যে কয়েকটি দ্বিগুণ-কৌতুকপূর্ণ সংখ্যা (যা উভয় তালিকায় প্রদর্শিত হয় এবং তাই উভয় সম্পর্কিত সংখ্যাকে বিভক্ত করে):

{2, 5, 16, 28, 68, 222, 555, 777, 22222, 55555, 2222222, 5555555, 1944919449}

এগুলিও অসীমভাবে বিদ্যমান রয়েছে। কিন্তু আপনি দেখতে পারেন, ছাড়া 16, 28, 68এই সব শুধুমাত্র একটি একক (পুনরাবৃত্তি) অঙ্ক দ্বারা গঠিত। এটি আরও আকর্ষণীয় প্রমাণ হবে যে কোনও বৃহত্তর সংখ্যা সেই সম্পত্তি না থাকলে দ্বিগুণ কূটকৌশলযুক্ত হতে পারে, তবে এটি কেবল এককী ধূর্ততার জন্য প্রমাণের এক ছদ্মবেশ হিসাবে নেমে যেতে পারে। পাল্টা উদাহরণ খুঁজে পেয়েছি 1944919449


100540625, 100540625আপনার ডান চতুর তালিকার কোনও কারণ আছে কি ?
isaacg

1
হ্যাঁ। কারণ আমি কপি এবং পেস্ট করতে পারি না।
মার্টিন এন্ডার

এটি 93,557 এর চেয়ে বেশি ছদ্মবেশী প্রাইমস খুঁজে না পাওয়ায় এটি গ্রহণ করা। এটি প্রথম উত্তর ছিল, সর্বাধিক ভোট দেওয়া হয়েছে এবং সবচেয়ে গভীরতায় যায়।
ক্যালভিনের

6

পার্ল (0.03 সেগুলিতে 1e5, 21-এর মধ্যে 1e8)। সর্বাধিক 93557 থেকে 1e11।

মূল সাথে খুব মিল। পরিবর্তনগুলির মধ্যে রয়েছে:

  • বেস চেহারা সন্ধান করুন। ছোট ভাষা-নির্ভর সঞ্চয়
  • এর পরিবর্তে বর্ধিত ডান শিফটটি মোড করুন। ভাষা নির্ভর মাইক্রো অপ্ট
  • ম্যাথ :: GMPz ব্যবহার করুন কারণ পার্ল 5 তে পাইথন এবং পার্ল 6 এর মতো অটো-ম্যাজিক বিগিন্ট নেই।
  • 2s <= int এর পরিবর্তে (বাম / গুলি)> = 2 ব্যবহার করুন Use

আমার দ্রুত মেশিনে 21 সেকেন্ডে প্রথম 1e8 প্রাইমগুলি করে, 1e9 এর জন্য 3.5 মিনিট, 1e10 এর জন্য 34 মিনিট। আমি একটু আশ্চর্য হয়েছি এটি ছোট ইনপুটগুলির জন্য পাইথন কোডের চেয়ে কিছুটা দ্রুত। আমরা সমান্তরাল করতে পারি (পারী / জিপির নতুন এটির parforprimeজন্য দুর্দান্ত হবে)। যেহেতু এটি একটি অনুসন্ধান তাই আমরা অনুমান করি যে হাত দ্বারা আমরা সমান্তরাল করতে পারি ( forprimesদুটি যুক্তি নিতে পারি)। forprimesমূলত পরী / জিপি-র মতো forprime- এটি অভ্যন্তরীণভাবে ভাগ করে দেয় এবং প্রতিটি ফলাফলের সাথে ব্লকটিকে কল করে। এটি সুবিধাজনক, তবে এই সমস্যার জন্য আমি এটি একটি পারফরম্যান্সের অঞ্চল বলে মনে করি না।

#!/usr/bin/env perl
use warnings;
use strict;
use Math::Prime::Util qw/forprimes/;
use Math::GMPz;

my @rbase = (
  [   0,"",       0,   0,  0, 0, 0, 0, 0, 0],
  [qw/1 0         1    1   1  1  1  1  1  1/],
  [qw/2 00        10   2   2  2  2  2  2  2/],
  [qw/3 000       11   10  3  3  3  3  3  3/],
  [qw/4 0000      100  11  10 4  4  4  4  4/],
  [qw/5 00000     101  12  11 10 5  5  5  5/],
  [qw/6 000000    110  20  12 11 10 6  6  6/],
  [qw/7 0000000   111  21  13 12 11 10 7  7/],
  [qw/8 00000000  1000 22  20 13 12 11 10 8/],
  [qw/9 000000000 1001 100 21 14 13 12 11 10/],
);

my($s,$left,$right,$slen,$i,$barray);
forprimes {
  ($s,$slen,$left,$right) = ($_,length($_),'','');
  foreach $i (0 .. $slen-1) {
    $barray = $rbase[substr($s,$i,1)];
    $left  .= $barray->[substr($s,$i-1,1)];
    $right .= $barray->[substr($s,($i+1) % $slen,1)];
  }
  $left = Math::GMPz::Rmpz_init_set_str($left,10) if length($left) >= 20;
  $right = Math::GMPz::Rmpz_init_set_str($right,10) if length($right) >= 20;
  print "$s      $left $right\n" if (($s<<1) <= $left && $left % $s == 0)
                                 || (($s<<1) <= $right && $right % $s == 0);
} 1e9;

5

থ্রেড এবং জিএমপি সহ সি ++ 11

সময় (একটি ম্যাকবুক এয়ারে):

  • 4 টি থ্রেড
    • 2.18986 এ 10 ^ 8
    • 21.3829 এ 10 ^ 9
    • 421.392 এস তে 10 ^ 10
    • 2557.22 সেকেন্ডে 10 ^ 11
  • 1 থ্রেড
    • 3.95095 এ 10 ^ 8
    • 37.7009 এ 10 ^ 9

প্রয়োজনীয়তা:

#include <vector>
#include <iostream>
#include <chrono>
#include <cmath>
#include <future>
#include <mutex>
#include <atomic>
#include "primesieve.hpp"
#include "gmpxx.h"

using namespace std;

using ull = unsigned long long;

mutex cout_mtx;
atomic<ull> prime_counter;


string ppnum(ull number) {
    if (number == 0) {
        return "0 * 10^0";
    }
    else {
        int l = floor(log10(number));
        return to_string(number / pow(10, l)) + " * 10^" + to_string(int(l));
    }
}


inline void bases(int& base, int& digit, mpz_class& sofar) {
    switch (base) {
        case 0:
            sofar *= 10;
            sofar += digit;
            break;
        case 1:
            sofar *= pow(10, digit);
            break;
        case 2:
            switch (digit) {
                case 0: sofar *= 10; break;
                case 1: sofar *= 10; sofar += 1; break;
                case 2: sofar *= 100; sofar += 10; break;
                case 3: sofar *= 100; sofar += 11; break;
                case 4: sofar *= 1000; sofar += 100; break;
                case 5: sofar *= 1000; sofar += 101; break;
                case 6: sofar *= 1000; sofar += 110; break;
                case 7: sofar *= 1000; sofar += 111; break;
                case 8: sofar *= 10000; sofar += 1000; break;
                case 9: sofar *= 10000; sofar += 1001; break;
            }
            break;
        case 3:
            switch (digit) {
                case 0: sofar *= 10; break;
                case 1: sofar *= 10; sofar += 1; break;
                case 2: sofar *= 10; sofar += 2; break;
                case 3: sofar *= 100; sofar += 10; break;
                case 4: sofar *= 100; sofar += 11; break;
                case 5: sofar *= 100; sofar += 12; break;
                case 6: sofar *= 100; sofar += 20; break;
                case 7: sofar *= 100; sofar += 21; break;
                case 8: sofar *= 100; sofar += 22; break;
                case 9: sofar *= 1000; sofar += 100; break;
            }
            break;
        case 4:
            switch (digit) {
                case 0: sofar *= 10; break;
                case 1: sofar *= 10; sofar += 1; break;
                case 2: sofar *= 10; sofar += 2; break;
                case 3: sofar *= 10; sofar += 3; break;
                case 4: sofar *= 100; sofar += 10; break;
                case 5: sofar *= 100; sofar += 11; break;
                case 6: sofar *= 100; sofar += 12; break;
                case 7: sofar *= 100; sofar += 13; break;
                case 8: sofar *= 100; sofar += 20; break;
                case 9: sofar *= 100; sofar += 21; break;
            }
            break;
        case 5:
            switch (digit) {
                case 0: sofar *= 10; break;
                case 1: sofar *= 10; sofar += 1; break;
                case 2: sofar *= 10; sofar += 2; break;
                case 3: sofar *= 10; sofar += 3; break;
                case 4: sofar *= 10; sofar += 4; break;
                case 5: sofar *= 100; sofar += 10; break;
                case 6: sofar *= 100; sofar += 11; break;
                case 7: sofar *= 100; sofar += 12; break;
                case 8: sofar *= 100; sofar += 13; break;
                case 9: sofar *= 100; sofar += 14; break;
            }
            break;
        case 6:
            switch (digit) {
                case 0: sofar *= 10; break;
                case 1: sofar *= 10; sofar += 1; break;
                case 2: sofar *= 10; sofar += 2; break;
                case 3: sofar *= 10; sofar += 3; break;
                case 4: sofar *= 10; sofar += 4; break;
                case 5: sofar *= 10; sofar += 5; break;
                case 6: sofar *= 100; sofar += 10; break;
                case 7: sofar *= 100; sofar += 11; break;
                case 8: sofar *= 100; sofar += 12; break;
                case 9: sofar *= 100; sofar += 13; break;
            }
            break;
        case 7:
            switch (digit) {
                case 0: sofar *= 10; break;
                case 1: sofar *= 10; sofar += 1; break;
                case 2: sofar *= 10; sofar += 2; break;
                case 3: sofar *= 10; sofar += 3; break;
                case 4: sofar *= 10; sofar += 4; break;
                case 5: sofar *= 10; sofar += 5; break;
                case 6: sofar *= 10; sofar += 6; break;
                case 7: sofar *= 100; sofar += 10; break;
                case 8: sofar *= 100; sofar += 11; break;
                case 9: sofar *= 100; sofar += 12; break;
            }
            break;
        case 8:
            switch (digit) {
                case 0: sofar *= 10; break;
                case 1: sofar *= 10; sofar += 1; break;
                case 2: sofar *= 10; sofar += 2; break;
                case 3: sofar *= 10; sofar += 3; break;
                case 4: sofar *= 10; sofar += 4; break;
                case 5: sofar *= 10; sofar += 5; break;
                case 6: sofar *= 10; sofar += 6; break;
                case 7: sofar *= 10; sofar += 7; break;
                case 8: sofar *= 100; sofar += 10; break;
                case 9: sofar *= 100; sofar += 11; break;
            }
            break;
        case 9:
            switch (digit) {
                case 0: sofar *= 10; break;
                case 1: sofar *= 10; sofar += 1; break;
                case 2: sofar *= 10; sofar += 2; break;
                case 3: sofar *= 10; sofar += 3; break;
                case 4: sofar *= 10; sofar += 4; break;
                case 5: sofar *= 10; sofar += 5; break;
                case 6: sofar *= 10; sofar += 6; break;
                case 7: sofar *= 10; sofar += 7; break;
                case 8: sofar *= 10; sofar += 8; break;
                case 9: sofar *= 100; sofar += 10; break;
            }
            break;
    };
}

vector<ull> crafty(ull start, ull stop) {
    cout_mtx.lock();
    cout << "Thread scanning from " << start << " to " << stop << endl;
    cout_mtx.unlock();
    vector<ull> res;

    auto prime_iter = primesieve::iterator(start);
    ull num;
    int prev, curr, next, fprev;
    int i, size;
    mpz_class left, right;
    unsigned long num_cpy;
    unsigned long* num_ptr;
    mpz_class num_mpz;


    while ((num = prime_iter.next_prime()) && num < stop) {
        ++prime_counter;
        left = 0;
        right = 0;
        size = floor(log10(num));
        i = pow(10, size);
        prev = num % 10;
        fprev = curr = num / i;
        if (i != 1) {
            i /= 10;
            next = (num / i) % 10;
        }
        else {
            next = prev;
        }
        for (size += 1; size; --size) {
            bases(prev, curr, left);
            bases(next, curr, right);
            prev = curr;
            curr = next;
            if (i > 1) {
                i /= 10;
                next = (num / i) % 10;
            }
            else {
                next = fprev;
            }
        }
        num_cpy = num;

        if (num != num_cpy) {
            num_ptr = (unsigned long *) &num;
            num_mpz = *num_ptr;
            num_mpz << sizeof(unsigned long) * 8;
            num_mpz += *(num_ptr + 1);
        }
        else {
            num_mpz = num_cpy;
        }
        if ((left % num_mpz == 0 && left / num_mpz >= 2) || (right % num_mpz == 0 && right / num_mpz >= 2)) {
            res.push_back(num);
        }
    }
    cout_mtx.lock();
    cout << "Thread scanning from " << start << " to " << stop << " is done." << endl;;
    cout << "Found " << res.size() << " crafty primes." << endl;
    cout_mtx.unlock();
    return res;
}

int main(int argc, char *argv[]) {
    ull start = 0, stop = 1000000000;
    int number_of_threads = 4;

    if (argc > 1) {
        start = atoll(argv[1]);
    }
    if (argc > 2) {
        stop = atoll(argv[2]);
    }
    if (argc > 3) {
        number_of_threads = atoi(argv[3]);
    }
    ull gap = stop - start;

    cout << "Start: " << ppnum(start) << ", stop: " << ppnum(stop) << endl;
    cout << "Scanning " << ppnum(gap) << " numbers" << endl;
    cout << "Number of threads: " << number_of_threads << endl;

    chrono::time_point<chrono::system_clock> tstart, tend;
    tstart = chrono::system_clock::now();

    cout << "Checking primes..." << endl;

    using ptask = packaged_task<decltype(crafty)>;
    using fur = future<vector<ull>>;

    vector<thread> threads;
    vector<fur> futures;
    for (int i = 0; i < number_of_threads; ++i) {
        auto p = ptask(crafty);
        futures.push_back(move(p.get_future()));
        auto tstop = (i + 1 == number_of_threads) ? (stop) : (start + gap / number_of_threads * (i + 1));
        threads.push_back(thread(move(p), start + gap / number_of_threads * i, tstop));
    }

    vector<ull> res;

    for (auto& thread : threads) {
        thread.join();
    }

    for (auto& fut : futures) {
        auto v = fut.get();
        res.insert(res.end(), v.begin(), v.end());
    }

    cout << "Finished checking primes..." << endl;

    tend = chrono::system_clock::now();
    chrono::duration<double> elapsed_seconds = tend - tstart;

    cout << "Number of tested primes: " << ppnum(prime_counter) << endl;
    cout << "Number of found crafty primes: " << res.size() << endl;
    cout << "Crafty primes are: ";
    for (auto iter = res.begin(); iter != res.end(); ++iter) {
        if (iter != res.begin())
            cout << ", ";
        cout << *iter;
    }
    cout << endl;
    cout << "Time taken: " << elapsed_seconds.count() << endl;
}

আউটপুট:

Start: 0 * 10^0, stop: 1.000000 * 10^11
Scanning 1.000000 * 10^11 numbers
Number of threads: 4
Checking primes...
Thread scanning from 25000000000 to 50000000000
Thread scanning from 0 to 25000000000
Thread scanning from 50000000000 to 75000000000
Thread scanning from 75000000000 to 100000000000
Thread scanning from 75000000000 to 100000000000 is done.
Found 0 crafty primes.
Thread scanning from 50000000000 to 75000000000 is done.
Found 0 crafty primes.
Thread scanning from 25000000000 to 50000000000 is done.
Found 0 crafty primes.
Thread scanning from 0 to 25000000000 is done.
Found 7 crafty primes.
Finished checking primes...
Number of tested primes: 4.118055 * 10^9
Number of found crafty primes: 7
Crafty primes are: 2, 5, 3449, 6287, 7589, 9397, 93557
Time taken: 2557.22

নাম = 12919 এ, ডানটি 120000000001000000000000 হওয়া উচিত This এটি একটি 64-বিট ইন্টিওভার প্রবাহিত হবে এবং আপনার প্রোগ্রামে r = 9223372036854775807 I আমার মনে হয় আপনাকে জিএমপি বা অনুরূপ কিছু ব্যবহার করার দরকার আছে।
দানাজে

খুব সুন্দর. 12 থ্রেড সহ 3930K এর সময়কাল 1e10 এবং 421 সেগুলিতে 1e11 এর 54 হয় is
দানাজে

সমঝোতা সি ++ 11 বৈশিষ্ট্যগুলি চেষ্টা করার জন্য এটি একটি ভাল অজুহাত ছিল
ম্যাটসয়েজ

1

সিএম, জিএমপি সহ, বহুবিধ

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

কম্পাইল: gcc -I/usr/local/include -Ofast crafty.c -pthread -L/usr/local/lib -lgmp && ./a.out

আপনার সিপিইউ শক্তি অনুদান করুন। আমার কাছে দ্রুত কম্পিউটার নেই।
আমার ম্যাকবুক এয়ারে 1 থ্রেড সহ 17 সেকেন্ডে 1e8।

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <gmp.h>
#include <pthread.h>
#include <string.h>

#define THREAD_COUNT 1           // Number of threads
#define MAX_DIGITS   32768       // Maximum digits allocated for the string... some c stuff
#define MAX_NUMBER   "100000000" // Number in string format
#define START_INDEX  1           // Must be an odd number >= 1
#define GET_WRAP_INDEX(index, stringLength) index<0?stringLength+index:index>=stringLength?index-stringLength:index

static void huntCraftyPrime(int startIndex) {

    char lCS [MAX_DIGITS];
    char rCS [MAX_DIGITS];
    char tPS [MAX_DIGITS];

    mpz_t tP, lC, rC, max;
    mpz_init_set_ui(tP, startIndex);
    mpz_init(lC);
    mpz_init(rC);
    mpz_init_set_str(max, MAX_NUMBER, 10);

    int increment = THREAD_COUNT*2;

    if (START_INDEX < 9 && startIndex == START_INDEX) {
        printf("10 10 2\n\n");
        printf("10 10 5\n\n");
    }

    while (mpz_cmp(max, tP) > 0) {
        mpz_get_str(tPS, 10, tP);
        int tPSLength = strlen(tPS);
        int l = 0, r = 0, p = 0;
        while (p < tPSLength) {
            char lD = tPS[GET_WRAP_INDEX(p-1, tPSLength)];
            char d  = tPS[GET_WRAP_INDEX(p  , tPSLength)];
            char rD = tPS[GET_WRAP_INDEX(p+1, tPSLength)];
            if (d == '0') {
                if (lD != '1') lCS[l++] = '0';
                if (rD != '1') rCS[r++] = '0';
            } else if (d == '1') {
                lCS[l++] = (lD != '1') ? '1' : '0';
                rCS[r++] = (rD != '1') ? '1' : '0';
            } else if (d == '2') {
                if (lD == '1') {
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                } else if (lD == '2') {
                    lCS[l++] = '1';
                    lCS[l++] = '0';
                } else {
                    lCS[l++] = '2';
                }
                if (rD == '1') {
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                } else if (rD == '2') {
                    rCS[r++] = '1';
                    rCS[r++] = '0';
                } else {
                    rCS[r++] = '2';
                }
            } else if (d == '3') {
                if (lD == '1') {
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                } else if (lD == '2') {
                    lCS[l++] = '1';
                    lCS[l++] = '1';
                } else if (lD == '3') {
                    lCS[l++] = '1';
                    lCS[l++] = '0';
                } else {
                    lCS[l++] = '3';
                }
                if (rD == '1') {
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                } else if (rD == '2') {
                    rCS[r++] = '1';
                    rCS[r++] = '1';
                } else if (rD == '3') {
                    rCS[r++] = '1';
                    rCS[r++] = '0';
                } else {
                    rCS[r++] = '3';
                }
            } else if (d == '4') {
                if (lD == '1') {
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                } else if (lD == '2') {
                    lCS[l++] = '1';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                } else if (lD == '3') {
                    lCS[l++] = '1';
                    lCS[l++] = '1';
                } else if (lD == '4') {
                    lCS[l++] = '1';
                    lCS[l++] = '0';
                } else {
                    lCS[l++] = '4';
                }
                if (rD == '1') {
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                } else if (rD == '2') {
                    rCS[r++] = '1';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                } else if (rD == '3') {
                    rCS[r++] = '1';
                    rCS[r++] = '1';
                } else if (rD == '4') {
                    rCS[r++] = '1';
                    rCS[r++] = '0';
                } else {
                    rCS[r++] = '4';
                }
            } else if (d == '5') {
                if (lD == '1') {
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                } else if (lD == '2') {
                    lCS[l++] = '1';
                    lCS[l++] = '0';
                    lCS[l++] = '1';
                } else if (lD == '3') {
                    lCS[l++] = '1';
                    lCS[l++] = '2';
                } else if (lD == '4') {
                    lCS[l++] = '1';
                    lCS[l++] = '1';
                } else if (lD == '5') {
                    lCS[l++] = '1';
                    lCS[l++] = '0';
                } else {
                    lCS[l++] = '5';
                }
                if (rD == '1') {
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                } else if (rD == '2') {
                    rCS[r++] = '1';
                    rCS[r++] = '0';
                    rCS[r++] = '1';
                } else if (rD == '3') {
                    rCS[r++] = '1';
                    rCS[r++] = '2';
                } else if (rD == '4') {
                    rCS[r++] = '1';
                    rCS[r++] = '1';
                } else if (rD == '5') {
                    rCS[r++] = '1';
                    rCS[r++] = '0';
                } else {
                    rCS[r++] = '5';
                }
            } else if (d == '6') {
                if (lD == '1') {
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                } else if (lD == '2') {
                    lCS[l++] = '1';
                    lCS[l++] = '1';
                    lCS[l++] = '0';
                } else if (lD == '3') {
                    lCS[l++] = '2';
                    lCS[l++] = '0';
                } else if (lD == '4') {
                    lCS[l++] = '1';
                    lCS[l++] = '2';
                } else if (lD == '5') {
                    lCS[l++] = '1';
                    lCS[l++] = '1';
                } else if (lD == '6') {
                    lCS[l++] = '1';
                    lCS[l++] = '0';
                } else {
                    lCS[l++] = '6';
                }
                if (rD == '1') {
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                } else if (rD == '2') {
                    rCS[r++] = '1';
                    rCS[r++] = '1';
                    rCS[r++] = '0';
                } else if (rD == '3') {
                    rCS[r++] = '2';
                    rCS[r++] = '0';
                } else if (rD == '4') {
                    rCS[r++] = '1';
                    rCS[r++] = '2';
                } else if (rD == '5') {
                    rCS[r++] = '1';
                    rCS[r++] = '1';
                } else if (rD == '6') {
                    rCS[r++] = '1';
                    rCS[r++] = '0';
                } else {
                    rCS[r++] = '6';
                }
            } else if (d == '7') {
                if (lD == '1') {
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                } else if (lD == '2') {
                    lCS[l++] = '1';
                    lCS[l++] = '1';
                    lCS[l++] = '1';
                } else if (lD == '3') {
                    lCS[l++] = '2';
                    lCS[l++] = '1';
                } else if (lD == '4') {
                    lCS[l++] = '1';
                    lCS[l++] = '3';
                } else if (lD == '5') {
                    lCS[l++] = '1';
                    lCS[l++] = '2';
                } else if (lD == '6') {
                    lCS[l++] = '1';
                    lCS[l++] = '1';
                } else if (lD == '7') {
                    lCS[l++] = '1';
                    lCS[l++] = '0';
                } else {
                    lCS[l++] = '7';
                }
                if (rD == '1') {
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                } else if (rD == '2') {
                    rCS[r++] = '1';
                    rCS[r++] = '1';
                    rCS[r++] = '1';
                } else if (rD == '3') {
                    rCS[r++] = '2';
                    rCS[r++] = '1';
                } else if (rD == '4') {
                    rCS[r++] = '1';
                    rCS[r++] = '3';
                } else if (rD == '5') {
                    rCS[r++] = '1';
                    rCS[r++] = '2';
                } else if (rD == '6') {
                    rCS[r++] = '1';
                    rCS[r++] = '1';
                } else if (rD == '7') {
                    rCS[r++] = '1';
                    rCS[r++] = '0';
                } else {
                    rCS[r++] = '7';
                }
            } else if (d == '8') {
                if (lD == '1') {
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                } else if (lD == '2') {
                    lCS[l++] = '1';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                } else if (lD == '3') {
                    lCS[l++] = '2';
                    lCS[l++] = '2';
                } else if (lD == '4') {
                    lCS[l++] = '2';
                    lCS[l++] = '0';
                } else if (lD == '5') {
                    lCS[l++] = '1';
                    lCS[l++] = '3';
                } else if (lD == '6') {
                    lCS[l++] = '1';
                    lCS[l++] = '2';
                } else if (lD == '7') {
                    lCS[l++] = '1';
                    lCS[l++] = '1';
                } else if (lD == '8') {
                    lCS[l++] = '1';
                    lCS[l++] = '0';
                } else {
                    lCS[l++] = '8';
                }
                if (rD == '1') {
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                } else if (rD == '2') {
                    rCS[r++] = '1';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                } else if (rD == '3') {
                    rCS[r++] = '2';
                    rCS[r++] = '2';
                } else if (rD == '4') {
                    rCS[r++] = '2';
                    rCS[r++] = '0';
                } else if (rD == '5') {
                    rCS[r++] = '1';
                    rCS[r++] = '3';
                } else if (rD == '6') {
                    rCS[r++] = '1';
                    rCS[r++] = '2';
                } else if (rD == '7') {
                    rCS[r++] = '1';
                    rCS[r++] = '1';
                } else if (rD == '8') {
                    rCS[r++] = '1';
                    rCS[r++] = '0';
                } else {
                    rCS[r++] = '8';
                }
            } else if (d == '9') {
                if (lD == '1') {
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                } else if (lD == '2') {
                    lCS[l++] = '1';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                    lCS[l++] = '1';
                } else if (lD == '3') {
                    lCS[l++] = '1';
                    lCS[l++] = '0';
                    lCS[l++] = '0';
                } else if (lD == '4') {
                    lCS[l++] = '2';
                    lCS[l++] = '1';
                } else if (lD == '5') {
                    lCS[l++] = '1';
                    lCS[l++] = '4';
                } else if (lD == '6') {
                    lCS[l++] = '1';
                    lCS[l++] = '3';
                } else if (lD == '7') {
                    lCS[l++] = '1';
                    lCS[l++] = '2';
                } else if (lD == '8') {
                    lCS[l++] = '1';
                    lCS[l++] = '1';
                } else if (lD == '9') {
                    lCS[l++] = '1';
                    lCS[l++] = '0';
                } else {
                    lCS[l++] = '9';
                }
                if (rD == '1') {
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                } else if (rD == '2') {
                    rCS[r++] = '1';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                    rCS[r++] = '1';
                } else if (rD == '3') {
                    rCS[r++] = '1';
                    rCS[r++] = '0';
                    rCS[r++] = '0';
                } else if (rD == '4') {
                    rCS[r++] = '2';
                    rCS[r++] = '1';
                } else if (rD == '5') {
                    rCS[r++] = '1';
                    rCS[r++] = '4';
                } else if (rD == '6') {
                    rCS[r++] = '1';
                    rCS[r++] = '3';
                } else if (rD == '7') {
                    rCS[r++] = '1';
                    rCS[r++] = '2';
                } else if (rD == '8') {
                    rCS[r++] = '1';
                    rCS[r++] = '1';
                } else if (rD == '9') {
                    rCS[r++] = '1';
                    rCS[r++] = '0';
                } else {
                    rCS[r++] = '9';
                }
            }
            ++p;
        }
        lCS[l] = '\0';
        rCS[r] = '\0';

        mpz_set_str(lC, lCS, 10);
        mpz_set_str(rC, rCS, 10);

        if ((mpz_divisible_p(lC, tP) && mpz_cmp(lC, tP) > 0) || (mpz_divisible_p(rC, tP) && mpz_cmp(rC, tP) > 0)){
            if (mpz_millerrabin(tP, 25)) {
                gmp_printf("%Zd %Zd %Zd\n\n", lC, rC, tP);
            }
        }
        mpz_add_ui(tP, tP, increment);
    }
}

static void *huntCraftyPrimeThread(void *p) {
    int* startIndex = (int*) p;
    huntCraftyPrime(*startIndex);
    pthread_exit(NULL);
}

int main(int argc, char *argv[]) {

    struct timeval time_started, time_now, time_diff;
    gettimeofday(&time_started, NULL);

    int  startIndexes[THREAD_COUNT];
    pthread_t threads[THREAD_COUNT];

    int startIndex = START_INDEX;
    for (int i = 0; i < THREAD_COUNT; ++i) {
        for (;startIndex % 2 == 0; ++startIndex);
        startIndexes[i] = startIndex;
        int rc = pthread_create(&threads[i], NULL, huntCraftyPrimeThread, (void*)&startIndexes[i]); 
        if (rc) { 
            printf("ERROR; return code from pthread_create() is %d\n", rc);
            exit(-1);
        }
        ++startIndex;
    }

    for (int i = 0; i < THREAD_COUNT; ++i) {
        void * status;
        int rc = pthread_join(threads[i], &status);
        if (rc) {
            printf("ERROR: return code from pthread_join() is %d\n", rc);
            exit(-1);
        }
    }

    gettimeofday(&time_now, NULL);
    timersub(&time_now, &time_started, &time_diff);
    printf("Time taken,%ld.%.6d s\n", time_diff.tv_sec, time_diff.tv_usec);

    pthread_exit(NULL);
    return 0;
}

0

পাইথন, 0.28 এর মধ্যে 93557 খুঁজে পেয়েছে

এটিও ব্যবহার করে ওপির কোডের সাথে খুব মিল pyprimes। আমি নিজেই এটি লিখেছি এক্সডি যদিও

import pyprimes, time

d = time.clock()

def to_base(base, n):
    if base == 1:
        return '0'*n
    s = ""
    while n:
        s = str(n % base) + s
        n //= base
    return s

def crafty(n):
    digits = str(n)
    l, r = "", ""
    for i in range(len(digits)):
        t = int(digits[i])
        base = int(digits[i-1])
        l += to_base(base, t) if base else digits[i]
        base = int(digits[(i+1)%len(digits)])
        r += to_base(base, t) if base else digits[i]
    l, r = int(l) if l else 0, int(r) if r else 0
    if (l%n==0 and 2 <= l/n) or (r%n==0 and 2 <= r/n):
        print(n, l, r, time.clock()-d)

for i in pyprimes.primes_above(1):
    crafty(i)

এটি শুরুর পর থেকে এটিও একটি সংখ্যা খুঁজে বের করে finds

আউটপুট:

2 10 10 3.156656792490237e-05
5 10 10 0.0006756015452219958
3449 3111021 3104100 0.012881854420378145
6287 6210007 11021111 0.022036544076745254
7589 751311 125812 0.026288406792971432
9397 1231007 1003127 0.03185028207808106
93557 123121012 10031057 0.27897531840850603

ফর্ম্যাট হয় number left right time। তুলনা হিসাবে, ওপির কোডটি আশেপাশে 93557 সন্ধান করে 0.37

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.