^{Из этого вопроса stackoverflow}

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

Пример дан

$$\begin{bmatrix} \color{blue}1&\color{red}2&\color{red}3&\color{red}4 \\ \color{red}5&6&7&\color{red}8 \\ \color{red}9&10&11&\color{red}{12} \\ \color{red}{13}&\color{red}{14}&\color{red}{15}&\color{red}{16}\end{bmatrix}$$

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

Теперь мы повторяем процесс для внутренних ценностей. В итоге получится матрица, подобная следующей

$$\begin{bmatrix} \color{blue}6&\color{red}7 \\ \color{red}{10}&\color{red}{11} \end{bmatrix}$$

И внутренние значения тогда $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.

Stax , 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.

ОК , 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 это было фактически применено.

Как ни странно, в этой ситуации я нашел самый короткий путь выхода из рекурсии - использовать блок try-catch:

Юлия 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 градусов по часовой стрелке), а затем повторяет до тех пор, пока в массиве не останется больше записей.

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','}

Попробуйте онлайн!