Prime Square คืออะไร

Prime Square เป็นสี่เหลี่ยมจัตุรัสซึ่งทั้งสี่ขอบมีจำนวนเฉพาะแตกต่างกัน
แต่อันไหน
และเราจะสร้างพวกเขาได้อย่างไร

นี่คือตัวอย่างของ 4x4 Prime Square

1009  
0  0     
3  0   
1021    

ก่อนอื่นเราเริ่มจากมุมซ้ายบน เรากำลังทำงานตามเข็มนาฬิกา
เราเลือกที่เล็กที่สุดจำนวนที่มีนายก4ตัวเลขซึ่งเป็น1009

แล้วเราต้องจำนวนเฉพาะที่เล็กที่สุดมีตัวเลขซึ่งเริ่มต้นด้วย4 9นี่คือ9001

ที่สาม (4 หลัก) จำนวนที่สำคัญจะต้องมี1เป็นหลักสุดท้ายของมัน (เพราะ9001สิ้นสุดลงด้วย1)
และยังเป็นที่เล็กที่สุดที่สำคัญ 4 หลักที่มีคุณสมบัตินี้ที่ไม่ได้ถูกนำมาใช้ก่อนที่จะเป็นขอบ
จำนวนเฉพาะนี้คือ1,021

หมายเลขเฉพาะหลักที่สี่ต้องมี4ตัวเลขเริ่มต้นด้วย1(เพราะ1009ขึ้นต้นด้วย a 1) และลงท้ายด้วย1(เพราะ1,021เริ่มต้นด้วย a 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

• input และ output จะได้รับโดยวิธีการที่สะดวกใด ๆ
• คุณสามารถพิมพ์ลงใน STDOUT หรือส่งคืนเป็นผลลัพธ์ของฟังก์ชัน
• ยอมรับได้ทั้งโปรแกรมหรือฟังก์ชั่น
• จำนวนของช่องว่างภายนอกใด ๆ ที่เป็นที่ยอมรับได้ตราบใดที่ตัวเลขเข้าแถวอย่างเหมาะสม
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• นี่คือรหัส - กอล์ฟเพื่อให้ใช้กฎการเล่นกอล์ฟตามปกติทั้งหมดและรหัสที่สั้นที่สุด (เป็นไบต์) ชนะ

แก้ไข
สิ่งนี้เป็นไปได้สำหรับทุกคนn
นี่คือช่วงเวลาสำหรับn=100

1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000289        
9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000091            
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000711             
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002191     

และสำหรับพวกคุณที่คุณไม่คิดว่าเป็นไปได้ที่นี่เป็นกรณีทดสอบทั้งหมด

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 ของฉันนี้เพื่อทำความเข้าใจว่าสี่เหลี่ยมจัตุรัสนั้นถูกสร้างด้วยΛCanvas ในตัวอย่างไร

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][→,↓,←,↑]

05AB1E , 35 33 32 31 ไบต์

-1 ไบต์ต้องขอบคุณ Kevin Cruijssen

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

JavaScript (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

เยลลี่ , 89 82 ไบต์

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

ลองออนไลน์!

อาจเป็นนักกอล์ฟ แต่ก็สามารถทำงานได้อย่างมีประสิทธิภาพสำหรับคนจำนวนมาก

เยลลี่ , 59 ไบต์

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

ลองออนไลน์!

คำตอบของ Jelly ที่สั้นลง แต่มีประสิทธิภาพน้อยกว่ามาก

จาวาสคริปต์, 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 art

รหัสเดิม

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 (ขั้นตอนสำหรับการลบตัวเลข n หลัก, 10 ⁿ substractions ต่อการตรวจสอบการหาร, 10 ^{n การ}ตรวจสอบการแบ่งแยกสำหรับการตรวจสอบเฉพาะและΩ (1) )

ความซับซ้อนที่เลวร้ายที่สุดเวลา: Ω (1000 ⁿ n) ในของ Knuth ใหญ่โอเมก้าสัญกรณ์ (n ขั้นตอนในการลบหมายเลข n หลัก 10 ⁿ substractions ต่อการตรวจสอบหาร 10 ⁿเช็คหารสำหรับการตรวจสอบที่สำคัญและ 10 ⁿการตรวจสอบที่สำคัญทำ)

ฉันสงสัยว่าn=100ใช้เวลาประมาณ 10 ^{203 การ}คำนวณ

Sidenote: ฉันตรวจสอบความถูกต้องของไวยากรณ์โดยใช้ 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))));

มันเพิ่งลบฟังก์ชั่นสุดท้ายเพราะพวกเขาไม่เคยใช้ จริง ๆ แล้วมันจะแย่ลงถ้ามันได้รับมอบหมายและไม่ถูกลบรวมถึงรหัสเพิ่มเติมที่ฉันเพิ่ม