숫자 N이 주어지면 왼쪽에 정렬 된 N x N 숫자 보드를 그려 공백을 남겨 둡니다 (공백으로) ( N = 5 인 다이어그램을 표시합니다 )

   2  3  4  5
6  7  8  9  10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25

당신의 임무는 단계적으로 에라토스테네스의 체를 만드는 것입니다. 먼저, 2로 시작하십시오. 소수이므로 여기에 그대로두고 2로 나눌 수있는 다른 모든 숫자를 적절한 수의 공백으로 바꾸십시오.

   2  3     5
   7     9    
11    13    15
   17    19   
21    23    25

다음으로 인쇄되지 않은 다음 번호 ( 3이 경우)로 이동하여 동일한 작업을 수행하십시오.

   2  3     5
   7          
11    13      
   17    19   
      23    25

그리고 N에 도달 할 때까지 계속 됩니다.

먼저 완전한 그리드를 인쇄해야하며 새 번호로 갈 때마다 배수를 제거한 상태로 보드를 인쇄하십시오. 빈 줄을 그 사이에 인쇄하십시오!

예

괄호 안의 텍스트는 ()참조 용이므로 인쇄 할 필요가 없습니다.

N = 2 :

  2 (complete grid)
3 4

  2 (remove multiples of 2)
3  

N = 3 :

  2 3 (complete grid)
4 5 6
7 8 9

  2 3 (remove multiples of 2)
  5  
7   9

  2 3 (remove multiples of 3)
  5  
7    

이것은 code-golf 이므로 바이트 수가 가장 적은 코드가 이깁니다.

젤리 , 34 바이트

Ṿ€“1“ ”ys³G
>®i©1ḍoṛ®¦
²R;1©ÇÐĿÑ€Y

온라인으로 사용해보십시오!

작동 원리

²R;1©ÇÐĿÑ€Y  Main link. Argument: n (integer)

²            Yield n².
 R           Range; yield [1, ..., n²].
   1©        Yield 1 and copy it to the register.
  ;          Append 1 to the range.
             This is the initial state. Let's call it S.
     ÇÐĿ     Call the second helper link until the results are no longer unique.
             This returns all unique results as an array.
        Ṅ€   Call the first helper link on each result.
          Y  Join, separating by linefeeds.

>®i©1ḍoṛ®¦   Second helper link. Argument: S (state)

>®           Compare all integers in S with the value in the register.
  i 1        Find the first index of 1 (i.e., the first number that is greater
             than the register.
   ©         Copy the index to the register. Let's call the index p.
     ḍ       Test all numbers in S for divisibility by p. This yield 1 for
             multiples of p, 0 otherwise.
      o      Logical OR; replace 0's with the corresponding values of S.
       ṛ®¦   Replace the 0 at index p with the corresponding element of S (p).
             For the purposes of the explanation, S is now the updated state.

Ṿ€“1“ ”ys³G  First helper link. Argument: A (array)

Ṿ€           Uneval each; convert all integers in A into strings.
  “1“ ”y     Replace each string "1" with the string " ".
        s³   Split into chunks of length n (command-line argument).
          G  Grid; separate row items by spaces (left-padding since the row items
             are strings), the rows themselves by linefeeds.

펄 250 243 231 202 157 바이트

$n=<>;@a=0..($e=$n*$n);$a[1]=$";for$p(1..$n){next if!$a[$p];for(1..$e){$a[$_]=""if!($p~~[(1,$_)]||$_%$p);printf"%-*s",1+length$e,$a[$_];say""if!($_%$n)}say}

현재 골프를 온라인으로 테스트하십시오! (로 실행해야합니다 perl -M5.010 main.pl)

두 개의 리터럴 개행은 각각 \ n 대신 1 바이트를 저장합니다.

샘플 출력 (입력 7) :

   2  3  4  5  6  7  
8  9  10 11 12 13 14 
15 16 17 18 19 20 21 
22 23 24 25 26 27 28 
29 30 31 32 33 34 35 
36 37 38 39 40 41 42 
43 44 45 46 47 48 49 

   2  3     5     7  
   9     11    13    
15    17    19    21 
   23    25    27    
29    31    33    35 
   37    39    41    
43    45    47    49 

   2  3     5     7  
         11    13    
      17    19       
   23    25          
29    31          35 
   37          41    
43          47    49 

   2  3     5     7  
         11    13    
      17    19       
   23                
29    31             
   37          41    
43          47    49 

   2  3     5     7  
         11    13    
      17    19       
   23                
29    31             
   37          41    
43          47       

나는 골프를 잘하지 않았다고 생각한다. 그래서 집에 돌아 왔을 때 면도 할 수있는 정도를 다시 한번 살펴볼 것이다.

1 : 7 바이트 편집 ( "print sprintf"를 명백한 "printf"로 변경)

편집 2 : 별도의 변수를 생성하는 대신 호출 된 한 위치에서 $ d를 명시 적으로 사용하고 일부 선언을 결합 하여 다른 위치에 공백을 추가 next하여 첫 번째 foreach루프 내의 명령문에 대한 내 조건 중 하나를 제거하여 12 바이트를 절약했습니다. . 두 개의 for 루프를 단일 루프로 재 작업하여 두 개의 변수 선언을 제거하고 unless명령문을 if-not 문으로 바꾸어 추가로 29 바이트를 추가했습니다 . 선언 my$e=$n*$n;후 $의 세 개의 인스턴스를 교체 N * $ N $ 전자와 (나 그들 중 하나에 대한 괄호를 드롭 할 수 있도록하는) ± 0 바이트를 얻을 밝혀졌다,하지만 어쨌든 그것을 유지.

편집 3 : @Dada 덕분에 40 바이트가 추가되었습니다 (가변 선언, 'foreach'가 'for'가되고 여러 위치에서 암시 적 $ _이되고 printf 문 크기를 줄였습니다). 로 전환 if!($c%$p||$c==$p||$p==1)하여 추가 1 바이트가 제거되었습니다 if!($p~~[(1,$_)]||$_%$p). 불행히도 smartmatch 연산자 ~~는 아직 실험적이며 실제 배열에서는 제대로 작동하지 않지만 대신 참조에 대해서는 작동하므로 배열 주변의 []가 필요합니다. 마지막 뒤에 2 개의 세미콜론과 빈 따옴표를 제거하여 4 바이트를 더 제거했습니다 say.

PHP, 155 바이트

for(;$d++<$n=$argv[1];$x&$a[$d]<1?:print"\n".chunk_split(join($a),$n*$l))for($i=$d*$x=$d>1;$n**2>=$i+=$d;)$a[$i]=str_pad($x|$i<2?"":$i,$l=strlen($n**2)+1);

@Crypto -3 바이트 감사합니다 @Titus -6 바이트 감사합니다

시도 해봐

루프 후 조건에서 처음으로 인쇄를 사용하는 경우

고장

for(;$d++<$n=$argv[1];
$x&$a[$d]<1?:print"\n".chunk_split(join($a),$n*$l))
#after loop print the grid if $d = 1 or is prime
for($i=$d*$x=$d>1;$n**2>=$i+=$d;)
$a[$i]=str_pad($x|$i<2?"":$i,$l=strlen($n**2)+1);
#fills the array at first run and replace positions with space in the next runs 

이전 버전 174 바이트

for(;$d++<=$n=$argv[1];!($d<2||$a[$d]>0)?:print chunk_split(join($a),$n*$l)."\n")for($i=$d<2?1:2*$d;$i<=$m=$n**2;$i+=$d)$a[$i]=str_pad($d<2?($i<2?"":$i):" ",$l=strlen($m)+1);  

그루비, 201 195191 바이트

{n->a=(1..n*n).toArray();y={a.collect{(it?"$it":"").padRight((""+n*n).size())}.collate(n).each{println it.join(" ")}};a[0]=0;y(a);(2..n).each{b->(b+1..n*n).each{if(it%b==0){a[it-1]=0}};y(a)}}

이것은 절대 클러스터입니다 ... 왼쪽 정렬이 내 바이트 수를 살해했습니다. 그러나 이봐, 작동합니다. 다음은 4에 대한 출력입니다.

   2  3  4 
5  6  7  8 
9  10 11 12
13 14 15 16

   2  3    
5     7    
9     11   
13    15   

   2  3    
5     7    
      11   
13         

   2  3    
5     7    
      11   
13         

언 골프 드 :

{
    n->
    a = (1..n*n).toArray();                           // Create initial array.
    y = {                                             // Createa  printing utility closure.
        a.collect {                                   // Create an array collection of...
            (it ? "$it":"").padRight((""+n*n).size()) // If 0, store "", else store number & right pad it.
        }.collate(n).each{                            // Collate by n (break into nxn grid).
            println it.join(" ")                      // print each separated by spaces.
        }
    };
    a[0]=0;                                           // Remove first element.
    y(a);                                             // Print initial status.
    (2..n).each{                                      // From 2 to n...
        b->
        (b+1..n*n).each{                              // From current number + 1 to end of grid...
            if(it%b==0){                              // If current grid position is divisible...
                a[it-1]=0                             // Replace with 0.
            }
        }
        y(a)                                          // Print it.
    }        
}

​

펄 115 114 113 112 바이트

에 +1 포함 -a

STDIN에서 입력 번호로 실행하십시오.

perl -M5.010 sieving.pl <<< 7

sieving.pl:

#!/usr/bin/perl -a
$_*=$_;$a.="$_"x$|++|$"x"@+".($_%"@F"?$":$/)for/\d+/..$_;*_=a;s^^$$_++||say;$.++;s//$&%$.|$&==$.?$&:$&&$_/eg^eg

그 때문에 최근 충분히 펄을 필요 -a의미한다 -n. 펄이 너무 오래된 경우 -n옵션을 추가하십시오 .

허용되는 후행 줄 바꿈을 인쇄합니다.

파이썬 2, 199202 201 바이트

@Oliver 덕분에 +3 바이트 (초기 멈추지 않았습니다) -1 바이트 (공백 없음)

def f(n,p={()}):
 m=n*n;g=['']+[[i,''][any(i>n and i%n<1for n in p)]for i in range(2,m+1)];x=min(set(g)-p);i=0
 while i<m+n:print' '.join('%%%ds'%-len(`m`)%v for v in g[i:i+n]);i+=n
 if x<=n:f(n,p|{x})

반복

자바 스크립트 (ES6), 190 189 바이트

콘솔에 직접 인쇄합니다.

f=(w,k=1,a=[...Array(w*w)].map((_,n)=>n&&n+1))=>k++<=w&&(k==2|a[k-2]&&console.log(a.map((n,x)=>`${n||''}    `.slice(0,`_${w*w}`.length)+(++x%w?'':`
`)).join``),f(w,k,a.map(n=>n==k|n%k&&n)))

데모

f=(w,k=1,a=[...Array(w*w)].map((_,n)=>n&&n+1))=>k++<=w&&(k==2|a[k-2]&&console.log(a.map((n,x)=>`${n||''}    `.slice(0,`_${w*w}`.length)+(++x%w?'':`
`)).join``),f(w,k,a.map(n=>n==k|n%k&&n)))

f(5)

배치, 464 바이트

@echo off
set/an=%1,s=n*n,t=s,c=1
set p=
:l
set/ac+=1,t/=10
set p= %p%
if %t% gtr 0 goto l
for /l %%i in (1,1,%1)do call:i %%i
exit/b
:i
set l=
set/af=0
call:f %1 %1
if %f%==0 for /l %%j in (1,1,%s%)do call:j %1 %%j
exit/b
:j
set/am=%2,f=!(m-1),g=%2%%n
call:f %1 %2
if %f% gtr 0 set m=
set m=%m% %p%
call set l=%%l%%%%m:~0,%c%%%
if %g%==0 echo(%l%&set l=
if %2==%s% echo(
exit/b
:f
for /l %%l in (2,1,%1)do if %%l neq %2 set/af+=!(%2%%%%l)

이것은 다소 힘들었다. 설명 : 루프를 사용하여 n원하는 열 너비 c및 적절한 양의 패딩을 계산할 수 있도록 제곱 하여 시작합니다 . 에서 외부 루프 에 다음 서브 루틴을 호출, 각 격자에 대해 한 번 실행됩니다 . 먼저 값이 1인지 또는 소수인지 확인합니다. 그렇지 않으면 해당 그리드를 건너 뜁니다. 발 내부 루프 에 다음 서브 루틴 호출, 행과 격자의 열 처리p:l1n:i1n*n:j . 각 값은 지금까지 찾은 소수 중 하나인지 또는 소수를 구분하지 않는지 확인합니다. 그렇다면 값이 출력 버퍼에 연결되고 원하는 열 너비로 채워집니다. 버퍼는 매번 인쇄되고 지워집니다n그리드 끝에 추가 빈 줄이 추가됩니다. :f레이블 인자 체크 루틴을 나타내고; F (X, Y)는 1을 추가 f(2) 사이에 각각 정수 x분할 것을 y제외 y자체.

제 195 화 191 185 204 바이트

f=function(N){a=b=1:N^2;i=1;a[1]="";S=sprintf;while(i<=N){for(j in b)cat(a[j]<-S(S("%%-%is",nchar(N^2)),if(j==i|j%%i|i<2)a[j]else ""),if(j%%N)"" else"\n");cat("\n");i=(grep("\\d",a[-(1:i)],v=T)[1]:1)[1]}}

6 개의 여분 바이트를 저장 한 @Billywob 덕분에!

줄 바꿈으로 들여 쓰기 :

f=function(N){
   a=b=1:N^2 #Initial array
   i=1 #Turn counter
   a[1]="" #1 never shown
   S=sprintf
   while(i<=N){
      for(j in b)
         cat(a[j]<-S(S("%%-%is",nchar(N^2)),if(j==i|j%%i|i<2)a[j]else ""),
             if(j%%N)"" else"\n") #Newline at end of row
      cat("\n") #Newline between turns
      i=(grep("\\d",a[-(1:i)],v=T)[1]:1)[1] #Select next prime as next i
   }
}

용법:

> f(2)
  2 
3 4 

  2 
3   

> f(3)
  2 3 
4 5 6 
7 8 9 

  2 3 
  5   
7   9 

  2 3 
  5   
7     

> f(9)
   2  3  4  5  6  7  8  9  
10 11 12 13 14 15 16 17 18 
19 20 21 22 23 24 25 26 27 
28 29 30 31 32 33 34 35 36 
37 38 39 40 41 42 43 44 45 
46 47 48 49 50 51 52 53 54 
55 56 57 58 59 60 61 62 63 
64 65 66 67 68 69 70 71 72 
73 74 75 76 77 78 79 80 81 

   2  3     5     7     9  
   11    13    15    17    
19    21    23    25    27 
   29    31    33    35    
37    39    41    43    45 
   47    49    51    53    
55    57    59    61    63 
   65    67    69    71    
73    75    77    79    81 

   2  3     5     7        
   11    13          17    
19          23    25       
   29    31          35    
37          41    43       
   47    49          53    
55          59    61       
   65    67          71    
73          77    79       

   2  3     5     7        
   11    13          17    
19          23             
   29    31                
37          41    43       
   47    49          53    
            59    61       
         67          71    
73          77    79       

   2  3     5     7        
   11    13          17    
19          23             
   29    31                
37          41    43       
   47                53    
            59    61       
         67          71    
73                79       

> f(12)
    2   3   4   5   6   7   8   9   10  11  12  
13  14  15  16  17  18  19  20  21  22  23  24  
25  26  27  28  29  30  31  32  33  34  35  36  
37  38  39  40  41  42  43  44  45  46  47  48  
49  50  51  52  53  54  55  56  57  58  59  60  
61  62  63  64  65  66  67  68  69  70  71  72  
73  74  75  76  77  78  79  80  81  82  83  84  
85  86  87  88  89  90  91  92  93  94  95  96  
97  98  99  100 101 102 103 104 105 106 107 108 
109 110 111 112 113 114 115 116 117 118 119 120 
121 122 123 124 125 126 127 128 129 130 131 132 
133 134 135 136 137 138 139 140 141 142 143 144 

    2   3       5       7       9       11      
13      15      17      19      21      23      
25      27      29      31      33      35      
37      39      41      43      45      47      
49      51      53      55      57      59      
61      63      65      67      69      71      
73      75      77      79      81      83      
85      87      89      91      93      95      
97      99      101     103     105     107     
109     111     113     115     117     119     
121     123     125     127     129     131     
133     135     137     139     141     143     

    2   3       5       7               11      
13              17      19              23      
25              29      31              35      
37              41      43              47      
49              53      55              59      
61              65      67              71      
73              77      79              83      
85              89      91              95      
97              101     103             107     
109             113     115             119     
121             125     127             131     
133             137     139             143     

    2   3       5       7               11      
13              17      19              23      
                29      31                      
37              41      43              47      
49              53                      59      
61                      67              71      
73              77      79              83      
                89      91                      
97              101     103             107     
109             113                     119     
121                     127             131     
133             137     139             143     

    2   3       5       7               11      
13              17      19              23      
                29      31                      
37              41      43              47      
                53                      59      
61                      67              71      
73                      79              83      
                89                              
97              101     103             107     
109             113                             
121                     127             131     
                137     139             143     

    2   3       5       7               11      
13              17      19              23      
                29      31                      
37              41      43              47      
                53                      59      
61                      67              71      
73                      79              83      
                89                              
97              101     103             107     
109             113                             
                        127             131     
                137     139                     

J, 125 바이트

p=:3 :'}."1,./('' '',.>)"1|:(-%:#y)]\((a:"_)`(<@":)@.*)"+y'
3 :'p@>~.|.(]*](*@|~+.=)({[:I.*){])&.>/\.(<"+i.-y),<]`>:@.*i.*:y'

이것은 암묵적인 J가 아니라 명시 적이지만, 암묵적으로 골프를 칠 수있는 방법이 있어야합니다.

용법

   p =: 3 :'}."1,./('' '',.>)"1|:(-%:#y)]\((a:"_)`(<@":)@.*)"+y'
   f =: 3 :'p@>~.|.(]*](*@|~+.=)({[:I.*){])&.>/\.(<"+i.-y),<]`>:@.*i.*:y'
   f 2
  2
3 4

  2
3  
   f 3
  2 3
4 5 6
7 8 9

  2 3
  5  
7   9

  2 3
  5  
7    
   f 4
   2  3  4 
5  6  7  8 
9  10 11 12
13 14 15 16

   2  3    
5     7    
9     11   
13    15   

   2  3    
5     7    
      11   
13         
   f 5
   2  3  4  5 
6  7  8  9  10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25

   2  3     5 
   7     9    
11    13    15
   17    19   
21    23    25

   2  3     5 
   7          
11    13      
   17    19   
      23    25

   2  3     5 
   7          
11    13      
   17    19   
      23      

수학, 133 바이트

Grid[#,Alignment->Left]~Print~"
"&/@FoldList[#/.(##|1&@@(2~r~i#2)->Null)&,(r=Range)[i=#^2]~Partition~#/.Rule[1,],Prime@r@PrimePi@#];&

PHP, 155 150 147 145 142 140 바이트

for(;$k++<$n=$argv[1];)if($k<2||$a[$k]){for($i=0;$i++<$n*$n;)echo$a[$i]=$k>1?$i>$k&$i%$k<1?"":$a[$i]:($i<2?"":$i),"\t\n"[$i%$n<1];echo"\n";}

고장

for(;$k++<$n=$argv[1];)
    if($k<2||$a[$k])    // if first iteration or number unprinted ...
{
    for($i=0;$i++<$n*$n;)
        echo
            $a[$i]=$k>1
                ?$i>$k&$i%$k<1
                    ?""         // sieve
                    :$a[$i]     // or copy value
                :($i<2?"":$i)   // first iteration: init grid
            ,
            // append tab, linebreak every $n columns
            "\t\n"[$i%$n<1]
        ;
    // blank line after each iteration
    echo"\n";
}