^{З цього питання stackoverflow}

Враховуючи двовимірний масив розміром , виведіть значення в напрямку проти годинникової стрілки. Вихід повинен починатись із зовнішньої сторони до внутрішньої, і початкова точка завжди буде .$M \times N$$(0,0)$

Приклад наведено:

Значення ребер проти годинникової стрілки тоді .$1,5,9,13,14,15,16,12,8,4,3,2$

Тепер ми повторимо процес для внутрішніх значень. Це закінчиться такою матрицею, як наступна

А внутрішні значення тоді$6,10,11,7$

Кінцевим результатом буде$1,5,9,13,14,15,16,12,8,4,3,2,6,10,11,7$

Правила

• Припустимо не порожній вхід
• Припустимо матричні значення як натуральні цілі числа
• Застосовуються стандартні методи вводу / виводу
• Застосовуються стандартні правила гольф-коду та критерії виграшу

Деякі тестові випадки

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

--------------------------------------------------------

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

-----------------------------------------------------
Input
[
    [1]
]
Output
1
-----------------------------------
Input
[
    [1, 2],
    [2, 1]
]
Output
1,2,1,2
-----------------------------------------------------
Input
[
    [1,2,3,6,7],
    [2,4,3,2,1],
    [3,2,4,5,6],
    [6,5,6,5,4],
    [10,4,7,8,9],
    [12,4,9,8,7]
]
Output
1,2,3,6,10,12,4,9,8,7,9,4,6,1,7,6,3,2,4,2,5,4,7,8,5,5,2,3,4,6

R , 54 байти

Кілька байтів зберегли @Giuseppe та @ J.Doe.

f=function(m)if(ncol(m))c(m[,1],f(t(m[nrow(m):1,-1])))

Спробуйте в Інтернеті!

Рекурсивно знімайте перший стовпець і реверсуйте / переносуйте рядки (роблячи нижній рядок новим першим стовпцем) решту матриці, поки ви не виявите лише один стовпець. "Традиційна" версія без вовків:

f <- function(m) {
 if(ncol(m) == 1) {
    m
  } else {
    c(m[,1], f(t(m[nrow(m):1,-1])))
  }
}

Було зазначено, що ncol(m) можемо використовувати гольф, щоб sum(m)зберегти ще один байт, оскільки нам дозволяється приймати додатні цілі матричні значення. Але я залишу це так, оскільки він працює для всіх матриць (навіть матриць рядків!)

Python 2 , 52 байти

f=lambda a:a and zip(*a)[0]+f(zip(*a[::-1])[1:])or()

Спробуйте в Інтернеті!

Pyth , 9 байт

shMM.utC_

Спробуйте тут!

Як?

shMM.utC_     Full program. Takes a 2D array (matrix) from STDIN.
    .u        Until a result that has occurred before is found, loop and collect...
        _     Reverse the matrix (reverse the order of its rows).
       C      Transpose.
      t       Remove first element.
 hMM          For each element in the resulting 3D array, get the heads of its elements.
s             Flatten.

Стакс , 7 байт

ôQÖG·í<

Запустіть і налагоджуйте його

Він займає масив рядків на одному рядку і видає виведений з нового рядка вихід.

Розпакований, неозорений та коментований, це виглядає приблизно так.

W       repeat the rest of the program until cancelled explicitly
  rM    rotate matrix *clock-wise* (yes, this is the opposite of the challenge)
  |c    assert matrix is truthy. (has rows) cancel otherwise.
  B     remove the top row of the matrix, and push separately to main stack
  rm    reverse the top row (this fixes the rotation direction), and print each value

Виконати цей

Pyth, 20 байт

J.TQWJ=+YhJ=J_.TtJ)Y

Спробуйте тут

Пояснення

J.TQWJ=+YhJ=J_.TtJ)Y
J.TQ                    Call the transposed input J.
    WJ            )     While J is not empty...
      =+YhJ             ... put the top row into Y (initially [])...
           =J   tJ      ... remove the top row...
             _.T        ... reverse and transpose (rotate clockwise).
                   Y    Output the result.

oK , 12 байт

*+,/(1_+|:)\

Спробуйте в Інтернеті!

Це зловживає тим, що ОК, здається, не надто переймається формою транспозиції. В до це буде 13 байт : *:',/(1_+|:)\.

       +|:   /reverse, then transpose (rotate right)
     1_      /remove first line
    (     )\ /fixpoint of the above, keeping intermediate results (scan)
  ,/         /concatenate all the rows
*+           /get the first element of each row

Чисто , 69 байт

import StdEnv,StdLib
? =transpose
@[h:t]=h++ @(reverse(?t))
@_=[]

@o?

Спробуйте в Інтернеті!

Переміщає наступний рядок / стовпчик на голову списку, щоб він міг відповідати шаблону аргументу.

Перший приклад виклику виглядає так:

@o? [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
@ h=:[1, 5, 9, 13] t=:[[2, 6, 10, 14], [3, 7, 11, 15], [4, 8, 12, 16]]
[1, 5, 9, 13] ++ @ h=:[14, 15, 16] t=:[[10, 11, 12], [6, 7, 8], [2, 3, 4]]
[1, 6, 9, 13, 14, 15, 16] ++ @ h=:[12, 8, 4] t=:[[11, 7, 3], [10, 6, 2]]
[1, 6, 9, 13, 14, 15, 16, 12, 8, 4] ++ @ h=:[3, 2] t=:[[7, 6], [11, 10]]
[1, 6, 9, 13, 14, 15, 16, 12, 8, 4, 3, 2] ++ @ h=:[6, 10] t=:[[7, 11]]
[1, 6, 9, 13, 14, 15, 16, 12, 8, 4, 3, 2, 6, 10] ++ @ h=:[11, 7] t=:[]
[1, 6, 9, 13, 14, 15, 16, 12, 8, 4, 3, 2, 6, 10, 11, 7] ++ @ []

Джулія 0,7 , 47 байт

f(m)=[m[:,1];sum(m)<1?[]:f(rotr90(m[:,2:end]))]

Спробуйте в Інтернеті!

Джулія має зручний вбудований для обертання матриці на 90 градусів, що виключає необхідність операцій транспозиції назад.

Як видно з попереджень компілятора, він наполягає на тому, що всі компоненти потрійного умовного повинні бути розділені пробілами, і в т. 1.0 це фактично виконується.

Як не дивно, але в цій ситуації найкоротшим способом, який я виявив, щоб вирватися з рекурсії, було використання блоку пробного лову:

Джулія 1,0 , 50 байт

f(m)=[m[:,1];try f(rotr90(m[:,2:end]))catch;[]end]

Спробуйте в Інтернеті!

JavaScript (Node.js) , 89 байт

f=a=>a>[]?[...a.map(x=>x[0]),...f(a[0].map((_,i)=>a.map(y=>y[i]).reverse()).slice(1))]:[]

Спробуйте в Інтернеті!

Бере перший колонку, перекладає решту, потім перевертає кожен рядок (= обертає матрицю на 90 градусів CW), а потім повторює, поки в масиві не буде більше записів.

APL (Dyalog) , 24 22 байти

{×≢⍵:⍵[;1],∇⍉⊖0 1↓⍵⋄⍬}

Спробуйте в Інтернеті!

Як?

{×≢⍵:⍵[;1],∇⍉⊖0 1↓⍵⋄⍬}
{                    } - a function
 ×≢⍵:                  - if non-empty:
     ⍵[;1]             - the left column
          ,∇⍉⊖0 1↓⍵    - repeat this function without the left column, rotated counter clockwise
                   ⋄⍬  - otherwise, return an empty vector

05AB1E , 13 11 10 байт

ΔRøćRˆ}¯˜þ

-2 байти завдяки @Emigna .

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

Δ         # Loop until the stack no longer changes:
 R        #  Reverse the order of the rows
          #   i.e. [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
          #    → [[13,14,15,16],[9,10,11,12],[5,6,7,8],[1,2,3,4]]
  ø       #  Zip, swapping rows and column
          #   → [[13,9,5,1],[14,10,6,2],[15,11,7,3],[16,12,8,4]]
   ć      #  Head extracted
          #   → [[14,10,6,2],[15,11,7,3],[16,12,8,4]] and [13,9,5,1]
    R     #  Reverse this row
          #   → [1,5,9,13]
     ˆ    #  Pop and push it to the global array
}         # After the loop:
 ¯        #  Push the global array
          #   i.e. [[1,5,9,13],[14,15,16],[12,8,4],[3,2],[6,10],[11],[7],"",""]
  ˜       #  Flatten it
          #   → [1,5,9,13,14,15,16,12,8,4,3,2,6,10,11,7,"",""]
   þ      #  Remove all empty string by only leaving all digits
          #   → ["1","5","9","13","14","15","16","12","8","4","3","2","6","10","11","7"]
          # (and output it implicitly)

Желе , 9 байт

ZḊUƊƬḢ€€Ẏ

Спробуйте в Інтернеті!

Вугілля деревне , 25 байт

≔⮌ＥＡ⮌ιθＷθ«≔Ｅ§θ⁰⮌Ｅθ§μλθＩ⊟θ

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення:

≔⮌ＥＡ⮌ιθ

Поверніть вхід на 180 °. Це з двох причин: а) останній рядок найлегше видалити, і б) простіше циклу, якщо рядок видалено в кінці циклу. (Я намагався відображати та виводити за годинниковою стрілкою, але це займало додатковий байт.)

Ｗθ«

Повторюйте, поки масив не буде порожнім.

≔Ｅ§θ⁰⮌Ｅθ§μλθ

Оберніть масив на 90 °.

Ｉ⊟θ

Видаліть останній рядок масиву і надрукуйте елемент у вигляді рядків на окремих рядках.

Рубін , 65 байт

->a{x,*a=a.transpose;(w,*a=a.transpose.reverse;x+=w)while a[0];x}

Спробуйте в Інтернеті!

PowerShell , 266 байт

Так .. PowerShell не найкращий для обробки матриць. Але алгоритм в основному такий же, як і вище. Кожен рядок представлений у вигляді рядка, розділеного комою, і ми в основному робимо обертання та переміщення для кожного шару. Я , ймовірно , може голитися більш геть, але ... Я перебуваю вже в піжамі ...

Filter F{$a=$_-replace"],|]|\s",''-split'\['|?{$_-ne''};$b=@();while($a-ne $null){$N=($a[0]-split',').Count-1;$a=0..$N|%{$i=$_;($a|%{($_-split',')[$i]})-join','};if($d){[array]::Reverse($a)}if($N-gt0){$b+=$a[0];$a=$a[1..$N]}else{$b+=$a;$a=$null};$d=$true}$b-join','}

Спробуйте в Інтернеті!