15

একটি নম্বর এন দেওয়া হয়েছে , 1 টি ফাঁকা রেখে (একটি স্থান হিসাবে) একটি বাম প্রান্তিক এন এক্স এন বোর্ডের অঙ্কন করুন (আমি এন = 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

আপনার কাজ হ'ল ধাপে ধাপে ইরোটোথিনিসের চালনা তৈরি করা। প্রথমে ২ দিয়ে শুরু করুন It's এটি প্রধান, তাই এটি এখানে রেখে দিন, এবং অন্যান্য সমস্ত সংখ্যা 2 দ্বারা বিভাজ্য স্থানগুলিকে যথাযথ সংখ্যার সাথে প্রতিস্থাপন করুন।

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

এরপরে, পরবর্তী অপরিশোধিত নম্বরটিতে যান ( 3এই ক্ষেত্রে) এবং একই কাজ করুন।

এবং এভাবেই, আপনি এন পৌঁছানোর আগ পর্যন্ত ।

আপনাকে প্রথমে সম্পূর্ণ গ্রিডটি মুদ্রণ করতে হবে এবং আপনি যখনই কোনও নতুন সংখ্যায় যান, তখন গুণকগুলি মুছে ফেলা সহ বোর্ডটি মুদ্রণ করুন। আপনি একটি ফাঁকা রেখা মুদ্রণ করেছেন তা নিশ্চিত করুন!

উদাহরণ

প্রথম বন্ধনীতে পাঠ্য ()কেবলমাত্র রেফারেন্সের জন্য, আপনার এটি মুদ্রণের দরকার নেই

এন = 2:

  2 (complete grid)
3 4

  2 (remove multiples of 2)
3

এন = 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 ascii-art primes

— অলিভার নি
সূত্র

সাধারণত একটি এন × এন চালনার জন্য আপনি এন এর পরে চালানো বন্ধ করে দিন ।

— নিল

1

উদাহরণস্বরূপ, যদি N=10, 100প্রধান না হয়, তাই কোনও এক সময় সরিয়ে দেওয়া হবে। সমস্ত সংখ্যা অবশ্যই 3 টি অক্ষরে প্যাড করা উচিত কারণ 1003 টি সংখ্যা রয়েছে?

— mbomb007

4

আপনি কেন সংখ্যা বামে রাখবেন?

— ডেনিস 21

2

নতুন লাইনের অনুসরণ কি গ্রহণযোগ্য?

— ডেনিস

2

অন্তর্নির্মিত গ্রিড অনুমোদিত? আউটপুট পোস্টের উদাহরণের সাথে একরকম দেখাচ্ছে তবে স্ট্রিং হবে না।

— জংহওয়ান মিন

7

জেলি , 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.

— ডেনিস
সূত্র

5

পার্ল, 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)

দুটি আক্ষরিক নিউলাইনগুলি প্রতিটিতে 1 বাইট সংরক্ষণ করে \ n।

নমুনা আউটপুট (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 বাইট সম্পাদনা করুন ("প্রিন্ট স্প্রিন্টফ" স্পষ্ট "প্রিন্টফ" এ পরিবর্তন করুন)

2 সম্পাদনা করুন: 12 টি বাইটগুলি স্পষ্টভাবে এক জায়গায় using d ব্যবহার করে আলাদা আলাদা ভেরিয়েবল তৈরির পরিবর্তে, কিছু ঘোষণার সংমিশ্রনের পরিবর্তে ডেকে আনা হয়েছিল nextএবং প্রথম foreachলুপের ভিতরে বিবৃতিটির জন্য আমার শর্তের একটি অপসারণ করে অন্য কোথাও একটি স্থান যুক্ত করে রেখেছেন by । দুটি লুপের জন্য দুটি একক লুপে পুনরায় কাজ করে দুটি ভেরিয়েবল ডিক্লেয়ারেশন মুছে ফেলে, এবং unlessবিবৃতিগুলিকে যদি-না-বিবৃতিতে পরিণত করে তবে অতিরিক্ত 29 বাইটগুলি গল্ফ করা হয়েছিল । Lar my$e=$n*$n;n * $ n এর তিনটি দৃষ্টান্ত $ e দিয়ে প্রতিস্থাপন করার পরে (আমাকে তার একটির জন্য পেরেন ড্রপ করার অনুমতি দিয়ে) ± 0 বাইট ফলন হয়েছে, তবে আমি তা যাইহোক এটি রেখে দিয়েছি।

সম্পাদনা 3: @ দাদাকে ধন্যবাদ, আরও 40 টি বাইট গল্ফ করা হয়েছিল (পরিবর্তনশীল ঘোষণা, 'ফোর্যাচ' হয়ে 'হয়ে', বিভিন্ন জায়গায় $ _, এবং প্রিন্টফ স্টেটমেন্টের আকারটি কাটা)। একটি অতিরিক্ত 1 বাইট বাঁক দ্বারা বন্ধ চাঁচা হয়েছিল if!($c%$p||$c==$p||$p==1)মধ্যে if!($p~~[(1,$_)]||$_%$p)। দুর্ভাগ্যক্রমে, অ্যারের আশেপাশের [] প্রয়োজনীয়, কারণ স্মার্টম্যাচ অপারেটর still এখনও পরীক্ষামূলক এবং সত্যিকার অ্যারেগুলিতে সঠিকভাবে কাজ করছে বলে মনে হয় না, তবে পরিবর্তে তাদের রেফারেন্সে কাজ করে। শেষের পরে দুটি সেমিকোলন এবং উদ্ধৃতি চিহ্নের খালি সেট অপসারণ করে আরও 4 টি বাইট সরানো হয়েছিল say।

— গ্যাব্রিয়েল বেনামি
সূত্র

1

এটি একটি ভাল শুরু, তবে আপনি এটি আরও অনেক গল্ফ করতে পারেন। ভেরিয়েবলগুলি ঘোষণা করবেন না (সুতরাং ব্যবহার করবেন না my)। ব্যবহারের পরিবর্তে ভিতরে -pথাকতে পতাকা ব্যবহার করুন । পরিবর্তে লিখুন (এই নির্দেশ সমতুল্য)। স্টেটমেন্ট মডিফায়ার পজিশনে রয়েছে এমন অবস্থাটির আশেপাশে প্রথম বন্ধনী ছেড়ে দিন (উদাহরণস্বরূপ পরিবর্তে । কোনও প্রথম বন্ধনী আরম্ভ করার প্রয়োজন নেই : আপনি পরিবর্তে পরিবর্তন করতে পারেন এবং তার পরিবর্তে উইল ব্যবহার করতে পারেন Write লিখুন (স্প্রিন্টফ ডকটি সম্পর্কে বিস্তারিত জানতে )N$_$n=<>forforeachifif!$c%$nif(!$c%$n)@a@a=0..$efor$_printf"%*s",1+length$e,$a[$c]*

— দাদা

1

$"পরিবর্তে ব্যবহার করুন " "। say""পরিবর্তে print"\n"(আপনার কোডে আপনার কাছে একটি লিটারেরাল নিউলাইন রয়েছে তবে আমি এটি মন্তব্যতে লিখতে পারি না) (আপনি -M5.010কমান্ড লাইনে যুক্ত করতে যোগ করবেন, তবে এটি বাইট গণনায় গণনা করা হবে না)। আপনি সম্ভবত 0..$e=$n*$nআরম্ভের সময়ে একটি বাইট সংরক্ষণ করতে ব্যবহার করতে পারেন $e। কটাক্ষপাত আছে Perl golfing টিপস , এটা দরকারী টিপস অনেকটা ধারণ করে। তবে নতুন পার্ল গল্ফার দেখে ভাল লাগল, স্বাগতম! :) (এবং আমার বানান ভুলগুলি ক্ষমা করুন, আমি আমার আগের মন্তব্যটি খুব দ্রুত লিখতে পারি)

— দাদা

@ দাদা আপনার পরামর্শের জন্য আপনাকে ধন্যবাদ! কমান্ড লাইনে চলমান কোডের সাথে আমি খুব বেশি পরিচিত নই (আমি এটিকে ফাইল হিসাবে চালানোর চেষ্টা করি) তবে আমি সেভাবে এটি করার চেষ্টা করব। হিসাবে হিসাবে if!$c%$n,! অপারেটরের% অপারেটরের চেয়ে অগ্রাধিকার রয়েছে, সুতরাং প্রযুক্তিগতভাবে এটি এমন হবে if((!$c)%$n)যা $ c = 0 (যা আমি চাই না) ব্যতীত অন্য কোনও কিছুর জন্যই মিথ্যা হয়ে আসে। আপনার অন্যান্য টিপস হিসাবে, আমি কি করতে পারি তা দেখতে পাবো! আপনাকে অনেক ধন্যবাদ!

— গ্যাব্রিয়েল বেনামি

আপনি না আছে যারা পরিবর্তন যদি আপনি হিসাবে ভাল একটি ফাইল ভিতরে তাদের করা কাজ করবে কমান্ড লাইন তে এটি চালানোর জন্য,। এর জন্য দুঃখিত !, আমি এটি পরীক্ষা করার জন্য আমার কম্পিউটারে ছিলাম না। আমার মনে হয় আপনি 160 টি অক্ষরে নামতে সক্ষম হবেন।

— দাদা

5

পিএইচপি, 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);

@ ক্রাইপ্টো -৩ বাইটস আপনাকে ধন্যবাদ @ টাইটাস -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);

— জার্গ হালসারম্যান
সূত্র

1

শর্ত পরিবর্তন করে -3 বাইট: !($d<2||$a[$d]>0)=>$d>1&&$a[$d]<1

— ক্রিপ্টো

1

-1 বাইট এই কৌতুক ব্যবহার পূর্ণসংখ্যা দৈর্ঘ্য পেতে $l=strlen($m)+1থেকে$l=log10($m)+2

— ক্রিপ্টো

1

-3 বাইট: এর $i=$d*$x=$d>1পরিবর্তে $i=$d<2?0:$dএবং $xঅন্য দুটি ঘটনার জন্য$d>1

— টাইটাস

1

-2 বাইট: এর $n*$n>=$i+=$dপরিবর্তে ($i+=$d)<=$m=$n**2এবং $n*$nঅন্য ঘটনার জন্য$m

— টাইটাস

1

-1 বাইট: নতুন লাইনটি অনুসরণ করার পরিবর্তে নেতৃত্ব দিচ্ছেন

— টাইটাস

3

খাঁজকাটা, 201 195 191 বাইট

{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

Ungolfed:

{
    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.
    }        
}

— ম্যাজিক অক্টোপাস উরন
সূত্র

2

এটি আমার কাছে বাম-সারিবদ্ধ দেখাচ্ছে না।

— ডেনিস

স্থির ... আমি এখন পর্যন্ত এটি সম্পাদনা করার সুযোগ পেলাম না ...

— ম্যাজিক অক্টোপাস উরন

@ ডেনিস আমি আসলে আপনার মন্তব্যগুলি দেখেছি এবং ভেবেছিলাম তিনি আপনার মন্তব্যের ভিত্তিতে এটি পরিবর্তন করেছেন।

— ম্যাজিক অক্টোপাস উরন

3

পার্ল, 115 114 113 112 বাইট

এর জন্য +1 অন্তর্ভুক্ত -a

এসটিডিনে ইনপুট নম্বর দিয়ে চালান:

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

পাইথন 2, 199 202 201 বাইট

+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})

repl.it

— জোনাথন অ্যালান
সূত্র

1

আপনি 1এবংfor

— অলিভার নি

2

জাভাস্ক্রিপ্ট (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)

স্নিপেট প্রসারিত করুন

— Arnauld
সূত্র

2

ব্যাচ, 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। প্রতিটি মান এটি এখন পর্যন্ত পাওয়া প্রধান সংখ্যাগুলির মধ্যে একটি কিনা, বা এখনও অবধি পাওয়া প্রধান সংখ্যাগুলির মধ্যে কোনওটি যদি এটি ভাগ করে না তা পরীক্ষা করে দেখা হয় is যদি তাই হয় তবে মানটি আউটপুট বাফারের সাথে সংযুক্ত হয়, যা পরে পছন্দসই কলামের প্রস্থে প্যাড করা হয়। বাফারটি প্রতিটি nলাইন মুদ্রিত এবং সাফ করা হয় এবং গ্রিডের শেষে অতিরিক্ত ফাঁকা লাইন যুক্ত হয়। :fট্যাগ ফ্যাক্টর-পরীক্ষণের সাবরুটিন উল্লেখ করে; f (x, y) fপ্রতিটি পূর্ণসংখ্যার জন্য 2 এর মধ্যে 1 যোগ করে এবংxবিভক্ত যে y, ব্যতীত yনিজেই।

— নিল
সূত্র

2

আর, 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]}}

Extra টি অতিরিক্ত বাইট সংরক্ষণের জন্য @ বিলিওউবকে ধন্যবাদ!

নতুন লাইনের সাথে ইন্ডেন্ট করা:

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

— plannapus
সূত্র

ভাল, আমি কোডগল্ফিংয়ের প্রয়োজনীয়তা মেনে চলার জন্য ম্যাট্রিকগুলি কীভাবে প্রিন্ট করতে হবে তা কখনই ঠিক বুঝতে পারছি না যে এগুলি ন্যায্য বলে বিবেচনা করা উচিত। আপনি যদিও কিছু বাইট সংরক্ষণ করতে পারেন। Exponentiation অপারেটর ^মাত্র এক যে যখন ব্যবহার সিকোয়েন্স উৎপাদিত ভেক্টরকৃত নয় :অর্থ হলো, আপনি যেমন ব্যবহার করতে পারেন 1:2^2পেতে 1 2 3 4। দ্বিতীয়ত আপনি সংজ্ঞা দিলে আপনি a=b=1:n^2পরে for(j in b)লুপ ওভারের জন্য অন্য ভেক্টর সংজ্ঞায়নের পরিবর্তে ব্যবহার করতে পারেন । আপনার কয়েকটা বাইট সংরক্ষণ করা উচিত।

— বিলিওব

প্রকৃতপক্ষে! ধন্যবাদ! অপারেটর অগ্রাধিকারের সঠিক

— ক্রমটি

চ (2) এবং চ (3) সংখ্যার এবং চ (9) এ দুটি স্পেসের মধ্যে তিনটি ফাঁক কেন? এটি সর্বদা একটি স্থান হওয়া উচিত।

— অলিভার নি

ওহ ঠিক আছে আমি আদর্শ হিসাবে 3 টি অক্ষর সেট আপ করেছি কারণ আমি এন = 10 দিয়ে পরীক্ষা করছিলাম, আমাকে এটি সংশোধন করতে দিন।

— প্ল্যানাপাস

1

জে, 125 বাইট

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

এটি স্পষ্টতই, স্পষ্টত জে নয়, তবে এটিকে স্বচ্ছভাবে গল্ফ করার একটি উপায় থাকা উচিত।

ব্যবহার

   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

— মাইল
সূত্র

1

গণিত, 133 বাইট

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

— জংহওয়ান মিন
সূত্র

1

পিএইচপি, 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";
}

— তিতাস
সূত্র

1

$a[$i]="";এর পরিবর্তে unset($a[$i]);4 বাইট সংরক্ষণ করা উচিত

— জার্গ হালসারম্যান

$i%$k<1 পরিবর্তে !($i%$k) একটি বাইট সংরক্ষণ করুন

— Jörg Hülsermann

ইরোটোথিনিসের চালনা, ধাপে ধাপে

উদাহরণ

জেলি , 34 বাইট

কিভাবে এটা কাজ করে

পার্ল, 250 243 231 202 157 বাইট

পিএইচপি, 155 বাইট

খাঁজকাটা, 201 195 191 বাইট

Ungolfed:

পার্ল, 115 114 113 112 বাইট

পাইথন 2, 199 202 201 বাইট

জাভাস্ক্রিপ্ট (ES6), 190 189 বাইট

ডেমো

ব্যাচ, 464 বাইট

আর, 195 191 185 204 বাইট

জে, 125 বাইট

ব্যবহার

গণিত, 133 বাইট

পিএইচপি, 155 150 147 145 142 140 বাইট