কিছু প্রাথমিক স্কয়ার করুন!

Question

প্রাইম স্কোয়ারটি কী?

একটি প্রাইম স্কোয়ার একটি বর্গ যেখানে সমস্ত চারটি প্রান্ত পৃথক মৌলিক সংখ্যা।
তবে কোনটি?
এবং আমরা কীভাবে তাদের নির্মাণ করব?

এখানে একটি 4x4 প্রাইম স্কোয়ারের উদাহরণ দেওয়া আছে

1009  
0  0     
3  0   
1021    

প্রথমে আমরা উপরের বাম কোণ থেকে শুরু করি। আমরা ঘড়ির কাঁটার দিকে কাজ করছি ।
আমরা সংখ্যার সাথে 4সংখ্যার সবচেয়ে সংখ্যক প্রাথমিক সংখ্যা বাছাই করি যা 1009 হয় ।

তারপরে আমাদের 4সংখ্যার ক্ষুদ্রতম সংখ্যার সংখ্যা প্রয়োজন, যা a দিয়ে শুরু হয় 9। এটি 9001

তৃতীয় (4-অঙ্ক) মূল সংখ্যাটি অবশ্যই 1তার শেষ সংখ্যা হিসাবে হবে (কারণ 9001 সমাপ্ত হয় 1)
এবং এছাড়াও এই সম্পত্তিটির সাথে সবচেয়ে ছোট 4-অঙ্কের প্রধান হতে হবে যা আগে হিসাবে প্রান্ত হিসাবে ব্যবহৃত হয়নি ।
এই প্রাথমিক সংখ্যাটি 1021

চতুর্থ মৌলিক সংখ্যা থাকতে হবে 4, সংখ্যা শুরু একটি সঙ্গে 1(কারণ 1009 একটি দিয়ে শুরু হয় 1) এবং শেষ সঙ্গে একটি 1(কারণ 1021 একটি দিয়ে শুরু হয় 1)
যে এই সম্পত্তি সঙ্গে ক্ষুদ্রতম 4 সংখ্যার মৌলিক সংখ্যা হয়েছে পূর্বের মত একটি প্রান্ত ব্যবহার করা হয়েছে হয় 1031

তোমার কাজ

আপনি একটি পূর্ণসংখ্যা দেওয়া হবে nথেকে 3 to 100
এই সংখ্যা এর মাত্রা হবে n x nবর্গক্ষেত্র
তারপর আপনি অবশ্যই ঠিক নিম্নলিখিত পরীক্ষার বিষয় আকারে আউটপুট এই স্কোয়ারের

পরীক্ষার মামলা

n=3  
Output    

101
3 0
113     

n=5    
Output     

10007
0   0
0   0    
9   0    
10061     

n=7     
Output    

1000003    
0     0     
0     0     
0     0     
0     0     
8     1     
1000037      

n=10      
Output     

1000000007      
0        0      
0        0     
0        0      
0        0       
0        0       
0        0      
1        0      
8        0       
1000000021      

n=20       
Output     

10000000000000000051     
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              
9                  8      
10000000000000000097

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

সম্পাদনা করুন
এটি সবার জন্য সম্ভব এটির জন্য n
প্রাইমগুলি এখানে রয়েছেn=100

1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000289        
9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000091            
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000711             
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002191     

এবং আপনারা যারা মনে করেন না যে এটি সম্ভব তা এখানে সমস্ত পরীক্ষার কেস

Comments

যদি এন 100 এর উপরে যেতে পারে তবে এন = 10 এর চেয়ে বড় কিছু পরীক্ষা করা ভাল হবে

— গ্যাস্ট্রোপনার

এটি কি প্রমাণযোগ্য যে এটি সবার পক্ষে সম্ভব n: পি? চ্যালেঞ্জ নিয়ে কোনও সমস্যা নয়, কেবল কৌতূহলী।

— ম্যাজিক অক্টোপাস উরন

@ ম্যাজিক অ্যাক্টোপাস ইউরান এটি অবশ্যই সবার পক্ষে সম্ভব নয় n: n= 1 এর জন্য, আমরা এই সীমাবদ্ধতাটি পূরণ করতে পারি না যে চারটি প্রান্তটি পৃথক প্রাইম, যখন n= 2 এর জন্য, আমরা 11,13,23 বাছাই করতে বাধ্য হচ্ছি, যার শেষে চূড়ান্ত প্রান্তটি রয়েছে 12 যা যৌগিক। আমার কাছে এটি প্রমাণ নেই যে এটি সমস্ত n> 2 এর পক্ষে সম্ভব , তবে অন্যথায় শিখলে হতবাক হয়ে যাবেন: অনানুষ্ঠানিকভাবে, সেখানে যতগুলি সংখ্যা থাকবে, তত বেশি "উইগল রুম" সীমাবদ্ধতাগুলি মেটানোর জন্য।

— ড্যানিয়েল ওয়াগনার

$p_{k+1}$$p_k$$k\ge463$$n\ge4$

@ ম্যাজিক অ্যাক্টপাস ইউরান গাণিতিক অগ্রগতির মূল সংখ্যাটির উপপাদ্যটি 1, 3, 7, এবং 9-এ শেষ হওয়া প্রাইমগুলির ঘনত্ব সম্পর্কে মোটামুটি শক্তিশালী কিছু বলেছে (সেখানে স্বরলিপিটিতে এন = 10, এ = 1/3/7/9) নিন; পর্যাপ্ত আকারের জন্য nকমপক্ষে দুটি দৈর্ঘ্যের প্রাইম রয়েছে যার nশুরু 1 দিয়ে শুরু হবে এবং প্রতিটি অঙ্কের সাথে শেষ হবে (অতএব আমরা নীচের প্রান্তটি বেছে নিতে পারি) এবং কমপক্ষে তিনটি প্রাইম 1 দিয়ে শুরু হবে এবং 1 দিয়ে শেষ হবে (অতএব আমরা একটি বেছে নিতে পারি বাম প্রান্ত)।

— ড্যানিয়েল ওয়াগনার

Answer 1

05AB1E , 64 63 56 53 48 46 বাইট tes

°ÅPIùćÐ4FˆθUKD.ΔθyXÅ?yXÅ¿)¯gè}ÐNĀiR}¦}I¯JŽ9¦SΛ

-1 থেকে বাইট ধন্যবাদ @ Mr.Xcoder
-5 ধন্যবাদ বাইট @Grimy ।

$n>4$$n>7$

ব্যাখ্যা:

°                 # Raise the (implicit) input to the power 10
 ÅP               # Get a list of primes within the range [2, n^10]
   Iù             # Only keep those of a length equal to the input
ć                 # Extract the head; push the remainder-list and first prime separately
 Ð                # Triplicate this first prime
4F                # Loop 4 times:
  ˆ               #  Add the (modified) prime at the top of the stack to the global array
  θU              #  Pop and store the last digit of the prime in variable `X`
  K               #  Remove this prime from the prime-list
  D               #  Duplicate the prime-list
   .Δ             #  Find the first prime `y` in the prime list which is truthy for:
     θ            #   Get the last digit of prime `y`
     yXÅ?         #   Check if prime `y` starts with variable `X`
     yXÅ¿         #   Check if prime `y` ends with variable `X`
     )            #   Wrap the three results above into a list
      ¯g          #   Get the amount of items in the global array
        è         #   And use it to index into these three checks
                  #   (Note that only 1 is truthy for 05AB1E, so the `θ` basically checks
                  #    if the last digit of prime `y` is 1)
    }Ð            #  Triplicate the found prime
      NĀi }       #  If the loop index is 1, 2, or 3:
         R        #   Reverse the found prime
      ¦           #  And then remove the first digit of the (potentially reversed) prime
}                 # After the loop:
 I                # Push the input as length
 ¯J               # Push the global array joined together to a single string
 Ž9¦S             # Push compressed integer 2460 converted to a list of digits: [2,4,6,0]
 Λ                # Draw the joined string in the directions [2,4,6,0] (aka [→,↓,←,↑])
                  # of a length equal to the input
                  # (which is output immediately and implicitly as result)

আমার এই 05AB1E ডগা দেখুন (অধ্যায় ইপিএসে দক্ষিন কোরিয়ায় কিভাবে পূর্ণসংখ্যার কম্প্রেস কিভাবে? ) কেন বুঝতে Ž9¦হয় 2460। এবং ক্যানভাস বিল্টিনের সাথে স্কোয়ারটি আউটপুট কীভাবে তা বোঝার জন্য আমার এই 05AB1E টিপটি দেখুনΛ ।

NĀiR}¦I¯JŽ9¦SΛn=4[1009,9001,1021,1031][1009,"001","201","301"]Λ
$a$I
$b$¯J"1009001201301"n=4
$c$Ž9¦S[2,4,6,0][→,↓,←,↑]

Comments

50: 4F°ÅP¯KIù.Δ1sЮθÅ¿Š®θÅ?Šθ)¯gè}©ˆ}ð¯2ô`€R«€¦J«Ž9¦SΛ 49: °ÅPIùć4FÐN1›iR}¦ˆθUKD.ΔÐθsXÅ?‚sXÅ¿ª¯gè]Ið¯J«Ž9¦SΛ 48:°ÅPIùćÐ4FˆθUKD.ΔÐθsXÅ?‚sXÅ¿ª¯gè}ÐNĀiR}¦}I¯JŽ9¦SΛ

— গ্রিমি

@ গ্রিমি ধন্যবাদ! খুব সুন্দর গল্ফ। আমি পরিবর্তন করে আপনার 48-বাইট সংস্করণের উপর ভিত্তি করে 2 আরও বেশি বাইট সংরক্ষণ করতে পারবেন চলেছি ÐθsXÅ?‚sXÅ¿ªকরতে θyXÅ?yXÅ¿)। )লুপের ক্ষেত্রের মধ্যে কেন কাজ করে ঠিক তা নিশ্চিত নয় , যেহেতু আমি আশা করেছি যে এটি প্রথম-পুনরাবৃত্তির মধ্যে প্রাইম-তালিকাটিও তার তালিকায় গুটিয়ে রাখবে। তবে তা ছাড়াও এর yyপরিবর্তে ব্যবহারের Ðssপরেও 1 বাইট সংরক্ষণ হয়। :)

— কেভিন ক্রুইজসেন

Answer 2

05AB1E , 35 33 32 31 বাইট

-1 বাইট ধন্যবাদ কেভিন ক্রুইজসেনকে

°ÅPIùΔÐXθÅ?Ïн©KX®¦«UNií]IXŽ9¦SΛ

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা:

°                 # 10 to the power of the input
 ÅP               # list of primes up to that
   Iù             # keep only those with the same length as the input

Δ                 # repeat until the list doesn't change
# This ends up doing a ton of unneeded work. 4F (to loop 4 times) would be
# enough, but Δ is shorter and the extra iterations don’t cause issues.
# At the start of each iteration, the stack only contains the list of primes,
# and the variable X contains the current list of digits we’ll want to print.
# Conveniently, X defaults to 1, which is our first digit.

 Ð    Ï           # push a filtered copy of the list, keeping only…
    Å?            # numbers that start with…
  Xθ              # the last character of X
       н          # get the first element: this is our next prime

 ©                # save this number to the register
  K               # remove it from the list of candidate primes
   X              # push X
    ®             # restore the number from the register
     ¦            # remove its first character
      «           # concatenate it to X
       U          # save the result to X

 Ni               # if N == 1 (second time through the loop)
   í              # reverse all elements in the list of candidate primes
    ]             # closes both this if and the main loop

      Λ           # Draw on a canvas…
I                 # using the input as length…
 X                # using X as the string to draw…
  Ž9¦S            # using [2,4,6,0] (aka [→,↓,←,↑]) as the directions to draw in

Comments

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

— গ্রিমি 20

আমি এখন এই উত্তরটি দেখতে পাচ্ছি। খুব সুন্দর! সাধারণ পদ্ধতি বাদে (এবং তাই প্রথম এবং শেষ অংশগুলি), চারটি প্রাইম নির্ধারণ এবং স্ট্রিং তৈরি করা এত আলাদাভাবে করা হয় যে আমি পৃথক উত্তরটি বুঝতে পারি। আমার কাছ থেকে +1 BTW, আপনি একটি বাইট সরানোর রক্ষা করতে পারে Θএ NΘ। কেবল 105AB1E এ সত্যবাদী, তাই if Nএবং if N == 1একই রকম।

— কেভিন ক্রুইজসেন

ধন্যবাদ কেভিন ক্রুজসেন! অবশ্যই আমি জানতাম, তবে আমি এটি ব্যবহার করতে ভুলে গেছি। অতীতের দিকে দৃষ্টিপাত, Θiএর 05AB1E সমতূল্য if (cond == true)...

— Grimmy

হ্যাঁ, এটা ঠিক। :) Θআপনি বাদে সবকিছু রূপান্তর করতে চাইলে এখনও দরকারী হতে 1পারে 0। তবে যদি বিবৃতিটির iজন্য এটি আপনার সিউডোকোডের মতো সত্যই প্রয়োজন হয় না == true।

— কেভিন ক্রুইজসেন 10'19

Answer 3

জাভাস্ক্রিপ্ট (ES8),  205 ... 185 177  173 বাইট

এর জন্য টিআইও-তে টাইমস আউট $n>8$ খুব অদক্ষ প্রাথমিকতার পরীক্ষার কারণে।

n=>([a,b,c]=[0,-1,--n,0].map(p=o=i=>o[(g=n=>{for(k=n++;n%k--;);k|o[n]|p[i]-n%10?g(n):p=n+''})((~i?1:p%10)*10**n)|p]=p),[...p].map((d,i)=>i?i<n?d.padEnd(n)+b[i]:c:a).join`
`)

এটি অনলাইন চেষ্টা করুন!

কিভাবে?

পদক্ষেপ # 1: 4 টি প্রাইমগুলি গণনা করা হচ্ছে

[a, b, c] =               // save the 3 first primes into a, b and c
                          // (the 4th prime will be saved in p)
  [ 0, -1, --n, 0 ]       // decrement n and iterate over [ 0, -1, n, 0 ]
  .map(p =                // initialize p (previous prime) to a non-numeric value
       o =                // use o as a lookup table
  i =>                    // for each value i in the list defined above:
    o[                    //   update o:
      (g = n => {         //     g = recursive function taking n
        for(k = n++;      //       set k = n and increment n
            n % k--;);    //       decrement k until it's a divisor of n
                          //       (notice that k is decremented *after* the test)
        k |               //       if k is not equal to 0 (i.e. n is not prime)
        o[n] |            //       or n was already used
        p[i] - n % 10 ?   //       or the last digit of n does not match the connected
                          //       digit (if any) with the previous prime:
          g(n)            //         do a recursive call
        :                 //       else:
          p = n + ''      //         stop recursion and save n coerced to a string into p
      })(                 //     initial call to g with:
        (~i ? 1 : p % 10) //       either 10 ** n if i is not equal to -1
        * 10 ** n         //       or (p % 10) * 10 ** n if i = -1
      ) | p               //     yield p
    ] = p                 //   set o[p] = p
  )                       // end of map()

পদক্ষেপ # 2: আউটপুট ফর্ম্যাট করা

[...p].map((d, i) =>      // for each digit d at position i in the last prime:
  i ?                     //   if this is not the first digit:
    i < n ?               //     if this is not the last digit:
      d.padEnd(n)         //       append d, followed by n - 1 spaces
      + b[i]              //       append the corresponding digit in the 2nd prime
    :                     //     else (last digit):
      c                   //       append the 3rd prime
  :                       //   else (first digit):
    a                     //     append the first prime
).join`\n`                // end of map(); join with carriage returns

Answer 4

জেলি , 89 82 বাইট

1ịÆn⁺f®$¿
’⁵*;Æn$©µDṪṪ×ḢÇ©;@©µ;Ç⁺;0ị®¤%⁵n/Ɗ¿$$©;Ç⁺%⁵’$¿$$µŒœṪDZUḊṖj€⁶x³¤ḊḊ¤;@Ḣ;2ị$

এটি অনলাইন চেষ্টা করুন!

অবশ্যই গল্ফিয়ার হতে পারে তবে বড় সংখ্যকদের জন্য দক্ষতার সাথে কাজ করে।

Answer 5

জেলি , 59 বাইট

DṪṪ=DZḢṪṪ3ƭƊ}Tịḟ@Ḣ
’;⁸⁵*æR/µḢ;ç¥⁺⁺µŒœṪDZUḊṖj€⁶x³¤ḊḊ¤;@Ḣ;2ị$

এটি অনলাইন চেষ্টা করুন!

খাটো তবে অনেক কম দক্ষ জেলি উত্তর।

Answer 6

জাভাস্ক্রিপ্ট, 484 বাইট

i=a=>a?(l=a=>a[(L=a=>a.length-1)(a)])(a)==9?i(r(a))+0:(r=a=>a.substr(0,L(a)))(a)+(+l(a)+1)%10:"1";s=(a,b)=>b?a==b?"":s(l(a)<l(b)?s(r(a),1):r(a),r(b))+Math.abs(l(a)-l(b)):a;m=(a,b)=>!a||!((c=L(a)-L(b))<0||!c&&a<b)&&m(s(a,b),b);p=(a,b="2")=>a/2<b||!(m(a,b)||!p(a,i(b)));a=>{for(M=1+(R=a=>"0".repeat(b))(z=a-1);!p(M=i(M)););for(N=M[z]+R(z);!p(N=i(N)););for(O=1+R(x=a-2);!p(O+n[z]);O=i(O));for(P=R(x);!p(m[0]+P+O[0]);P=i(P));for(S="\n",j=0;j<x;)S+=P[i]+R(x)+N[++i]+"\n";return M+S+O+N[z]}

সর্বশেষ নামহীন ফাংশনটি ASCII আর্ট দেয়।

আসল কোড

function inc(a){
  if (!a) return "1";
  if (a[a.length-1]=="9") return inc(a.substr(0,a.length-1))+"0";
  return a.substr(0,a.length-1)+(+a[a.length-1]+1)%10;
}
function sub(a,b){
  if (!b) return a;
  if (a==b) return "";
  var v=a.substr(0,a.length-1);
  if (a[a.length-1]<b[b.length-1]) v=sub(v,1);
  return sub(v,b.substr(0,b.length-1))+Math.abs(a[a.length-1]-b[b.length-1])
}
function multof(a,b){
  if (!a) return true;
  if (a.length<b.length||a.length==b.length&&a<b) return false;
  return multof(sub(a,b),b);
}
function isprime(a){
  for (var i="2";a/2>i;i=inc(i)){
    if (multof(a,i)) return false;
  }
  return true;
}
function square(a){
  for (var m="1"+"0".repeat(a-1);!isprime(m);m=inc(m)){}
  for (var n=m[a-1]+"0".repeat(a-1);!isprime(n);n=inc(n)){}
  for (var o="1"+"0".repeat(a-2);!isprime(o+n[a-1]);o=inc(o)){}
  for (var p="0".repeat(a-2);!isprime(m[0]+p+o[0]);p=inc(p)){}
  var s="";
  for (var i=0;i<a-2;i++) s+=p[i]+"0".repeat(a-2)+n[i+1]+"\n";
  return m+"\n"+s+o+n[a-1];
}

সেরা এবং গড় সময় জটিলতা: Ω (100 ^N ঢ) Knuth এর বড় ওমেগা স্বরলিপি (ঢ এন অঙ্ক সংখ্যা, 10 বিয়োগ জন্য পদক্ষেপ ^এন বিভাজ্যতা চেক প্রতি substractions, 10 ^ঢ প্রাইম চেকের জন্য বিভাজ্যতা পরীক্ষা এবং che (1) প্রধান চেক )।

সবচেয়ে খারাপ সময়ের জটিলতা: নুথের বড়-ওমেগা স্বরলিপিতে 1000 (1000 ^এন এন) (n সংখ্যা সংখ্যার বিয়োগের জন্য n পদক্ষেপ, বিভাজ্যতা পরীক্ষায় 10 ^এন বিয়োগফল , প্রাইম চেকের জন্য 10 ^এন বিভাজ্যতা পরীক্ষা এবং 10 ^এন প্রাইম চেক করা হয়েছে)।

আমার সন্দেহ n=100হয় প্রায় ²⁰³ গণনা লাগে ।

সিডিনোট: আমি ইউগ্লিফাইজেএস 3 ব্যবহার করে সিনট্যাক্সটি যাচাই করেছি এবং এটি আমার চেয়ে আরও ভালভাবে গল্ফ করেছে, 47.13% বেশি সাশ্রয় করেছে এবং 282 বাইট আয় করেছে। যাইহোক, আমি সিদ্ধান্ত নিয়েছি যে আমার স্কোরটি না তৈরি করব কারণ আমার মনে হচ্ছে এটি প্রতারণা করছে।

i=(s=>s?9==(l=(l=>l[(L=(l=>l.length-1))(l)]))(s)?i(r(s))+0:(r=(l=>l.substr(0,L(l))))(s)+(+l(s)+1)%10:"1"),s=((L,i)=>i?L==i?"":s(l(L)<l(i)?s(r(L),1):r(L),r(i))+Math.abs(l(L)-l(i)):L),m=((l,r)=>!l||!((c=L(l)-L(r))<0||!c&&l<r)&&m(s(l,r),r)),p=((l,s="2")=>l/2<s||!(m(l,s)||!p(l,i(s))));

এটি কেবল সর্বশেষ ফাংশনটি মুছে ফেলেছে কারণ সেগুলি কখনই ব্যবহৃত হয় না। আমি যুক্ত করা অতিরিক্ত কোডটি বাদ দিয়ে যদি এটি বরাদ্দ করা হয় এবং মোছা না হয় তবে এটি আসলে আরও খারাপ হয়ে গিয়েছিল।

Comments

এটা কি অসম্পূর্ণ মনে হচ্ছে? এবং গল্ফ না?

— কানেক্টইউরচার্জার

হ্যাঁ. সমাপ্ত / golfed।

— নারুয়োকো