এই অ্যারেটিকে ম্যাট্রিক্সে পরিণত করুন

Question

ইনপুট হিসাবে একটি অ-নেস্টেড অ্যারে নিন। নিম্নলিখিত পদ্ধতিটি ব্যবহার করে এটিকে ম্যাট্রিক্সে পরিণত করুন:

যাক আমার অ্যারে হয় [1, 2, 3, 4, 5]

প্রথমত, আমি সেই অ্যারেটি 5 বার পুনরাবৃত্তি করি: (দৈর্ঘ্য)

[[1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5]]

তারপরে, আমি এটিটি তির্যকগুলি সহ পড়েছিলাম:

[[1],
 [2, 1],
 [3, 2, 1],
 [4, 3, 2, 1],
 [5, 4, 3, 2, 1],
 [5, 4, 3, 2],
 [5, 4, 3],
 [5, 4],
 [5]]

আমি এই অ্যারে সমতল করে এটিকে পাঁচটি (দৈর্ঘ্যের) টুকরো টুকরো করে বিভক্ত করেছি:

[[1, 2, 1, 3, 2],
 [1, 4, 3, 2, 1],
 [5, 4, 3, 2, 1],
 [5, 4, 3, 2, 5],
 [4, 3, 5, 4, 5]]

এটি কোড গল্ফ। সবচেয়ে কম বাইট জেতা

Comments

পরের বার, দয়া করে জিনিসগুলি বড় করুন।

— অলিভার নি

মূল অ্যারেটির দৈর্ঘ্য 5 ব্যতীত এটি কীভাবে কাজ করবে?

@ আইস ৫২৩ আমি এটি একই জিনিস ধরে নিচ্ছি, আপনি কেবল 'পাঁচ'টি দৈর্ঘ্যের সাথে প্রতিস্থাপন করুন

— অলিভার নি

আমরা কি সবসময় ধনাত্মক পূর্ণসংখ্যা হিসাবে ধরে নিতে পারি?

— লুইস মেন্ডো

@ জনসেনা আপনার প্রথম উত্তরটি গ্রহণ করা উচিত নয়, আপনার পোস্টটি ট্রেশন এবং কিছু উত্তর পেতে কিছুটা সময় দেওয়া উচিত।

— কেডে

Answer 1

05 এ বি 1 ই, 13 বাইট

.p¹.sR¦«í˜¹gä

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

ব্যাখ্যা:

                # Implicit input
 .p             # Get prefixes
   ¹            # Get first input
    .s          # Get suffixes
      R         # Reverse
       ¦        # Remove first element
        «       # Concatenate
         í      # Reverse every one
          ˜     # Flatten
           ¹gä  # Split into pieces of the length
                # Implicit print

Comments

আপনার এটি মুদ্রণের দরকার নেই

এবং কীভাবে আপনি

এইসব গল্ফিং ল্যাঙ্গুয়েজগুলির অনেকগুলি, যেমন 05AB1E, ইনপুট অনুরোধ এবং আউটপুট উত্পাদন করার জন্য ডিফল্ট নিয়ম তৈরি করেছে, যাতে প্রোগ্রামারকে তাদের উপরের বাইটগুলি নষ্ট করতে না হয়।

আউটপুট সত্যিই পছন্দসই আউটপুটটির সাথে মেলে না। এটি কোনও ম্যাট্রিক্স নয় এবং সংখ্যাগুলি মেলে না।

— কার্ল নেপ্ফ

ঠিক আছে, এটি একটি ম্যাট্রিক্স, তবে সংখ্যাগুলি সঠিক নয় (বা ট্রাইটিনলাইন ডট কম গণনা করে)

— কার্ল নেপফ

Answer 2

জেলি , 11 বাইট

WẋLŒDUṙLFsL

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

ব্যাখ্যা

               Input: array z
WẋL            length(z) copies of z
   ŒD          Diagonals (starting with main diagonal)
     U         Reverse each
      ṙL       Rotate left length(z) places
               (now the top-left diagonal is in front)
        F      Flatten
         sL    Split into chunks of size length(z)

Comments

হুম যখন আমি এটি Lব্যবহার করে দেখতে গিয়েছিলাম এমন অদ্ভুত জিনিস ছিল, তাই আমি নিবন্ধকটি ব্যবহার করেছি: / আমি কেবল এটি আবার চেষ্টা করেছি এবং এটি কাজ করে ... মূলত একই তাই আমার ধারণা আমি কেবল আমার সরিয়ে ফেলব।

— জোনাথন অ্যালান

অবশ্যই জেলির "ডায়াগোনাল" অন্তর্নির্মিত রয়েছে .... :)

— গ্রেগ মার্টিন

Answer 3

পাইথন 2, 105 96 বাইট

-1 এবং -4 এবং -4 বাইট Flp.Tkc ধন্যবাদ

a=input()
n=len(a)
L,M=[],[]
for i in range(n):L+=a[i::-1];M+=a[:i:-1]
print zip(*[iter(L+M)]*n)

লুপ জন্য আইটেম যোগ করা বর্ণনাতে, বাস্তব জাদু জিপ যা থেকে ঘটে মত এখানে

Comments

স্প্যামের জন্য দুঃখিত, তবে এখন আর কেবল একবার ব্যবহার করা হয়েছে, আপনি কেবল এটি সরাসরি রাখতে পারেন: পি

— ফ্লিপট্যাক

@ Flp.Tkc কোনও সমস্যা নেই, আমি খুশি :)

— কার্ল ন্যাপফ

Answer 4

জাভাস্ক্রিপ্ট (ES6) 100 101 105

a=>eval("for(u=r=[],i=l=a.length;i+l;i--)for(j=l;j--;v&&((u%=l)||r.push(s=[]),s[u++]=v))v=a[j-i];r")

কম গল্ফড

a => {
  u = 0
  for(r=[], i=l=a.length; i+l>0; i--)
    for(j=l; j--; )
    {
      v = a[j-i]
      if (v) 
      {
        u %= l
        if (u==0) r.push(s=[])
        s[u++] = v
      }
    }
  return r
}

পরীক্ষা

F=
a=>eval("for(u=r=[],i=l=a.length;i+l;i--)for(j=l;j--;v&&((u%=l)||r.push(s=[]),s[u++]=v))v=a[j-i];r")

function update() {
  var a=I.value.match(/\d+/g)
  if (a) {
    var r=F(a)
    O.textContent = r.join`\n`
  }
}

update()

<input id=I value='1 2 3 4 5' oninput='update()'>
<pre id=O></pre>

Comments

বাহ, এটি এড়ানোর খুব চালাক উপায় return। ES6 টিপ থ্রেডে আপনার এটি সম্পর্কে একটি টিপ পোস্ট করা উচিত।

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

@ ইথ প্রডাকশনগুলির এটির খুব সরু সুযোগ রয়েছে। বেশিরভাগ সময়, ইওল ভাল হয়।

— edc65

@ ইথ প্রডাকশনগুলি এই মুহূর্তে evalআরও ভাল :(

— edc65

@ এথ প্রডাকশনগুলি আমি টিপটি পোস্ট করেছি, এমনকি যদি এটি খুব কমই কার্যকর হয় তবে, ক্ষেত্রে

— edc65

Answer 5

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

!Gg*tRwZRhPXzGne!

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

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

নিম্নলিখিত ব্যাখ্যাটি [1 2 3 4 5]উদাহরণ হিসাবে ইনপুট ব্যবহার করে । অন্তর্বর্তী ফলাফল দেখার জন্য, %কোডের কোনও বিবৃতি দেওয়ার পরে commentোকান (মন্তব্য প্রতীক)।

দ্রষ্টব্য যে ;ম্যাট্রিক্সের জন্য সারি বিভাজক। সুতরাং [1 2]একটি সারি ভেক্টর, [1; 2]একটি কলাম ভেক্টর এবং [1 0; 0 1]এটি 2 × 2 পরিচয় ম্যাট্রিক্স।

!     % Implicitly input a row vector. Transpose. Gives a column vector
      % STACK: [1; 2; 3; 4; 5]
Gg    % Push input with all (nonzero) values replaced by ones
      % STACK: [1; 2; 3; 4; 5], [1 1 1 1 1]
*     % Multiply, with broadcast. Gives a square matrix
      % STACK: [1 1 1 1 1;
                2 2 2 2 2;
                3 3 3 3 3;
                4 4 4 4 4;
                5 5 5 5 5]
tR    % Duplicate. Upper triangular part
      % STACK: [1 1 1 1 1;
                2 2 2 2 2;
                3 3 3 3 3;
                4 4 4 4 4;
                5 5 5 5 5],
               [1 1 1 1 1
                0 2 2 2 2;
                0 0 3 3 3;
                0 0 0 4 4;
                0 0 0 0 5]
wZR   % Swap. Lower triangular part, below main diagonal 
      % STACK: [1 1 1 1 1;
                0 2 2 2 2;
                0 0 3 3 3;
                0 0 0 4 4;
                0 0 0 0 5],
               [0 0 0 0 0;
                2 0 0 0 0;
                3 3 0 0 0;
                4 4 4 0 0;
                5 5 5 5 0]
h     % Concatenate horizontally
      % STACK: [1 1 1 1 1 0 0 0 0 0;
                0 2 2 2 2 2 0 0 0 0;
                0 0 3 3 3 3 3 0 0 0;
                0 0 0 4 4 4 4 4 0 0;
                0 0 0 0 5 5 5 5 5 0]
P     % Flip vertically
      % STACK: [0 0 0 0 5 5 5 5 5 0;
                0 0 0 4 4 4 4 4 0 0;
                0 0 3 3 3 3 3 0 0 0;
                0 2 2 2 2 2 0 0 0 0;
                1 1 1 1 1 0 0 0 0 0]
Xz    % Column vector of nonzeros, taken in column-major order
      % STACK: [1;2;1;3;2;1;4;3;2;1;5;4;3;2;1;5;4;3;2;5;4;3;5;4;5]
Gne   % Reshape into a matrix with as many rows as input size
      % STACK: [1 1 5 5 4;
                2 4 4 4 3;
                1 3 3 3 5;
                3 2 2 2 4;
                2 1 1 5 5]
 !    % Transpose. Implicitly display
      % STACK: [1 2 1 3 2;
                1 4 3 2 1;
                5 4 3 2 1;
                5 4 3 2 5;
                4 3 5 4 5]

Answer 6

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

a=>a.map(_=>b.splice(0,a.length),b=[].concat(...a.map((_,i)=>a.slice(~i)),...a.map((_,i)=>a.slice(0,~i))).reverse())

ঠিক আছে, এটি একটি শুরু ...

Answer 7

আর, 84 বাইট

t(matrix(unlist(split(m<-t(matrix(rev(x<-scan()),l<-sum(1|x),l)),row(m)-col(m))),l))

স্টিডিন এবং আউটপুটগুলি থেকে ইনপুট পড়ে / একটি আর-ম্যাট্রিক্স দেয়।

reversed_x <- rev(x<-scan())                # Read input from stdin and reverse
m <- t(matrix(reversed_x,l<-sum(1|x),l))    # Repeat and fit into matrix
diag_list <- split(m,row(m)-col(m))         # Split into ragged list of diagonals
t(matrix(unlist(diag_list),l))              # Flatten and transform back to matrix

ব্যাখ্যা

এই উত্তরটির সর্বাধিক আকর্ষণীয় দিকটি হ'ল কীভাবে তির্যকগুলি পুনরুদ্ধার করা হয়। সাধারণভাবে কোনও অবজেক্টটি splitফাংশনটি ব্যবহার করে বিভক্ত হতে পারে যদি এমন কোনও বস্তু সরবরাহ করা হয় যার উপর উপাদানকে বিভক্ত করা হয়। এই কারণগুলি তৈরি করতে আমরা ব্যবহার করতে পারি colএবং rowযা যথাক্রমে কলাম এবং সারি সূচকগুলি সহ একটি ম্যাট্রিক্স প্রদান করে। পার্থক্যগুলি গ্রহণ করে: row(m)-col(m)আমরা একটি ম্যাট্রিক্স পেয়েছি:

     [,1] [,2] [,3] [,4] [,5]
[1,]    0   -1   -2   -3   -4
[2,]    1    0   -1   -2   -3
[3,]    2    1    0   -1   -2
[4,]    3    2    1    0   -1
[5,]    4    3    2    1    0

যাতে প্রতিটি তির্যক স্বতন্ত্রভাবে চিহ্নিত করা হয়। আমরা এখন এই ম্যাট্রিক্সের উপর ভিত্তি করে বিভক্ত করতে পারি এবং এটিকে প্রয়োগ করে এটিকে একটি র‌্যাগড তালিকায় পরিণত করতে পারি split:

$`-4`
[1] 1
$`-3`
[1] 2 1 
$`-2`
[1] 3 2 1
$`-1`
[1] 4 3 2 1
$`0`
[1] 5 4 3 2 1
$`1`
[1] 5 4 3 2
$`2`
[1] 5 4 3
$`3`
[1] 5 4
$`4`
[1] 5

(প্রতিটি ভেক্টরের নাম উপরের ম্যাট্রিক্সের তির্যক মানের সাথে কীভাবে মিল রয়েছে তা নোট করুন)।

শেষ পদক্ষেপটি কেবল সমতল এবং এটিকে ফর্মের ম্যাট্রিক্সে পরিণত করা:

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    2    1    3    2
[2,]    1    4    3    2    1
[3,]    5    4    3    2    1
[4,]    5    4    3    2    5
[5,]    4    3    5    4    5

Answer 8

গণিত 93 বাইট

Partition[Flatten[Table[If[i>n,#[[n;;(i-n+1);;-1]],#[[i;;1;;-1]]],{i,1,2(n=Length@#)-1}]],n]&

আমি এখানে এই কোডটি কীভাবে লিখব (109 বাইট):

Partition[Reverse@Flatten[Table[Reverse@Diagonal[ConstantArray[Reverse@#,n],k],{k,-(n=Length@#)+1,n-1}]],n]&

ক্রমবর্ধমান ইনপুট ভেক্টরের কারণে এই ম্যাট্রিক্স প্লটটি কাঠামো থেকে একটি ভাল ধারণা দেয়।

এখানে এলোমেলো ইনপুট ভেক্টর সহ ম্যাট্রিক্স প্লট। স্পষ্টতই কিছু কাঠামো এখনও বিদ্যমান।

Answer 9

গণিত, 92 বাইট

n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&;{Most@r[#~n~Rest],#~n~Most}~ArrayReshape~{l,l}&

একটি যুক্তিযুক্ত তালিকা হিসাবে এটি যুক্তিযুক্ত হিসাবে ফাংশন। এই জাতীয় কোনও কার্যক্রমে অন্য কাঠামো থাকতে পারে তবে আশা করি আমি এই কাঠামোটি বেশ ভালভাবে গল্ফ করেছি ...

প্রথম অংশটি দুটি আর্গুমেন্টের n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&একটি ফাংশন সংজ্ঞায়িত করে n: প্রথমটি দৈর্ঘ্যের একটি তালিকা l, এবং দ্বিতীয়টি তালিকাগুলিতে প্রয়োগ করার জন্য একটি ফাংশন। বিপরীত যুক্তির তালিকায় nসেই ফাংশনের l-1সময় প্রয়োগ করে, ফলাফলটি তার আউটপুট তালিকার সমস্ত ফলাফল সংরক্ষণ করে। (সংজ্ঞা দেওয়া rএবং lপথে কেবল গল্ফ করা ing)

nমূল তালিকায় দু'বার বলা হয়, একবার ফাংশনটি থাকার সাথে Rest(তালিকার প্রথম উপাদানটি ড্রপ করুন) এবং একবার ফাংশনটি দিয়ে Most(শেষ উপাদানটি ফেলে দিন)। এটি সমস্ত পছন্দসই সাবলিস্ট তৈরি করে, তবে পুরো তালিকাটি সেখানে দু'বার রয়েছে (অতএব অতিরিক্ত Most) এবং প্রথমার্ধটি পিছনের ক্রমে সেখানে রয়েছে (সুতরাং r[...])। শেষ ~ArrayReshape~{l,l}অবধি, বর্তমান তালিকার কাঠামোটি ভুলে যায় এবং এটিকে একটি lএক্স lঅ্যারে হিসাবে জোর করে ।

Answer 10

গণিত, 85 বাইট

আক্ষরিকভাবে প্রস্তাবিত পদক্ষেপগুলি সম্পাদন করা:

(l=Length@#;Partition[Flatten@Table[Reverse@Diagonal[Table[#,l],i],{i,-l+1,l-1}],l])&

আমার অন্ত্রে বলছেন যে Partএই খাটোটি করার জন্য একটি চতুর উপায় থাকা উচিত , তবে আমি যতটা চেষ্টা করেছি তা 85 বাইটের চেয়ে দীর্ঘ হয়েছে।

Answer 11

রুবি (১১০ বাইট)

n=a.size
b=[*(0...n)]
b.product(b).group_by{|i,j|i+j}.flat_map{|_,f|f.sort.map{|i,j|a[i][j]}}.each_slice(n).to_a
  #=> [[1, 2, 1, 3, 2],
  #    [1, 4, 3, 2, 1],
  #    [5, 4, 3, 2, 1],
  #    [5, 4, 3, 2, 5],
  #    [4, 3, 5, 4, 5]]

sortঅপারেশন প্রয়োজন হতে পারে না, কিন্তু গণনীয় # group_by জন্য ডক হ্যাশ মান মূল্যবোধের ক্রম (যা অ্যারে হয়) নিশ্চয়তা দেয় না, কিন্তু রুবি বর্তমান সংস্করণ ক্রম এক আশা এবং ক্রম আমি প্রয়োজন হবে sortছিল আমার কোড থেকে সরানো হয়েছে।

নিম্নরূপ পদক্ষেপ।

n=a.size 
  #=> 5 
b=[*(0...n)]
  #=> [0, 1, 2, 3, 4] 
c = b.product(b)
  #=> [[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [1, 0], [1, 1], [1, 2], [1, 3],
  #    [1, 4], [2, 0], [2, 1], [2, 2], [2, 3], [2, 4], [3, 0], [3, 1], [3, 2],
  #    [3, 3], [3, 4], [4, 0], [4, 1], [4, 2], [4, 3], [4, 4]] 
d=c.group_by{|i,j|i+j}
  #=> {0=>[[0, 0]],
  #    1=>[[0, 1], [1, 0]],
  #    2=>[[0, 2], [1, 1], [2, 0]],
  #    3=>[[0, 3], [1, 2], [2, 1], [3, 0]],
  #    4=>[[0, 4], [1, 3], [2, 2], [3, 1], [4, 0]],
  #    5=>[[1, 4], [2, 3], [3, 2], [4, 1]],
  #    6=>[[2, 4], [3, 3], [4, 2]],
  #    7=>[[3, 4], [4, 3]],
  #    8=>[[4, 4]]} 
e=d.flat_map{|_,f|f.sort.map{|i,j|a[i][j]}}
  #=> [1, 2, 1, 3, 2, 1, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 5, 4, 3, 5, 4, 5] 
f=e.each_slice(n)
  #=> #<Enumerator: [1, 2, 1, 3, 2, 1, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2,
  #                  5, 4, 3, 5, 4, 5]:each_slice(5)>

শেষ অবধি, f.to_aপূর্বে দেখানো অ্যারে প্রদান করে।