कुछ प्रधान वर्ग बनाएं!

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 में प्रिंट कर सकते हैं या इसे फ़ंक्शन परिणाम के रूप में वापस कर सकते हैं।
• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं।
• बाहरी व्हाट्सएप की कोई भी राशि स्वीकार्य है, इसलिए जब तक संख्या उचित रूप से पंक्तिबद्ध न हो जाए
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

EDIT
यह सभी के लिए संभव है n
यहाँ के लिए primes हैंn=100

1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000289        
9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000091            
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000711             
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002191     

और उन लोगों के लिए जो आपको नहीं लगता कि यह संभव है यहां सभी परीक्षण मामले हैं

Comments

यदि n 100 तक जा सकता है, तो n = 10. की तुलना में कुछ बड़े परीक्षण मामलों का होना अच्छा हो सकता है

— गैस्ट्रोपनर

क्या यह साबित हो सकता है कि यह सभी के लिए संभव है n: पी? चुनौती के साथ कोई समस्या नहीं, बस जिज्ञासु।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn यह निश्चित रूप से सभी के लिए संभव नहीं है n: n= 1 के लिए, हम बाधा को संतुष्ट नहीं कर सकते हैं कि चार किनारे अलग-अलग हैं, जबकि n= 2 के लिए, हमें 11,13,23 चुनने के लिए मजबूर किया जाता है, जिस पर अंतिम छोर है 12 जो समग्र है। मेरे पास ऐसा कोई प्रमाण नहीं है कि यह सभी n> 2 के लिए संभव है , लेकिन अन्यथा सीखने के लिए चौंक जाएंगे: अनौपचारिक रूप से, जितने अधिक अंक होंगे, बाधाओं को संतुष्ट करने के लिए उतने ही "wiggle कमरे" होंगे।

— डैनियल वैगनर

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

@MagicOctopusUrn अंकगणितीय प्रगति के लिए प्रमुख संख्या प्रमेय 1, 3, 7, और 9 में समाप्त होने वाले अपराधों के घनत्व के बारे में काफी मजबूत बात कहती है (वहाँ संकेतन में n = 10, a = 3/3/7/9) ले; पर्याप्त रूप से बड़े के लिए 1 से शुरू होने वाले और उन अंकों में से प्रत्येक के साथ समाप्त होने के nकम से कम दो प्राइम हैं n(इसलिए हम एक निचला किनारा चुन सकते हैं) और 1 से शुरू होने वाले और 1 से समाप्त होने के कम से कम तीन प्राइम हैं (इसलिए हम एक को चुन सकते हैं बायाँ किनारा)।

— डैनियल वैगनर

Answer 1

05AB1E , 64 63 56 53 48 46 बाइट्स

°Å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 बाइट्स

केविन क्रूज़सेन के लिए धन्यवाद

°Å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

यह आंशिक रूप से केविन के उत्तर पर आधारित है , लेकिन इस बिंदु पर यह काफी अलग है कि मुझे लगा कि यह एक टिप्पणी के बजाय इसके स्वयं के जवाब के योग्य है।

— ग्रैमी

मैं केवल अब इस उत्तर को देखता हूं। बहुत अच्छा! सामान्य विधि (और इसलिए पहले और अंतिम भाग) के अलावा, चार अपराधों का निर्धारण और स्ट्रिंग का निर्माण इतनी अलग तरह से किया जाता है कि मैं अलग-अलग उत्तर को समझ सकता हूं। मुझ से +1। Btw, आप एक बाइट को हटाने Θपर बचा सकते हैं NΘ। केवल 105AB1E में सच्चाई है, इसलिए if Nऔर if N == 1समान हैं।

— केविन क्रूज़सेन

@KevinCruijssen धन्यवाद! बेशक मैं जानता था कि, लेकिन मैं इसका इस्तेमाल करना भूल गया। पीछे मुड़कर देखें तो Θiकी 05AB1E बराबर है if (cond == true)...

— ग्रिमी

हां, यह सही है। :) Θअभी भी उपयोगी यदि आप के अलावा सब कुछ परिवर्तित करना चाहते हो सकता है 1के लिए 0। लेकिन अगर बयान के लिए i, यह वास्तव में आवश्यक नहीं है कि आपके छद्म कोड के साथ == true।

— केविन क्रूज़सेन

Answer 3

जावास्क्रिप्ट (ईएस 8),  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 primes कंप्यूटिंग

[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 ^एन एन) नुथ की बड़ी-ओमेगा अंकन में (एन एन अंकों की संख्या, 10 को घटाकर के लिए चरणों ⁿ विभाज्यता जांच प्रति substractions, 10 ^एन प्रधानमंत्री की जांच के लिए विभाज्यता जांच, और Ω (1) प्रधानमंत्री के चेक किया )।

सबसे बुरा समय जटिलता: Ω (1000 ^एन एन) नुथ की बड़ी-ओमेगा अंकन में (एन एन अंकों की संख्या, 10 को घटाकर के लिए चरणों ⁿ विभाज्यता जांच, 10 प्रति substractions ⁿ प्रधानमंत्री की जांच, और 10 के लिए विभाज्यता जांच ⁿ प्रधानमंत्री चेकों किया)।

मुझे संदेह n=100है कि लगभग 10 ²⁰³ गणनाएँ हैं।

सिडेनोट: मैंने UglifyJS 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।

— नारुयोक