Prime Square nedir?

Bir Prime Square, dört kenarın da farklı asal sayılar olduğu bir karedir.
Ama hangileri?
Ve onları nasıl inşa ederiz?

İşte bir 4x4 Prime Square örneği

1009  
0  0     
3  0   
1021    

İlk önce sol üst köşeden başlıyoruz. Saat yönünde çalışıyoruz . 1009 rakamlı
en küçük asal sayıyı seçiyoruz . 4

Sonra sahip en küçük asal sayı ihtiyaç 4bir ile başlar basamak, 9. Bu 9001

Üçüncü (4 basamaklı) asal sayı 1, son basamağı olmalıdır (çünkü 9001 ile biter 1)
ve ayrıca daha önce kenar olarak kullanılmayan bu özelliğe sahip en küçük 4 basamaklı asal olmalıdır .
Bu asal sayı 1021

Dördüncü asal sayı olması gerekir 4, basamak başlangıç bir ile 1(nedeniyle 1009 bir ile başlar 1) ve uç ile 1(nedeniyle 1021 bir ile başlar 1)
bu özelliği ile en az 4 basamaklı asal sayı bir kenar olarak daha önce kullanılmamış olan 1031

Senin görevin

Sen bir tamsayı verilecektir ngelen 3 to 100
boyutları olacaktır Bu sayı n x nmeydanda
Sonra yapmanız gerekir tam olarak aşağıdaki test durumlarda şeklinde çıktı bu kare

Test Durumları

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

• Giriş ve çıkış herhangi bir uygun yöntemle verilebilir .
• STDOUT'a yazdırabilir veya işlev sonucu olarak geri gönderebilirsiniz.
• Tam bir program veya bir işlev kabul edilebilir.
• Sayılar uygun şekilde hizalandığı sürece herhangi bir miktarda yabancı boşluk kabul edilebilir
• Standart boşluklar yasaktır.
• Bu kod golfüdür, bu nedenle her zamanki golf kuralları geçerlidir ve en kısa kod (bayt cinsinden) kazanır.

DÜZENLE
Bu herkes için mümkündür n
İşte için temellern=100

1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000289        
9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000091            
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000711             
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002191     

Ve bunun mümkün olduğunu düşünmediğiniz kişiler için TÜM test örnekleri

05AB1E , 64 63 56 53 48 46 bayt

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

@ Mr.Xcoder sayesinde -1 bayt
-5 bayt sayesinde @Grimy .

$n>4$$n>7$ .)

Açıklama:

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

Bu 05AB1E bahşiş ucuma bakın (bölüm NedenŽ9¦olduğunuanlamak için Büyük tamsayılar nasıl sıkıştırılır? )2460 . Ve benim bu 05AB1E ipucuna bakın kare ile çıkış nasıl anlamak ΛTuval yerleşiğini.

Tuvali bir karede yazdırmak için ilgili kod: NĀiR}¦ve I¯JŽ9¦SΛ. Hadi alalımn=4[1009,9001,1021,1031][1009,"001","201","301"]Λ
$a$I
$b$¯J"1009001201301"n=4
$c$ (yön) = Ž9¦S: sırasıyla [2,4,6,0]olacak yönler[→,↓,←,↑]

05AB1E , 35 33 32 31 bayt

Kevin Cruijssen sayesinde -1 bayt

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

Çevrimiçi deneyin!

Açıklama:

°                 # 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 ...  185177173 bayt

İçin TIO'da zaman aşımına uğradı $n>8$ çünkü çok verimsiz öncelik testi.

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

Çevrimiçi deneyin!

Nasıl?

Adım # 1: 4 Asalın Hesaplanması

[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.Adım: Çıktıyı biçimlendirme

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

Jöle , 89 82 bayt

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

Çevrimiçi deneyin!

Kesinlikle daha golf olabilir, ancak büyük sayılar için verimli bir şekilde çalışır.

Jöle , 59 bayt

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

Çevrimiçi deneyin!

Daha kısa ama çok daha az verimli Jelly cevabı.

JavaScript, 484 bayt

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

Son adlandırılmamış işlev ASCII resmini döndürür.

Orijinal kod

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

En iyi ve ortalama zaman karmaşıklığı: Knuth'un büyük omega gösteriminde Ω (100 ⁿ n) (n basamaklı sayıların çıkarılması için n adım, bölünebilirlik kontrolü başına 10 ⁿ çıkarma, 10 ⁿ prime kontrolü için bölünebilirlik kontrolü ve Ω (1) prime kontrolleri yapıldı ).

En kötü zaman karmaşıklığı: Knuth'un büyük omega gösterimlerinde Ω (1000 ⁿ n) (n basamaklı sayıların çıkarılması için n adım, bölünebilirlik kontrolü başına 10 ⁿ çıkarma, hazır kontrol için 10 ⁿ bölünebilirlik kontrolü ve 10 ⁿ prime kontrol yapılması).

Sanıyorum n=100yaklaşık 10 ²⁰³ hesap yapıyor.

Sidenote: UglifyJS 3 kullanarak sözdizimini doğruladım ve benden daha iyi golf oynadı,% 47.13 daha fazla tasarruf sağladı ve 282 bayt kazandım. Ancak, hile olduğunu hissettiğim için puanımı vermemeye karar verdim.

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

Hiç kullanılmadıkları için son işlevi sildiler. Eklediğim ek kod dahil olmak üzere atanmış ve silinmemişse aslında daha da kötüleşti.