Quảng trường chính là gì?

Prime Square là một hình vuông trong đó tất cả bốn cạnh là các số nguyên tố khác nhau.
Nhưng cái nào?
Và làm thế nào để chúng ta xây dựng chúng?

Dưới đây là một ví dụ về Quảng trường Prime Prime

1009  
0  0     
3  0   
1021    

Đầu tiên chúng ta bắt đầu từ góc trên bên trái. Chúng tôi đang làm việc theo chiều kim đồng hồ .
Chúng tôi chọn số nguyên tố nhỏ nhất có các 4chữ số là 1009 .

Sau đó, chúng ta cần số nguyên tố nhỏ nhất có 4chữ số, bắt đầu bằng a 9. Đây là 9001

Số nguyên tố thứ ba (4 chữ số) phải có 1là chữ số cuối cùng của nó (vì 9001 kết thúc bằng 1)
và cũng là số nguyên tố 4 chữ số nhỏ nhất với thuộc tính này chưa được sử dụng trước đây làm cạnh .
Số nguyên tố này là 1021

Số nguyên tố thứ tư phải có các 4chữ số, bắt đầu bằng một 1(vì 1009 bắt đầu bằng a 1) và kết thúc bằng một 1(vì 1021 bắt đầu bằng a 1)
Số nguyên tố 4 chữ số nhỏ nhất với thuộc tính này chưa được sử dụng trước đó vì cạnh là 1031

Nhiệm vụ của bạn

Bạn sẽ được cấp một số nguyên ntừ 3 to 100
Số này sẽ là kích thước của n x nhình vuông
Sau đó bạn phải xuất ra hình vuông này chính xác dưới dạng các trường hợp kiểm tra sau

Các trường hợp thử nghiệm

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

• Đầu vào và đầu ra có thể được đưa ra bởi bất kỳ phương pháp thuận tiện .
• Bạn có thể in nó sang STDOUT hoặc trả lại dưới dạng kết quả chức năng.
• Một chương trình đầy đủ hoặc một chức năng được chấp nhận.
• Bất kỳ số lượng khoảng trắng ngoại lai nào đều được chấp nhận, miễn là các số xếp thành hàng một cách thích hợp
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

EDIT
Điều này có thể cho tất cả n
Dưới đây là các số nguyên tố chon=100

1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000289        
9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000091            
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000711             
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002191     

Và đối với những người bạn không nghĩ rằng điều này là có thể thì đây là TẤT CẢ các trường hợp thử nghiệm

05AB1E , 64 63 56 53 48 46 byte

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

-1 byte nhờ @ Mr.Xcoder
-5 byte nhờ @Grimy .

$n>4$$n>7$

Giải trình:

°                 # 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)

Xem 05AB1E mẹo này của tôi (phần Làm thế nào để nén các số nguyên lớn? ) Để hiểu tại sao Ž9¦là 2460. Và hãy xem mẹo 05AB1E này của tôi để hiểu cách hình vuông được xuất ra với tích hợp Λ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 byte

-1 byte nhờ Kevin Cruijssen

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

Hãy thử trực tuyến!

Giải trình:

°                 # 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 byte

$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`
`)

Hãy thử trực tuyến!

Làm sao?

Bước # 1: tính toán 4 số nguyên tố

[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()

Bước # 2: định dạng đầu ra

[...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

Thạch , 89 82 byte

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

Hãy thử trực tuyến!

Chắc chắn có thể là golfier, nhưng hoạt động hiệu quả cho số lượng lớn.

Thạch , 59 byte

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

Hãy thử trực tuyến!

Câu trả lời Jelly ngắn hơn nhưng kém hiệu quả hơn nhiều.

JavaScript, 484 byte

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]}

Hàm không tên cuối cùng trả về nghệ thuật ASCII.

Mã gốc

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];
}

Độ phức tạp thời gian trung bình và tốt nhất: (100 ⁿ n) trong ký hiệu big-omega của Knuth (n bước để trừ n số chữ số, 10 ^{n cơ bản} cho mỗi lần kiểm tra chia hết, 10 ⁿ chia hết kiểm tra để kiểm tra số nguyên tố, và Ω (1) kiểm tra thủ thực hiện ).

Độ phức tạp thời gian tồi tệ nhất: (1000 ⁿ n) trong ký hiệu big-omega của Knuth (n bước để trừ n số chữ số, 10 ^{n cơ số} cho mỗi lần kiểm tra chia hết, kiểm tra chia hết 10 ⁿ cho kiểm tra chính và 10 ⁿ kiểm tra chính được thực hiện).

Tôi nghi ngờ n=100mất khoảng 10 ²⁰³ tính toán.

Sidenote: Tôi đã xác thực cú pháp bằng cách sử dụng UglifyJS 3 và nó chơi golf tốt hơn tôi đã làm, tiết kiệm hơn 47,13% và kiếm được 282 byte. Tuy nhiên, tôi quyết định không làm cho điểm số của mình vì tôi cảm thấy như nó là gian lận.

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))));

Nó chỉ xóa chức năng cuối cùng vì chúng không bao giờ được sử dụng. Nó thực sự trở nên tồi tệ hơn nếu nó được chỉ định và không bị xóa, bao gồm cả mã bổ sung mà tôi đã thêm.