2D অ্যারেতে সারি এবং কলামগুলিকে ব্লক-বাছাই করুন

Question

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

বিধি

• ইনপুটটি 2D অ্যারে পূর্ণসংখ্যার এবং 1-সূচকযুক্ত পূর্ণসংখ্যা হবে। এই পূর্ণসংখ্যাটি সংখ্যাটি ধনাত্মক হলে বাছাই করার জন্য সারিটি বা সংখ্যাটি নেতিবাচক হলে বা কলামটি বাছাই করতে হবে (অথবা আপনি চাইছেন এমন অন্যভাবে) উপস্থাপন করবে। উদাহরণ: একটি 4x3(সারি x কলাম) অ্যারে দেওয়া আপনি একটি দিয়ে দ্বিতীয় কলামটি বাছাই করতে পারেন-2 যুক্তির সাহায্যে বা তৃতীয় সারিতে3 । এই দ্বিতীয় যুক্তিটি কখনই শূন্য হবে না এবং এর নিরঙ্কুশ মানটি অ্যারের সাথে সম্পর্কিত মাত্রার চেয়ে বড় কখনও হবে না।
• প্রদত্ত সারি বা কলামটি বাছাই করতে প্রয়োজনীয় ট্রান্সফর্মেশনগুলি প্রয়োগ করে আউটপুট একটি 2D অ্যারেও হবে। বিকল্পভাবে আপনি কেবল অ্যারে STDOUT এ লিখতে পারেন।
• আউটপুট অ্যারেতে নির্দিষ্ট সারি বা কলামটি আরোহণ ক্রমে সাজানো থাকবে। কেবলমাত্র নোট করুন যে যখন আপনার একটি সারিতে দুটি সংখ্যা অদলবদল করা দরকার তখন পুরো কলামগুলি যেখানে নম্বরগুলি দেয় সেগুলি অদলবদল করা হবে। এবং যখন আপনাকে একটি কলামে দুটি সংখ্যা অদলবদল করা দরকার, পুরো সারিগুলিতে যেখানে নম্বরগুলি রাখা হয়েছে সেগুলি সরিয়ে নেওয়া হবে।
• সাজানোর জন্য সারি / কলামে একই সংখ্যাটি বেশ কয়েকবার প্রদর্শিত হবে, আপনি যে মানগুলি অদলবদল করেছেন সে অনুসারে কয়েকটি সমাধান সম্ভব হবে, কেবলমাত্র বাকী সারি / কলামগুলিকে অদলবদলের সাথে সাথে করুন।

উদাহরণ

Positive indices for rows and negative indices for columns

[5  8  7  6                                  [1  3  2  4
 1  3  2  4   order by -3 (3rd column)  -->   9  6  3  0
 9  6  3  0]                                  5  8  7  6]

[5  8  7  6                                  [9  6  3  0
 1  3  2  4   order by -4 (4th column)  -->   1  3  2  4
 9  6  3  0]                                  5  8  7  6]

[5  8  7  6                                  [5  7  8  6
 1  3  2  4     order by 2 (2nd row)  -->     1  2  3  4
 9  6  3  0]                                  9  3  6  0]

[5  8  7  6                                  [6  7  8  5
 1  3  2  4     order by 3 (3rd row)  -->     4  2  3  1
 9  6  3  0]                                  0  3  6  9]

[1  2                                    [1  2     [3  2
 3  2]   order by -2 (2nd column)  -->    3  2] or  1  2]  (both are valid)

[7  5  9  7                                  [5  7  7  9     [5  7  7  9
 1  3  2  4     order by 1 (1st row)  -->     3  1  4  2  or  3  4  1  2
 9  6  3  0]                                  6  9  0  3]     6  0  9  3]

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

Comments

এটি স্যান্ডবক্স থেকে আসে ।

— চার্লি

আমরা কি পূর্ণসংখ্যার উপস্থাপনা পরিবর্তন করতে পারি? সারিগুলির জন্য নেতিবাচক এবং কলামগুলির জন্য ধনাত্মক?

— লুইস ফেলিপ দে জেসুস মুনোজ

@ লুইসেলিপডিজেসাস মুনোজ হ্যাঁ, এটি প্রশ্নে বর্ণিত হয়েছে।

— চার্লি

একটি সারি / কলামে নকল সংখ্যা থাকতে পারে?

— কেভিন ক্রুইজসেন

@ কেভিন ক্রুজসেন হ্যাঁ, বিধিগুলির শেষ উদাহরণ এবং শেষ পয়েন্টটি দেখুন।

— চার্লি

Answer 1

আর , 55 বাইট

function(x,n)`if`(n>0,x[,+x[n,]],x[+x[,-n],])
`+`=order

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

+অপারেটরটিকে (প্রকৃতপক্ষে আর একটি ফাংশন) ফাংশনে পুনরায় সাইন ইন orderকরে, যা কোনও ভেক্টরের সূচককে সবচেয়ে ছোট থেকে বৃহত্তমতে ফিরিয়ে দেয়। তারপরে এটি ঠিক অ্যারে কারসাজি।

Comments

এটি একটি পুনরাবৃত্ত ফাংশনটির মতোই সংক্ষিপ্ত :-)

— জিউসেপে

Answer 2

আর , 55 বাইট

f=function(m,i)"if"(i<0,t(f(t(m),-i)),m[,order(m[i,])])

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

এনজিএম এর উত্তরের বিকল্প ; একটি পুনরাবৃত্ত ফাংশন যা DimChtz এর উত্তর দ্বারা অনুপ্রাণিত হয়েছিল

Answer 3

মতলব, 73 62 47 বাইট

@(m,i){sortrows(m,-i) sortrows(m',i)'}{(i>0)+1}

অনলাইনে চেষ্টা করে দেখুন!

-১১ বাইটস @ জিউসেপ্পকে ধন্যবাদ।

-15 বাইটস @ লুইস মেন্ডোকে ধন্যবাদ।

Answer 4

জাপট , 18 17 বাইট

সারিগুলির জন্য নেতিবাচক এবং কলামগুলির জন্য ধনাত্মক

>0?VñgUÉ:ßUa Vy)y

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

Comments

এটি ব্যর্থ হয় যখন Uনেতিবাচক হয় - যদিও পূর্ববর্তী 17 বাইট সংস্করণটি কাজ করে।

— শেগি

@ শেগি আমার খারাপ, যদিও এটি যাইহোক কাজ করবে, তা মোটেও চেক করিনি

— লুইস ফিলিপ দে জেসুস মুনোজ

কোনও খারাপ ধারণা নয়, তবে এটির প্রথম যুক্তি হিসাবে কোনও ক্রিয়াকলাপটি পাস করা ßস্বয়ংক্রিয়ভাবে প্রয়োগ হয়ে যায় U। এটি আক্ষরিক স্ট্রিংগুলি পাস করার চেষ্টা করার সাথে সমস্যা তৈরি করতে পারে তবে আরও তদন্তের জন্য যাইহোক গিটহাব রেপোতে একটি পরামর্শ পোস্ট করুন।

— শেগি

Answer 5

05 এ বি 1 ই , 25 24 14 বাইট

diø}Σ¹Ä<è}¹diø

খুব বড় -10 ধন্যবাদ বাইট @Emigna ।

সারিগুলি বাছাই করতে একটি ইতিবাচক পূর্ণসংখ্যা-ইনপুট ব্যবহার করে, কলামগুলির জন্য negativeণাত্মক।

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

ব্যাখ্যা:

di }      # If the (implicit) integer input is positive:
  ø       #  Swap the rows and columns of the (implicit) matrix input
          #   i.e. 3 and [[5,8,7,6],[1,3,2,4],[9,6,3,0]]
          #    → [[5,1,9],[8,3,6],[7,2,3],[6,4,0]]
Σ    }    # Sort the rows of this matrix by:
 ¹Ä       #  Take the absolute value of the input
          #   i.e. -3 → 3
   <      #  Decreased by 1 to make it 0-indexed
          #   i.e. 3 → 2
    è     #  And index it into the current row
          #   i.e. [5,8,7,6] and 2 → 7
          #   i.e. [5,1,9] and 2 → 9
          #  i.e. [[5,1,9],[8,3,6],[7,2,3],[6,4,0]] sorted by [9,6,3,0]
          #   → [[6,4,0],[7,2,3],[8,3,6],[5,1,9]]
          #  i.e. [[5,8,7,6],[1,3,2,4],[9,6,3,0]] sorted by [7,2,3]
          #   → [[1,3,2,4],[9,6,3,0],[5,8,7,6]]
¹di       # And if the integer input was positive:
   ø      #  Swap the rows and columns back again now that we've sorted them
          #   i.e. 3 and [[6,4,0],[7,2,3],[8,3,6],[5,1,9]]
          #    → [[6,7,8,5],[4,2,3,1],[0,3,6,9]]
          # (And implicitly output the now sorted matrix)

Comments

আমি পেয়েছি diø}Σ¹Ä<è]¹diøযা আপনার একটি উপসেট, তাই আমি আলাদা উত্তর পোস্ট করছি না।

— Emigna

@ এমিগনা ডাং, আপনি এটিকে এত সহজ দেখিয়েছেন .. এখন যেহেতু আমি এটি দেখতে পাচ্ছি আমি বিশ্বাস করতে পারি না যে আমি নিজেই সে সম্পর্কে ভেবে দেখিনি, তবে এটি একই সাথে বুদ্ধিমান .. ধন্যবাদ! একটি সম্পূর্ণ 10 বাইট আপনাকে ধন্যবাদ সংরক্ষণ করেছে।

— কেভিন ক্রুইজসেন

Answer 6

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

t=m=>m[0].map((_,x)=>m.map(r=>r[x]))
f=(m,k)=>k<0?m.sort((a,b)=>a[~k]-b[~k]):t(f(t(m),-k))

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

কিভাবে?

জেএসের কোনও নেটিভ ট্রান্সপোজেশন পদ্ধতি নেই, সুতরাং আমাদের একটি সংজ্ঞা দেওয়া দরকার:

t = m =>              // given a matrix m[]
  m[0].map((_, x) =>  // for each column at position x in m[]:
    m.map(r =>        //   for each row r in m[]:
      r[x]            //     map this cell to r[x]
    )                 //   end of map() over rows
  )                   // end of map() over columns

প্রধান ফাংশন:

f = (m, k) =>         // given a matrix m[] and an integer k
  k < 0 ?             // if k is negative:
    m.sort((a, b) =>  //   given a pair (a, b) of matrix rows, sort them:
      a[~k] - b[~k]   //     by comparing a[-k - 1] with b[-k - 1]
    )                 //   end of sort
  :                   // else:
    t(f(t(m), -k))    //   transpose m, call f() with -k and transpose the result

$k=2$

$$M=\pmatrix{5&8&7&6\\1&3&2&4\\9&6&3&0}\rightarrow t(M)=\pmatrix{5&1&9\\8&3&6\\7&2&3\\6&4&0}\rightarrow f(t(M),-2)=\pmatrix{5&\mathbf{\color{red}1}&9\\7&\mathbf{\color{red}2}&3\\8&\mathbf{\color{red}3}&6\\6&\mathbf{\color{red}4}&0}\\f(M,2)=t(f(t(M),-2))=\pmatrix{5&7&8&6\\\mathbf{\color{red}1}&\mathbf{\color{red}2}&\mathbf{\color{red}3}&\mathbf{\color{red}4}\\9&3&6&0}$$

Answer 7

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

y0>XH?!]w|2$XSH?!

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

বা সমস্ত পরীক্ষার কেস যাচাই করুন

ব্যাখ্যা

y       % Implicit inputs: number n, matrix M. Duplicate from below: pushes n, M, n
0>      % Greater than 0?
XH      % Copy into clipboard H
?       % If true
  !     %   Transpose matrix. This way, when we sort the rows it will correspond
        %   to sorting the columns of the original M
]       % End
w       % Swap: moves n to top
|       % Absolute value
2$XS    % Two-input sortrows function: sorts rows by specified column
H       % Push contents from clipboard H
?       % If true
  !     %   Transpose again, to convert rows back to columns
        % Implicit end
        % Implicit display

Answer 8

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

{⍺<0:⍉(-⍺)∇⍉⍵⋄⍵[;⍋⍺⌷⍵]}

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

Answer 9

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

f=lambda m,n:n<0and sorted(m,key=lambda l:l[~n])or zip(*f(zip(*m),-n))

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

---

যদি nনেতিবাচক হয় তবে সারিগুলি কলামের ভিত্তিতে বাছাই করা হয় n।

অন্যথায় ম্যাট্রিক্স স্থানান্তরিত হয়, একইভাবে বাছাই করা হয় এবং আবার স্থানান্তরিত হয়।

Answer 10

জেলি , 12 বাইট

ZṠ}¡
çị@ÞA}ç

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

Answer 11

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

(x,y)=>{Func<int[][],int[][]>shift=a=> a[0].Select((r,i)=>a.Select(c=>c[i]).ToArray()).ToArray();return y>0?shift(shift(x).OrderBy(e=>e[y-1]).ToArray()):x.OrderBy(e=>e[-y-1]).ToArray();}

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

Ungolfed:

    private static int[][] Blocksort0a(int[][] array, int sortingInstruction)
    {
        Func<int[][], int[][]> shift = a => a[0].Select((r, i) => a.Select(c => c[i]).ToArray()).ToArray();

        sortingInstruction++;

        array = sortingInstruction < 0 ? 
        shift(shift(array).OrderBy(e => e[-sortingInstruction]).ToArray()) 
             : 
        array.OrderBy(e => e[sortingInstruction]).ToArray();

        return null;
    }

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

এখন অর্ডারিং সহজ, সংখ্যা-এ-ইনডেক্স (আর্গুমেন্ট -1) দ্বারা অনুভূমিক অ্যারে অর্ডার করুন, বাছাইয়ের আগে এবং পরে optionচ্ছিকভাবে অ্যারে স্থানান্তর করুন।

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

Answer 12

সি # (.নেট কোর) , 142/139 138/135 বাইট (এবং এখনও কেভিনের অন্য -1)

(a,s)=>s<0?a.OrderBy(e=>e[~s]).ToArray():a.Select(f=>a[s-1].Select((v,j)=>new{v,j}).OrderBy(e=>e.v).Select(e=>f[e.j]).ToArray()).ToArray()

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

Ungolfed:

    private static int[][] Blocksort0b(int[][] array, int sortingInstruction)
    {
        if (sortingInstruction < 0) { return array.OrderBy(e => e[-sortingInstruction - 1]).ToArray(); }
        var rowIndices = array[sortingInstruction - 1].Select((value, index) => (value, index)).OrderBy(e => e.value);
        var newRow = new int[array[0].Length];
        for (var i = 0; i < array.Length; i++)
        {
            int horizontalIndexer = 0;
            foreach (var e in rowIndices)
            {
                newRow[horizontalIndexer++] = array[i][e.index];
            }
            array[i] = newRow.ToArray();
        }
        return array;
    }

নতুন সমস্ত ইনলাইন পদ্ধতির; নেতিবাচক উত্তর এখনও উপাদান-এ-সূচক দ্বারা অ্যারে আদেশ। অন্যথায়, মান-সূচক-জুটির একটি সংগ্রহ অ্যারে-এ-ইনডেক্স থেকে তৈরি করা হয় এবং মান অনুসারে বাছাই করা হয়। এটি কার্যকরভাবে যুক্ত হওয়ার সাথে যুক্ত সূচকের একটি সংগ্রহ তৈরি করে। তারপরে প্রতিটি অ্যারের জন্য পূর্বনির্ধারিত পজিশনের উপাদানগুলি নির্বাচন করা হয়। বেশ কয়েকটি কোড এবং কুৎসিত, কুরুচিপূর্ণ, কুশ্রী ** চুপচাপ sobs ** ইনপুট পরামিতিগুলির পুনরায় ব্যবহার জড়িত রয়েছে এবং আপনি সেখানে যান ... 142 বাইট।

আবার অ্যারে যুক্তিটি কঠোরভাবে প্রয়োগ করা হয়, .ToArray () কলগুলির জন্য বেশ কয়েকটি ওভারহেড যুক্ত করে।

135 বাইট দাবি, আহ ?! সি # 7.2 ইনফারার্ড মান-টিপলসগুলি অতিরিক্ত তিন বাইট ছাঁটাই করবে, তবে tio.run অনুমতি দেয় না। এর জন্য, এই সহজ উত্তর যাচাইয়ের জন্য পোস্ট করার সিদ্ধান্ত নিয়েছে।

Comments

চমৎকার উত্তর. গল্ফ করার জন্য কয়েকটি ছোট ছোট জিনিস রয়েছে। (a,s)=>একটি সংবাহন হতে পারে a=>s=>। (s<0)?প্রথম বন্ধনী প্রয়োজন হয় না, এবং -s-1হতে পারে ~s। এটি অনলাইনে ব্যবহার করে দেখুন: 137 বাইট

— কেভিন ক্রুইজসেন

খুব সুন্দর! চরিত্রটি বাঁচানোর জন্য আমি ফাংশনটিকে আর একটি ফাংশনটি আবারও দিয়ে দিতে পারি নি, আমি আনন্দিতভাবে অবাক হয়েছি। ধন্যবাদ! অপারেটর এবং প্রথম বন্ধনীকে নির্মোহভাবে উপেক্ষা করার একটি দৃ case় কেস। আমি নোট এবং প্রথম বন্ধনী আপডেট করেছি, তবে আপনাকে ফাংশন-রিটার্নিং-ফাংশনের জন্য সমস্ত সম্মান ছেড়ে দেব।

— বারোডাস

Answer 13

জাভা (ওপেনজেডিকে 8) , 326 বাইট

(a,b)->{int l=a.length,w=a[0].length,k,m,t,i;if(b>0){for(i=0;i<w;i++){for(k=1;k<(w-i);k++){if(a[b-1][k-1]>a[b-1][k]){for(m=0;m<l;m++){t=a[m][k];a[m][k]=a[m][k-1];a[m][k-1]=t;}}}}}else{b*=-1;for(i=0;i<l;i++){for(k=1;k<(l-i);k++){if(a[k-1][b-1]>a[k][b-1]){for(m=0;m<w;m++){t=a[k][m];a[k][m]=a[k-1][m];a[k-1][m]=t;}}}}}return a;}

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

ভাল ছেলেরা, এই প্রশ্নটি আমার জন্য খুব হতাশাব্যঞ্জক, এবং আমি আমার উত্তরটি পোস্ট করে জানলাম আমি কিছু ভুলে যাচ্ছিলাম, ভাগ্যক্রমে আমাদের এখানে কেভিন ক্রুইজসেনের মতো কিংবদন্তি রয়েছে আমাদের সাহায্য করার জন্য :)

জাভা (ওপেনজেডিকে 8) , 281 বাইট

a->b->{int l=a.length,w=a[0].length,k,m,t,i;if(b>0)for(i=0;i<w;i++)for(k=0;++k<w-i;)for(m=0;a[b-1][k-1]>a[b-1][k]&m<l;a[m][k]=a[m][k-1],a[m++][k-1]=t)t=a[m][k];else for(b*=-1,i=0;i<l;i++)for(k=0;++k<l-i;)for(m=0;a[k-1][b-1]>a[k][b-1]&m<w;a[k][m]=a[k-1][m],a[k-1][m++]=t)t=a[k][m];}

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

Comments

আমি এখনও আসল অ্যালগরিদমের দিকে নজর দিইনি, তবে আপনি সমস্ত বন্ধনীগুলি সরিয়ে এবং লুপের অভ্যন্তরে সমস্ত কিছু রেখে (35 টি অভ্যন্তরীণ if-বিবৃতি সহ) 35 বাইট সংরক্ষণ করতে পারেন। অনলাইনে এটি ব্যবহার করে দেখুন: 291 বাইট সম্পাদনা: এখানে স্পেস ইন্ডেন্টেশন সহ যাতে আপনি আরও পরিষ্কারভাবে আমার পরিবর্তনগুলি দেখতে পারেন।

— কেভিন ক্রুইজসেন

@ কেভিন ক্রুজসেন আমি জানতাম যে আমি কিছু মিস করছি

— এক্স 1 এম 4 এল

আপনি ইনপুট-অ্যারে সংশোধন করছেন যেহেতু , আপনি এটির a->b->পরিবর্তে এটি একটি কারিঙ ইনপুট তৈরি করতে এবং স্টেটমেন্টটি (a,b)->সরাতে পারেন return। 281 বাইট এখনও একটি দুর্দান্ত উত্তর, যদিও। আমার কাছ থেকে +1 আমি 05AB1E এ চ্যালেঞ্জটি করেছি, তবে জাভাতে এটি চেষ্টাও করতে পারিনি। ;)

— কেভিন ক্রুইজসেন

270 বাইট

— সিলিংক্যাট

Answer 14

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

import StdEnv,Data.List,Data.Func
$n#f=if(n>0)transpose id
=f o sortBy(on(<)\u=u!!(abs n-1))o f

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

Answer 15

কোটলিন , 192 বাইট

{m:Array<Array<Int>>,s:Int->if(s<0){m.sortBy{it[-s-1]}}else{val a=Array(m[0].size){c->Array(m.size){m[it][c]}}
a.sortBy{it[s-1]}
(0..m.size-1).map{r->(0..m[0].size-1).map{m[r][it]=a[it][r]}}}}

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

Answer 16

রুবি , 69 বাইট

->a,n{f=->x{[0,x.transpose,x][n<=>0]};f[f[a].sort_by{|x|x[n.abs-1]}]}

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

Answer 17

লাল , 190 185 বাইট

func[b n][t: func[a][c: length? a/1 a: to[]form a
d: copy[]loop c[append/only d extract a c take a]d]d: does[if n > 0[b: t b]]d
m: absolute n sort/compare b func[x y][x/(m) < y/(m)]d b]

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

ব্যাখ্যা:

f: func [ b n ] [
    t: func [ a ] [                            ; helper transpose function 
        c: length? a/1                         ; c is the length of the rows
        a: to-block form a                     ; flatten the list
        d: copy []                             ; an empty block (list)
        loop c [                               ; do as many times as the number of columns  
            append/only d extract a c          ; extract each c-th element (an entire column)
                                               ; and append it as a sublist to d
            take a                             ; drop the first element
        ] 
        d                                      ; return the transposed block (list of lists)
    ]
   d: does [ if n > 0 [ b: t b ] ]             ; a helper function (parameterless) to transpose 
                                               ; the array if positive n
   d                                           ; call the function  
   m: absolute n                               ; absolute n
   sort/compare b func[ x y ] [ x/(m) < y/(m) ]; sort the array according to the chosen column 
   d                                           ; transpose if positive n
   b                                           ; return the array  
]

আমার আসল সমাধানটি 175 বাইট দীর্ঘ, তবে এটি টিআইওতে কাজ করে না। এটি এখানে, রেড কনসোলে নরমালিল কাজ করছে:

লাল , 175 বাইট

func[b n][d: does[if n > 0[c: length? b/1 a: to-block form b
t: copy[]loop c[append/only t extract a c take a]b: t]]d
m: absolute n sort/compare b func[x y][x/(m) < y/(m)]d b]

Answer 18

ভিবিএ (এক্সেল), 205 বাইট

হ্যাঁ! দ্বিতীয়তমতম বাইট গণনা! আমি পুরোপুরি হারিনি: ডি

Golfed:

Sub d(a)
With ActiveSheet.Sort
  .SortFields.Clear
  .SortFields.Add Key:=IIf(a<0,ActiveSheet.Columns(Abs(a)),ActiveSheet.Rows(Abs(a)))
  .SetRange ActiveSheet.UsedRange
  .Orientation=IIf(a<0,1,2)
  .Apply
End With
End Sub

এটি UsedRange ব্যবহার করে খোলা (সক্রিয়) কার্যপত্রকের সমস্ত ডেটা বাছাই করে ... যা বগি হতে পারে, তবে কেবল সম্পাদিত কক্ষগুলি থাকা উচিত।

UnGolfed:

Sub d(a)
  'Clear any Sort preferences that already exists
  ActiveSheet.Sort.SortFields.Clear
  'Use the column if A is negative, the row if A is positive
  ActiveSheet.Sort.SortFields.Add Key:=IIf(a < 0, ActiveSheet.Columns(Abs(a)), ActiveSheet.Rows(Abs(a)))
  'Set the area to sort
  ActiveSheet.Sort.SetRange ActiveSheet.UsedRange
  'Orient sideways if sorting by row, vertical if by column
  ActiveSheet.Sort.Orientation = IIf(a < 0, xlTopToBottom, xlLeftToRight)
  'Actually sort it now
  ActiveSheet.Sort.Apply
End Sub

Comments

যদি আপনি ধরে নেন যে অ্যাক্টিভীটটি শীট 1, তবে আপনি এটি 169 বাইট হিসাবে নামিয়ে নিতে পারেনSub d(a) With Sheet1.Sort .SortFields.Clear .SortFields.Add IIf(a<0,Columns(Abs(a)),Rows(Abs(a))) .SetRange Sheet1.UsedRange .Orientation=(a<0)+2 .Apply End With End Sub

— টেলর স্কট

এছাড়াও, আমি মনে করি যে আপনি নিরাপদে ধরে নিতে পারেন যে কোনও .SortFieldsসংজ্ঞায়িত নেই তাই আপনি .Sortfields.Clearলাইনটিও সরাতে পারবেন ।

— টেলর স্কট

Answer 19

পার্ল 6 , 43 বাইট

{($!=$_>0??&[Z]!!*[])o*.sort(*[.abs-1])o$!}

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

কার্ড ফাংশন।

ব্যাখ্যা

{                                         } # Block returning function composed of
                                       o$!  # 1. Apply $! (transpose or not)
                     o*.sort(*[.abs-1])     # 2. Sort rows by column abs(i)-1
     $_>0??&[Z]                             # 3. If i > 0 transpose matrix
               !!*[]                        #    Else identity function
 ($!=               )                       #    Store in $!

Answer 20

ফিজিকা , 45 বাইট

আরনাউল্ডের জেএস উত্তরের সাথে খুব মিল ।

F=>n;m:n<0&&Sort[->u:u{~n};m]||Zip@F#Zip@m#-n

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

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

লিঙ্কিত উত্তরে আরও বিস্তৃত এবং চাক্ষুষ ব্যাখ্যা পাওয়া যাবে।

F=>n;m:           // Create a function F that takes two arguments, n and m.
       n<0&&      // If n < 0 (i.e. is negative)
Sort[->u{~n};m]   // Sort the rows u of m by the result of the function u[~n].
                  // In short, sort by indexing from the end with n.
||    F#Zip@m#-n  // Else, apply F to Zip[m] and -n. Uses a new feature, binding.
  Zip@            // And transpose the result.

Answer 21

জে , 32 বাইট

f=.[/:({"1~<:)
g=.(f&.|:|)`f@.(0<])

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

দ্রষ্টব্য: g=. মূল ক্রিয়াটি গণনা করে না।

একই বাইটগুলির জন্য একটি স্পষ্ট সংস্করণ

জে , 32 বাইট

4 :'y(]/:{"1)&.(|:^:(x<0))~<:|x'

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

Answer 22

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

(fn f[A i](if(< i 0)(sort-by #(nth %(- -1 i))A)(apply map list(f(apply map list A)(- i)))))

আরগ, apply map list* 2।