ভূমিকা

ধরুন আপনার কাছে পূর্ণসংখ্যার তালিকার একটি তালিকা রয়েছে (বা আসলে কোনও বস্তু রয়েছে তবে আসুন সরলতার জন্য পূর্ণসংখ্যায় লেগে থাকুন)। তালিকাগুলি বিভিন্ন দৈর্ঘ্যের হতে পারে এবং এর কয়েকটি খালি থাকতে পারে। আসুন তালিকাগুলি একটি সারণী বিন্যাসে লিখুন:

[[ 1,   2,   3,   4,   5],
 [ 6,   7],
 [ 8,   9,  10,  11],
 [],
 [12,  13,  14],
 [15,  16,  17,  18]]

এই টেবিলের, 5 উল্লম্ব কলাম হয়েছে সংখ্যার ধারণকারী 1, 6, 8, 12, 15, 2, 7, 9, 13, 16, 3, 10, 14, 17, 4, 11, 18, এবং 5। আমরা যদি প্রতিটি কলামের বিপরীত, আমরা তালিকা প্রাপ্ত 15, 12, 8, 6, 1, 16, 13, 9, 7, 2, 17, 14, 10, 3, 18, 11, 4, এবং 5। আগের মতো সারিগুলির দৈর্ঘ্য ঠিক রেখে সেই নম্বরগুলি আবার টেবিলের কলামগুলিতে প্লাগ করা যাক:

[[15,  16,  17,  18,   5],
 [12,  13],
 [ 8,   9,  14,  11],
 [],
 [ 6,   7,  10],
 [ 1,   2,   3,   4]]

আপনার কাজটি এই ক্রিয়াকলাপটি বাস্তবায়ন করা।

ইনপুট এবং আউটপুট

আপনার ইনপুটটি সারিগুলি উপস্থাপন করে, অ-সংযুক্তি পূর্ণসংখ্যার তালিকার একটি তালিকা। সারিগুলির বিভিন্ন দৈর্ঘ্য হতে পারে এবং এর কয়েকটি খালিও থাকতে পারে। সর্বদা কমপক্ষে একটি সারি থাকবে। আপনার আউটপুটটি উপরে বর্ণিত প্রতিটি কলামকে বিপরীত করার ফলাফল। ইনপুট এবং আউটপুট যে কোনও যুক্তিসঙ্গত বিন্যাসে থাকতে পারে।

প্রতিটি ভাষায় সর্বনিম্ন বাইট গণনা জয়ী হয়। স্ট্যান্ডার্ড কোড-গল্ফ বিধি প্রযোজ্য।

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

[[]] -> [[]]
[[],[]] -> [[],[]]
[[8,5,1]] -> [[8,5,1]]
[[1,200],[0,3]] -> [[0,3],[1,200]]
[[],[3,9],[1],[]] -> [[],[1,9],[3],[]]
[[],[5,8,7],[0,6,5,7,1]] -> [[],[0,6,5],[5,8,7,7,1]]
[[1,8,5],[7,5,4],[],[1]] -> [[1,5,4],[7,8,5],[],[1]]
[[],[],[2],[],[31],[],[5],[],[],[],[7]] -> [[],[],[7],[],[5],[],[31],[],[],[],[2]]
[[1,10,100,1000],[2,20,200],[3,30],[4],[5,50,500],[6,60],[7]] -> [[7,60,500,1000],[6,50,200],[5,30],[4],[3,20,100],[2,10],[1]]
[[8,4],[3,0,4,8,1],[8],[0,8],[9,7,1,6],[3,8,1,9,5]] -> [[3,8],[9,7,1,9,5],[0],[8,8],[3,0,1,6],[8,4,4,8,1]]
[[3,9,3],[5],[1],[3,5],[9,0,6,2],[1,3],[4,9,2],[6,6,7,8,7]] -> [[6,6,7],[4],[1],[9,9],[3,3,2,8],[1,0],[5,5,6],[3,9,3,2,7]]
[[8,5,6],[3,5,2,4,9],[4,3,8,3,7],[6,1,1],[1,8,9,9],[9,1,2],[8,7]] -> [[8,7,2],[9,1,9,9,7],[1,8,1,3,9],[6,1,8],[4,3,2,4],[3,5,6],[8,5]]
[[2,4],[1,4],[0,8,7,3],[4,9,2,5],[2,8,0],[0,8,3],[7,3,1],[],[3,3,7,8]] -> [[3,3],[7,3],[0,8,7,8],[2,8,1,5],[4,9,3],[0,8,0],[1,4,2],[],[2,4,7,3]]

code-golf array-manipulation

— Zgarb
সূত্র

1

আমরা কি নাল দিয়ে আউটপুট সারি প্যাড করতে পারি? (উদাঃ [[1,9],[3],[2,4,5]] -> [[2,4],[3,null],[1,9,5]])

— ETH প্রোডাকশনগুলি

@ETH প্রোডাকশনগুলি না, আউটপুটে কেবল সংখ্যা থাকতে হবে।

— Zgarb

-1 কারণ এটি সাধারণ নয় (negative

— ণাত্মক

5

জেলি , 16 বাইট

ḟṚṁṣj
z-ç€-ZFḟ-ṁ

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

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

z-ç€-ZFḟ-ṁ  Main link. Argument: M (matrix / 2D array)

z-          Zip the rows of M, using -1 as filler.
  ç€-       Map the helper link over the result, with right argument -1.
     Z      Zip the rows of the result.
      F     Flatten the resulting matrix.
       ḟ-   Filterfalse -1; remove all occurrences of -1.
         ṁ  Mold; shape the result like M.


ḟṚṁṣj       Helper link.
            Left argument: A (row / 1D array). Right argument: -1

ḟ           Filterfalse; remove all occurrences of -1.
 Ṛ          Reverse the resulting vector.
   ṣ        Split A at occurrences of -1.
  ṁ         Mold; shape the vector to the left like the 2D array to the right.
    j       Join the resulting 2D array, separating by -1.

— ডেনিস
সূত্র

ভাল, ṣউপরের লাইনে খুব চালাক! ( ḟṚṁṣjনা ⁸ḟ⁹Ṛṁ⁸ṣ⁹¤j⁹ডান?) নইলে ছিল এই আরো বাইট এক জন্য

— এরিক Outgolfer

হ্যাঁ, এটি ঠিক তাই করে।

— ডেনিস

4

জাপট , 15 13 বাইট

@ শেগি কে 2 বাইট সংরক্ষণ করা হয়েছে

y@=XfÊX£o
®fÄ

এটি অনলাইন পরীক্ষা!

দ্বিতীয় লাইনটি সরিয়ে দেওয়া যেতে পারে যদি আমাদের 4 টি বাইট সংরক্ষণ করে নাল মানগুলির সাথে সারিগুলিকে প্যাড করার অনুমতি দেওয়া হয়।

ব্যাখ্যা

 y@  =XfÊ X£  o      Implicit: U = input array
UyX{U=Xfl Xm{Uo}}    (Ungolfed)
UyX{            }    Map each column X in the input by this function:
    U=Xfl              Set U to X filtered to only items whose factorial is truthy;
                       this just gets rid of the empty slots in the column.
          Xm{  }       Map each item in X to
             Uo          the last item in U, popping this item from the list.
                       Due to the way .map works in JS, this is only called on real items
                       and not empty slots, so this preserves empty slots.
                     Newline: set U to the resulting column-reversed array
 ®   fÄ              Due to the way y works, there will now be `undefined` in some rows.
UmZ{Zf+1}            (Ungolfed)
 mZ{    }            Map each row Z in U to
    Zf+1               Z filtered to only items where the item + 1 is truthy.
                     undefined + 1 is NaN, which is falsy, and thus eliminated.
                     Implicit: output result of last expression

— ETHproductions
সূত্র

সুন্দর! তোমাদের নিকটে নামিয়া এটা পেতে পারি 13 বাইট প্রতিস্থাপন l;সঙ্গে Êএবং mf_Äসঙ্গে ®fÄ।

— শেগি

আসলে, কেবল mfদ্বিতীয় লাইনের জন্য কাজ করছে বলে মনে হচ্ছে।

— শেগি

@ শেগি ধন্যবাদ, তাদের কথা ভাবেননি! mfদুর্ভাগ্যক্রমে, ফলাফলের যে কোনও শূন্য থেকে মুক্তি পাবে ...

— ETH প্রোডাকশনগুলি

আহা, হ্যাঁ, এটা ভাবছিলাম না।

— শেগি

4

এপিএল (ডায়ালগ ইউনিকোড) , 20 19 16 বাইট ^{এসবিসিএস}

-4 এনএনজি ধন্যবাদ।

পুরো প্রোগ্রাম। এসটিডিএন থেকে ইনপুট দেওয়ার জন্য অনুরোধ জানানো হয়।

⍟0~¨⍨↓⍉⌽@×⍤1⍉↑*⎕

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

উদাহরণস্বরূপ ওয়াক-থ্রো সহ ব্যাখ্যা

⎕ মূল্যায়ন ইনপুট জন্য প্রম্পট
[[1,8,5],[7,5,4],[],[1]]

*এর শক্তিতে ই উত্থাপন ( ই ^এন যা নিশ্চিত করে যে কোনও জিরো থাকবে না)
[[2.7,2981,148.4],[1096.6,148.4,54.6],[],[2.7]]

↑ জিরোসের সাথে প্যাডিং করে একটি একক ম্যাট্রিক্সে তালিকাগুলি মেশান:
┌ ┐
│2.7E0 3.0E3 1.5E2│
│1.1E3 1.5E2 5.5E1│
│0.0E0 0.0E0 0.0E0│
│2.7E0 0.0E0 0.0E0│
└ ┘

⍉ TRANSPOSE
┌ ┐
│2.7E0 1.1E3 0.0E0 2.7E0│
│3.0E3 1.5E2 0.0E0 0.0E0│
│1.5E2 5.5E1 0.0E0 0.0E0│
└ ┘

⌽@×⍤1 প্রতিটি সারির ইতিবাচক উপাদানগুলি বিপরীত করুন
┌ ┐
│2.7E0 1.1E3 0.0E0 2.7E0│
│1.5E2 3.0E3 0.0E0 0.0E0│
│5.5E1 1.5E2 0.0E0 0.0E0│
└ ┘

⍉ TRANSPOSE
┌ ┐
│2.7E0 1.5E2 5.5E1│
│1.1E3 3.0E3 1.5E2│
│0.0E0 0.0E0 0.0E0│
│2.7E0 0.0E0 0.0E0│
└ ┘

↓ ম্যাট্রিক্সকে তালিকার তালিকায় বিভক্ত করুন
[[2.7,148.4,54.6],[1096.6,2981,148.4],[0,0,0],[2.7,0,0]]

0~¨⍨ প্রতিটি তালিকা থেকে শূন্য সরান
[[2.7,148.4,54.6],[1096.6,2981,148.4],[],[2.7]]

⍟ প্রাকৃতিক লগারিদম
[[1,5,4],[7,8,5],[],[1]]

— আদম
সূত্র

ইনপুট -1 অন্তর্ভুক্ত থাকলে কি হবে?

— ngn

@ngn ইনপুটটিতে কখনও নেতিবাচক সংখ্যা থাকবে না; বিভাগ "ইনপুট এবং আউটপুট" দেখুন।

— Zgarb

@ জগারব এটি নিখুঁত, ধন্যবাদ

— ngn

@ অ্যাডম আমি মিক্স-প্রতিটি-বিভাজনের পরিবর্তে র‌্যাঙ্ক 1 ব্যবহার করার জন্য সম্পাদনা করেছি।

— ngn

@ আদম এছাড়াও: মেপুঃ / পরিবর্তে +1 / -1 কভার ⎕fr সঙ্গে পরীক্ষা ← 1287 লগ ইন করুন

— ngn

3

K4 , 36 বাইট

সমাধান:

+{x[w]:|x w:&~^x;x}'x'[::;]@!|/#:'x:

উদাহরণ:

q)k)+{x[w]:|x w:&~^x;x}'x'[::;]@!|/#:'x:(1 2 3 4 5;6 7;8 9 10 11;0#0N;12 13 14;15 16 17 18)
15 16 17 18 5
12 13        
8  9  14 11  

6  7  10     
1  2  3  4

q)k)+{x[w]:|x w:&~^x;x}'x'[::;]@!|/#:'x:(0#0N;5 8 7; 0 6 5 7 1)

0 6 5    
5 8 7 7 1

ব্যাখ্যা:

এটির একটি ব্যথা হয়েছে এবং আমি এখনও যথাযথ সূচকে সহজ করার জন্য কাজ করছি।

উদাহরণস্বরূপ এ ইনডেক্স করার পরিবর্তে, x[0]যা প্রথম সারিতে ফিরে আসবে , আমরা প্রথম কলামটি নিতে চাই , যা ব্যবহার করে করা যেতে পারে x[;0]।

তবে ভেরিয়েবলের yমধ্যে x[;]এটি পরিবর্তন করে x[y]না কেন x[;y]এটি চলাফেরা করে ::না:x[::;] ।

এটি তালিকার তালিকায় উল্টানোর সমতুল্য, তবে ফ্লিপের জন্য সমস্ত তালিকা সমান দৈর্ঘ্যের হওয়া দরকার!

+{x[w]:|x w:&~^x;x}'x'[::;]@!|/#:'x: / the solution
                                  x: / save input as variable x
                               #:'   / count (#:) each (') 
                             |/      / take the max of these lengths
                            !        / til, range 0..max-1
                           @         / apply (index into)
                      [::;]          / :: is a kind of null, 
                    x'               / index into x at each of these    
 {              ; }'                 / two statement lambda on each (')
              ^x                     / null x (returns true if entry is null)
             ~                       / not, so flip true/false
            &                        / where, indexes where true
          w:                         / save as variable w  
        x                            / index into w at these indexes
       |                             / reverse
  x[w]:                              / store this back in variable x at indexes w
                 x                   / return x from function
+                                    / flip the result

— streetster
সূত্র

3

হাস্কেল , 174 বাইট

f x=map g.h.map(g.reverse>>=(!)).h$take(maximum$length<$>x).(++z).map pure<$>x
g=concat
h x|g x==[]=x|4>2=foldr(zipWith(:))z x
x!(c:d)|c==[]=c:x!d|a:b<-x=[a]:b!d
_!y=y
z=[]:z

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

Ungolfed / ব্যাখ্যা

ধারণাটি হ'ল সমস্ত উপাদানগুলিকে মোড়ানো []এবং সারিগুলিকে প্যাড করা [](negativeণাত্মক পূর্ণসংখ্যার সাথে প্যাডিংয়ের চেয়ে ছোট হতে হবে, এটি নেতিবাচক ইনপুটগুলিকেও ভাল যা মঞ্জুরি দেয়), তারপরে স্থানান্তর, সমস্ত সারি বিপরীত এবং পুনরায় স্থানান্তর এবং প্রতিটি সারি চ্যাপ্টা করা :

map concat                                   -- flatten each row
  . transpose'                               -- transpose (*)
  . map (\row-> reverse (concat row) ! row)  -- reverse each row (see below)
  . transpose'                               -- tranpose (*)
  $ take (maximum $ length <$> x)            -- only keep up as many as longest row
      . (++ z)                               -- pad row with [],[],..
      . map (\e-> [e])                       -- wrap elements in []
 <$> x

^{* এই ট্রান্সপোজ ফাংশন ( h) কেবলমাত্র কোনও উপাদান না থাকলে তালিকাটি ফিরিয়ে দেয়।}

বিপরীত ফাংশনটি []উপাদানগুলিকে উপেক্ষা করতে হবে (উদা। [[],[1],[],[3],[4]]-> [[],[4],[],[3],[1]]), এটি দুটি আর্গুমেন্ট গ্রহণ করে এটি করে: প্রথমটি হ'ল বিপরীত ক্রমে উপাদানগুলি (যেমন। [4,3,1]) এবং দ্বিতীয়টি মূল সারি row

x@(a:b) ! (c:d)
 | c == []   = c:x ! d    -- if current element is []: skip it
 | otherwise = [a]:b ! d  -- else: replace with new one (a) and continue
_ ! y = y                 -- base case (if no new elements are left): done

— ბიმო
সূত্র

2

পাইথন 2 , 111 105 92 বাইট

def f(l):x=map(lambda*n:[v for v in n if-1<v],*l);return[map(list.pop,x[:len(k)])for k in l]

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

— ovs
সূত্র

আপনি বাইট সংরক্ষণ করার printপরিবর্তে ব্যবহার করতে পারেন return।

— জোনাথন ফ্রেচ

2

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

(a,d=[],g=s=>a.map(b=>b.map((c,i)=>(d[i]=d[i]||[])[s](c))))=>g`push`&&g`pop`

সম্পাদনা করুন: 3 টি বাইট সংরক্ষিত হয়েছে @ ইটিআর প্রডাকশনগুলির জন্য ধন্যবাদ।

— নিল
সূত্র

পছন্দ করুন আমি কেন জানি না এটি ভেবেছিলাম না, তা না হলে আমি আগেই এটি করতাম।

— নিল

1

এপিএল (ডায়ালগ ইউনিকোড) , 27 বাইট ^{এসবিসিএস}

≢¨⍴¨∘↓∘⍉⍉∘↑{⍵\⌽⍵/⍺}⍤1∘⍉∘↑=⍨

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

— ngn
সূত্র

আমি মনে করি আপনি এটিকে উত্সাহ দিয়েছেন।

— অ্যাডাম

আমি জানতাম আমি ব্যবহার করতে @পারি তবে তা আমার কাছে নেই।

— ngn

0

ক্লোজার, 123 বাইট

#(map(fn[i R](map(fn[j _](let[V(for[Q %](get Q j))F filter](nth(reverse(F + V))(count(F +(take i V))))))(range)R))(range)%)

আমি (+ nil)একটি ব্যতিক্রম ছুঁড়ে ফেলার আশা করছিলাম তবে এটি মূল্যায়ন করে nil: ও

এটি প্যাডিং ছাড়াই পরিচালিত হয়, পরিবর্তে এটি পূর্বের সারিগুলির মধ্যে কতগুলি বর্তমান সারি হিসাবে কমপক্ষে দীর্ঘ তা গণনা করে R।

— NikoNyrh
সূত্র

আকার সংরক্ষণের সময় কলামগুলি বিপরীত করুন

ভূমিকা

ইনপুট এবং আউটপুট

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

জেলি , 16 বাইট

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

জাপট , 15 13 বাইট

ব্যাখ্যা

এপিএল (ডায়ালগ ইউনিকোড) , 20 19 16 বাইট এসবিসিএস

K4 , 36 বাইট

হাস্কেল , 174 বাইট

Ungolfed / ব্যাখ্যা

পাইথন 2 , 111 105 92 বাইট

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

এপিএল (ডায়ালগ ইউনিকোড) , 27 বাইট এসবিসিএস

ক্লোজার, 123 বাইট

এপিএল (ডায়ালগ ইউনিকোড) , 20 19 16 বাইট ^{এসবিসিএস}

এপিএল (ডায়ালগ ইউনিকোড) , 27 বাইট ^{এসবিসিএস}