যার দৈর্ঘ্য, যোগফল এবং পণ্যটি প্রধানতম সেটিকে সন্ধান করুন

Question

সংখ্যাটি 113প্রথম প্রাইম যার দৈর্ঘ্য 3প্রধান, ডিজিটাল যোগফল 5 = 1 + 1 + 3প্রাইম এবং ডিজিটাল পণ্য 3 = 1 * 1 * 3প্রাইম।

এই 3 টি বৈশিষ্ট্যযুক্ত একটি প্রধানকে সর্বোচ্চ প্রধানমন্ত্রী বলা হবে । প্রাইমস 11117এবং 1111151অন্যান্য উদাহরণ।

লক্ষ্য

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

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

স্কোরিং

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

(আপনি যদি গাণিতিকভাবে প্রমাণ করতে পারেন যে হয় হয় অনেকগুলি সুপ্রিম প্রাইম রয়েছে বা না হয় আমি আপনাকে 200 বর্ধিত প্রতিনিধি দেব কারণ :)

বিস্তারিত

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

• পৃষ্ঠাটি কম বিশৃঙ্খল রাখতে ফর্মটিতে বৃহত্তর (100+ অঙ্ক) সুপ্রিম প্রাইমগুলি রাখুন:

  {[number of 1's before the prime digit]}[prime digit]{[number of 1's after the prime digit]}
  

  তাই 1111151হিসাবে প্রকাশ করা যেতে পারে {5}5{1}।

Comments

আমরা কি প্রাইমগুলির একটি তালিকা দিয়ে শুরু করতে পারি, বা ইন্টারনেট থেকে একটি তালিকা আনতে পারি এবং সর্বোচ্চতা যাচাই করে ঘন্টাটি ব্যয় করতে পারি?

— স্পার

যদি আপনি সর্বাধিক পরিচিত সুপ্রিম প্রাইম দিয়ে শুরু করতে পারেন তবে এটি এমন একটি চ্যালেঞ্জ হয়ে দাঁড়ায় যে এমন একটি প্রোগ্রাম লিখতে পারেন যে দুটি সর্বোচ্চ শীর্ষস্থানীয় প্রধানের মধ্যে সবচেয়ে বড় ব্যবধান ছড়িয়ে দিতে ঠিক এক ঘন্টা ব্যয় করতে পারে। :(

— স্পার

০ টি না থাকার পরে, কোনও সম্ভাব্য সর্বোচ্চ প্রধান অবশ্যই স্পষ্টভাবে 1 ^ n [3 | 5 | 7] 1 ^ এম, অর্থাৎ কিছু 1s, 10 এর নীচে যে কোনও প্রাইম এবং আরও 1 টি হতে হবে। এখনই আপনি এটিকে আরও চাপিয়ে দিতে পারেন const

— ইনগো বার্ক

রায়ান এমএসই সম্পর্কিত অসীম অনেক সুপ্রিম প্রাইমের অস্তিত্ব সম্পর্কে একটি সম্পর্কিত প্রশ্ন শুরু করেছেন । যদি আপনার এই প্রশ্নের জন্য কোনও অন্তর্দৃষ্টি থাকে তবে দয়া করে ওজন করুন!

— সেমিকাস্লাসিকাল

আমি সহজেই দেখাতে পারি যে বর্তমানে অসীম সংখ্যক সর্বোচ্চ প্রধানের প্রমাণ নেই (এবং এটি যথেষ্ট পরিমাণে কাজ এর দিকে চলে গেছে)) মাইকেলেলিয়েলসন.আর্গ / পোলিমাথ ১/২ এর মতে , আমরা জানি যে প্রাইমগুলি 246 এর মতো ছোট ফাঁক দিয়ে অসীমভাবে আসে, তবে অসীম সর্বোচ্চ প্রাইমসের প্রমাণের জন্য আমাদের 2, 4 বা 6 এর ফাঁক প্রয়োজন (প্রাইমগুলির সাথে মিল রেখে) একটি 3, 5, বা তাদের কোথাও 7)।

— টিম এস

Answer 1

পার্ল, 15101 ডিজিট, minutes 83} 7 {15017}, 8 মিনিট। সর্বাধিক পাওয়া: 72227 সংখ্যা

আমার মডিউল ম্যাথ :: প্রাইম :: ইউটিউল এবং এর জিএমপি ব্যাক এন্ড ব্যবহার করে । এটিতে ইস_ বিপিএসডাব্লু পরীক্ষা (পারির আইপিসডোপ্রাইমের তুলনায় কিছুটা আরও কঠোর), is_prime () রয়েছে যা একটি র্যান্ডম-বেস এমআর যুক্ত করে, এবং is_provable_prime () যা বিএলএস 75 টি 5 বা ইসিপিপি চালাবে সহ বেশ কয়েকটি সংমিশ্রণ পরীক্ষা রয়েছে । এই আকার এবং প্রকারভেদে, একটি প্রমাণ করা দীর্ঘ সময় নিতে চলেছে। আমি পেডেন্টিক ভেরিফায়ার সাবতে আরও একটি এমআর পরীক্ষায় ফেলেছি। একটি কোর 2 ই 7500 এর টাইমস যা অবশ্যই আমার দ্রুততম কম্পিউটার নয় (এটি আমার i7-4770K- তে 2.5 মিনিট সময় নেয়)।

টিম এস যেমন উল্লেখ করেছেন, আমরা একক টেস্টে এক ঘন্টা সময় নেয় এমন অবধি, বৃহত্তর মানগুলি সন্ধান করতে পারি। এই E7500 এ 000 15000 অঙ্কে এটি একটি এমআর পরীক্ষার জন্য প্রায় 26 সেকেন্ড এবং পুরো is_prime এর জন্য 2 মিনিট সময় নেয় (ট্রায়াল ডিভিশন প্লাস বেস -2 এমআর প্লাস ই এস লুকাশাস প্লাস একটি এলোমেলো-বেস এমআর)। আমার i7-4770K 3x দ্রুত গতিতে চলেছে। আমি কয়েকটি মাপ চেষ্টা করেছিলাম, প্রধানত এটি অন্য ব্যক্তির ফলাফলের ক্ষেত্রে কী হয়েছিল তা দেখে। আমি 8k, 20k, এবং 16k চেষ্টা করেছিলাম, প্রতি 5 মিনিট পরে হত্যা করি। আমি তখন প্রতি 10m ডলারে অগ্রগতিতে 15 কে চেষ্টা করেছি এবং চতুর্থটিতে ভাগ্যবান হয়েছি।

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

এটি পার্ল থ্রেডের সাথে সমান্তরাল হতে পারে বা মডিউলের সমান্তরাল ফিবোনাচি প্রাইম ফাইন্ডারের উদাহরণগুলির অনুরূপ এমসিই ব্যবহার করে।

একক কোর ব্যবহার করে নিষ্ক্রিয় আই -4--4770০ কে সময় এবং ফলাফল:

• ইনপুট 3000, 16 সেকেন্ড, 3019 সংখ্যা, {318} 5 {2700}
• ইনপুট 4000, 47 সেকেন্ড, 4001 সংখ্যা, {393} 7 {3607}
• ইনপুট 4100, 5 সেকেন্ড, 4127 ডিজিট, {29} 7 {4097}
• ইনপুট 6217, 5 সেকেন্ড, 6217 সংখ্যা, {23} 5 {6193}
• ইনপুট 6500, 5 মিনিট, 6547 সংখ্যা, {598} 5 {5948}
• ইনপুট 7000, 15 মিনিট, 7013 সংখ্যা, 11 2411} 7 {4601}
• ইনপুট 9000, 11 মিনিট, 9001 ডিজিট, 2 952} 7 {8048}
• ইনপুট 12000, 10 মিনিট, 12007 সংখ্যা, {652} 5 {11354}
• ইনপুট 15100, 2.5 মিনিট, 15101 সংখ্যা, {83} 7 {15017}
• ইনপুট 24600, 47 মিনিট, 24671 ডিজিট, {621} 7 {24049}
• ইনপুট 32060, 18 মিনিট, 32063 সংখ্যা, {83} 7 {31979}
• ইনপুট 57000, 39 মিনিট, 57037 সংখ্যা, {112} 5 {56924}
• ইনপুট 72225, 42 মিনিট, 72227 সংখ্যা, {16} 3 {72210}

৩২ কেটের অঙ্কের ফলাফলের জন্য, আমি প্রতিটি সময়ে একই সাথে 000২০০০ থেকে শুরু করে ধারাবাহিক যুক্তি দিয়ে rip টি স্ক্রিপ্ট চালু করেছিলাম। 57k এর জন্য আমি ক্রমান্বিত স্ক্রিপ্টগুলি 500 ঘন্টা ইনপুট ইনক্রিমেন্টে এক ঘন্টার জন্য একযোগে 6 টি চলতে দেব যতক্ষণ না 57k ফলাফল 57 মিনিটের মধ্যে ফিরে আসে। K০ কেটের অঙ্কের ফলাফলটি 70k আপ থেকে একের পর এক প্রাইম করে পাওয়া গিয়েছিল, সুতরাং অবশ্যই এক ঘন্টার মধ্যে খুঁজে পাওয়া যায় নি (যদিও আপনি একবার জানেন যে কোথায় শুরু করতে হবে)।

এই পান্ডুলিপি:

#!/usr/bin/env perl
use warnings;
use strict;
use Math::Prime::Util qw/:all/;
use Math::Prime::Util::GMP;  # Just to ensure it is used.

my $l = shift || 1000;  $l--;

while (1) {
  $l = next_prime($l);
  my @D = grep { is_prime($l-1 + $_) } (3,5,7);
  next unless scalar @D > 0;
  for my $s (0 .. $l-1) {
    my $e = $l-$s-1;
    warn "   checking $l $s\n" unless $s % 100;
    for my $d (@D) {
      my $n = "1"x$s . $d . "1"x$e;
      die unless length($n) == $l;
      verify_supreme($n,$s,$d,$e) if is_prime($n);  # ES BPSW + 1 rand-base M-R
    }
  }
}
sub verify_supreme {  # Be pedantic and verify the result
  my($n,$s,$d,$e) = @_;
  die "Incorrect length" unless is_prime(length($n));
  die "Incorrect sum" unless is_prime(vecsum(split(//,$n)));
  my $prod = 1; $prod *= $_ for split(//,$n);
  die "Incorrect product" unless is_prime($prod);
  die "n is not a prime!" unless miller_rabin_random($n,1);  # One more M-R test
  die "{$s} $d {$e}\n";
}

Comments

আমাকে এই লাইব্রেরিতে পরিচয় করানোর জন্য +1! আমার মেশিনে প্রাইমগুলি 10 ^ 7 এর কম ( পুনরায় সিপিথনেরgmpy2 সাথে এবং পাইপি এর সাথে তুলনা করে my_math) পুনরুক্ত করার সময়

— প্রিমো

আমি খুশি তুমি এটা পছন্দ করেছো! forprimes { ...do stuff... } 1e7;10x বা ততোধিক গতিযুক্ত (অন্যান্য অনেকগুলি দুর্দান্ত ধারণাগুলির জন্য পরী / জিপি থেকে কুডোস) সহ অন্যান্য উপায় রয়েছে । আমি সর্বদা প্রতিক্রিয়াটির প্রশংসা করি তাই আপনার পছন্দ মতো কিছু যদি কাজ না করে তবে আমাকে জানান।

— ডানাজে

Answer 2

পাইপায় পাইথন ২.7, 0 2404} 3 {1596} (} 10 ^ 4000)

11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

এটি 4000 থেকে শুরু করার প্রায় 50 মিনিটের পরে এটি পেয়েছে Therefore সুতরাং, আমি অনুমান করব যে এটি এই কোড পদ্ধতির উচ্চতর সীমা।

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

সম্ভাব্যতা তালিকা তৈরি করা হয়েছিল যে পণ্যগুলির প্রয়োজনীয়তা পূরণের জন্য, সংখ্যাটি অবশ্যই প্রাইম ব্যতীত সকলেরই হওয়া উচিত। উপরন্তু, যোগফল এবং দৈর্ঘ্যের সম্পর্কের কারণে প্রধান 2 হতে পারে না এবং ডিজিটাল যোগফলটি 3% দিয়ে বিভাজ্য হওয়া উচিত নয়,% 3 প্রয়োজনীয়তা প্রদান করে।

is_prime http://codepad.org/KtXsydxK থেকে নেওয়া হয়েছে , @ প্রিমো লিখেছেন

দ্রষ্টব্য: এই is_prime ফাংশনটি আসলে একটি বেইলি-পিএসডাব্লু সিউডোপ্রাইম পরীক্ষা, তবে কোনও পাল্টা উদাহরণ নেই, তাই আমি এই পার্থক্য সম্পর্কে চিন্তা করতে যাচ্ছি না।

#http://codepad.org/KtXsydxK
from my_math import is_prime
import time,random
LLIMIT=2748
time.clock()
start_time=time.time()
checked=0
while time.time()-start_time<3600:
    small_primes = [a for a in range(LLIMIT,2*LLIMIT) if is_prime(a)]
    leng,dig=(0,0)
    for a in small_primes:
        if a+2 in small_primes:
            leng,dig=(a,3)
            break
        if a+4 in small_primes:
            leng,dig=(a,5)
            break
        if a+6 in small_primes:
            leng,dig=(a,7)
            break
    start=time.clock()
    print leng,dig,time.clock(),checked
    for loc in random.sample(range(leng),50):
        checked+=1
        if is_prime(int('1'*loc+str(dig)+'1'*(leng-loc-1))):
            print leng-1,loc,dig,time.clock(),time.clock()-start, \
                  int('1'*loc+str(dig)+'1'*(leng-loc-1))
            break
    LLIMIT=leng+1

Comments

দুর্ভাগ্যক্রমে আমি লিঙ্কটি ছাড়া আর কিছুই জানি না। আমি এখানে লিঙ্কটি পেয়েছি: কোডগল্ফ.স্ট্যাকেক্সেক্সঞ্জ / প্রশ্নগুলি 10739/… প্রথম উত্তর

— এসইএএসিজি 5'20

ঠিক আছে তাহলে. আমি তোমাকে ক্রেডিট করব

— isaacg

এটি এমন একটি ASCII এর মতো যেখানে

— ওয়ালি

হতে পারে আপনার এই ফাংশনটির নতুন নাম রাখা উচিত is_very_very_very_very_very_very_very_probably_prime()...

— ট্রাইকোপল্যাক্স

ম্যাথমেটিকা এবং ম্যাপেল উভয়ই একই পদ্ধতি ব্যবহার করে, তাই এটি এত খারাপ হতে পারে না।

— প্রিমো

Answer 3

PARI / GP, 4127 সংখ্যা digit

(10 ⁴¹²⁷ -1) / 9 + 2 * 10 ⁵¹⁵

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

supreme(lim,startAt=3)={
    forprime(d=startAt,lim,
        my(N=10^d\9, P=select(p->isprime(d+p),[1,2,4,6]), D, n=1);
        if(#P==0, next);
        if(#P==1,
            for(i=0,d-1,
                if (ispseudoprime(D=N+n*P[1]), print(D));
                n*=10
            );
            next
        );
        D=vector(#P-1,i,P[i+1]-P[i]);
        for(i=0,d-1,
            forstep(k=N+n*P[1],N+n*P[#P],n*D,
                if (ispseudoprime(k), print(k))
            );
            n*=10
        )
    )
};
supreme(4200, 4100)

মোটামুটি পুরানো মেশিনের একটি কোরতে গণনা করতে এটি 36 মিনিট সময় নিয়েছে। এক ঘন্টার মধ্যে 5000 টির বেশি অঙ্কের পক্ষে এটির কোনও সমস্যা খুঁজে পেতে কোনও সমস্যা হবে না, আমি নিশ্চিত, তবে আমি অধৈর্যও।

সবচেয়ে ভাল সমাধান হ'ল অভ্যন্তরীণ লুপ ব্যতীত সমস্ত কিছু করার জন্য কোনও যুক্তিসঙ্গত ভাষা ব্যবহার করা, তারপরে প্রাইমফর্মের জন্য একটি অ্যাবসি ফাইল তৈরি করুন যা নির্দিষ্ট ধরণের গণনার জন্য অনুকূলিত। এটি গণনাটিকে কমপক্ষে 10,000 অঙ্ক পর্যন্ত ঠেলাতে সক্ষম হওয়া উচিত।

সম্পাদনা : আমি উপরে বর্ণিত হাইব্রিড সমাধানটি প্রয়োগ করেছি, তবে আমার পুরানো মেশিনে আমি> = 10,000 অঙ্কের সাথে প্রথম ঘন্টাটি এক ঘণ্টারও কম সময়ে খুঁজে পাচ্ছি না। যদি আমি এটিকে দ্রুত কোনও কিছুতে চালিত না করি তবে আমাকে কম উচ্চতর লক্ষ্যে পরিবর্তন করতে হবে।

Comments

আপনি কীভাবে 4100 থেকে শুরু করতে জানেন?

— isaacg

@ আইস্যাকগ: আমি ম্যাথমেটিকা ​​সমাধানের চেয়ে বড় হওয়ার চেষ্টা করছিলাম যা 4000 এরও বেশি ছিল I আমি 'নং-আপ-মাই-হাতা' নম্বর হিসাবে 100 এর পরবর্তী একাধিকটিতে গিয়েছিলাম। আসলে এটি মনে হয় এটি একটি দুর্ভাগ্যজনক শুরুর জায়গা, যেহেতু একটি প্রাইম খুঁজে পেতে আমাকে প্রত্যাশার চেয়ে বেশি (এবং ম্যাথামেটিকার চেয়ে বেশি দীর্ঘ) যেতে হয়েছিল।

— চার্লস

না, আসলে আপনি অবিশ্বাস্যভাবে ভাগ্যবান ছিলেন। (4127,3) হ'ল 4100 এর পরে প্রথম জুটি এবং খাঁটি সুযোগে এটির একটি প্রধানমন্ত্রী হওয়ার ঘটনা ঘটে। অনেকগুলি জুটির কোনও প্রাইম নেই।

— isaacg

@ আইস্যাকগ: সম্ভবত তাই। আমার হিউরিস্টিকস স্পষ্টভাবে বন্ধ, যেহেতু আমি প্রদত্ত জোড়াতে প্রাইম সন্ধানের সম্ভাবনা ~ 80% আশা করতাম: 1 - এক্সপ্রেস (-15 / (4 * লগ 10)), তবে তারা এর চেয়ে বিরল বলে মনে হয়, তাই তারা তাদের আকারের এলোমেলো {2, 3, 5 like -র মতো কাজ করবেন না (যতক্ষণ না আমি গণনাটি গুছিয়ে নিই)।

— চার্লস

@ আইস্যাকগ: যে কোনও ক্ষেত্রে আমি এখনই উল্লেখ করা "আরও ভাল সমাধান" নিয়ে কাজ করছি: কঠোর পরিশ্রমকে পিএফজিডব্লু করার জন্য। এটি প্রথম 20 জোড়া 10 ^ 10000 এর উপরে অনুসন্ধান করেছিল এবং কিছুই না পেয়ে কেবলমাত্র 15 মিনিট সময় নেয়।

— চার্লস

Answer 4

গাণিতিক 3181 ডিজিট

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

f[primeDigitLength_]:=
Module[{id=ConstantArray[1,primeDigitLength-1]},
permutations=Reverse@Sort@Flatten[Table[Insert[id,#,pos],{pos,primeDigitLength}]&/@{3,5,7},1];
Flatten[Select[permutations,PrimeQ[FromDigits[#]]\[And]PrimeQ[Plus@@#]&,1],1]]

উদাহরণ

এটি আমার প্রথম পরীক্ষা, 3181 সংখ্যা সহ সমাধানের সন্ধান। এটি 26 সেকেন্ডের মধ্যে প্রথম কেসটি খুঁজে পেয়েছে।

যুক্তি দিয়ে চলুন। তারপরে আমরা প্রোগ্রামে নিজেই পদক্ষেপ নেব।

আসুন শুরু করি, যেমনটি করি, "450 তম প্রধান কী?" আমরা কি বহু সংখ্যার (3181) সমাধান পেতে পারি?

primeDigits = Prime[450]

3181

---

সংখ্যাগুলি যোগ করে নম্বরটি পাওয়া যায়।

number = FromDigits[digits];

তবে এটি প্রদর্শন করার পরিবর্তে আমরা অঙ্কগুলি কী এবং সেগুলি কোথায় রয়েছে তা পরিবর্তে আমরা জিজ্ঞাসা করতে পারি।

DigitCount[number]

{3180, 0, 0, 0, 0, 0, 1, 0, 0, 0}

এর অর্থ হ'ল এখানে 1 ডিজিটের 3180 টি উদাহরণ রয়েছে এবং and সংখ্যার একক উদাহরণ রয়েছে।

অঙ্ক 7 এ কোন অবস্থানে?

Position[digits, 7][[1, 1]]

142

সুতরাং 7 সংখ্যাটি 142 তম সংখ্যা। বাকি সব 1 এর।

---

অবশ্যই, অঙ্কগুলির গুণমান অবশ্যই একটি প্রধান হতে হবে, যথা 7।

digitProduct = Times @@ digits

7

---

এবং অঙ্কগুলির যোগফলও একটি প্রাথমিক।

digitSum = Plus @@ digits
PrimeQ[digitSum]

3187
সত্য

---

এবং আমরা জানি যে সংখ্যার সংখ্যাটি একটি মৌলিক। মনে রাখবেন, আমরা 450 তম প্রধান নির্বাচন করেছি, যিনি 3118।

সুতরাং সমস্ত শর্ত পূরণ করা হয়েছে।

Comments

যদি আমার ভুল না হয় তবে এর যোগফল 4009 যা প্রাইম নয়।

— উঠুন

একটি জিনিস: এটি কি সমস্ত সংখ্যার যোগফল নয় যা মূল এবং সংখ্যার সংখ্যা নয়? আপনার ক্ষেত্রে আপনাকে পরীক্ষা করতে হবে 4002 * 1 + 7 = 4009এবং 4003 অনুসারে নয়।

— জনরাইড

@ জনরাইড: দু'জনেরই প্রধান হওয়া উচিত।

— জন্মানো

@gerw ঠিক আছে। সংখ্যার সংখ্যা এবং অঙ্কগুলির যোগফল এবং অঙ্কগুলির গুণাবলী সমস্তই প্রধান হতে হয়।

— ক্যালভিনের শখ 16

আপনি সব ঠিক ছিল। আমার আগের জমাতে আমি প্রাথমিকতার জন্য অঙ্কের অঙ্কটি পরীক্ষা করতে ভুলে গেছি। নিম্নলিখিতটির (যেটি কোনও বিষয়ই প্রধান নয়) তা দেখার মাধ্যমে এটি করা হয়েছে: অঙ্কের দৈর্ঘ্য + ২, অঙ্কের দৈর্ঘ্য _৪, অথবা অঙ্কের দৈর্ঘ্য +6।

— ডেভিডসি

Answer 5

পাইথন 2.7, 6217 সংখ্যা: {23} 5 {6193} 6 মিনিট 51 সেকেন্ড

আমি আমার নিজস্ব সংস্করণে কাজ করছিলাম এবং এটা দেখে হতাশ হয়েছি যে @ আইস্যাকটি আমাকে খুব_এমনই পদ্ধতির সাথে ঘুষি মারেছে, যদিও_সেই (খুব_প্রায়) _প্রাইম () দিয়ে। যাইহোক, আমি দেখতে পাচ্ছি যে আমার কিছু উল্লেখযোগ্য পার্থক্য রয়েছে যার ফলস্বরূপ কম সময়ে ভাল উত্তর দেওয়া যায় (যখন আমি is_primeও ব্যবহার করি)। এটি স্পষ্ট করার জন্য, 4000 থেকে শুরু করার পরে, আমি পাইপই নয় , স্ট্যান্ডার্ড পাইথন ইন্টারপ্রেটারটি (২.7 সংস্করণেও) ব্যবহার করে মাত্র ২ min মিনিট, ৩ seconds সেকেন্ডে ৪০০১ ডিজিটের উত্তর ({393} 7 {3607}) এ পৌঁছেছি সংস্করণ। এছাড়াও, আমি সংখ্যাগুলি পরীক্ষা করে 'স্পট' করছি না। পরীক্ষার্থীদের সব পরীক্ষা করা হয়।

এখানে প্রাথমিক উন্নতিগুলি রয়েছে:

1. বিরুদ্ধে পরীক্ষা করার জন্য প্রাইমগুলির একটি তালিকা তৈরি করতে এবং ("ছোট প্রাইমস" এর সংস্করণ) তার জন্য একটি https://stackoverflow.com/questions/567222/simple-prime-generator-in-python/568618#568618 ) ব্যবহার করুন এবং যোগ্য সংখ্যা দৈর্ঘ্য উত্পন্ন করার জন্য।

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

সম্পাদনা: এখন মাল্টিপ্রসেসিং সহ

এটি পূর্ববর্তী সংস্করণগুলিতে উল্লেখযোগ্য পরিবর্তন is এর আগে, আমি লক্ষ্য করেছি যে আমার 8-কোর মেশিনটি খুব কমই কাজ করছে, সুতরাং, আমি পাইথনের মাল্টিপ্রসেসিংয়ে প্রথম হাত চেষ্টা করার সিদ্ধান্ত নিয়েছি (প্রথমবার)। ফলাফল খুব সুন্দর!

এই সংস্করণে, 7 বাচ্চাদের প্রক্রিয়া তৈরি হয়েছে, যা সম্ভাব্য সম্ভাবনাগুলির একটি সারি (সংখ্যা_ দৈর্ঘ্য + যোগ্য সংখ্যা) থেকে একটি 'কার্য' গ্রহণ করে। তারা এটি খুঁজে না পাওয়া অবধি বিভিন্ন [7,5,3] পজিশনের চেষ্টা করে মন্থন করে। যদি এটি হয় তবে সন্ধান করা নতুন দীর্ঘতম দৈর্ঘ্যের মাস্টার প্রক্রিয়াটিকে অবহিত করুন। যদি শিশুরা একটি নাম্বার দৈর্ঘ্যের উপর কাজ করে যা সংক্ষিপ্ত হয়, তবে তারা কেবল জামিন দেয় এবং পরবর্তী দৈর্ঘ্য পান।

আমি এই রানটি 6000 দিয়ে শুরু করেছি, এবং এটি এখনও চলছে, তবে এখনও পর্যন্ত আমি ফলাফলগুলি নিয়ে খুব সন্তুষ্ট।

প্রোগ্রামটি এখনও সঠিকভাবে থামছে না, তবে আমার কাছে বিশাল চুক্তি নয়।

এখন কোড:

#!/usr/bin/env python
from __future__ import print_function

import sys
from multiprocessing import Pool, cpu_count, Value
from datetime import datetime, timedelta

# is_prime() et al from: http://codepad.org/KtXsydxK - omitted for brevity
# gen_primes() from: https://stackoverflow.com/questions/567222/simple-prime-generator-in-python/568618#568618 - ommitted for brevity
from external_sources import is_prime, gen_primes


def gen_tasks(start_length):
    """
    A generator that produces a stream of eligible number lengths and digits
    """
    for num_length in gen_primes():
        if num_length < start_length:
            continue

        ns = [ n for n in [7,5,3] if num_length + n - 1 in prime_list ]
        if ns:
            yield (num_length, ns)


def hunt(num_length, ns):
    """
    Given the num_length and list of eligible digits to try, build combinations
    to try, and try them.
    """

    if datetime.now() > end_time or num_length <= largest.value:
        return

    print('Tasked with: {0}, {1}'.format(num_length, ns))
    sys.stdout.flush()
    template = list('1' * num_length)
    for offset in range(num_length):
        for n in ns:
            if datetime.now() > end_time or num_length <= largest.value:
                return

            num_list = template[:]
            num_list[offset] = str(n)
            num = int(''.join(num_list))

            if is_prime(num):
                elapsed = datetime.now() - start_time
                largest.value = num_length
                print('\n{0} - "{1}"\a'.format(elapsed, num))


if __name__ == '__main__':
    start_time = datetime.now()
    end_time = start_time + timedelta(seconds=3600)

    print('Starting @ {0}, will stop @ {1}'.format(start_time, end_time))

    start_length = int(sys.argv[1])

    #
    # Just create a list of primes for checking. Up to 20006 will cover the first
    # 20,000 digits of solutions
    #
    prime_list = []
    for prime in gen_primes():
        prime_list.append(prime)
        if prime > 20006:
            break;
    print('prime_list is primed.')

    largest = Value('d', 0)

    task_generator = gen_tasks(start_length)

    cores = cpu_count()
    print('Number of cores: {0}'.format(cores))


    #
    # We reduce the number of cores by 1 because __main__ is another process
    #
    pool = Pool(processes=cores - 1)

    while datetime.now() < end_time:
        pool.apply_async(hunt, next(task_generator))

Comments

আপনি কোডপ্যাডের লিঙ্কটিকে [ভাঙ্গা, প্রয়োজনে] আমদানি হিসাবে উপস্থাপন করলে আরও পরিষ্কারভাবে পড়তে হবে

— স্পার

আমি মনে করি এটি বিভ্রান্তিকর হবে কারণ অন্য প্রান্তের কোডটি আসলে এর মতো আমদানিযোগ্য নয় able

— mkoistinen

আইসাকের সিনট্যাক্স ব্যবহার করুন। ইউআরএল মন্তব্য করুন, তারপরে অস্তিত্বহীন প্যাকেজ থেকে আমদানি করুন (আমার_ম্যাথ, তার ক্ষেত্রে)

— স্পার

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

— isaacg

my_mathএছাড়াও প্রাইমগুলির একটি তালিকা তৈরি করতে ব্যবহার করা যেতে পারে while prime < 20006: prime = next_prime(prime),। la । মনে হয় প্রায় 3 গুণ তত দ্রুত gen_primesএবং আরও বেশি মেমরি দক্ষ।

— প্রিমো

Answer 6

সি, জিএমপি - 24 7224} 5 {564} = 7789

অনুপ্রেরণা এবং কৌশলগুলির জন্য @ বিস্মৃতকে @ কুডোস এবং আপনারা সবাইকে।
এবং এই প্রশ্নের জন্য মাস্টারফুল প্রশ্ন জিজ্ঞাসা @ ক্যালভিনের শখগুলিও।

কম্পাইল: gcc -I/usr/local/include -o p_out p.c -pthread -L/usr/local/lib -lgmp

আপনি যদি নিজের গণনা শক্তি অনুদান বা পারফরম্যান্স সম্পর্কে কৌতূহল বোধ করেন তবে নির্দ্বিধায় কোডটি অনুলিপি করুন এবং সংকলন করুন। ;) আপনার জিএমপি ইনস্টল করা দরকার।

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

#define THREAD_COUNT 1
#define MAX_DIGITS   7800
#define MIN_DIGITS   1000

static void huntSupremePrime(int startIndex) {

    char digits[MAX_DIGITS + 1];

    for (int i = 0; i < MAX_DIGITS; digits[i++] = '1');

    digits[MAX_DIGITS] = '\0';
    mpz_t testPrime, digitSum, digitCount, increment;

    for (int j = 0; j < MAX_DIGITS - startIndex; digits[j++] = '0');

    int step = THREAD_COUNT * 2;

    for (int i = startIndex, l = MAX_DIGITS - startIndex; i > MIN_DIGITS - 1; 
        i -= step, l += step) {
        fprintf(stderr, "Testing for %d digits.\n", i);
        mpz_init_set_ui(digitCount, i);
        if (mpz_millerrabin(digitCount, 10)) {
            for (int j = 3; j < 8; j += 2) {
                mpz_init_set_ui(digitSum, i - 1 + j);
                if (mpz_millerrabin(digitSum, 10)) {
                    gmp_printf("%Zd \n", digitSum);
                    digits[MAX_DIGITS - 1] = j + 48;
                    mpz_init_set_str(testPrime, digits, 10);
                    mpz_init_set_ui(increment, (j - 1) * 99);
                    for (int k = 0; k < i/20; ++k) {
                        if (mpz_millerrabin(testPrime, 25)) {
                            i = 0;
                            j = 9;
                            k = l;
                            gmp_printf("%Zd\n", testPrime);
                            break;
                        }
                        mpz_add(testPrime, testPrime, increment);
                        mpz_mul_ui(increment, increment, 100);
                        fprintf(stderr, "TICK %d\n", k);
                    }

                }
            }
        }
        for (int j = 0; j < step; digits[l + j++] = '0');

    }
}

static void *huntSupremePrimeThread(void *p) {
    int* startIndex = (int*) p;
    huntSupremePrime(*startIndex);
    pthread_exit(NULL);
}

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

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

    int startIndex = MAX_DIGITS;
    for (int i = 0; i < THREAD_COUNT; ++i) {
        for (;startIndex % 2 == 0; --startIndex);
        startIndexes[i] = startIndex;
        int rc = pthread_create(&threads[i], NULL, huntSupremePrimeThread, (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);
        }
    }

    pthread_exit(NULL);
    return 0;
}

Answer 7

PFGW, 6067 সংখ্যা, {5956} 7 {110}

নিম্নলিখিত ইনপুট ফাইল এবং নম্বরগুলি প্রিফ্যাক্টর সহ পিএফজিডাব্লু চালান -f100। আমার কম্পিউটার (Haswell i5- এ) তে 2-3 সম্পর্কে CPU- র মিনিটের মধ্যে, এটা পিআরপি (10 ^ (6073-6) -1) / 9 + 6 * 10 ^ 110 , অথবা খুঁজে বের করে {5956} 7 {110} । আমি পূর্বের সমস্ত সাবমিশনের তুলনায় কিছুটা বেশি-না-আমার-হাতা নম্বর হিসাবে প্রারম্ভের পয়েন্ট হিসাবে 6000 সংখ্যা বেছে নিয়েছি।

ABC2 $a-$b & (10^($a-$b)-1)/9+$b*10^$c
a: primes from 6000 to 6200
b: in { 2 4 6 }
c: from 0 to 5990

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

পিএস কিছু অর্থে, এটি "কোড" সমাধান নয় কারণ আমি ইনপুট ফাইল ছাড়াও কিছু লিখিনি ... তবে তারপরে, গাণিতিক সমস্যার অনেকগুলি এক-লাইন গণিতের সমাধানগুলি একইভাবে বর্ণনা করা যেতে পারে, যেমনটি পারে আপনার জন্য কঠোর পরিশ্রম করে এমন একটি লাইব্রেরি ব্যবহার করা। বাস্তবে, আমি মনে করি দুজনের মধ্যে একটি ভাল রেখা আঁকানো শক্ত। আপনি যদি চান তবে আমি এমন একটি স্ক্রিপ্ট লিখতে পারি যা PFGW ইনপুট ফাইল তৈরি করে এবং PFGW কে কল করে calls স্ক্রিপ্টটিও সমান্তরালভাবে অনুসন্ধান করতে পারে, সমস্ত 4 টি কোর ব্যবহার করতে এবং ~ 4 বার (আমার সিপিইউতে) অনুসন্ধান ত্বরান্বিত করতে পারে।

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

Answer 8

পাইথন 2.7, 17-19 সংখ্যা

11111111171111111

5 সেকেন্ডে 511111111111111 (13 সংখ্যা) এবং 3 মিনিটের মধ্যে এই 17 ডিজিটের সর্বোচ্চ প্রধানমন্ত্রী পাওয়া গেছে। আমি অনুমান করব যে টার্গেট মেশিনটি এটি চালাতে পারে এবং এক ঘণ্টারও কম সময়ের মধ্যে 19 ডিজিটের সর্বোচ্চ প্রধানমন্ত্রী পেতে পারে। এই পদ্ধতির ভাল স্কেল হয় না কারণ এটি মেমরিতে লক্ষ্য সংখ্যাগুলির অর্ধেক সংখ্যার প্রাইম রাখে। 17 ডিজিটের অনুসন্ধানের জন্য 100 এম বুলিয়ানগুলির একটি অ্যারে সঞ্চয় করা দরকার। 19 টি সংখ্যার জন্য 1B উপাদান অ্যারের প্রয়োজন হবে এবং 23 সংখ্যা পাওয়ার আগে মেমরিটি শেষ হয়ে যাবে। রানটাইমও সম্ভবত হবে।

আদিমতার পরীক্ষা পদ্ধতি যে বিভক্তিকর প্রাইমগুলির একটি হাস্যকরভাবে বড় অ্যারে জড়িত না সেগুলি আরও ভাল মূল্য দিতে পারে।

#!/usr/bin/env python
import math
import numpy as np
import sys

max_digits = int(sys.argv[1])
max_num = 10**max_digits

print "largest supreme prime of " + str(max_digits) + " or fewer digits"

def sum_product_digits(num):
    add = 0
    mul = 1
    while num:
         add, mul, num = add + num % 10, mul * (num % 10), num / 10
    return add, mul

def primesfrom2to(n):
    # http://stackoverflow.com/questions/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Input n>=6, Returns a array of primes, 2 <= p < n """
    sieve = np.ones(n/3 + (n%6==2), dtype=np.bool)
    sieve[0] = False
    for i in xrange(int(n**0.5)/3+1):
        if sieve[i]:
            k=3*i+1|1
            sieve[      ((k*k)/3)      ::2*k] = False
            sieve[(k*k+4*k-2*k*(i&1))/3::2*k] = False
    return np.r_[2,3,((3*np.nonzero(sieve)[0]+1)|1)]

def checkprime(n):
    for divisor in primes:
        if (divisor>math.sqrt(n)):
            break
        if n%divisor==0:
            return False
    return True

# make an array of all primes we need to check as divisors of our max_num
primes = primesfrom2to(math.sqrt(max_num))
# only consider digit counts that are prime
for num_digits in primes:
    if num_digits > max_digits:
        break
    for ones_on_right in range(0,num_digits):
        for mid_prime in ['3','5','7']:
            # assemble a number of the form /1*[357]1*/
            candidate = int('1'*(num_digits-ones_on_right-1)+mid_prime+'1'*ones_on_right)
            # check for primeness of digit sum first digit product first
            add, mul = sum_product_digits(candidate)
            if add in primes and mul in primes:
                # check for primality next
                if checkprime(candidate):
                    # supreme prime!
                    print candidate

Answer 9

গণিত 4211 4259 সংখ্যা

নম্বর সহ: {1042} 7 {3168} {388} 3 {3870}

যা নিম্নলিখিত কোড দ্বারা উত্পন্ন হয়েছিল:

TimeConstrained[
 Do[
  p = Prime[n];
  curlargest = Catch[
    If[PrimeQ[p + 6],
     list = ConstantArray[1, p];
     Do[
      temp = FromDigits[ReplacePart[list, i -> 7]];
      If[PrimeQ[temp],
       Throw[temp]
       ], {i, p}]
     ];

    If[PrimeQ[p + 4],
     list = ConstantArray[1, p];
     Do[
      temp = FromDigits[ReplacePart[list, i -> 5]];
      If[PrimeQ[temp],
       Throw[temp]
       ], {i, p}]
     ];
    If[PrimeQ[p + 2],
     list = ConstantArray[1, p];
     Do[
      temp = FromDigits[ReplacePart[list, i -> 3]];
      If[PrimeQ[temp],
       Throw[temp]
       ], {i, p}]
     ];
    Throw[curlargest];
    ]

  , {n, 565, 10000}]
 , 60*60]

নিক্ষেপগুলির ফলে এটি বর্তমানে পাওয়া একই সংখ্যার সাথে অন্যান্য সংখ্যার জন্য পরীক্ষা বন্ধ করে দেয়। যেহেতু এটি সবচেয়ে তাৎপর্যপূর্ণ অঙ্কে পরীক্ষা শুরু করে তার অর্থ হ'ল সংখ্যার সংখ্যাটি যদি কোনও ট্রিপলিটের সদস্য না হয় তবে সর্বদা বৃহত্তম সংখ্যাকে ফেরত দেয়।

পূর্ববর্তী উত্তরগুলির একটির নীচে কেবল পরীক্ষা শুরু করা হয়েছিল :)

এটি শেষ হয়ে গেলে, নম্বরটি পরিবর্তনশীল কার্লজাস্টে সংরক্ষণ করা হয়

Answer 10

জাভাস্ক্রিপ্ট, 3019 সংখ্যা, {2,273} 5 {745}

এটি টম উয়ের বিগইন্টেজার.জেজে অন্তর্ভুক্ত মিলাররবিন পরীক্ষা ব্যবহার করে।

0 => থেকে শুরু করে 2,046 সংখ্যা = {1799} 7 {263 one এক ঘন্টা ।

3000 => 3,019 সংখ্যা থেকে শুরু করে = 2 2,273} 5 {745 one এক ঘন্টা, কম 3 সেকেন্ডের মধ্যে ।

এটি যখন 0 থেকে শুরু হয়েছিল, প্রোগ্রামটি এগিয়ে চলে গেল এবং শেষ স-প্রাইম পাওয়া দৈর্ঘ্যের 1.5x দৈর্ঘ্যে আবার অনুসন্ধান শুরু করে। তারপরে আমি যখন দেখলাম এটি কত দ্রুত চলছে, আমি অনুমান করেছি যে এটি এক ঘন্টার মধ্যে 3000 থেকে শুরু হবে - যা এড়াতে মাত্র 3 সেকেন্ডের সাহায্যে করেছিল।

আপনি এখানে চেষ্টা করে দেখতে পারেন: http://goo.gl/t3TmTk
(সমস্ত এস-প্রাইমগুলি গণনা করতে সেট করুন, বা এগিয়ে এড়িয়ে যান))

প্রোগ্রামটি "1" এর স্ট্রিং তৈরি করে কাজ করে তবে একটি "3", "5" বা "7" দিয়ে কাজ করে। "5" এ শেষ হওয়া সংখ্যাগুলি প্রত্যাখ্যান করার জন্য আমি ইসএসটিপ্রাইম ফাংশনে একটি দ্রুত চেক যুক্ত করেছি।

if (IsIntPrime(length)) {

    var do3s = IsIntPrime(length + 2);
    var do5s = IsIntPrime(length + 4);
    var do7s = IsIntPrime(length + 6);

    if (do3s || do5s || do7s) {

        // loop through length of number
        var before, digit, after;

        for (var after = 0; after <= length - 1; after++) {

            before = length - after - 1;
            beforeStr = Ones(before);
            afterStr = Ones(after);

            if (do3s && IsStrPrime(beforeStr + (digit = "3") + afterStr)) { RecordAnswer(); if (brk) break; }
            if (AreDone()) break;

            if (do5s && IsStrPrime(beforeStr + (digit = "5") + afterStr)) { RecordAnswer(); if (brk) break; }
            if (AreDone()) break;

            if (do7s && IsStrPrime(beforeStr + (digit = "7") + afterStr)) { RecordAnswer(); if (brk) break; }
            if (AreDone()) break;

            if (after % 10 == 0) document.title = "b=" + bestLength + ", testing=" + length + "-" + after;
        }
    }
}

এটি বেশ মজা ছিল। ডিজিটাল রিমুভড প্রাইম কী বলে তা গণনা করতে আমি বহু বছর আগে একটি ধাঁধাটির কথা মনে করিয়ে দিই । এটি একটি প্রাথমিক সংখ্যা যা আপনি যদি কোনও অঙ্ক সরিয়ে ফেলেন, তবে অবশিষ্ট সংখ্যাটি এখনও প্রধান is উদাহরণস্বরূপ 1037 হ'ল একটি অঙ্ক সরানো প্রধান কারণ 1037, 037, 137, 107 এবং 103 প্রধান। আমি একটি ৮৪ অঙ্ক দীর্ঘ এবং সর্বাধিক আমার জানা সবচেয়ে দীর্ঘ 332 অঙ্ক দীর্ঘ found আমি নিশ্চিত যে এই ধাঁধাটির জন্য ব্যবহৃত কৌশলগুলি আমরা আরও অনেক বেশি খুঁজে পেতে পারি। (তবে পরীক্ষার নম্বরগুলি বেছে নেওয়া কিছুটা জটিল - সম্ভবত?)

Comments

আরই: অঙ্কটি মুছে ফেলা হয়েছে, আমাদের এখানে রয়েছে । ৩৩২ সংখ্যাও জিততে পারে।

— primo

Answer 11

অ্যাক্সিয়াম, 3019 ডিজিট 8 318} 5 {2700}

)time on

-- Return true if n is pseudo prime else return false
-- **Can Fail**
prime1(n:PI):Boolean==
     n=1=>false
     n<4=>true
     i:=5;sq:=sqrt(1.*n)
     repeat
       if i>sq or i>50000 then break
       if n rem i=0       then return false
       i:=i+2
     if i~=50001        then return true
     --output("i")
     if powmod(3,n,n)=3 then return true
     --output("e")
     false

-- input  'n': must be n>1 prime
-- output [0] if not find any number, else return 
-- [n,a,b,c,z] 'n' digits of solution, 
-- 'a' number of '1', 'b' central digit, 'b' number of final digit '1'
-- 'z' the number found
g(n:PI):List NNI==
    x:=b:=z:=1
    for i in 1..n-1 repeat
        z:=z*10+1
        b:=b*10
    repeat
       --output b
       k:=0    -- 3 5 7 <-> 2 4 6
       for i in [2,4,6] repeat
           ~prime?(n+i)=>0 --somma
           k:=k+1
           t:=z+b*i
           if prime1(t) then return [n,x-1,i+1,n-x,t]
       --if x=1 then output ["k=", k] 
       if k=0  then break
       x:=x+1
       b:=b quo 10
       if b<=0 then break
    [0]

-- start from number of digits n
-- and return g(i) with i prime i>=n 
find(n:PI):List NNI==
    i:=n
    if i rem 2=0 then i:=i+1 
    repeat
        if prime?(i) then --solo le lunghezze prime sono accettate
             output i 
             a:=g(i)
             if a~=[0] then return a
        i:=i+2

529 সেকেন্ডে 3000 আরম্ভের মান থেকে ফলাফল

(4) -> find(3000)
   3001
   3011
   3019

   (4)
   [3019, 318, 5, 2700, Omissis]
                                            Type: List NonNegativeInteger
       Time: 0.02 (IN) + 525.50 (EV) + 0.02 (OT) + 3.53 (GC) = 529.07 sec