13

यह केल्विन के शौक से हाल ही में गुणा तालिका चुनौती से प्रेरित है ।

एक फ़ंक्शन या प्रोग्राम लिखें जो एक पूर्णांक Nको इनपुट और प्रिंट के रूप में लेता है या एक एन-बाय-एन अद्वितीय गुणन सर्पिल देता है। कोड को 0 और 1000 के बीच N के लिए (सिद्धांत रूप में) काम करना होगा (हालांकि इसका उत्पादन कठिन हो सकता है)। आउटपुट निम्न प्रक्रिया द्वारा उत्पादित तालिका के बराबर होना चाहिए:

एन-बाय-एन गुणन तालिका भरें। उदाहरण के लिए N = 3:
```
1 2 3
2 4 6
3 6 9
```
ऊपरी बाएँ कोने से एक सर्पिल दक्षिणावर्त का पालन करें, उन संख्याओं पर ध्यान दें जो आप यात्रा करते हैं। जब आप एक नंबर पर जाते हैं जो आपने पहले से ही देखा है, तो इसे 0 से बदल दें।

कुछ उदाहरण इसे और अधिक स्पष्ट कर सकते हैं:

n = 0:
0

n = 1:
1

n = 2:       //   Spiral order:
1  2         //   1  2
0  4         //   4  3

n = 3:
1  2  3      //   1  2  3
0  4  6      //   8  9  4
0  0  9      //   7  6  5

n = 4:
1  2  3  4   //   1   2   3   4
0  0  6  8   //  12  13  14   5
0  0  9 12   //  11  16  15   6
0  0  0 16   //  10   9   8   7

n = 5:
1   2   3   4   5
0   0   6   8  10
0   0   9  12  15
0   0   0  16  20
0   0   0   0  25

n = 10:
1   2   3   4   5   6   7   8   9  10
0   0   0   0   0  12  14  16  18  20
0   0   0   0  15   0  21  24  27  30
0   0   0   0   0   0  28  32  36  40
0   0   0   0  25   0  35   0  45  50
0   0   0   0   0   0  42  48  54  60
0   0   0   0   0   0  49  56  63  70
0   0   0   0   0   0   0  64  72  80
0   0   0   0   0   0   0   0  81  90
0   0   0   0   0   0   0   0   0 100

नंबर इस तरह पाए जाते हैं:

कोई भी उचित आउटपुट प्रारूप स्वीकार किया जाता है, लेकिन यह एक एन-बाय-एन मैट्रिक्स होना चाहिए, यह सिर्फ एक सूची नहीं हो सकती है। नीचे दिए गए ऐसे प्रारूप को स्वीकार कर लिया जाता है, क्योंकि एन आसानी से 1-बाय-एन कॉलम या एन-बाय-1 नंबर के रूप में अलग-अलग होते हैं:

[[1 2 3][0 4 6][0 0 9]]   <-- OK

[[1 0 0][2 4 0][3 6 9]]   <-- OK

ans =                     <-- OK
    1  2  3
    0  4  6
    0  0  9

बाइट्स में सबसे छोटा कोड जीत जाता है।

code-golf number arithmetic

— स्टीवी ग्रिफिन
स्रोत

मैं अपनी छोटी आँख से eratosthenes की एक संशोधित चलनी की जासूसी करता हूँ! मुझे पूरा यकीन है कि एक पैटर्न है जिसे आप यहाँ इस्तेमाल कर सकते हैं जो मैंने कहीं और देखा है।

— Addison Crump

2

n=0जहां गुणन सारणी में शून्य नहीं है, वहां उत्पादन क्यों होगा । मैं समझ सकता हूं n=1कि आउटपुट 1 होगा, लेकिन शून्य क्यों शामिल है?

— टॉम कारपेंटर

@TomCarpenter, यह एक बुरा निर्णय हो सकता है, लेकिन मुझे पता था कि "N = 0 के बारे में क्या होगा?" - सवाल, इसलिए मैंने N = 0 -> 0 नियम बनाया। रेट्रोस्पेक्ट में, यह कहना बेहतर होगा कि N> 0, लेकिन अब थोड़ा बहुत देर हो चुकी है मुझे डर लग रहा है = /

— Stewie Griffin

2

@StewieGriffin आपने कहा था कि आउटपुट N-by-N मैट्रिक्स n=0होना चाहिए , इसलिए आउटपुट के लिए 0-by-0 मैट्रिक्स होना चाहिए, या प्रश्न असंगत होगा।

— एलेफाल्फा

3

जे, 22 बाइट्स

,~$[:(*~:)[:,1*/~@:+i.

यह 0-बाय-0 मैट्रिक्स के लिए आउटपुट देता है n=0।

— alephalpha
स्रोत

8

मैथेमेटिका 123 122 117 98 92 73 बाइट्स

24 बाइट्स के साथ लेगियनममाल 978 और एक और 19 को एलेफाल्फा द्वारा धन्यवाद बचाया गया!

हैरानी की बात यह है कि इस तालिका में, किसी भी संख्या के कई उदाहरणों में nसर्पिल में समान सापेक्ष क्रम होगा जैसा कि वे तालिका में करते हैं! किसी संख्या की पहली उपस्थिति nबहुत सेल पर होती है, जहां वह संख्या तालिका में पहले दिखाई देती है (जब कोई तालिका पंक्ति द्वारा पंक्ति में भरती है)। इसका मतलब है कि दृष्टिकोण सर्पिल बाधा को पूरी तरह से अनदेखा कर सकता है, क्योंकि इसका परिणाम पर कोई असर नहीं पड़ता है। (नीचे स्पष्टीकरण देखें।)

ReplacePart[t=1##&~Array~{#,#},Join@@(Rest[t~Position~#]&/@Union@@t)->0]&

उदाहरण

ReplacePart[t=1##&~Array~{#,#},Join@@(Rest[t~Position~#]&/@Union@@t)->0]&[10]

{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {0, 0, 0, 0, 0, 12, 14, 16, 18, 20}, {0, 0, 0 0, 0, 15, 0, 21, 24, 27, 30}, {0, 0, 0, 0, 0, 0, 28, 32, 36, 40}, {0, 0, 0, 25, 25 0, 35, 0, 45, 50}, {0, 0, 0, 0, 0, 0, 42, 48, 54, 60}, {0, 0, 0, 0, 0, 49, 56, 63, 70}, {0, 0, 0, 0, 0, 0, 64, 72, 72, 80}, {0, 0, 0, 0, 0, 0, 81, 90}, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 100}}

Grid[%]

व्याख्या

हम इस तथ्य का फायदा उठाते हैं कि किसी भी अंक, n के पदों का सर्पिल-क्रम, फ़ंक्शन द्वारा लौटाए गए पंक्ति-कॉल स्थितियों के क्रम के समान है Positions,!

प्रत्येक संख्या की पहली घटना का स्थान (चाहे सर्पिल या तालिका स्थिति द्वारा एक आदेश) द्वारा वापस लौटाया गया पहला तत्व होगा Position। यह पहली घटना सेल के रूप में यह छोड़ दिया जाएगा। संख्या के शेष उदाहरणों को 0 से बदल दिया जाता है।

आइए देखें कि यह कैसे काम करता है, के मामले की जांच करना n==18। गुणन तालिका के साथ शुरू करने के लिए विचार है:

(t = Table[k Range@#, {k, #}] &[10]) // Grid

और प्रत्येक नंबर की पंक्ति-कॉल स्थिति का पता लगाएं। उदाहरण के लिए, 18 पंक्ति 2, कर्नल 9 (पहला उदाहरण) में स्थित है; पंक्ति 3, कर्नल 6; पंक्ति 6, कर्नल 3; और पंक्ति 9, कर्नल 2. ये संबंधित सर्पिल-क्रम के पद {44, 58, 68, 82} हैं।

Position[t, 18]

{{2, 9}, {3, 6}, {6, 3}, {9, 2}}

निम्न तालिका से पता चलता है।

18 के अंतिम 3 उदाहरणों को 0. द्वारा प्रतिस्थापित करने की आवश्यकता है (हम एक बड़े बोल्ड नीले शून्य का उपयोग करेंगे ताकि उन्हें आसानी से देखा जा सके।)

ReplacePart[%, {{3, 6}, {6, 3}, {9, 2}} -> Style[0, {Blue, Bold, 16}]]// Grid

— DavidC
स्रोत

क्या लिखने का कारण नहीं है Function?

— लेजिओनमाला 978

1

मुझे नेस्टेड शुद्ध कार्यों से परेशानी हो रही थी, लेकिन इस पुनरावृत्ति की आवश्यकता नहीं है। धन्यवाद।

— 21

मैं newline को छोड़कर 117 बाइट्स गिनता हूं।

— लीजनमॉमल

इसके अलावा, कुछ और

— गोल्‍फ

कुछ और ReplacePart[t=1##&~Array~{#,#},Join@@(Rest[t~Position~#]&/@Union@@t)->0]&

— गोल्फ

2

पायथन, 99 95 90 89 87 81 बाइट्स

गोल्फ कोड:

n=range(1,input()+1);m=[]
for x in n:l=[(x*y,0)[x*y in m]for y in n];m+=l;print l

Ungolfed:

n=range(1,input()+1);
m=[]
for x in n:
  l=[(x*y,0)[x*y in m]for y in n];
  m+=l;
  print l

आउटपुट:

10 
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
[0, 0, 0, 0, 0, 12, 14, 16, 18, 20]
[0, 0, 0, 0, 15, 0, 21, 24, 27, 30] 
[0, 0, 0, 0, 0, 0, 28, 32, 36, 40]
[0, 0, 0, 0, 25, 0, 35, 0, 45, 50] 
[0, 0, 0, 0, 0, 0, 42, 48, 54, 60]
[0, 0, 0, 0, 0, 0, 49, 56, 63, 70] 
[0, 0, 0, 0, 0, 0, 0, 64, 72, 80]
[0, 0, 0, 0, 0, 0, 0, 0, 81, 90] 
[0, 0, 0, 0, 0, 0, 0, 0, 0, 100]

— CSᵠ
स्रोत

इनपुट बाइट शेव के लिए thanx @valuah

— CS

2

MATLAB, 96 88 87 86 79 बाइट्स

यह 79 बाइट कोड है, जो उदाहरण के आउटपुट (n = 0 के लिए विशेष रूप से) का अनुसरण करता है

n=input('');m=+(n>0);for i=1:n;a=i*(1:i);for j=a;m(m==j)=0;end;m(1:i,i)=a;end;m

यह एक 75 बाइट्स है, n = 0 को छोड़कर एक ही व्यवहार है जो प्रश्न के निहितार्थ के अनुसार एक खाली सरणी का उत्पादन करेगा (N सरणी = 0 द्वारा 0 = खाली सरणी)।

n=input('');m=[];for i=1:n;a=i*(1:i);for j=a;m(m==j)=0;end;m(1:i,i)=a;end;m

यह ऑक्टेव के साथ भी काम करता है । आप इसे यहाँ ऑनलाइन आज़मा सकते हैं । कोड पहले से ही 'multspiral.m' नामक फ़ाइल के रूप में जोड़ा गया है। इसलिए ओक्टेव प्रॉम्प्ट पर, टाइप करें multspiralऔर एंटर दबाएं। आपको तब तालिका का आकार दर्ज करना चाहिए (उदाहरण 4)। इसके बाद आउटपुट प्रिंट किया जाएगा।

यह कैसे काम करता है?

पहले यह आवश्यक के रूप में एक इनपुट नंबर लेता है (जैसे 6, 4, आदि)

n=input('');

फिर हम मामलों को संभालते हैं n=0और n=1- इन्हें विशेष उपचार दिया जाता है क्योंकि वे दो हैं जो नियम का पालन नहीं कर रहे हैं मैं सरणियों के लिए उपयोग कर रहा हूं - वास्तव में यह 5 बाइट्स कम हो सकता है यदि अस्पष्ट n=0मामले के लिए नहीं ।

m=+(n>0);

तब के सभी मूल्यों के लिए n>2, हम कुछ लूपिंग करते हैं जब तक कि मैट्रिक्स सही आकार में न हो जाए।

for i=2:n;

वास्तव में nऔर n+1सभी के बीच केवल तीन सरल अंतर हैं n>=2। य़े हैं:

एक नया कॉलम उस सरणी में सबसे दाईं ओर जोड़ा जाता है जिसमें संख्याएँ होती हैं n(1:n)। इसके साथ आसानी से गणना की जाती है:
```
 a=i*(1:i);
```
जो भी तत्व उस नए कॉलम में जोड़े जाएंगे उन्हें मौजूदा मैट्रिक्स (शून्य पर सेट) से हटा दिया जाना चाहिए क्योंकि वे हमेशा नए कॉलम की तुलना में सर्पिल में आएंगे। यह वर्तमान मैट्रिक्स में सभी तत्वों को सेट करने के लिए लूप के लिए एक नेस्टेड का उपयोग करके निकाला जाता है जो नए कॉलम में शून्य हैं।
```
for j=a;
    m(m==j)=0;
end;
```
एक नई पंक्ति सबसे नीचे है, जिसके लिए हर तत्व को छोड़कर जो नए कॉलम में है वह शून्य होगा। जब नया कॉलम जोड़ा गया, क्योंकि सीमा सूचकांकों के जानबूझकर बनाए जाने के कारण 0. स्वचालित रूप से गद्देदार हो जाते हैं। MATLAB की मजबूत विशेषताओं में से एक यह है कि यह बिना किसी विशेष हैंडलिंग के सरणियों को बढ़ा सकता है, इसलिए हम नई पंक्ति और कॉलम को आसानी से जोड़ सकते हैं साथ में:
```
m(1:i,i)=a;
```

अंत में हमारे पास लूप के लिए अंत है - जो एक बार पहुंच जाता है, मैट्रिक्स mमें हमारा आउटपुट होता है। जैसा कि आप अपने आउटपुट प्रारूप के साथ लचीले हैं, मैट्रिक्स को mअर्धविराम के बिना बस एक नई रेखा के रूप में दिखाया गया है

end;
m

एक उदाहरण के रूप में, यदि हम प्रोग्राम चलाते हैं, तो संख्या 10 दर्ज करें, हमें निम्न आउटपुट मिलते हैं:

m =
     1     2     3     4     5     6     7     8     9    10
     0     0     0     0     0    12    14    16    18    20
     0     0     0     0    15     0    21    24    27    30
     0     0     0     0     0     0    28    32    36    40
     0     0     0     0    25     0    35     0    45    50
     0     0     0     0     0     0    42    48    54    60
     0     0     0     0     0     0    49    56    63    70
     0     0     0     0     0     0     0    64    72    80
     0     0     0     0     0     0     0     0    81    90
     0     0     0     0     0     0     0     0     0   100

— टॉम बढ़ई
स्रोत

1

हास्केल, 103 99 बाइट्स

import Data.Lists
f 0=[[0]]
f n=chunksOf n$foldr(\c d->c:replace[c][0]d)[][a*b|a<-[1..n],b<-[1..n]]

प्रयोग उदाहरण: f 4-> [[1,2,3,4],[0,0,6,8],[0,0,9,12],[0,0,0,16]]।

मैंने अभी-अभी Data.Listsमॉड्यूल की खोज की है जिसमें सूचियों (जैसे replace) और फिर से निर्यात पर अच्छे कार्य हैं Data.List, Data.List.Splitऔर Data.List.Extras।

— nimi
स्रोत

1

रूबी, 67 63 61 बाइट्स

->n{s,x=1..n,{};s.map{|c|s.map{|r|x[v=c*r]==1?0:(x[v]=1;v)}}}

63 बाइट्स

->n{s,x=1..n,{};s.map{|c|s.map{|r|e=x[v=c*r]==1?0:v;x[v]=1;e}}}

67 बाइट्स

->n{s,x=1..n,[];s.map{|c|s.map{|r|e=x.include?(v=c*r)?0:v;x<<v;e}}}

उपयोग:

->n{s,x=1..n,{};s.map{|c|s.map{|r|x[v=c*r]==1?0:(x[v]=1;v)}}}[10]
=> [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [0, 0, 0, 0, 0, 12, 14, 16, 18, 20], [0, 0, 0, 0, 15, 0, 21, 24, 27, 30], [0, 0, 0, 0, 0, 0, 28, 32, 36, 40], [0, 0, 0, 0, 25, 0, 35, 0, 45, 50], [0, 0, 0, 0, 0, 0, 42, 48, 54, 60], [0, 0, 0, 0, 0, 0, 49, 56, 63, 70], [0, 0, 0, 0, 0, 0, 0, 64, 72, 80], [0, 0, 0, 0, 0, 0, 0, 0, 81, 90], [0, 0, 0, 0, 0, 0, 0, 0, 0, 100]]

— वासु अडारी
स्रोत