24

একটি পূর্ণসংখ্যা দেওয়া এন ≥ 1, আউটপুট একটি 2 ডি উপস্থাপনা ^† প্রস্থের একটি শতাংশ সাইন এন । নির্মাণ নিম্নরূপ:

একটি তৈরি করুন এন দ্বারা এন ম্যাট্রিক্স (অথবা তালিকার তালিকা) শূণ্যসমূহ ভরা।
উপরের-বাম এবং নীচে-ডান কোণে সন্নিবেশ করুন।
নীচে-বাম থেকে উপরের ডানদিকে তির্যকটিতে রাখুন।

ইনপুট n = 4 এর জন্য, এই নির্মাণটি দেখতে পাবেন:

1. 4x4 matrix of 0s
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
2. 1s in TL and BR corners
1 0 0 0
0 0 0 0
0 0 0 0
0 0 0 1
3. 1s across BL-TR diagonal
1 0 0 1
0 0 1 0
0 1 0 0
1 0 0 1

এটি একটি কোড-গল্ফ , তাই বাইটের মধ্যে সংক্ষিপ্ততম প্রোগ্রামটি জিতে।

^† আমি 1s এবং 0 এর ম্যাট্রিক্স ব্যবহার করি তবে কোনও অ-শ্বেতস্থান অক্ষর এবং স্পেসগুলির স্ট্রিং ব্যবহার করাও এটি গ্রহণযোগ্য। সুতরাং, উপরের উদাহরণটি দেখতে পারে:

#  #
  # 
 #  
#  #

অথবা

#     #
    #
  # 
#     #

পরীক্ষার মামলা

n
output

1
1

2
1 1
1 1

3
1 0 1
0 1 0
1 0 1

4
1 0 0 1
0 0 1 0
0 1 0 0
1 0 0 1

10
1 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0 1

চূড়ান্ত নোট

একটি ব্যাখ্যা যোগ করা প্রশংসিত হবে।

code-golf ascii-art

— কনর ও ব্রায়ান
সূত্র

আমাদের সমাধানগুলি 0 সূচকযুক্ত হতে পারে?

— ক্রিটিকি লিথোস

5

পছন্দ করুন আপনি প্রস্থ গ্রহণ করছেন, কোনও সূচক নয়।

— কনর ও'ব্রায়ান

আমরা কি তালিকার একটি তালিকা আউটপুট করতে পারি?

— xnor

@ এক্সনর হ্যাঁ; তালিকাগুলির তালিকা এবং ম্যাট্রিক্স আমার পোস্টে সমার্থক। আমি এই প্রশ্নের সাথে যুক্ত করব

— কনার ও'ব্রায়ান

নোট করুন যে এটি '1'+'0'*(n-2)সাদা স্থান

— ক্যালকুলেটরফলাইন

8

জেলি , 6 বাইট

²Rm’Ṭs

এটি অনলাইন চেষ্টা করুন!

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

²Rm’Ṭs  Main link. Argument: n

²       Square; yield n².
 R      Range; yield [1, ..., n²].
   ’    Decrement; yield n-1.
  m     Modular; yield every (n-1)-th element of the range, staring with the first.
    Ṭ   Untruth; yield a Boolean array with 1's at the specified indices.
     s  Split the resulting array into chunks of length n, creating a matrix.

— ডেনিস
সূত্র

এছাড়াও, ²Ḷ%’¬sবা+þ%’=2

— ইটিএইচ প্রোডাকশনগুলি

²Ḷọ’sএত কাছে আছে ...

— ডেনিস

যদি কেবলমাত্র 1-বাইট থাকে তবে "x দ্বারা y" লিংকটি ...

— ETH প্রোডাকশন

@ এথ প্রডাকশনগুলি আছে ḍ@তবে এটি দুটি বাইট।

— এরিক আউটগল্ফার

এবং আমি ভেবেছিলাম যে আমি ⁼þµ+1¦Ṫṁ³UGডেনিস-এর কিছু ²সমাধান সমাধান না হওয়া পর্যন্ত ...

— এরিক দি আউটগল্ফার

11

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

n=>[...Array(n)].map((_,y,a)=>a.map(_=>y++%~-n<1|0))

— ETHproductions
সূত্র

7

ভী , 15 বাইট

Àé ÀÄ|r#L.|ò.kl

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

Àé<space>        " Argument times insert a space
ÀÄ               " Argument times duplicate this line
                 " This gives an arg-by-arg matrix of spaces
                 "  and brings the cursor to the end of the first line
|r#              " Go to the beginning of this line and replace the first character with #
L.               " Go to the end of this matrix (bottom-right corner) and replace that character with a #
|                " Go to the beginning of the last line
ò                " Recursively do:
 .               "  Repeat the last action, r#, replace the character under the cursor with #
 kl              "  Go 1 up and 1 right

— ক্রিটসি লিথোস
সূত্র

6

পাইথন 2 , 58 57 বাইট

n=input()
x='#'.ljust(n-1)*3
exec'print x[:n];x=x[1:];'*n

এটি অনলাইন চেষ্টা করুন!

— যষ্টি
সূত্র

5

জিএনইউ এপিএল, 17 15 বাইট

{1=⍵∨⍵⍵⍴1=⍳⍵-1}

এটি আজব দিন ... জিএনইউ আসলে ডায়ালগ এপিএলকে পরাজিত করেছে ... ওহো।

টিআইও জিএনইউ এপিএল সমর্থন করে না ...

ব্যাখ্যা (ইনপুটটি হ'ল ⍵):

1=⍳⍵-1 - 1 followed by ⍵-2 0's
⍵⍵⍴    - fit into a square
⍵∨     - gcd ⍵ (0 gcd n = n)
1=     - test each element for equality with 1

— Zachary
সূত্র

Ninja'd?

— ক্রিটসি লিথোস

ওখানে ... নিয়ে যাও।

— জাকারি

বিশ্বাস করতে পারি না যে আমাকে আসলে আমার পুরানো জিএনইউ এপিএলটি ছড়িয়ে দিতে হয়েছিল, বাহ!

— জাকারি

ও নিও !!

— জাকারি

ওহ, আমি এর কাছ থেকে অনুপ্রেরণা নেব 1=⍵∨এবং আমার সমাধানে এটি বাস্তবায়ন করতে যাচ্ছি

— ক্রিটসি লিথোস

5

পাইথন 2 , 46 বাইট

lambda n:zip(*[iter(`10L**n`[:-3]*-~n+'1')]*n)

এটি অনলাইন চেষ্টা করুন!

আউটপুট পছন্দ

[('1', '0', '0', '1'), ('0', '0', '1', '0'), ('0', '1', '0', '0'), ('1', '0', '0', '1')]

পাইথন 2 , 48 বাইট

lambda n:zip(*[iter([1]+(n*[0]+[1])[2:]*-~n)]*n)

এটি অনলাইন চেষ্টা করুন!

আউটপুট পছন্দ

[(1, 0, 0, 1), (0, 0, 1, 0), (0, 1, 0, 0), (1, 0, 0, 1)]

পাইথন 3 , 48 বাইট

lambda n:('%d'*n+'\n')*n%(1,*(*[0]*n,1)[2:]*-~n)

এটি অনলাইন চেষ্টা করুন!

পাইথন 3 এ একটি সম্পূর্ণ ভিন্ন স্ট্রিং-প্রতিস্থাপনের পদ্ধতি Out ফলাফলগুলি যেমন:

— xnor
সূত্র

আপনি করতে পারবেন না 10L 10?

— জাকারি

@ জ্যাচারý আমি সর্বদা Lশেষের দিকে সেখানে নির্ভর করছি যাতে আমি একই সংখ্যক অক্ষরকে বৃহত সংখ্যক এবং ক্ষুদ্রের শেষে কাটাতে পারি।

— xnor

ওহ, দুঃখিত, আমি ভুল করে ভেবেছিলাম আপনি কেবল এটি সংখ্যা হিসাবে ব্যবহার করছেন। আমি কখনই জানতাম না 10এবং 10Lআলাদা ছিলাম ।

— জাকারি

4

জেলি , 9 বাইট

=þ¹UF1Q¦s

এটি অনলাইন চেষ্টা করুন!

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

=þ¹UF1Q¦s  Main link. Argument: n

  ¹        Identity; yield n.
=þ         Equals table; compare each i in [1, ..., n] with each j in [1, ..., n].
           This yields the n×n identity matrix.
   U       Upend; reverse each row.
    F      Flatten the matrix.
       ¦   Sparse application:
      Q        Unique; yield the unique elements of the constructed array, i.e.,
               [1] if n = 1 and [0, 1] if n > 1.
     1         Yield 1.
           This replaces the elements at indices 0 (last) and 1 (first) with 1.
        s  Split the resulting array into chunks of length n.

— ডেনিস
সূত্র

4

এপিএল (ডায়ালগ) , 18 বাইট

{⍵=1:⍵⋄⍵ ⍵⍴1=⍳⍵-1}

এটি অনলাইন চেষ্টা করুন!

ইনপুট 1 এর জন্য এই কাজটি করাতে 6 বাইট যুক্ত হয়েছে।

টেস্টকেস 4 এ দেখছি, আমরা আউটপুটটি দেখতে পাচ্ছি

এটি ম্যাট্রিক্স জুড়ে মূলত 1 0 0 পুনরাবৃত্তি হয়। অন্য কথায়, 1 0 0 একটি 4-বাই -4 ম্যাট্রিক্স আকারে। সুতরাং এই সমাধানে, আমরা প্রথমে 1 এবং ট্রেলিং 0 এর সাহায্যে এই ভেক্টরটি তৈরি করি 1=⍳⍵-1এবং তারপরে এটি ব্যবহার করে আকার দেব ⍵ ⍵⍴। তবে ইনপুট 1 এর জন্য এই বর্কস, সুতরাং আমাদের শর্তসাপেক্ষ তৈরি করতে হবে এবং 6 বাইট বাড়ানো দরকার ...

{⍵=1:⍵⋄⍵ ⍵⍴1=⍳⍵-1}    The right argument is ⍵
 ⍵=1:⍵                 If ⍵ is 1 return itself
⋄                      Otherwise
 ⍳⍵-1                   Create a range 1 .. ⍵-1
 1=                     Equals 1; 1 0 0 {⍵-2 0's} ...
 ⍵ ⍵⍴                   Shape in a ⍵-by-⍵ matrix

— ক্রিটসি লিথোস
সূত্র

4

Haskell, , 55 বাইট

প্রথমে আমার পন্থাটি ছিল পুনরাবৃত্তভাবে ট্রান্সপোজড আইডেন্টিটি ম্যাট্রিক্স উত্পন্ন করার জন্য, তবে তারপরে প্রথম এবং শেষ লাইনটি ঠিক করার জন্য কিছু কুৎসিত / লম্বা মামলার পার্থক্য প্রয়োজন। সুতরাং আমি পরিচয় ম্যাট্রিক্স উত্পন্ন করার জন্য অন্য উপায়ের সন্ধান করলাম যা এই ধারণাটি পেয়েছিলাম ।

f n=[[sum[1|x+y`elem`[2,n+1,2*n]]|y<-[1..n]]|x<-[1..n]]

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

[[x+y|y<-[1..n]]|x<-[1..n]]

এই ম্যাট্রিক্স উত্পন্ন করে (এর জন্য n=4):

[2,3,4,5]
[3,4,5,6]
[4,5,6,7]
[5,6,7,8]

আপনি দেখতে পাচ্ছেন উপরের বাম উপাদানটি 2(সাধারণভাবে), সমস্ত তির্যক উপাদানগুলি 5(সাধারণভাবে n+1) এবং নীচের ডান উপাদানটি 8(সাধারণভাবে 2*n) হয়। সুতরাং আমাদের যা করতে হবে তা x+yহ'ল একটি উপাদান কিনা তা পরীক্ষা করা [2,n+1,2*n]।

— ბიმო
সূত্র

4

আর , 54 42 বাইট

-12 বাইট জারকো ডাবলডামকে ধন্যবাদ

n=scan();m=diag(n)[,n:1];m[1,1]=m[n,n]=1;m

একটি ম্যাট্রিক্স প্রদান; স্টাডিন থেকে পড়া। একটি পরিচয় ম্যাট্রিক্স তৈরি করে diag(n), এটিকে নীচে থেকে উপরে ফ্লিপ করে [,n:1], উপরের বাম এবং নীচে ডানদিকে সেট করে 1এবং তারপরে ''প্রস্থ সহ কনসোল ( ) এ লিখুন n।

এটি অনলাইন চেষ্টা করুন!

— : Giuseppe
সূত্র

আপনাকে একটি ম্যাট্রিক্স আউটপুট দেওয়ার অনুমতি দেওয়া হয়েছে, সুতরাং আপনি এটি কোনও ফাংশনে ( pryr::f) রূপান্তর করে কয়েকটি বাইট সংরক্ষণ করতে পারেন ।

— জেএডি

@ জারকো ডাবডেলডাম আমি পারতাম, তবে তারপরে আমার মনে হয় আমাকে ভাষাটি পরিবর্তন করতে হবে R+pryrযাতে আমি পৃথক ভাষা বিবেচনা করি; আপনি জমা দিতে নির্দ্বিধায়! তারপরে আপনি গাভী উত্তরটির উত্তরটি থেকে ধারণাটি ব্যবহার করতে পারেন যা আমার কাছে মনে হয় যে এই প্রসঙ্গে (1-লাইনার) এর চেয়ে আরও ছোট হবে।

— জিউসেপ

হুম, আমি নিশ্চিত নই যে সৎ হতে লাইনটি কোথায় আঁকতে হবে। আপনি কি কোনও লাইব্রেরিকে আলাদা ভাষা ব্যবহারের বিষয়টি বিবেচনা করবেন?

— জেএডি

1

এছাড়াও, function(n)সম্ভবত ব্যবহার সম্ভবত আরও খাটো হতে পারে

— জেএডি

1

: কোনটি oneliner বাস্তবায়ন আপনি রেফারেন্সড তুলনায় খাটোfunction(n)matrix(rep(c(1,rep(0,n-2)),n+1),n,n)

— JAD

4

এমএটিএল , 7 বাইট

XyPl5L(

এমএটিএল অনলাইন এ চেষ্টা করুন !

ব্যাখ্যা

পরিচয় ম্যাট্রিক্স ( Xy) তৈরি করুন , উল্লম্বভাবে ফ্লিপ করুন ( P), প্রথম এবং শেষ এন্ট্রিগুলিতে ( ) (মান 1 ( l) লিখুন 5L, যা উপরের বাম এবং নীচে ডানদিকে রয়েছে।

— লুইস মেন্ডো
সূত্র

4

ডায়ালগ এপিএল, 12 11 10 বাইট

,⍨⍴×,2↓⊢↑×

এটি অনলাইনে চেষ্টা করুন

-1 বাইট ধন্যবাদ lstefano।

কিভাবে?

,⍨⍴×,2↓⊢↑×
       ⊢↑× - argument-length extension of the sign of the argument (1)
     2↓    - Drop the first two elements
   ×,      - Prepend a one
,⍨⍴        - Shape into a square array with dimensions of input x input

— Zachary
সূত্র

আমি গুরুত্ব সহকারে ভাবি না যে এটি আর গল্ফ করা যেতে পারে ... বাহ!

— জাকারি

এটি করতে পারে: ,⍨⍴×,2↓⊢↑×(10 বাইট) আমি যুক্ত করতে

— প্ররোচিত

ARG 5 সাথে অনলাইনে চেষ্টা করুন - ARG 1 অনলাইনে পরখ করে দেখুন

— lstefano

তুমি আমাকে মজা করছ, বাহ! সাইনামের দুর্দান্ত অপব্যবহার।

— জাকারি

3

সি # (.নেট কোর) , 121 91 88 বাইট

-30 বাইট কারণ পুরানো উপায় বোকা ছিল।

ভেরিয়েবল ইনিশিয়ালেশনের চারদিকে ঘোরাফেরা করে -3 বাইট

n=>{int i=0,k=n-1;int[,]b=new int[n,n];b[0,0]=b[k,k]=1;for(;i<n;)b[i++,k--]=1;return b;}

এটি অনলাইন চেষ্টা করুন!

লুপগুলি 1 টি পূরণ করার জন্য অ্যারেটি পুনরাবৃত্তি করে। 1 এবং 0 এর একটি অ্যারে প্রদান করে।

— jkelm
সূত্র

ঘোষণা bযেমন varকিছু বাইট সংরক্ষণ করুন।

— TheLethalCoder

3

05 এ বি 1 ই , 14 11 7 বাইট

n<ÝI<Öô

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

n<Ý      # push range [0 ... n^2-1]
   I<Ö   # check each for equality to 0 when modulus with n-1 is taken
      ô  # split in pieces of size n

— Emigna
সূত্র

3

কাঠকয়লা , 14 12 7 বাইট

^{-5 বাইট ধন্যবাদ নীলকে !}

↗Ｎ⸿/‖Ｏ↘

এটি অনলাইন চেষ্টা করুন!

— notjagan
সূত্র

আমি মনে করি না যে এটি আরও খাটো হতে পারে ...

— এরিক দি আউটগল্ফার

1

ঠিক আছে, আগে আমি এটি ছাঁটাই Ｎν◨/ν←↙ν‖Ｏ↘, কিন্তু তারপর আমি সঙ্গে এসেছি ↗Ｎ⸿/‖Ｏ↘!

— নিল

@ নীল বাহ, আমি জানি না কী ⸿করে। এটি কি আসল অবস্থানে পুনরায় সেট হয়?

— notjagan

না, ⸿এর মতো ¶এটি এটি একটি সারি নিচে চলে যায় তবে এটি Ｊস্ট্রিংয়ের শুরুতে কলামের পরিবর্তে সর্বদা কলাম শূন্যে যায় (দ্বারা পরিমাপ করা হয় ), উদাহরণস্বরূপ Ｊ⁵¦⁵⸿একই Ｊ⁰¦⁶।

— নিল

3

সি ++, 144 বাইট

#include<string>
#define S std::string
S p(int n){S r;for(int i=0;i<n;++i){r+=S(n,32);r[r.size()-1-i]=35;r+=10;}r[0]=r[r.size()-2]=35;return r;}

এটি '#' এবং 35 এর মধ্যে একটি বাইট পার্থক্যের সুবিধা নেয়

— HatsuPointerKun
সূত্র

ঠিক কোথায় আপনার কোড মধ্যে এক বাইট পার্থক্য সুবিধা লাগবে '#'এবং 35?

— জাকারি

@ জাচারý মনে হচ্ছে এটি আমার আইডিই এক্সে ছিল)

— হাটসুপয়েন্টারকুন

2

গণিত, 72 বাইট

(s=Table[0,#,#];s[[1,1]]=s[[#,#]]=1;Table[s[[#+1-i,i]]=1,{i,#}];Grid@s)&

ইনপুট

[5]

আউটপুট

1 0 0 0 1
0 0 0 1
0 0 1 0 0
0 1 0 0 0
1 1 0 0 0 1

— J42161217
সূত্র

1

সমস্যা আপনাকে মুদ্রণ / প্রদর্শন করতে বলবে না, যাতে আপনি 5 বাইট সংরক্ষণ করার Grid@sসাথে প্রতিস্থাপন করতে পারেন s।

— মার্ক এস।

2

পাইথন 2 , 86 62 বাইট

n=input();a=('1'+'0'*(n-2))*2+'1'
exec'print a[:n];a=a[1:];'*n

এটি অনলাইন চেষ্টা করুন!

-২৪ বাইট: রডের একটি ধারণাকে ধন্যবাদ!

— কৈশোর রায়
সূত্র

2

পাওয়ারশেল , 67 বাইট

param($n)0..--$n|%{-join(("1"+"0"*(($n-1),0)[!$n])*3)[$_..($_+$n)]}

এটি অনলাইন চেষ্টা করুন!

$nথেকে ইনপুট নেয় এবং লুপ 0করে --$n(যেমন,$n প্রাক হ্রাস)। প্রতিটি পুনরাবৃত্তি, আমরা s এর 1পরে একটি স্ট্রিং তৈরি করি $n-1 0, তারপরে সেই আউটকে 3বহুবার (যেমন, 100010001000ইনপুট দেওয়ার জন্য 5)। তারপর আমরা একটি আবর্তিত ভিত্তিতে থেকে শুরু যে মধ্যে সূচক 0করতে 0 + $n। এই অক্ষরগুলি -joinএকটি স্ট্রিংয়ে সম্পাদিত হয় যা পাইপলাইনে রেখে যায়। আউটপুট অন্তর্ভুক্ত।

(এনবি - এর বিশেষ কেস পরিচালনা করতে অতিরিক্ত 9 বাইট প্রয়োজন requires n=1 । আমাদের গ্যারান্টিযুক্ত থাকলে 58-বাইট কোডের নীচে দেওয়া আছে n>1)

param($n)0..--$n|%{-join(("1"+"0"*($n-1))*3)[$_..($_+$n)]}

— AdmBorkBork
সূত্র

2

ডায়ালগ এপিএল ভি 16, 23 বাইট

{(1@(1 1)(⍵ ⍵))⌽∘.=⍨⍳⍵}

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা:

{(1@(1 1)(⍵ ⍵))⌽∘.=⍨⍳⍵} -(input ⍵) 
                ∘.=⍨⍳⍵  - identity matrix with size ⍵×⍵
               ⌽        - flip that
 (1@(1 1)(⍵ ⍵))         - place 1 into the corners using the v16 operator @ (At)

— Zachary
সূত্র

2

লুয়া, 117 বাইট

m=arg[1]+0 for y=m,1,-1 do s=""for x=1,m do s=s..((x==1 and y==m or x==m and y==1 or x==y)and"#"or" ")end print(s)end

চেষ্টা করে দেখুন

কোড বেশ সহজ। এটি প্রথম আর্গুমেন্টের সাথে মি সেট করে, তারপরে এটিকে একটি সংখ্যায় রূপান্তর করতে 0 যুক্ত করে, তারপরে এক্স কোর্ডের মাধ্যমে এগিয়ে ওয়াই কমর্ডের জন্য পিছনের দিকে পুনরাবৃত্তি করে এবং যদি এটি একটি = যদি x == y বা এটি অন্য কোণে রাখে।

এই প্রোগ্রামটি "যদি" কীওয়ার্ডটি কখনই ব্যবহার করে না।

— AI221
সূত্র

2

অক্টাভা, 37 বাইট

@(n)sparse([1 n:-1:1 n],[1 1:n n],!0)

এটি অনলাইন চেষ্টা করুন!

শতাংশ সাইন প্রতিনিধিত্ব করে একটি স্পারস ম্যাট্রিক্স উত্পন্ন করে।

— rahnema1
সূত্র

2

জাপট , 12 বাইট

²ovUÉ hT1 òU

একটি 2 ডি অ্যারে / ম্যাট্রিক্স প্রদান করে।

এটি অনলাইন চেষ্টা করুন! ব্যবহার করে-Qঅ্যারে-ফর্ম্যাট করা আউটপুট দেখানোর পতাকা ।

ব্যাখ্যা

²ovUÉ hT1 òU

অন্তর্ভুক্ত: U= ইনপুট পূর্ণসংখ্যা

²o

স্কোয়ার U( ²), অ্যারে [0, U*U)( o) তৈরি করুন এবং এর মাধ্যমে প্রতিটি আইটেম ম্যাপ করুন ...

vUÉ

1যদি এটি ( v) দ্বারা U-1( UÉ) দ্বারা বিভাজ্য হয় , অন্যথায় 0।

hT1

hসূচক 0 ( T) তে আইটেমটি ( ) সেট করুন 1।

òU

অ্যারের òদৈর্ঘ্যের টুকরা ( ) এ বিভক্ত করুন U।

— জাস্টিন মেরিনার
সূত্র

প্রযুক্তিগতভাবে ইতিমধ্যে প্রতিটি দ্বারা বিভাজ্য hT1হিসাবে আপনার আসলে প্রয়োজন বলে আমি মনে করি না । এটি ব্যতীত, দুর্দান্ত কাজ :-)0UU

— ইটিএইচ প্রোডাকশন

@ETH প্রোডাকশনস যা একটি ইনপুট নিয়ে কাজ করার জন্য যুক্ত করা হয়েছিল 1। এটি ছাড়া, এটি ফিরে আসে[[0]] কারণ আপাতদৃষ্টিতে শূন্যটি শূন্য দ্বারা বিভাজ্য নয়।

— জাস্টিন মেরিনার

আহ, এটা ডাং। আমার যদিও এটি ঠিক করা উচিত কিনা তা আমি জানি না ...

— ETH প্রোডাকশনস

2

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

for(;$i<$l*$l;)echo($i++%($l-1)?0:1).($i%$l?'':"\n");

ম্যাট্রিক্সের পাশের দৈর্ঘ্য $l । এই কোডটিতে একটি পিএইচপি বিজ্ঞপ্তি এবং এমনকি পিএইচপি সতর্কতা রয়েছে যখন 0 দ্বারা বিভাগের জন্য $l=0, কিন্তু কাজটি করে!

— jstnthms
সূত্র

দেখে মনে হচ্ছে আপনি ইনপুটটি পূর্বনির্ধারিত ভেরিয়েবল (-> $l) এ সঞ্চয় করবেন to দুর্ভাগ্যক্রমে এটি আমাদের গ্রহণযোগ্য উপায় ইনপুট নেওয়ার এক নয় । লিঙ্কযুক্ত মেটা পোস্টে আপনি বিকল্পগুলি খুঁজে পাবেন, উদাহরণস্বরূপ রিডডেসির উত্তরে দেখা যায় কমান্ড লাইন যুক্তি ব্যবহার করে ।

— নিমি

সম্পন্ন এবং গল্ফড: while($i**.5<$n=$argn)echo$i++%~-$n?0:1,"\n"[$i%$n];বা while($i**.5<$n=$argn)echo+!($i++%~-$n),"\n"[$i%$n];(প্রতিটি 52 বাইট)

— টাইটাস

প্রয়োজন <?শুরুতে।

— মনাসেখ্যাটজ-রিইনস্টেট মনিকা

2

পাইথন 2 , 93 বাইট

n=input()
a='1'+'0'*(n-2)+'1'
print a
for i in range(1,n-1):print str(10**i).zfill(n)
print a

এটি অনলাইন চেষ্টা করুন!

— রোহিত-পান্ডে
সূত্র

ভাল চেষ্টা করুন, তবে এন = 1 এর জন্য কাজ করে না।

— মিউ

2

রুবি, 47 বাইট

->n{([1]+[0]*(n-2)).cycle.each_slice(n).take n}

এটি অ্যারের একটি অ্যারে প্রদান করে।

কোডটি বেশ সোজা।

এটা একটা সৃষ্টি n-1সঙ্গে অ্যারের 1প্রথম উপাদান এবং বাকি ভরা যেমন0 গুলি (যেমন [1, 0, 0, 0])
এটি পুনরাবৃত্তি করে
লাগবে nn উপাদানের টুকরা

এটি অনলাইন চেষ্টা করুন!

— এরিক ডুমিনিল
সূত্র

2

জে, 14 বাইট

-]\*:$1,0$~-&2

Ungolfed:

- ]\ (*: $ (1,0 $~ -&2))

এটি অনলাইন চেষ্টা করুন!

— দুর্ভাগ্যআনয়নকারী
সূত্র

চিন্তার জন্য খাদ্য: একটি 10 বাইট সমাধান রয়েছে :)

— কনর ও'ব্রায়ান

@ কনরও'ব্রায়েন আপনাকে অভিশাপ দেবে। এটি ইতিমধ্যে এখানে সকাল 3 টা

— জোনাহ

এখানে একই, এবং আমরা এখানে: ডি

— কনর

1

@ কনরও'ব্রায়েন কি ছিল 0=<:|i.@,~?

— মাইল

@ মাইলস হ্যাঁ, এটি ছিল :)

— কনর ও'ব্রায়ান

2

পাইথন 3, 97 বাইট

def f(n):
    m=[[0+(j==n-i-1)for j in range(n)]for i in range(n)]
    m[0][0]=1
    m[-1]=m[0]
    return m

ব্যাখ্যা

m=[[0+(j==n-i-1)for j in range(n)]for i in range(n)]

এটি একটি তালিকা বোধগম্যতা, এটি 0+(j==n-i-1)একটি অন্তর্নিহিত রূপান্তর j==n-i-1করার একটি ছোট উপায় ( intফাংশনের বিপরীতে ) এবং তারপরে m[-1]=m[0]নীচে ডান 1 তৈরির চেয়ে ছোট, কারণ উপরের এবং নীচের সারিগুলি অভিন্ন।

— করণ এলঙ্গোভান
সূত্র

2

চতুর্থ, 273 (কোনও মন্তব্য ছাড়াই) 170 (গল্ফড-ইশ)

: % 2 base ! cr dup 1- 1 swap lshift 1 or . cr 2 over 2 - dup 0< 0= if
0 ?do 2dup s>d rot <# 0 ?do # loop #> type cr 2*  loop
1 or . else drop drop then cr drop decimal ;

(মন্তব্য করা সংস্করণটি স্পষ্ট করতে 273 সংস্করণ:)

: newbase
 base @ swap base ! ;
: 0u.r
 swap s>d rot <# 0 ?do # loop #> type ;
: frame
 1- 1 swap lshift 1 or ;
: %
 2 newbase swap
 cr dup frame . cr
 2 over 2 -
 dup 0< 0= if
  0 ?do
   2dup swap 0u.r cr
   2* 
  loop
  1 or .
 else
  drop drop
 then
cr
drop base ! ;

(দ্রষ্টব্য, যেহেতু ফোরস্পেস স্পেস প্রাথমিক সীমানা হিসাবে ফোর, প্রতিটি গাড়ীর রিটার্ন অপসারণ কোনও পার্থক্য করতে পারে না Ind

(মন্তব্য করেছেন):

( Uses bit array, max 64 width on AMD64 with gforth. )

( Could shave an extra thirty or so bytes by not restoring )
( the numeric base, )
( and a few more by pulling frame and 0u.r into the definition. )

: newbase ( n -- oldbase )  ( swap base with n )
 base @ swap base ! ;

: 0u.r ( u width -- )  ( unsigned numeric output, no leading zero suppression )
 swap s>d rot <# 0 ?do # loop #> type ;

: frame ( n -- f )  ( frame )
 1- 1 swap lshift 1 or ;

: %  ( n -- )  ( Make the % sign )
 2 newbase swap ( Use binary output. )
 cr dup frame . cr ( Frame the first line. )
 2 over 2 -
 dup 0< 0= if ( Are we already done? )
  0 ?do ( Loop doesn't do the first or last. )
   2dup swap 0u.r cr ( Zero fill, right justify. )
   2* 
  loop
  1 or . ( Put the second frame out. )
 else
  drop drop
 then
cr
drop base ! ;

(ফাঁসির উদাহরণ:)

1 % 
1 

 ok
2 % 
11 
11 
 ok
3 % 
101 
010
101 
 ok
10 % 
1000000001 
0000000010
0000000100
0000001000
0000010000
0000100000
0001000000
0010000000
0100000000
1000000001 
 ok
40 % 
1000000000000000000000000000000000000001 
0000000000000000000000000000000000000010
0000000000000000000000000000000000000100
0000000000000000000000000000000000001000
0000000000000000000000000000000000010000
0000000000000000000000000000000000100000
0000000000000000000000000000000001000000
0000000000000000000000000000000010000000
0000000000000000000000000000000100000000
0000000000000000000000000000001000000000
0000000000000000000000000000010000000000
0000000000000000000000000000100000000000
0000000000000000000000000001000000000000
0000000000000000000000000010000000000000
0000000000000000000000000100000000000000
0000000000000000000000001000000000000000
0000000000000000000000010000000000000000
0000000000000000000000100000000000000000
0000000000000000000001000000000000000000
0000000000000000000010000000000000000000
0000000000000000000100000000000000000000
0000000000000000001000000000000000000000
0000000000000000010000000000000000000000
0000000000000000100000000000000000000000
0000000000000001000000000000000000000000
0000000000000010000000000000000000000000
0000000000000100000000000000000000000000
0000000000001000000000000000000000000000
0000000000010000000000000000000000000000
0000000000100000000000000000000000000000
0000000001000000000000000000000000000000
0000000010000000000000000000000000000000
0000000100000000000000000000000000000000
0000001000000000000000000000000000000000
0000010000000000000000000000000000000000
0000100000000000000000000000000000000000
0001000000000000000000000000000000000000
0010000000000000000000000000000000000000
0100000000000000000000000000000000000000
1000000000000000000000000000000000000001 
 ok

(চূড়ান্ত দ্রষ্টব্য: ফোর্স ইন্টারপ্রেটারের বিট প্রস্থের তুলনায় একটারও কম কাজ করে g আমি উপরেরটি গফার্থে, এএমডি ran ran এ চালিয়েছি An একটি প্রাচীন ১ 16-বিট ফোর্থ কেবল 15 বিট প্রস্থে যাবে, এবং কিছুটা সংশোধন করার প্রয়োজন হবে))

— জোল রিস
সূত্র

আপনি যদি নিজের উত্তরে মন্তব্য কোড রাখতে চান তবে তা ঠিক আছে তবে আপনার কোথাও গল্ফড ডাউন কোডও দরকার।

— পাভেল

ধন্যবাদ ফিনিক্স সম্পন্ন.

— জোয়েল রিস

2

সি # (.নেট কোর) , 65 বাইট

w=>{var l=new int[w*w];for(int i=0;i<w*w;i+=w-1)l[i]=1;return l;}

এটি অনলাইন চেষ্টা করুন!

অ্যালগোরিদম অন্যান্য সি # উত্তর থেকে উল্লেখযোগ্যভাবে পৃথক, তাই আমি উন্নতি হিসাবে পরিবর্তে আলাদাভাবে পোস্ট করার সিদ্ধান্ত নিয়েছি। শীর্ষে রেট দেওয়া জেলি উত্তরটি দ্বারা অনুপ্রাণিত হয়ে আমি আগে কিছুটা কম কমপ্যাক্ট করছি something আউটপুটটি একটি রৈখিক অ্যারে, সুতরাং এটি পদ্ধতির বাইরে 2D-তে আবৃত করতে কিছু যুক্তি প্রয়োজন। সত্যিকারের 2 ডি অ্যারে হিসাবে আউটপুট দিতে বিকল্প সংস্করণের 6 টি অতিরিক্ত বাইট প্রয়োজন:

w=>{var l=new int[w,w];for(int i=0;i<w*w;i+=w-1)l[i/w,i%w]=1;return l;}

আমার কাছে একটি আকর্ষণীয় অ-প্রতিযোগিতামূলক সংস্করণও রয়েছে।

using System.Linq;w=>new int[w*w].Select((_,i)=>i%(w-1)<1)

এটি প্রায় সঠিক আউটপুট দিয়ে শেষ হয়, ফলস্বরূপ IEnumerable<bool>1/0 এর পরিবর্তে সত্য / মিথ্যা দিয়ে তৈরি হয় এবং এটি 2D কাঠামোর পরিবর্তে লিনিয়ার, এবং যদিও কোডটির সঠিক লাইনের using System.Collections.Genericপ্রয়োজন হয় না , তবে প্রয়োজনীয় কিছু করতে প্রয়োজনীয় আউটপুট। আমি যেমন বলেছি, এটি বৈধ হওয়ার খুব কাছাকাছি তবে বেশ নয়।

— কামিল দ্রাকারী
সূত্র

দ্বিতীয়টির জন্য ?1:0কাজ হিসাবে যেমন একটি ত্রৈমাসিক ব্যবহার করে এবং আমি বিশ্বাস করি যে ফলাফলের একটি অ্যারেটি ঠিক হওয়া উচিত। সংগ্রহগুলিও ব্যবহার করে এই কোডটির প্রয়োজন হয় না।

— TheLethalCoder

প্রথমটির জন্য, w*wকোনও পরিবর্তনশীলকে সেট করা এবং intঘোষণাকে লুপের বাইরে নিয়ে যাওয়া আপনার কোনও কিছু বাঁচাতে পারে?

— TheLethalCoder

@ দ্য লেথলকোডার w*wএকক অক্ষর ভেরিয়েবলের দুটি উদাহরণ প্রতিস্থাপন করে 4 টি বাইট সাশ্রয় int i=0করে লুপের বাইরে চলতে একটি সেমিকোলন প্রয়োজন যার দাম 1 বাইট, এবং পরে ,s=w*wঘোষণায় 6 বাইট লাগবে, সুতরাং এটি নেট +3 বাইট জাল করে।

— কামিল দ্রাকারী

আপনার সম্পূর্ণ 2D- উপস্থাপন সমাধানের বাইট গণনাটি ব্যবহার করা উচিত। সংক্ষিপ্ত সমাধান দ্বারা ফিরে আসা অ্যারেটি কমপক্ষে বৈধ হওয়ার জন্য কিছু প্রকার ডিলিমিটার অন্তর্ভুক্ত করতে হবে।

— জাকব

শতাংশ সাইন তৈরি করুন

পরীক্ষার মামলা

চূড়ান্ত নোট

জেলি , 6 বাইট

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

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

ভী , 15 বাইট

ব্যাখ্যা

পাইথন 2 , 58 57 বাইট

জিএনইউ এপিএল, 17 15 বাইট

পাইথন 2 , 46 বাইট

পাইথন 2 , 48 বাইট

পাইথন 3 , 48 বাইট

জেলি , 9 বাইট

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

এপিএল (ডায়ালগ) , 18 বাইট

Haskell, , 55 বাইট

ব্যাখ্যা

আর , 54 42 বাইট

এমএটিএল , 7 বাইট

ব্যাখ্যা

ডায়ালগ এপিএল, 12 11 10 বাইট

কিভাবে?

সি # (.নেট কোর) , 121 91 88 বাইট

05 এ বি 1 ই , 14 11 7 বাইট

কাঠকয়লা , 14 12 7 বাইট

সি ++, 144 বাইট

গণিত, 72 বাইট

পাইথন 2 , 86 62 বাইট

পাওয়ারশেল , 67 বাইট

ডায়ালগ এপিএল ভি 16, 23 বাইট

লুয়া, 117 বাইট

অক্টাভা, 37 বাইট

জাপট , 12 বাইট

ব্যাখ্যা

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

পাইথন 2 , 93 বাইট

রুবি, 47 বাইট

জে, 14 বাইট

পাইথন 3, 97 বাইট

ব্যাখ্যা

চতুর্থ, 273 (কোনও মন্তব্য ছাড়াই) 170 (গল্ফড-ইশ)

(মন্তব্য করা সংস্করণটি স্পষ্ট করতে 273 সংস্করণ:)

(মন্তব্য করেছেন):

(ফাঁসির উদাহরণ:)

সি # (.নেট কোর) , 65 বাইট