13

ক্যালভিনের শখগুলি সাম্প্রতিক গুণিত সারণী চ্যালেঞ্জ দ্বারা অনুপ্রাণিত হয়েছে ।

কোনও ফাংশন বা প্রোগ্রাম লিখুন যা কোনও পূর্ণসংখ্যাকে Nইনপুট হিসাবে গ্রহণ করে এবং প্রিন্ট করে বা N-by-N অনন্য গুণিত সর্পিল দেয়। কোডটি অবশ্যই (তত্ত্বীয়ভাবে) N এর জন্য 0 এবং 1000 এর মধ্যে কাজ করবে (এটি আউটপুট করা শক্ত হতে পারে)। আউটপুট নিম্নলিখিত পদ্ধতি দ্বারা উত্পাদিত টেবিলের সমতুল্য হওয়া উচিত:

একটি এন-বাই-এন গুণক সারণী পূরণ করুন। যেমন এন = 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

— স্টিও গ্রিফিন
সূত্র

আমি আমার ছোট চোখের সাথে গুপ্তচরবৃত্তি করছি ইরোটোসনেসগুলির একটি পরিবর্তিত চালনী! আমি নিশ্চিত যে এখানে একটি প্যাটার্ন আপনি ব্যবহার করতে পারেন যা আমি কোথাও বা অন্য কোথাও দেখেছি।

— অ্যাডিসন ক্র্যাম্প

2

n=0যেখানে গুণনের টেবিলগুলিতে শূন্য নেই সেখানে কেন আউটপুট হবে । আমি বুঝতে পারি n=1আউটপুট 1 হবে, তবে কেন শূন্য অন্তর্ভুক্ত?

— টম কার্পেন্টার

@ টমকার্পেন্টার, এটি একটি খারাপ সিদ্ধান্ত হতে পারে, তবে আমি জানতাম যে "এন = 0 সম্পর্কে কী হবে?" - প্রশ্ন, তাই আমি এন = 0 -> 0 বিধি তৈরি করেছিলাম। পূর্ববর্তী অঞ্চলে, এন> 0 বলা ভাল হতে পারে তবে এখন অনেকটা দেরী হয়ে গেছে আমার ভয় হচ্ছে = /

— স্টিভি গ্রিফিন

2

@ স্টিভিগ্রিফিন আপনি বলেছেন যে আউটপুটটি অবশ্যই একটি এন-বাই-এন ম্যাট্রিক্স n=0হওয়া উচিত , সুতরাং আউটপুটটি 0-বাই-0 ম্যাট্রিক্স হওয়া উচিত, বা প্রশ্নটি বেমানান হবে।

— আলেফাল্ফা

3

জে, 22 বাইট

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

এটি 0-বাই-0 ম্যাট্রিক্সের জন্য আউটপুট দেয় n=0।

— alephalpha
সূত্র

8

গণিত 123 122 117 98 92 73 বাইট

২৪ বাইটের সাহায্যে লেজিওনম্যামাল ৯ion৮ এবং আলেফাল্ফার সাহায্যে আরও ১৯ জনকে ধন্যবাদ জানানো হয়েছে!

আশ্চর্যজনকভাবে, এই টেবিলটিতে, কোনও পুরো সংখ্যার একাধিক উদাহরণের 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, 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, 0, 64, 72, 80}, {0, 0, 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}

নিম্নলিখিত টেবিল হিসাবে দেখায়।

১৮ টির চূড়ান্ত 3 টি দৃষ্টান্ত 0 দিয়ে প্রতিস্থাপন করা দরকার large (আমরা একটি বড় গা bold় নীল রঙের জিরো ব্যবহার করব যাতে সেগুলিকে সহজেই চিহ্নিত করা যায়))

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

— DavidC
সূত্র

একটি না লেখার কোনও কারণ আছে Function?

— LegionMammal978

1

নেস্টেড খাঁটি ফাংশন নিয়ে আমার সমস্যা হচ্ছে, তবে এই পুনরাবৃত্তির এটির প্রয়োজন হয় না। ধন্যবাদ।

— ডেভিডসি

আমি নিউলাইনটি বাদ দিয়ে 117 বাইট গণনা করছি।

— লিজিয়নম্যামাল 978

এছাড়াও, আরও কিছু গল্ফ

— লিজিওনম্যামাল 978

আরও কিছু গল্ফ: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ᵠ
সূত্র

ইনপুট বাইট শেভের জন্য থ্যাঙ্কস @ ভ্যালুয়াহ

— CSᵠ

2

ম্যাটল্যাব, 96 88 87 86 79 বাইট

এটি by৯ বাইট কোড, যা উদাহরণস্বরূপ ফলাফলগুলি অনুসরণ করে (বিশেষত এন = ০ এর জন্য)

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 বাইট রয়েছে, এন = 0 ব্যতীত একই আচরণ রয়েছে যা প্রশ্নের জড়িত হিসাবে খালি অ্যারে তৈরি করবে (এন দ্বারা এন অ্যারে = 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- এগুলিকে বিশেষ চিকিত্সা দেওয়া হয় কারণ এগুলি দুটি হ'ল আমি অ্যারে তৈরির জন্য যে নিয়মটি ব্যবহার করছি তা অনুসরণ করে না - বাস্তবে অস্পষ্ট n=0ক্ষেত্রে না হলে এটি 5 বাইট সংক্ষিপ্ত হতে পারে ।

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 ম্যাটল্যাবের একটি শক্তিশালী বৈশিষ্ট্য হ'ল এটি কোনও বিশেষ পরিচালনা ছাড়াই অ্যারে বৃদ্ধি করতে পারে, তাই আমরা নতুন সারি এবং কলামটি কেবল যুক্ত করতে পারি সঙ্গে:
```
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]]

— ভাসু আদারী
সূত্র

অনন্য গুনে সর্পিল