একটি 2 ডি অ্যারের আশেপাশের জিরোগুলি সরান

Question

এটি এই প্রশ্নের দ্বিমাত্রিক সংস্করণ ।

একটি অ-খালি 2-মাত্রিক অ্যারে / ম্যাট্রিক্স দেওয়া হয়েছে যেখানে কেবল অ-নেতিবাচক পূর্ণসংখ্যা রয়েছে:

$$\begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & {\color{Red}0} & 0 & 1 & 0 \\ {\color{Red}0} & {\color{Red}0} & 0 & 0 & 1 \\ {\color{Red}0} & {\color{Red}0} & 1 & 1 & 1 \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix}$$

আশেপাশের শূন্যগুলি অপসারণ করে অ্যারের আউটপুট করুন, অর্থাৎ আশেপাশের শূন্যগুলি ছাড়াই বৃহত্তম বৃহত্তম সুসংগত সুব্রায়:

$$\begin{bmatrix} 0 & 1 & 0 \\ 0 & 0 & 1 \\ 1 & 1 & 1 \end{bmatrix}$$

উদাহরণ:

$$\begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & {\color{Red}0} & 0 & 1 & 0 \\ {\color{Red}0} & {\color{Red}0} & 0 & 0 & 1 \\ {\color{Red}0} & {\color{Red}0} & 1 & 1 & 1 \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} 0 & 1 & 0 \\ 0 & 0 & 1 \\ 1 & 1 & 1 \end{bmatrix}$$

Input:
[[0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1], [0, 0, 1, 1, 1], [0, 0, 0, 0, 0]]

Output:
[[0, 1, 0], [0, 0, 1], [1, 1, 1]]

$$\begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & 0 & 0 & 3 \\ {\color{Red}0} & 0 & 0 & 0 \\ {\color{Red}0} & 5 & 0 & 0 \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} 0 & 0 & 3 \\ 0 & 0 & 0 \\ 5 & 0 & 0 \end{bmatrix}$$

Input:
[[0, 0, 0, 0], [0, 0, 0, 3], [0, 0, 0, 0], [0, 5, 0, 0], [0, 0, 0, 0]]

Output:
[[0, 0, 3], [0, 0, 0], [5, 0, 0]]

$$\begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{bmatrix} \mapsto \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{bmatrix}$$

Input:
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Output:
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

$$\begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} \end{bmatrix}$$

Input:
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Output:
[]

$$\begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ 1 & 1 & 1 & 1 \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} 1 & 1 & 1 & 1 \end{bmatrix}$$

Input:
[[0, 0, 0, 0], [1, 1, 1, 1], [0, 0, 0, 0]]

Output:
[[1, 1, 1, 1]]

$$\begin{bmatrix} {\color{Red}0} & 1 & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & 1 & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & 1 & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} 1 \\ 1 \\ 1 \end{bmatrix}$$

Input:
[[0, 1, 0, 0], [0, 1, 0, 0], [0, 1, 0, 0]]

Output:
[[1], [1], [1]]

$$\begin{bmatrix} 1 & 1 & 1 & 1 \\ 1 & 2 & 3 & 1 \\ 1 & 1 & 1 & 1 \end{bmatrix} \mapsto \begin{bmatrix} 1 & 1 & 1 & 1 \\ 1 & 2 & 3 & 1 \\ 1 & 1 & 1 & 1 \end{bmatrix}$$

Input:
[[1, 1, 1, 1], [1, 2, 3, 1], [1, 1, 1, 1]]

Output:
[[1, 1, 1, 1], [1, 2, 3, 1], [1, 1, 1, 1]]

Comments

@ ম্যাথএইচ-তেমন কোনও ভাষাই কোনও কিছুই মুশকিল নয়। :)এটি সংক্ষিপ্ত করা কেবল কঠিন।

— ব্যবহারকারী 202729

আমরা কি শেষ পরীক্ষার ক্ষেত্রে খালি ম্যাট্রিক্সের পরিবর্তে মিথ্যা আউটপুট দিতে পারি?

— - মনিকা পুনরায় ইনস্টল করুন

এছাড়াও, যদি আউটপুট একটি অ-বর্গক্ষেত্র ম্যাট্রিক্স হতে পারে তবে দয়া করে এটির জন্য একটি পরীক্ষার কেস যুক্ত করুন।

— - মনিকা পুনরায় ইনস্টল করুন

একটি পরীক্ষার কেস যা আমার আগের জমাটি ভেঙে দিয়েছে: [[0, 0, 0, 0], [0, 0, 0, 0], [1, 1, 1, 1], [0, 0, 0, 0]]( 1

— ফলাফলটির

আরে, কি পরীক্ষার কেস যুক্ত করা সম্ভব $$\begin{bmatrix}1&1&1&1\\1&2&3&1\\1&1&1&1\end{bmatrix}$$

— বিটা ডিকায়

Answer 1

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

JYa

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

ব্যাখ্যা

J      % Push 1j
Ya     % With complex 2nd input, this unpads the matrix in the
       % 1st input (implicit). The unpad value is 0 by default
       % Display (implicit)

Comments

"JYa JYa JYa JYa"

— মস্তিষ্ক গাইড

আমি পছন্দ করি অর্ধেক কোডটি ঠিক কীভাবে (implicit)।

— JangHwan মিন

Answer 2

ওল্ফ্রাম ভাষা (গণিত) , 42 বাইট by

#&@@CellularAutomaton[{,{},0{,}},{#,0},0]&

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

সেলুলার অটোমাতা প্রকৃতপক্ষে জীবন , মহাবিশ্ব এবং সমস্ত কিছুর উত্তর । ¹

কিভাবে?

CellularAutomatonএকটি ইনপুট অ্যারে এবং একটি alচ্ছিক পটভূমি মান গ্রহণ করে। সুতরাং, {#,0}নির্দিষ্ট করে যে সেলুলার অটোমেটনের নিয়মটি ইনপুটটিতে প্রয়োগ করা উচিত, এর একটি পটভূমি ধরে 0।

এখানে একটি পরিষ্কার জিনিস CellularAutomatonআউটপুট কেটে দেয় যাতে ব্যাকগ্রাউন্ড সেলগুলির কোনও সীমানা উপস্থিত না হয় (কারণ অন্যথায় আউটপুটটি অসীম বিমানে থাকে)।

কোডটি নিয়মটি {Null, {}, {0, 0}}প্রয়োগ করে - Nullপ্রতিটি কক্ষের 0-ব্যাসার্ধ প্রতিবেশীর সাথে মাথা প্রয়োগ করে (অর্থাত্ কেবল কেন্দ্র: ঘরটি নিজেই) - ঠিক 0সময়। এর ফলাফলটি মূল ইনপুট, তবে পটভূমি অপসারণ সহ (যেমন, আশেপাশে 0গুলি কাটা )।

---

^{১. আমার উত্তরের বাইকোয়েন্ট দেখুন? ;)}

Comments

চমৎকার বিল্টিন গালাগালি ... ভাল ম্যাথমেটিকার একটি অন্তর্নির্মিত রয়েছে, সরাসরি প্রকাশ করা হয়নি।

— ব্যবহারকারী 202729

কোনও এক্সকেসিডি 505 রেফারেন্স নেই?

— ফলস এছলং করা

সেলুলার অটোমাতা এবং চূড়ান্ত উত্তরের জন্য +1।

— হাইলিরাডিওঅ্যাকটিভ

Answer 3

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

(a,z)=>(g=A=>A.slice(A.map(m=M=(r,i)=>M=(z?a:r).some(n=>z?n[i]:n)?1/m?i:m=i:M)|m,M+1))(a).map(z=g)

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

কিভাবে?

একটি অন্তর্নির্মিত জিপের অভাবকে কাটিয়ে ওঠার জন্য , আমরা একটি ফাংশন g () সংজ্ঞায়িত করি যা বৈশ্বিক পতাকা z এর মানের উপর নির্ভর করে ইনপুট ম্যাট্রিক্স a [] এর সারি বা কলামগুলিতে পরিচালনা করতে সক্ষম ।

g () নূন্যতম সূচক মি এবং সর্বাধিক সূচী এম এর জন্য খালি শূন্য সারিগুলির সন্ধান করে (যদি z অপরিবর্তিত থাকে) বা খালি শিরোনাম (যদি z সংজ্ঞায়িত করা হয়) এবংম্যাট্রিক্স নিজেই বা প্রদত্ত সারিরসংশ্লিষ্ট স্লাইসটি প্রদান করে ম্যাট্রিক্স এর।

সংক্ষেপ:

• আমরা প্রথমে z অপরিশোধিত ম্যাট্রিক্সে জি () চালনার মাধ্যমে সারিগুলি সরিয়ে ফেলি
• তারপরে আমরা z সংজ্ঞায়িত করে প্রতিটি সারিতে g () ডেকে কলামগুলি সরিয়ে ফেলি যা এটি বরং অস্বাভাবিক দিকে নিয়ে যায়.map(z=g)

মন্তব্য

(a, z) => (               // a[] = input matrix; z is initially undefined
  g = A =>                // g() = function taking A = matrix or row
    A.slice(              //   eventually return A.slice(m, M + 1)
      A.map(m = M =       //     initialize m and M to non-numeric values
        (r, i) =>         //     for each row or cell r at position i in A:
        M = (z ? a : r)   //       iterate on either the matrix or the row
        .some(n =>        //       and test whether there's at least one
          z ? n[i] : n    //       non-zero cell in the corresponding column or row
        ) ?               //       if so:
          1 / m ? i       //         update the maximum index M (last matching index)
                : m = i   //         and minimum index m (first matching index)
        :                 //       otherwise:
          M               //         let M (and m) unchanged
      ) | m,              //     end of map(); use m as the first parameter of slice()
      M + 1               //     use M+1 as the second parameter of slice()
    )                     //   end of slice()
  )(a)                    // invoke g() on the matrix with z undefined
  .map(z = g)             // invoke g() on each row of the matrix with z defined

Comments

এটা চিত্তাকর্ষক।

— জ্যাক হেলস

@ জেক, আরনাউল্ড সম্পূর্ণ ভিন্ন মাত্রায় বেঁচে আছেন। তবে আপনি যদি অত্যন্ত ভাগ্যবান হন তবে আপনি মাঝে মধ্যে একটি কৌশল খুঁজে পেতে পারেন যা তিনি মিস করেছেন এবং একটি সংক্ষিপ্ত সমাধান পোস্ট করতে পারেন। প্রক্রিয়াতে, আপনি জাভাস্ক্রিপ্ট সম্পর্কে খুব গভীর বোঝার বিকাশ করবেন।

— রিক হিচকক

@ রিক হিচকক কোড কোড প্যাটার্ন সনাক্তকরণে আমি তেমন ভাল নই এবং আমি নিয়মিত প্রচুর জিনিস মিস করছি, যদিও আমি সেগুলি আগে দেখেছি। এই বিশেষ উদাহরণে, আমি পুনর্ব্যাবহার্যোগ্যতা ফোকাস করা হয়ে ছিল গ্রাম () এবং আপডেট পথে বেশ একটি সুস্পষ্ট অপ্টিমাইজেশান মিস মি এবং এম (-9 বাইট)। আমি সম্পূর্ণরূপে সম্মত হই যে কোনও ভাষার সূক্ষ্মতা সম্পর্কে অনেক কিছু শিখার জন্য কোড-গল্ফিং একটি দুর্দান্ত (এবং মজাদার) উপায়।

— আর্নল্ড

Answer 4

হাস্কেল , 62 61 বাইট

f.f.f.f
f=reverse.foldr(zipWith(:))e.snd.span(all(<1))
e=[]:e

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

foldr(zipWith(:))eসঙ্গে e=[]:eএকটি হল সামান্য খাটোtranspose , আর snd.span(all(<1))তালিকার একটি তালিকা থেকে শূন্য নেতৃস্থানীয় তালিকা ড্রপ। হিসাবে transposeদ্বারা অনুসরণ reverseএকটি 2D তালিকা 90 দ্বারা একটি ঘূর্ণন সমান °, কোড f.f.f.fমাত্র চার গুণ বেশি zeros এবং ঘোরান নেতৃস্থানীয় তালিকা ড্রপ ।

Answer 5

পাইথ , 13 বাইট

V2=.sCQ]m0Q;Q

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

Comments

আমি মনে করি =_CQ যে জায়গায় কাজ করবে =Q_CQ।

— মিঃ এক্সকোডার

Answer 6

জেলি , 10 বাইট

œr€0z0Uµ4¡

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

Answer 7

ব্র্যাচল্যাগ , 24 22 20 19 বাইট

{s.h+>0∧.t+>0∧}\↰₁\

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

ফলাফলের ম্যাট্রিক্সকে অ্যারের অ্যারে হিসাবে আউটপুট দেয় বা খালি আউটপুট দেওয়ার জন্য মিথ্যা।

(ইনটল প্রিডিকেট পরামর্শ দেওয়ার জন্য এবং 1 বাইট সংরক্ষণ করার জন্য @ ফ্যাটালাইজকে ধন্যবাদ জানাই))

ব্যাখ্যা

পূর্বাভাস 0 (প্রধান):

{...}     Define and call predicate 1 to remove all-zero rows
  \       Transpose the result
   ↰₁     Call pred 1 again, now to remove all-zero columns
     \    Transpose the result to have correct output orientation

ভবিষ্যদ্বাণী 1:

?s.h+>0∧.t+>0∧
  .           output is
 s              a subsequence of the rows of
?              the input (implicit)
   h          also, output's head element (first row)
    +>0        has a sum > 0 (i.e. has at least one non-zero value)
       ∧.t+>0  and similarly the output's tail element (last row)
∧              (don't implicitly unify that 0 with the output)

Comments

প্রথম বিধেয় ইনলাইন লেখা 1 বাইট খাটো: {s.h+>0∧.t+>0∧}\↰₁\ । (এটি কোনও ব্র্যাচল্যাগ উত্তরের পক্ষে সত্য, নতুন লাইনে ভবিষ্যদ্বাণী করা যদি আপনি আরও পাঠযোগ্য জিনিস লিখতে চান তবেই বাস্তবায়িত হবে)।

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

@ ফ্যাটালাইজ ধন্যবাদ, আপডেট (শেষ অবধি)! আমি কখনই ভাবিনি যে ইনলাইন প্রিকেট সিনট্যাক্স উভয়ই একটি সংজ্ঞা এবং প্রিডিকেট অ্যাপ্লিকেশন, বেশ দুর্দান্ত।

— সূন্দর - মনিকা

Answer 8

আর , 96 100 97 বাইট

function(m)m[~m,~t(m),drop=F]
"~"=function(x,z=seq(r<-rowSums(x)))z>=min(y<-which(r>0))&z<=max(y)

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

~সাহায্যকারী একটি অ-নেতিবাচক ভেক্টর এবং আয় সঙ্গে একটি ভেক্টর লাগে FALSEজন্য "বহি" 0ভেক্টরের s এবং TRUEpositives এবং কোন "অভ্যন্তর" জন্য 0গুলি। এই ফাংশনটি ইনপুট ম্যাট্রিক্সের সারি এবং কলামের অঙ্কগুলিতে প্রয়োগ করা হয়।

~এবং ! অপারেটরদের আর এর পার্সার চিকিত্সা ব্যবহার করুন।

@ ডিজিএমএল এর মন্তব্য অনুসারে সংশোধন করা হয়েছে, তবে কিছু জ্যাকেট @ জে.ডো থেকে ফিরে গেছে

Comments

আমি মনে করি আপনার drop=Fমতো আমার যুক্ত করা উচিত , অন্যথায় এই 2 টি পরীক্ষা সারি এবং কলামের পরিবর্তে কোনও ভেক্টরকে ফিরিয়ে দেবে: এটি অনলাইনে চেষ্টা করুন!

— ডিগইমএল সমস্ত

সঙ্গে 97 বাইটdrop=F । এখনও এক টনের নিচে!

— জে.ডো

Answer 9

আর , 89 79 বাইট

function(m,y=apply(which(m>0,T),2,range)){y[!1/y]=0;m[y:y[2],y[3]:y[4],drop=F]}

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

পরীক্ষার কেস কোডের জন্য @ জিএনএম এবং 10 জ্যাকেট বাঁচানোর জন্য @ জে.ডোকে ধন্যবাদ!

• drop=Fডিফল্ট আর আচরণের কারণে একক সারি / কর্নাল ম্যাট্রিক্সকে ভেক্টরগুলিতে পরিণত করার কারণে আমাকে প্যারামিটার যুক্ত করতে হয়েছিল ...

Comments

আমি লক্ষ্য করি না যে আমার আগের কোডটি শূন্যের ক্ষেত্রে ব্যর্থ হচ্ছে ... এখন দুর্ভাগ্যক্রমে এটি আরও অনেকগুলি বাইটের সাথে ঠিক করা হয়েছে :(

— ডিগএমআল

আমি আশা করি আমি এটি +2 করতে পারতাম। ফেননামের সত্যই চমৎকার ব্যবহার।

— জেসি

79 বাইটগুলি সূচক ব্যবহার করে rangeএবং

— টুইট করছে

@ জে.ডো: অবশ্যই রেঞ্জ! দুর্দান্ত ধারণা ধন্যবাদ!

— digEmAll সমস্ত

Answer 10

এপিএল (ডায়ালগ ক্লাসিক) , 17 15 বাইট

{⍉⌽⍵⌿⍨∨\∨/×⍵}⍣4

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

Answer 11

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

ইনপুটটি সংশোধন করে ফিরে আসে। একটি তালিকা ইনপুট হিসাবে পাস করা উচিত।

def f(a):exec'while a and 1>sum(a[-1]):a.pop()\na[:]=zip(*a)[::-1]\n'*4

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

---

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

এটি ইনপুটটিও পরিবর্তন করে তবে এটি কাজ করে ....

def f(a):exec'while a and 1>sum(a[-1]):a.pop()\na=zip(*a)[::-1]\n'*4;return a

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

Answer 12

ওল্ফ্রাম ভাষা (গণিত) , by 66 বাইট

If[Max@#>0,ImageCrop@Image[#~ArrayPad~1,r="Real"]~ImageData~r,{}]&

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

এখন শূন্যগুলির সাথে অ্যারে প্যাড করে কাজ করে (ধন্যবাদ @ জংহওয়ানমিন)!

4 বাইট সংরক্ষণের জন্য দ্বিতীয়বার জংহওয়ানমিনকে ধন্যবাদ জানাই

Answer 13

জেলি , 12 বাইট

Ṗ§Ṫ¬ȧƲ¿UZµ4¡

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

একটি ফাংশন হিসাবে.

Answer 14

ওল্ফ্রাম ভাষা (ম্যাথমেটিকা) , 48 বাইট

Nest[Reverse@Thread@#//.{{0..},a___}->{a}&,#,4]&

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

এটি স্বাভাবিক উপায়ে করছেন।

Comments

দুর্ভাগ্যক্রমে \[Transpose]এখানে কাজ করতে পারবেন না।

— ব্যবহারকারী 202729

Answer 15

হুশ , 11 বাইট

!5¡(T0mo↔↓¬

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

আমার মনে হচ্ছে !5¡অংশটি ছোট করে কিছু বাইট মুভ করা যেতে পারে ।

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

!5¡(

$5^{\text{th}}$

mo↔↓¬

ইনপুটটির বর্তমান সংস্করণটির উপরে মানচিত্র এবং: কেবলমাত্র শূন্যের দীর্ঘতম উপসর্গটি বাদ দেওয়ার পরে প্রতিটি বিপরীত করুন (এই উপসর্গটি হুস্কের ব্যবহার করে সম্পাদন করা হয় ↓যা এটি প্রথম ফাংশন যা প্রথম থেকেই ধারাবাহিক উপাদানগুলির দীর্ঘতম রান সংগ্রহ করে এমন কোনও ফাংশন চলাকালীন সত্যবাদী ফলাফলের তালিকা তৈরি করে, যেমন ¬যৌক্তিক নয়)।

T0

প্রতিস্থাপন, নিখোঁজ এন্ট্রিগুলিকে 0 দিয়ে প্রতিস্থাপন করুন ।

Answer 16

রেটিনা , 87 বাইট

/.\[(?!0,)/^+`\[0, 
[
/(?<! 0)]./^+`, 0]
]
\[(\[0(, 0)*], )+
[
(, \[0(, 0)*])+]|\[0]]
]

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

/.\[(?!0,)/^+`

কমপক্ষে একটি সারি শূন্য দিয়ে শুরু না হওয়া অবধি ...

\[0, 
[

... প্রতিটি সারি থেকে নেতৃস্থানীয় শূন্য সরান।

/(?<! 0)]./^+`

কমপক্ষে একটি সারি শূন্যের সাথে শেষ না হওয়া অবধি ...

, 0]
]

... প্রতিটি সারি থেকে পিছনের শূন্যটি সরান।

\[(\[0(, 0)*], )+
[

শূন্যের নেতৃস্থানীয় সারিগুলি সরান।

(, \[0(, 0)*])+]|\[0]]
]

শূন্যের শেষ সারি বা শেষের শূন্যটি সরিয়ে ফেলুন।

Comments

@ রিকহিচকক এটি বিন্যাস সংবেদনশীল, ফাঁকা স্থান যুক্ত করুন: এটি অনলাইনে চেষ্টা করুন!

— নীল

Answer 17

কাঠকয়লা , 48 বাইট

Ｆ⁴«Ｗ∧θ¬Σ§θ±¹Σ⊟θ¿θ≔⮌Ｅ§θ⁰Ｅ觧θνλθ»⪫[]⪫Ｅθ⪫[]⪫ι, ¦, 

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। ফর্ম্যাট করার জন্য 15 বাইট অন্তর্ভুক্ত। ব্যাখ্যা:

Ｆ⁴«

4 বার পুনরাবৃত্তি করুন।

Ｗ∧θ¬Σ§θ±¹

অ্যারেটি খালি না থাকায় পুনরাবৃত্তি করুন তবে এর শেষ সারিটি শূন্যের সমষ্টি ...

Σ⊟θ

অ্যারে থেকে শেষ সারিটি সরান এবং এর যোগফলের দৈর্ঘ্যের একটি লাইন মুদ্রণ করুন, কিছুই নয়।

¿θ≔⮌Ｅ§θ⁰Ｅ觧θνλθ»

যদি অ্যারেটি খালি না থাকে তবে এটি স্থানান্তর করুন।

⪫[]⪫Ｅθ⪫[]⪫ι, ¦, 

প্রদর্শনের জন্য অ্যারেটি সুন্দরভাবে ফর্ম্যাট করুন। ( Ｉθপরিবর্তে স্ট্যান্ডার্ড আউটপুট হবে ।)

Answer 18

জাভাস্ক্রিপ্ট, 144 140 129 127 বাইট

w=>(t=w=>(q=(s=w=>w.some((r,j)=>r.find(e=>e,i=j))?w.slice(i).reverse():[[]])(s(w)))[0].map((e,j)=>q.map((e,i)=>q[i][j])))(t(w))

140 -> 129 বাইটস, ধন্যবাদ @ আরনাউল্ড

অ্যালগরিদম

• দু'বার করুন:
  • প্রথম অ-শূন্য সারিটি সন্ধান করুন
  • পূর্ববর্তী সারিগুলি কেটে ফেলে দিন
  • বিপরীত
  • প্রথম অ-শূন্য সারিটি সন্ধান করুন
  • পূর্ববর্তী সারিগুলি কেটে ফেলে দিন
  • বিপরীত
  • পক্ষান্তরিত করা

f = w=>(t=w=>(q=(s=w=>w.some((r,j)=>r.find(e=>e,i=j))?w.slice(i).reverse():[[]])(s(w)))[0].map((e,j)=>q.map((e,i)=>q[i][j])))(t(w));

w1 = [[0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1], [0, 0, 1, 1, 1], [0, 0, 0, 0, 0]];
w2 = [[0, 0, 0, 0], [0, 0, 0, 3], [0, 0, 0, 0], [0, 5, 0, 0], [0, 0, 0, 0]];
w3 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
w4 = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]];

console.log(f(w1).join("\n"));
console.log(f(w2).join("\n"));
console.log(f(w3).join("\n"));
console.log(f(w4));

Comments

আপনি (এখন একক) প্রধান ফাংশন আর্গুমেন্টের আশেপাশে প্রথম বন্ধন থেকে মুক্তি পেতে সহায়ক ফাংশন ঘোষণার পরিবর্তে এবং পুনর্বিন্যাসের মাধ্যমে আপনি 7 বাইট সংরক্ষণ করতে পারেন । some/somefindIndex/find

— আর্নল্ড

আমি মনে করি আপনি পারেন আরো 4 বাইট সংরক্ষণ না থাকার গুলি রিটার্ন [[]]যাতে টি কাজ পাবে নিশ্চিত করা হয় w[0]।

— আর্নল্ড

Answer 19

পাইথন 2 , 118 116 বাইট

f=lambda a,n=4,s=sum:n and f(zip(*a[max(i for i in range(len(a))if s(s(a[:i],()))<1):][::-1]),n-1)or(s(s(a,()))>0)*a

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

---

সংরক্ষিত:

• -2 বাইট, shooqie ধন্যবাদ

Comments

s=sum

— লাম্বদা

Answer 20

পিএইচপি (> = 5.4), 200 194 186 184 বাইট

(-6 nullখালি অ্যারের পরিবর্তে ফিরে বাইট )

(-8 ধন্যবাদ বাইট তিতাস )

(-2 রেফারেন্স ধন্যবাদ দ্বারা কলিং সঙ্গে বাইট তিতাস )

function R(&$a){$m=$n=1e9;foreach($a as$r=>$R)foreach($R as$c=>$C)if($C){$m>$r&&$m=$r;$M>$r||$M=$r;$n>$c&&$n=$c;$N>$c||$N=$c;}for(;$m<=$M;)$o[]=array_slice($a[$m++],$n,$N-$n+1);$a=$o;}

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

কিভাবে?

খুঁজে বের করে সর্বনিম্ন এবং সারি (জন্য সর্বোচ্চ সূচক $m& $M) ও কলাম ( $n& $Nথেকে) এবং প্রতিস্থাপিত উপ অ্যারে ইনপুট $m,$nকরার $M,$N(এই রেফারেন্স দ্বারা একটি কল)।

Comments

এর সাথে 6 বাইট সংরক্ষণ করুনif($C){$m>$r&&$m=$r;$M>$r||$M=$r;$n>$c&&$n=$c;$N>$c||$N=$c;}

— টাইটাস

... এবং এর সাথে দুটি বাইটwhile($m<=$M)$o[]=array_slice($a[$m++],$n,$N-$n+1);

— টাইটাস

@ টিটাস: দুর্দান্ত টিপসের জন্য ধন্যবাদ। ব্যবহারের কৌতুক পছন্দ &&এবং ||আমি করছি নিশ্চিত আমি পাশাপাশি অন্যান্য স্থানে যে কৌতুক ব্যবহার করতে সক্ষম হবে।

— রাত 2

আপনি রেফারেন্স দ্বারা কল সহ আরও দুটি বাইট সংরক্ষণ করতে পারেন: $a=পরিবর্তে return।

— তিতাস

Answer 21

অক্টাভা, 48 49 বাইট

@(a)sparse(1-min([x y v]=find(a))+x,1-min(y)+y,v)

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

ননজারো পয়েন্টগুলি সন্ধান করুন এবং এগুলিকে একটি নতুন স্পার্স ম্যাট্রিক্সে পুনর্বিন্যাস করুন।

Comments

উত্তর!

— rahnema1

Answer 22

কে (এনএনজি / কে) , 22 বাইট

{4{+|(+/&\~+/x)_'x}/x}

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

Answer 23

জে , 24 বাইট

(|.@|:@}.~0=+/@{.)^:4^:_

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

ব্যাখ্যা

(|.@|:@}.~0=+/@{.)^:4^:_
            +/                sum
              @               of
               {.             the first row
          0=                  is zero? (1 = true, 0 = false)
       }.~                    chop off that many rows from the front
 |.@|:@                       rotate by 90 deg (transpose then reverse)
(                )^:4         repeat this process 4 times (rotating a total of 360 deg)
                     ^:_      fixpoint - repeat until no change

Answer 24

রুবি , 73 63 বাইট

->a{4.times{_,*a=a while a[0]&.sum==0;a=a.reverse.transpose};a}

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

সম্পাদনা: সরলীকৃত, এছাড়াও পূর্ববর্তী সংস্করণ সবার জন্য ক্র্যাশ 0গুলি

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

• 4 বার করুন:
  • প্রথম লাইনটি সরাতে হবে যখন সেখানে প্রথম লাইন থাকবে এবং এটি পূর্ণ 0 এস
  • অ্যারে ঘড়ির কাঁটার দিকে 90 by ঘোরান °
• অ্যারে ফিরিয়ে দিন

Comments

লিঙ্কটি সঠিক, তবে কোড ব্লকে আপনার উত্তরটি &.sum<0পরিবর্তে বলে &.sum<1।

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

@ কনরও ব্রায়েন আমার খারাপ, নতুন সংস্করণ খালি অ্যারে (শুন্য <1) এর জন্য কাজ করে না। যাইহোক লক্ষ্য করার জন্য ধন্যবাদ

— Asone Tuhid

Answer 25

অক্টাভা , 78 74 বাইট

function x=f(x)
for k=1:nnz(~x)*4,x=rot90(x);x=x(:,~~cumsum(any(x,1)));end

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

ব্যাখ্যা

এটি ম্যাট্রিক্সকে 90ডিগ্রি ( x=rot90(x)) দ্বারা পর্যাপ্ত সংখ্যক ( ) দ্বারা আবর্তিত করে for k=1:... end। ঘূর্ণনের সংখ্যাটি একাধিক 4, সুতরাং চূড়ান্ত ম্যাট্রিক্সের মূল ওরিয়েন্টেশন রয়েছে। বিশেষত, ঘূর্ণন 4সংখ্যা ম্যাট্রিক্স ( nnz(~x)*4) এর জিরো সংখ্যার চেয়ে বহুগুণ বেশি ।

প্রতিটি ঘোরার জন্য, যদি কেবল জিরো সমন্বিত বামদিকে এক বা একাধিক কলাম থাকে তবে সেগুলি সরানো হবে ( x=x(:,~~cumsum(any(x,1))))।

এই প্রক্রিয়াটির পরে ম্যাট্রিক্সের যা অবশিষ্ট রয়েছে তা হ'ল ফাংশন ( function x=f(x)) দ্বারা আউটপুট ।

Answer 26

স্ট্যাক্স , 14 বাইট

Ç·W≈y§╗♦º{¬║8•

এটি চালান এবং এটি ডিবাগ করুন

বিকল্প, এছাড়াও 14 বাইট

Ç·W≈x≈ƒHq♣☻»íÅ

এটি চালান এবং এটি ডিবাগ করুন

Answer 27

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

function f(&$a){for($s=array_shift;!max($a[0]);)$s($a);for($p=array_pop;!max(end($a));)$p($a);for($w=array_walk;!max(($m=array_map)(reset,$a));)$w($a,$s);while(!max($m(end,$a)))$w($a,$p);}

রেফারেন্স দ্বারা কল।

ভাঙ্গন

// call by reference
function f(&$a)
{
    // while first row is all zeroes, remove it
    while(!max($a[0]))array_shift($a);
    // while last row is all zeroes, remove it
    while(!max(end($a)))array_pop($a);
    // while first column is all zeroes, remove it
    while(!max(array_map(reset,$a)))array_walk($a,array_shift);
    // while last column is all zeroes, remove it
    while(!max(array_map(end,$a)))array_walk($a,array_pop);
}

Answer 28

পরিষ্কার , 73 বাইট

import StdEnv,StdLib
$ =dropWhile(all((>)1))o reverse o transpose

$o$o$o$

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

লাইকোনির হাস্কেল উত্তরের সাথে খুব মিল ।

Answer 29

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

lambda a,l=1:a if l>4else([a.pop()for b in a if sum(a[-1])<1],f(zip(*a[::-1]),l+1))[1]

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

তালিকার একটি তালিকা নেয়, টিউপসগুলির একটি তালিকা প্রদান করে।

ব্যাখ্যা

হ্যাককে অপব্যবহার করে তালিকা বোঝার বাইরে। এটি সমতুল্য প্রসারিত কোড:

def f(a,l=1):
    # after 4 rotations, the list is back in its original orientation, return
    if l > 4:
        return a
    else:
        # helper variable to store return values
        ret = []
        # "trim" all rows from "bottom" of list that only contain 0s
        # since we are always checking le that item in the list, don't need range(len(a))
        # since we are only removing at most one item per iteration, will never try to remove more than len(a) items
        # brackets surrounding generator force it to be consumed make a list, and therefore actually pop() list items
        ret.append([a.pop() for b in a if sum(a[-1]) < 1])
        # rotate the array, increase the number of rotations, and recursively call this function on the new array/counter
        ret.append(f(zip(*a[::-1]), l + 1)))
        # we only put both items in a list in order to stay in the one-line lambda format
        # discard the popped items and return the value from the recursive call
        return ret[1]

Answer 30

জাপট -h , 23 11 বাইট

4Æ=sUb_dà z

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

---

ব্যাখ্যা

                :Implicit input of 2D-array U
4Æ              :Map the range [0,4)
   s            :  Slice U from
    Ub          :   The first index in U where
      _dà      :    Any element is truthy (not zero)
          z     :  Rotate 90 degrees
  =             :  Reassign to U for the next iteration
                :Implicitly output the last element