ब्लॉक-छँटाई पंक्तियों और स्तंभों को 2 डी सरणी में

Question

पूर्णांक के 2 डी सरणी को देखते हुए, चलो ब्लॉकों में इसकी पंक्तियों और स्तंभों को क्रमबद्ध करते हैं। इसका मतलब है कि आपको केवल एक दी गई पंक्ति या कॉलम को क्रमबद्ध करना होगा, लेकिन इसे 2 डी सरणी में हर दूसरी पंक्ति या स्तंभ पर छंटनी के लिए आवश्यक परिवर्तनों को लागू करना होगा।

नियम

• इनपुट पूर्णांक का 2 डी सरणी और 1-अनुक्रमित पूर्णांक होगा। यह पूर्णांक पंक्ति को सॉर्ट करने का प्रतिनिधित्व करेगा यदि संख्या सकारात्मक है, या स्तंभ को सॉर्ट किया जाना है यदि संख्या नकारात्मक है (या दूसरा तरीका जो आप चाहते हैं)। उदाहरण: एक 4x3(पंक्तियों x कॉलम) सरणी को देखते हुए आप एक -2तर्क के साथ दूसरा स्तंभ या एक 3तर्क के साथ तीसरी पंक्ति को सॉर्ट कर सकते हैं । यह दूसरा तर्क कभी शून्य नहीं होगा और इसका निरपेक्ष मान सरणी के संबंधित आयाम से अधिक कभी नहीं होगा।
• आउटपुट भी दिए गए पंक्ति या स्तंभ को सॉर्ट करने के लिए लगाए गए आवश्यक परिवर्तनों के साथ पूर्णांक का 2 डी सरणी होगा। वैकल्पिक रूप से आप सिर्फ 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

यह सैंडबॉक्स से आता है ।

— चार्ली

क्या हम पूर्णांक प्रतिनिधित्व को बदल सकते हैं? पंक्तियों के लिए नकारात्मक और स्तंभों के लिए सकारात्मक?

— लुइस फेलिप डी जीसस मुनोज

@LuisfelipeDejesusMunoz हाँ, यह प्रश्न में कहा गया है।

— चार्ली

क्या एक पंक्ति / स्तंभ में डुप्लिकेट किए गए नंबर हो सकते हैं?

— केविन क्रूज़सेन

@KevinCruijssen हाँ, नियमों के अंतिम उदाहरण और अंतिम बिंदु देखें।

— चार्ली

Answer 1

आर , 55 बाइट्स

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

इसे ऑनलाइन आज़माएं!

+फ़ंक्शन को ऑपरेटर (वास्तव में आर में एक फ़ंक्शन) को पुन: असाइन orderकरता है, जो एक वेक्टर के सूचक को सबसे छोटे से सबसे बड़े तक लौटाता है। तो यह सिर्फ सरणी हेरफेर है।

Comments

यह एक पुनरावर्ती कार्य के रूप में छोटा है :-)

— Giuseppe

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}

इसे ऑनलाइन आज़माएं!

-11 बाइट्स @Giuseppe को धन्यवाद।

-15 बाइट्स @LuisMendo को धन्यवाद।

Answer 4

जाप , 18 17 बाइट्स

पंक्तियों के लिए नकारात्मक और स्तंभों के लिए सकारात्मक

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

इसे ऑनलाइन आज़माएं!

Comments

यह Uनकारात्मक होने पर विफल रहता है - पिछले 17 बाइट संस्करण काम करता है, हालांकि।

— झबरा

@ मेरी बुरी, मैं हालांकि यह वैसे भी काम करेगा, बिल्कुल भी जांच नहीं किया

— लुइस फेलिप डी जेउस मुनोज

एक बुरा विचार नहीं है, हालांकि, पहले के तर्क के रूप में एक फ़ंक्शन पास करना ßस्वचालित रूप से लागू हो जाता है U। यह शाब्दिक तार पास करने की कोशिश के साथ मुद्दों को पैदा कर सकता है, लेकिन आगे की जांच के लिए वैसे भी गिटहब रेपो को एक सुझाव पोस्ट कर सकता है।

— झबरा

Answer 5

05AB1E , 25 24 14 बाइट्स

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

व्हॉटिंग -१० बाइट्स @Emigna की बदौलत ।

स्तंभों के लिए ऋणात्मक, पंक्तियों को सॉर्ट करने के लिए एक सकारात्मक पूर्णांक-इनपुट का उपयोग करता है।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

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

जावास्क्रिप्ट (ईएस 6), 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

MATL , 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

APL (Dyalog Classic) , 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

सी # (.NET कोर) , 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) द्वारा क्षैतिज सरणी, क्रमबद्ध रूप से पहले और बाद में सरणी को स्थानांतरित करना।

देखा कि कैसे प्रश्न विशेष रूप से सरणियों के बारे में बात करता है, हम सरणी को कुछ समय (बहुत, बहुत बेकार) में बदल देते हैं। कोड गोल्फ हेहे में इस तरह की क्रिया भाषा का उपयोग करने के लिए थोड़ा सा मूर्खतापूर्ण महसूस करना।

Answer 12

सी # (.NET कोर) , 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;
    }

नई ऑल-इनलाइन दृष्टिकोण; नकारात्मक जवाब अभी भी तत्व-पर-सूचकांक द्वारा सरणियों का आदेश देता है। अन्यथा, मूल्य-सूचकांक-जोड़ी का एक संग्रह सरणी-एट-इंडेक्स से बना है और मूल्य द्वारा क्रमबद्ध है। यह प्रभावी रूप से जोड़े जाने के क्रम में सूचकांकों का एक संग्रह बनाता है। फिर प्रत्येक सरणी के लिए, पूर्वनिर्धारित पदों में तत्वों का चयन किया जाता है। काफी कुछ ट्रिमिंग कोड और बदसूरत, बदसूरत, कुरूप ** चुपचाप ** इनपुट मापदंडों का पुन: उपयोग शामिल है, और वहाँ आप ... 142 बाइट्स।

फिर, सरणियों तर्क को सख्ती से लागू किया जाता है, .ToArray () कॉल के लिए कुछ ओवरहेड जोड़ते हैं।

135 बाइट्स का दावा, एह ?! C # 7.2 अनुमानित मूल्य-टुपल्स एक अतिरिक्त तीन बाइट्स ट्रिम कर देंगे, लेकिन tio.run अनुमति नहीं देता है। इसके बाद, यह वह उत्तर है जो मैंने आसान सत्यापन के लिए पोस्ट करने का निर्णय लिया है।

Comments

अच्छा उत्तर। गोल्फ के लिए कुछ छोटी चीजें हैं। (a,s)=>एक करी हो सकता है a=>s=>। (s<0)?कोष्ठक की जरूरत नहीं है, और -s-1हो सकता है ~s। इसे ऑनलाइन आज़माएँ: 137 बाइट्स

— केविन क्रूज़सेन

मिठाई! मुझे कभी भी किसी चरित्र को बचाने के लिए फ़ंक्शन को वापस करने की अनुमति नहीं मिली, मुझे सुखद आश्चर्य हुआ। धन्यवाद! इसके अलावा ऑपरेटर और कोष्ठक की अनदेखी का एक मजबूत मामला। मैंने नहीं और कोष्ठकों को अपडेट किया, लेकिन फ़ंक्शन-रिटर्निंग-फ़ंक्शन के लिए आपको सभी सम्मान छोड़ देंगे।

— बरोडस

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 बाइट्स को सभी ब्रैकेट को हटाकर और लूप्स के अंदर सब कुछ डालकर बचा सकते हैं (इनर-इफ-स्टेटमेंट सहित)। इसे ऑनलाइन आज़माएँ: 291 बाइट EDIT: यहाँ स्पेस इंडेंटेशन के साथ ताकि आप अधिक स्पष्ट रूप से मेरे द्वारा किए गए परिवर्तनों को देख सकें।

— केविन क्रूजेसेन

@ केविनक्रूजसेन मुझे पता था कि मैं कुछ याद कर रहा हूं

— X1M4L

इसके अलावा, आप a->b->इसके बजाय एक करी इनपुट बना सकते हैं और -statement को (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 बाइट्स लंबा है, लेकिन यह TIO में काम नहीं करता है। यहाँ यह लाल कंसोल में काम कर रहे सामान्य है:

लाल , 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

VBA (एक्सेल), 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

यह UseRange ... का उपयोग करते हुए खुले (सक्रिय) वर्कशीट के सभी डेटा को सॉर्ट करता है ... जिसमें केवल वे ही सेल होते हैं जिन्हें संपादित किया गया है।

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* २।