एराटोस्थनीज की छलनी, कदम से कदम

15

एक संख्या एन को देखते हुए , एक रिक्त संरेखित N x N संख्याओं का बोर्ड बनाएं, 1 रिक्त स्थान (एक स्थान के रूप में) को छोड़कर (मैं 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

आपका काम है, Sieve of Eratosthenes का निर्माण करना, कदम से कदम। सबसे पहले, 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

और इतने पर, जब तक आप एन तक नहीं पहुंचते ।

आपको पहले पूरा ग्रिड प्रिंट करने की आवश्यकता है, और हर बार जब आप एक नए नंबर पर जाते हैं, तो बोर्ड को हटाए गए गुणकों के साथ प्रिंट करें। सुनिश्चित करें कि आप बीच में एक रिक्त रेखा मुद्रित करते हैं!

उदाहरण

कोष्ठक में पाठ ()सिर्फ संदर्भ के लिए हैं, आपको इसे प्रिंट करने की आवश्यकता नहीं है

एन = 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
आप संख्या छोड़ क्यों करेंगे ?
— डेनिस
2
अनुगामी newlines स्वीकार्य हैं?
— डेनिस
2
अंतर्निहित ग्रिड की अनुमति है? आउटपुट पोस्ट में उदाहरण के समान दिखाई देगा, लेकिन एक स्ट्रिंग नहीं होगा।
— 3

जवाबों:

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)

दो शाब्दिक newlines प्रत्येक \ 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 बाइट्स ("प्रिंट स्प्रिंट" को स्पष्ट "प्रिंटफ" में बदलना)

संपादित करें 2: 12 बाइट्स को एक ही स्थान पर $ d का उपयोग करके स्पष्ट रूप से सहेजा गया था, जिसे अलग-अलग चर बनाने के बजाय कुछ घोषणाओं को जोड़कर, और nextपहले foreachलूप के अंदर बयान के लिए मेरी एक शर्तों को समाप्त करके कहीं और जगह जोड़कर बुलाया गया था। । एक अतिरिक्त 29 बाइट्स को एक लूप में दो छोरों के लिए परिश्रम से बाहर निकाला गया था, दो चर घोषणाओं को नष्ट कर दिया था, और unlessयदि नहीं बयान में बयान बदल दिया। my$e=$n*$n;फिर घोषणा करते हुए $ n के साथ $ n * $ n के तीन उदाहरणों की जगह (मुझे उनमें से एक के लिए एक पराग को छोड़ने की अनुमति देता है) by 0 बाइट्स देने के लिए निकला, लेकिन मैंने इसे वैसे भी रखा।

संपादित करें 3: @ दादा के लिए धन्यवाद, 40 अन्य बाइट्स को बाहर निकाल दिया गया (चर घोषणाएं, 'फॉरच' 'के लिए' बन गईं, कई स्थानों पर $ _ निहित है, और प्रिंटफ़ स्टेटमेंट आकार में कटौती)। एक अतिरिक्त 1 बाइट को मोड़कर मुंडा if!($c%$p||$c==$p||$p==1)गया if!($p~~[(1,$_)]||$_%$p)। दुर्भाग्य से, सरणी के चारों ओर [] आवश्यक है, क्योंकि स्मार्टमैच ऑपरेटर ~~ अभी भी प्रयोगात्मक है और वास्तविक सरणियों पर ठीक से काम नहीं करता है, लेकिन इसके बजाय उनके संदर्भों पर काम करता है। आखिरी के बाद दो अर्धविराम और उद्धरण चिह्नों के खाली सेट को हटाकर 4 और बाइट्स निकाले गए say।

— गेब्रियल बेनामी
स्रोत
1
यह एक अच्छी शुरुआत है, लेकिन आप इसे बहुत अधिक बढ़ा सकते हैं। चरों को घोषित न करें (ताकि उपयोग न करें my)। का प्रयोग करें -pध्वज के लिए Nअंदर $_उपयोग करने के बजाए $n=<>। forइसके बजाय लिखें foreach(यह निर्देश समकक्ष हैं)। की शर्त के आसपास कोष्ठक ड्रॉप ifकि (उदाहरण के लिए बयान संशोधक स्थिति में हैं if!$c%$nके बजाय if(!$c%$n)कोई प्रारंभ करने की जरूरत वाले कोष्ठक। @a: @a=0..$eआप करने के लिए छोड़ सकते हैं। forचर और $_बजाय इस्तेमाल किया जा wiil लिखें। printf"%*s",1+length$e,$a[$c]उस के बारे में जानकारी के लिए ( `` sprintf` डॉक *)
— दादा
1
के $"बजाय का उपयोग करें " "। say""इसके बजाय print"\n"(आपके पास अपने कोड में एक लैटरल न्यूलाइन है लेकिन मैं इसे टिप्पणी में नहीं लिख सकता) (आप -M5.010कमांड लाइन में जोड़ देंगे , लेकिन यह बाइट गिनती में नहीं है)। आप शायद 0..$e=$n*$nएक बाइट को बचाने के लिए उपयोग कर सकते हैं $e। पर्ल गोल्फिंग टिप्स पर एक नजर डालें , इसमें बहुत सारे उपयोगी टिप्स हैं। लेकिन एक नया पर्ल गोल्फर देखना अच्छा है, आपका स्वागत है! :) (और मेरी वर्तनी की गलतियों को माफ़ करें, हो सकता है कि मैंने अपनी पिछली टिप्पणी बहुत तेज़ी से लिखी हो)
— दादा
@ दादा आपकी सलाह के लिए धन्यवाद! मैं कमांड लाइन पर चलने वाले कोड से बहुत परिचित नहीं हूं (मैं इसे एक फ़ाइल के रूप में चलाने के लिए तैयार हूं) लेकिन मैं इसे इस तरह से करने पर एक नज़र डालूंगा। के रूप if!$c%$nमें,! ऑपरेटर का% ऑपरेटर पर पूर्वता है, इसलिए तकनीकी रूप से यह ऐसा होगा if((!$c)%$n)जो $ c = 0 (जो मुझे नहीं चाहिए) के अलावा किसी और चीज के लिए गलत है। आपके अन्य सुझावों के लिए, मैं देखूंगा कि मैं क्या कर सकता हूं! आपका बहुत बहुत धन्यवाद!
— गेब्रियल बेनामी
आपको इसे कमांड लाइन पर चलाने की ज़रूरत नहीं है , यदि आप उन्हें फ़ाइल के अंदर भी रखते हैं तो वे संशोधन काम करेंगे। इसके लिए क्षमा करें !, मैं इसे जांचने के लिए अपने कंप्यूटर पर नहीं था। आपको लगता है कि मुझे लगता है कि नीचे 160 पात्रों के लिए सक्षम होना चाहिए।
— दादा
5

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

@ क्रिप्टो -3 बाइट्स शुक्रिया @ टिट्स -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.
    }        
}

​

— जादू ऑक्टोपस Urn
स्रोत
2
यह मेरे लिए बाएँ-संरेखित नहीं दिखता है।
— डेनिस
फिक्स्ड ... मुझे अब तक इसे संपादित करने का मौका नहीं मिला ...
— मैजिक ऑक्टोपस Urn
@ डेनिस ने वास्तव में आपकी टिप्पणियों को देखा और सोचा कि उसने आपकी टिप्पणी के आधार पर इसे बदल दिया है।
— मैजिक ऑक्टोपस Urn
3

पर्ल, 115 114 113 113 बाइट्स

के लिए +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

पायथन 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

जावास्क्रिप्ट (ईएस 6), 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)))

डेमो

कोड स्निपेट दिखाएं

— 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, और उचित मात्रा में पैडिंग की गणना pकर सके :l। से बाहरी पाश 1करने के लिए nतो प्रत्येक ग्रिड के लिए एक बार चलाता है, सबरूटीन बुला :i। पहले मान को यह देखने के लिए जांचा जाता है कि यह 1 या अभाज्य है; यदि नहीं, तो उस ग्रिड को छोड़ दिया जाता है। से भीतरी पाश 1करने के लिए n*nतो, पंक्तियों और ग्रिड के स्तंभ संभालती सबरूटीन बुला:j। प्रत्येक मान की जाँच यह देखने के लिए की जाती है कि क्या यह अब तक पाए गए अभाज्य संख्याओं में से एक है, या यदि कोई भी अभाज्य संख्याएँ नहीं मिली हैं जो इसे विभाजित करती हैं। यदि ऐसा है तो मान आउटपुट बफर के लिए समाप्‍त हो जाता है, जिसे तब वांछित कॉलम की चौड़ाई पर रखा जाता है। बफर को हर में मुद्रित और साफ़ किया जाता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]}}

@Billywob को धन्यवाद 6 अतिरिक्त बाइट्स के लिए बचाया!

नई कहानियों के साथ प्रस्तुत:

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
स्रोत
अच्छा, मैं कभी नहीं समझ सकता कि मैट्रिसेस को ठीक से प्रिंट करने के लिए कैसे कोडगॉल्फिंग आवश्यकताओं का पालन करने के लिए कभी भी मन नहीं छोड़ता। आप हालांकि कुछ बाइट्स बचा सकते हैं। घातांक ऑपरेटर ^केवल एक ही है जिसे अनुक्रम उत्पन्न करते समय वेक्टर नहीं किया जाता है :जिसका अर्थ है कि आप इसका उपयोग कर सकते हैं जैसे 1:2^2कि प्राप्त करने के लिए 1 2 3 4। दूसरी बात यह है कि यदि आप परिभाषित a=b=1:n^2करते हैं कि आप बाद में for(j in b)लूप पर एक और वेक्टर को परिभाषित करने के बजाय उपयोग कर सकते हैं। आपको कुछ बाइट्स बचानी चाहिए।
— बिलीवोब
वास्तव में! धन्यवाद! ऑपरेटर वरीयता के सटीक क्रम को कभी भी याद नहीं रख सकते ...
— प्लाननापस
F (2) और f (3) में संख्याओं के बीच तीन स्थान और f (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

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";
}
— टाइटस
स्रोत
1
$a[$i]="";इसके बजाय unset($a[$i]);4 बाइट्स बचाना चाहिए
— Jörg Hülsermann
$i%$k<1!($i%$k)एक बाइट बचाने के बजाय
— Jörg Hülsermann
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.