ম্যাট্রিকের তালিকার জন্য আমার স্বরলিপি ঠিক করুন, অংশ 1

Question

কখনও কখনও, আমার কোডে ধ্রুব ম্যাট্রিকের তালিকা রয়েছে:

[ [[1, 0],
   [0, 1]],

  [[1, 0],
   [0,-1]],

  [[0, 1],
   [1, 0]],

  [[0,-1],
   [1, 0]] ]

এটি পর্দার রিয়েল এস্টেটের এক ভয়ানক ব্যবহার। আমি বরং এগুলি একে অপরের পাশে লিখতাম:

[   [[1, 0],    [[1, 0],    [[0, 1],    [[0,-1],
     [0, 1]],    [0,-1]],    [1, 0]],    [1, 0]]   ]

আপনি দেখতে পাবেন এটি এখনও একটি সিনট্যাক্টিক্যালি বৈধ নেস্টেড তালিকা, এটি এখন আর আয়তক্ষেত্রাকার নয় এবং এর খুব আলাদা কাঠামো রয়েছে (বিশেষত, প্রতিবার আমি 1x1 এর চেয়ে বড় ম্যাট্রিক্স যুক্ত করলে এটি আরও গভীর হয়)। তবে এই নতুন তালিকা থেকে ম্যাট্রিকের প্রাথমিক তালিকাটি পুনর্গঠন করা এখনও সম্ভব।

ভবিষ্যতে আমি এই বাক্য গঠনটি ব্যবহার করতে পারি, আমার আপনার কিছু কোড লিখতে হবে যা অনুভূমিক বিন্যাসে লিখিত ছিল এমন অ্যারেগুলিকে রূপান্তর করে যা তারা প্রতিনিধিত্ব করে ম্যাট্রিকের তালিকায়।

উত্স কোডের লেআউটে উত্তরগুলি 2 ডি প্যাটার্নের সাথে মেলে না তা নিশ্চিত করার জন্য, ইনপুটটি কেবল অ্যারে অবজেক্ট হিসাবে দেওয়া হবে, বা যদি আপনি কোনও স্ট্রিং উপস্থাপনা গ্রহণ করেন তবে এটিতে কোনও স্পেসস্পেস থাকবে না তা নির্দেশ করে আক্ষরিক কোড লেখা ছিল। সুতরাং আপনি কিছু ইনপুট পেতে চাই:

[[[1, 0], [[1, 0], [[0, 1], [[0,-1], [0, 1]], [0,-1]], [1, 0]], [1, 0]]]

এবং আউটপুটটি নিম্নলিখিত অ্যারে বা তার স্ট্রিং প্রতিনিধিত্ব হওয়া উচিত (আবার কোনও আর বিন্যাসের প্রয়োজন নেই):

[[[1, 0], [0, 1]], [[1, 0], [0,-1]], [[0, 1], [1, 0]], [[0,-1], [1, 0]]]

এটি দ্বি-অংশ চ্যালেঞ্জের প্রথম এবং সহজ অংশ। এটির মধ্যে, আপনি ধরে নিতে পারেন যে সমস্ত ম্যাট্রিকগুলি বর্গক্ষেত্রযুক্ত এবং একই মাত্রা রয়েছে এবং সেগুলি একে অপরের পাশে যথাযথভাবে সংযুক্ত রয়েছে। দ্বিতীয় অংশে আমরা এই অনুমানগুলি শিথিল করব।

বিধি

ইনপুটটি নেস্টেড তালিকা বা এর ক্যানোনিকাল স্ট্রিং উপস্থাপনা (আপনার পছন্দের ভাষায়) হবে এবং ফলাফলটি আপনাকে একই ফর্ম্যাটে আউটপুট করা উচিত। ফলাফলটিতে সর্বদা কমপক্ষে একটি ম্যাট্রিক্স থাকবে এবং ম্যাট্রিকগুলি 1x1 এর মতো ছোট হতে পারে। ম্যাট্রিকগুলিতে কেবল 128 এর চেয়ে কম মান সহ পূর্ণ (স্বাক্ষরিত) পূর্ণসংখ্যা থাকবে।

আপনি কোনও প্রোগ্রাম বা একটি ফাংশন লিখতে পারেন এবং ইনপুট গ্রহণ এবং আউটপুট সরবরাহের মানক পদ্ধতিগুলির কোনও ব্যবহার করতে পারেন ।

আপনি যে কোনও প্রোগ্রামিং ভাষা ব্যবহার করতে পারেন তবে নোট করুন যে এই ফাঁকগুলি ডিফল্টরূপে নিষিদ্ধ করা হয়েছে।

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

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

প্রতিটি পরীক্ষা কেস একটি আছে) তালিকা ম্যাট্রিক্স পরবর্তী প্রতিটি অন্যান্য চমত্কারভাবে পরিপূর্ণ হিসাবে তারা কোডে হবে (এই হল না আপনার ইনপুট), খ) বিদেশী হোয়াইটস্পেস ছাড়া অবিন্যস্ত তালিকা ( এই আপনার ইনপুট হয়), গ) প্রত্যাশিত আউটপুট

Pretty: [ [[0]] ]
Input:  [[[0]]]
Output: [[[0]]]

Pretty: [  [[-1]],  [[0]],  [[1]]  ]
Input:  [[[-1]],[[0]],[[1]]]
Output: [[[-1]],[[0]],[[1]]]

Pretty: [  [[1, 0],   [[1, 0],   [[0, 1],   [[0,-1],
            [0, 1]],   [0,-1]],   [1, 0]],   [1, 0]]  ]
Input:  [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]]
Output: [[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]

Pretty: [  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
            [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
            [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]
Input:  [[[1,0,0],[[127,63,31],[[1,0,0],[[0,0,0],[0,1,0],[15,0,-15],[0,0,1],[0,0,0],[0,0,1]],[-31,-63,-127]],[0,1,0]],[0,0,0]]]
Output: [[[1,0,0],[0,1,0],[0,0,1]],[[127,63,31],[15,0,-15],[-31,-63,-127]],[[1,0,0],[0,0,1],[0,1,0]],[[0,0,0],[0,0,0],[0,0,0]]]

Comments

আমি মনে করি আমি বুঝতে পারি এই চ্যালেঞ্জটি কী অনুপ্রাণিত করেছিল ...

— নীল

কি [([1, 0], [0, 1]), ([1, 0], [0, -1]), ([0, 1], [1, 0]), ([0, -1], [1, 0])]তৃতীয় testcase জন্য বৈধ আউটপুট? এটি মিশ্র তালিকা এবং টুপল।

— ovs

@ ওভস না, দুঃখিত। যেহেতু ইনপুট এবং আউটপুট ফর্ম্যাটটি মিলবে, তাই সম্পর্কিত ইনপুটটি হবে [([1,0], ([1, 0}, ...এবং এটি আপনাকে অতিরিক্ত তথ্য দেবে।

— মার্টিন এন্ডার

@ নীল কী এই চ্যালেঞ্জকে অনুপ্রাণিত করেছে?

— ইয়ার

@RandomUser সব বিষয় গল্ফ করার ইচ্ছা। স্বল্প পরিমাণে পর্দার রিয়েল এস্টেট জয়!

— ডেনিস

Answer 1

জেলি , 20 15 13 11 বাইট

Fðs⁹œsZµḢḢL

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

পটভূমি

বেশিরভাগ জিনিসের মতো, একবার আপনি কী করতে হবে তা ভেবে দেখার পরে এই চ্যালেঞ্জটি বরং সহজ। এবং আমি অবশেষে তিনটি মোছা এবং একটি রোলব্যাকের পরে ...

প্রথমত, আমাদের অবশ্যই ম্যাট্রিকগুলির মাত্রাগুলি বের করতে হবে। এটি বলার চেয়ে সহজ করা হয়েছে: প্রথম উপাদানটির প্রথম উপাদানটি প্রথম আউটপুট ম্যাট্রিক্সের প্রথম সারি হয়, সুতরাং এর দৈর্ঘ্য বর্গাকার আউটপুট ম্যাট্রিক্সের কলামের সংখ্যার সমান।

উদাহরণস্বরূপ, যদি ইনপুট হয়

[  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
    [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
    [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]

প্রথম উপাদানটির প্রথম উপাদানটি [1, 0, 0], যার দৈর্ঘ্য ℓ = 3 ।

আমরা যদি ইনপুটটি সমতল করি এবং এটিকে দৈর্ঘ্যের খণ্ডে বিভক্ত করি তবে আমরা ভুল ক্রমে হলেও আউটপুট ম্যাট্রিক্সের সমস্ত সারি পাই। আমাদের উদাহরণ ইনপুট জন্য, এটি দেয়

[  [1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0],
   [0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0],
   [0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]  ]

চূড়ান্ত আউটপুট পেতে, আমাদের প্রথমে সারি অ্যারেটিকে equal সমান দৈর্ঘ্যের খণ্ডে বিভক্ত করতে হবে । আমাদের উদাহরণ ইনপুট জন্য, এটি দেয়

[ [[1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0]],
  [[0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0]],
  [[0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]] ]

প্রতিটি কলাম এখন আউটপুট ম্যাট্রিকগুলির মধ্যে একটি, সুতরাং ফলাফলের ম্যাট্রিক্সের অ্যারেগুলি স্থানান্তর করা যা করা বাকি রয়েছে। আমাদের উদাহরণ ইনপুট জন্য, যে দেয়

[
 [[1, 0, 0],
  [0, 1, 0],
  [0, 0, 1]],

 [[127,  63,   31],
  [ 15,   0,  -15],
  [-31, -63, -127]],

 [[1, 0, 0],
  [0, 0, 1],
  [0, 1, 0]],

 [[0, 0, 0],
  [0, 0, 0],
  [0, 0, 0]]
]

পছন্দসই হিসাবে

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

Fðs⁹œsZµḢḢL  Monadic link. Argument: A (ragged array)


F            Monadic chain. Argument: A

F            Flatten A. This yields the vector V.


       µḢḢL  Monadic chain. Argument: A

        Ḣ    Head; retrieve the first element of A.
         Ḣ   Head; retrieve the first element of the first element of A.
          L  Compute ℓ, the length of the resulting array.


 ðs⁹œsZ      Dyadic chain. Left argument: V. Right argument: ℓ

  s⁹         Split V into chunks of length ℓ.
    œs       Split the result into ℓ chunks of equal length.
      Z      Zip/transpose the result.

Answer 2

পাইথ , 12 বাইট

CcJlhhQc.nQJ

এটি আমার জেলি উত্তর একটি বন্দর।

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

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

পাইথ প্রোগ্রামটি নিম্নোক্তভাবে পার্স করে (সিউডো কোড)।

C(c(J = l(h(h(Q))), c(.n(Q), J)))

কিউ একটি পরিবর্তনশীল যা ইনপুট ধারণ করে। জে একটি অনির্ধারিত পরিবর্তনশীল।

প্রথম J = l(h(h(Q)))প্রধান দোকানে মাথা (প্রথম উপাদান) দৈর্ঘ্য প্রশ্ন মধ্যে জে ।

তারপরে, কিউকে.n(Q) সমতল করে এবং ফলকে J দৈর্ঘ্যের টুকরো টুকরো করে ।c(..., J)

এরপরে, জে টুকরোতে c(J, ...)ফলাফলটি বিভক্ত করে ।

অবশেষে, C(...)ফলাফলটি স্থানান্তর করে।

Comments

অর্ন্তা ম্যাটার দেই

— লিকি নুন

Answer 3

পাইথ , 29 বাইট

.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

পরীক্ষা স্যুট.

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

.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

              z        input
             :      3  split at matches of the following regex
               "\B,"   /\B,/
            J          store at J
           U           [1,2,...,len(J)]

                           J  J
                        @R1   take the second character of each
                              substring in J
                     x\[      indices of all occurrences of "["

          -   filter away the elements in ^ from the
              elements in ^^ to find the first substring
              which does not start with "[["
         h    the first element
              note: this will generate an error if
              all substrings start with "[[", e.g. in the
              first example. We will deal with the error later.
       cJ     split J in groups of the specified length
      C       transpose                             ^
     s        flatten                               |
  j\,         join with ","                         |
.x            if the above code generated an error (|), return
              the following instead:
                            z      the input

অ্যালগরিদম

আসুন ইনপুটটিতে কাজ করি [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]]।

আমরা এখানে খাঁটি স্ট্রিং অপারেশন ব্যবহার করব।

প্রথমত, আমরা কমাগুলিতে ইনপুটটি বিভক্ত করি যা গভীরতম তালিকার অংশ নয় (এটি রেজেক্সে বিভাজন দ্বারা সম্পন্ন হয়) \B, ):

[[[1,0]
[[1,0]
[[0,1]
[[0,-1]
[0,1]]
[0,-1]]
[1,0]]
[1,0]]]

তারপরে, আমরা প্রথম সাবস্ট্রিংয়ের সূচকটি পাই যা দিয়ে শুরু হয় না [[(এটি সূচীতে অক্ষরটি কিনা তা পরীক্ষা করে করা হয় 1)[ )। এই ক্ষেত্রে, এটি হ'ল 4, কারণ সূচক 4 এ স্ট্রিংগুলি [0,1]]যা শুরু হয় না [[।

তারপরে, আমরা সাবস্ট্রিংগুলি 4 টি গ্রুপে গ্রুপ করব এবং তারপরে ট্রান্সপোজ করব:

[[[1,0]
[0,1]]
[[1,0]
[0,-1]]
[[0,1]
[1,0]]
[[0,-1]
[1,0]]]

এবং তারপরে আমরা তাদের সাথে কমাতে যোগ দেব:

[[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]

Comments

আপনি ডেনিস দ্বারা সবেমাত্র ছড়িয়ে পড়েছিলেন ।

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

Answer 4

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

f=(a,n=1)=>a[0][n]?a[0][n][0][0]?f(a,n+1,a[0].splice(n,1,...a[0][n])):n>1?[...Array(n)].map((_,i)=>a[0].filter((_,j)=>j%n==i)):a:a

চারটি মামলা রয়েছে:

• একটি 1 × n অ্যারে, যা সবেমাত্র ফিরে এসেছে (এটি প্রথম পরীক্ষা, তবে বিপরীত)
• একটি এম × n অ্যারে যা এখনও সমতল হয়নি, যা আমরা nএকই সাথে গণনা করে এক ধাপে পুনরাবৃত্তভাবে চ্যাপ্টা করি ।
• একটি এম × n অ্যারে যা সমতল করা হয়েছে, যেখানে আমরা প্রতিটি nতম উপাদানকে ফিল্টার আউট করি ।
• একটি এম × 1 অ্যারে, যা সবেমাত্র ফিরে এসেছে

Answer 5

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

ডেনিসের উত্তর একটি বন্দর । কোড:

¬¬g¹˜sô¬gäø

সিপি -1222 এনকোডিং ব্যবহার করে । এটি অনলাইন চেষ্টা করুন!

Answer 6

গণিত, 104 বাইট

l=Length;(m=l@#[[1,1]];n=l@Flatten@#/m;Table[Partition[#~ArrayReshape~{n,m},n/m][[j,i]],{i,n/m},{j,m}])&

ইনপুট

{{{1, 0}, {{1, 0}, {{0, 1}, {{0, -1}, {0, 1}, {0, -1}}, {1, 0} }, {1, 0}}}

আউটপুট

{{{1, 0}, {0, 1}}, {{1, 0}, {0, -1}}, {{0, 1}, {1, 0}}, {{0, -1 }, {1, 0}}}

ইনপুট

{{{1, 0, 0}, {{127, 63, 31}, {{1, 0, 0}, {{0, 0, 0}, {0, 1, 0}, {15, 0, -15}, {0, 0, 1}, {0, 0, 0}, {0, 0, 1}}, {-31, -63, -127}, {0, 1, 0}}, {0, 0, 0}}}

আউটপুট

{{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}, {{127, 63, 31}, {15, 0, -15}, {-31, - 63, -127}}, {{1, 0, 0}, {0, 0, 1}, {0, 1, 0}}, {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}}}

{{{0}}} এবং {{{-1}}, {{0}}, {{1}}} কাজও

-11 বাইটস মার্টিন ইন্ডারকে ধন্যবাদ