정수의 2D 배열이 주어지면 행과 열을 블록으로 정렬하십시오. 즉, 주어진 행이나 열만 정렬해야하지만 2D 배열의 다른 모든 행이나 열에 정렬하는 데 필요한 변환을 적용해야합니다.

규칙

• 입력은 정수의 2D 배열과 1- 인덱스 정수입니다. 이 정수는 숫자가 양수이면 정렬 될 행을 나타내거나 숫자가 음수이면 (또는 원하는 다른 방식으로) 정렬 될 열을 나타냅니다. 예 : 4x3(행 x 열) 배열이 주어지면 두 번째 열을 -2인수로 정렬 하거나 세 번째 열을 인수로 정렬 할 수 있습니다 3. 이 두 번째 인수는 절대 0이 아니며 절대 값은 배열의 해당 차원보다 크지 않습니다.
• 주어진 행이나 열을 정렬하기 위해 필요한 변환이 적용된 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]

이것은 code-golf 이므로 각 언어마다 가장 짧은 코드가 이길 수 있습니다!

R , 55 바이트

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

온라인으로 사용해보십시오!

+연산자 (실제로 R의 order함수 )를 함수에 재 지정합니다. 이 함수는 벡터의 인덱스를 최소에서 최대로 반환합니다. 그런 다음 배열 조작입니다.

R , 55 바이트

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

온라인으로 사용해보십시오!

ngm의 답변에 대한 대안 ; DimChtz의 답변 에서 영감을 얻은 재귀 함수

Matlab, 73 62 47 바이트

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

온라인으로 사용해보십시오!

@Giuseppe 덕분에 -11 바이트.

@LuisMendo 덕분에 -15 바이트.

apt , 18 17 바이트

행의 경우 음수, 열의 경우 음수

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

온라인으로 사용해보십시오!

05AB1E , 25 24 14 바이트

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

@Emigna 덕분에 무려 -10 바이트 .

양의 정수 입력을 사용하여 행을 정렬하고 열의 경우 음수를 사용합니다.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

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)

자바 스크립트 (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))

온라인으로 사용해보십시오!

어떻게?

JS에는 기본 전치 방법이 없으므로 정의해야합니다.

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$

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

APL (Dyalog Classic) , 23 바이트

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

온라인으로 사용해보십시오!

파이썬 2 , 71 70 바이트

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

온라인으로 사용해보십시오!

경우 n음수, 행은 열을 기준으로 분류되어 있습니다 n.

그렇지 않으면 행렬이 바뀌어 같은 방식으로 정렬되어 다시 바뀝니다.

젤리 , 12 바이트

ZṠ}¡
çị@ÞA}ç

온라인으로 사용해보십시오!

C # (. 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();}

온라인으로 사용해보십시오!

언 골프 드 :

    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)로 수평 배열을 정렬하고 선택적으로 정렬 전후 배열을 이동합니다.

질문이 배열에 대해 구체적으로 이야기하는 방식을 살펴보면 배열로 몇 번 변환합니다 (매우 낭비). 코드 골프 hehe에서 그런 장황한 언어를 사용하는 것이 약간 바보 같은 느낌.

C # (.NET Core) , 142/139 138/135 바이트 (Kevin의 또 다른 -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()

온라인으로 사용해보십시오!

언 골프 드 :

    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 바이트가 있습니다.

다시 말하지만 arrays 인수는 엄격하게 적용되어 .ToArray () 호출에 약간의 오버 헤드가 추가됩니다.

135 바이트 청구, 응?! C # 7.2 추론 된 값 튜플은 추가로 3 바이트를 트리밍하지만 tio.run은 허용하지 않습니다. 따라서 이것은 쉬운 확인을 위해 게시하기로 결정한 답변입니다.

자바 (OpenJDK 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;}

온라인으로 사용해보십시오!

글쎄,이 질문은 나에게 매우 실망 스러웠고, 나는 내 대답을 게시했다. 나는 무언가를 잊고 있었다. 행운 적으로 우리는 Kevin Cruijssen 과 같은 전설이있다. 를 돕기 위해 여기에있다 :)

자바 (OpenJDK 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];}

온라인으로 사용해보십시오!

클린 , 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

온라인으로 사용해보십시오!

코 틀린 , 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]}}}}

온라인으로 사용해보십시오!

루비 , 69 바이트

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

온라인으로 사용해보십시오!

빨강 , 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에서는 작동하지 않습니다. 다음은 Red 콘솔에서 정상 작동하는 것입니다.

빨강 , 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]

VBA (Excel), 205 바이트

예이! 두 번째로 긴 바이트 수! 나는 완전히 잃지 않았다 : D

골프 :

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

이것은 BugRa가 될 수 있지만 UsedRange ...를 사용하여 열린 (활성) 워크 시트의 모든 데이터를 정렬하지만 편집 된 셀만 포함해야합니다.

언 골프 드 :

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

펄 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 $!

피지 카 , 45 바이트

Arnauld의 JS answer 와 매우 유사합니다 .

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.

J , 32 바이트

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

온라인으로 사용해보십시오!

참고 : g=. 동사의 개수는 포함되지 않습니다.

동일한 바이트에 대한 명시 적 버전

J , 32 바이트

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

온라인으로 사용해보십시오!

클로저, 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.