^{From this stackoverflow question}

Given a 2D array of size $ M x N $, output the values in a anti-clockwise fashion. The output must start from the outside to the inside and the initial point always is going to be $(0,0)$.

Example Given:

$$ beginbmatrix colorblue1&colorred2&colorred3&colorred4 \ colorred5&6&7&colorred8 \ colorred9&10&11&colorred12 \ colorred13&colorred14&colorred15&colorred16endbmatrix $$

The edge values in counterclockwise is then $ 1,5,9,13,14,15,16,12,8,4,3,2 $.

Now we repeat the process for the inner values. This will end up with a matrix like the following

$$ beginbmatrix colorblue6&colorred7 \ colorred10&colorred11 endbmatrix$$

And the inner values is then $ 6,10,11,7 $

The final result will be then $ 1,5,9,13,14,15,16,12,8,4,3,2,6,10,11,7 $

Rules

• Assume non-empty input


• Assume matrix values as positive integers


• Standard I/O Methods apply


• Standard code-golf rules and winning criteria apply

Some test cases

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 bytes

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

Try it online!

Recursively strip off the first column and rotate the rest of the matrix until you end up with only one column. Ungolfed "traditional" version:

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

Python 2, 52 bytes

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

Try it online!

Pyth, 20 bytes

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

Try it here

Explanation

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.

Jelly, 9 bytes

ZḊUƊƬḢ€€Ẏ

Try it online!

Stax, 7 bytes

ôQÖG·í<

Run and debug it

It takes an array of rows on one line, and produces newline-separated output.

Unpacked, ungolfed, and commented, it looks like this.

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

Run this one

Pyth, 9 bytes

shMM.utC_

Try it here!

How?

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.

Charcoal, 25 bytes

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

Try it online! Link is to verbose version of code. Explanation:

≔⮌ＥＡ⮌ιθ

Rotate the input by 180°. This is for two reasons: a) the last row is the easiest to remove, and b) it's easier to loop if the row is removed at the end of the loop. (I did try reflecting and outputting clockwise but that took an extra byte.)

Ｗθ«

Repeat until the array is empty.

≔Ｅ§θ⁰⮌Ｅθ

Rotate the array by 90°.

§μλθＩ⊟θ

Remove the last row of the array and print the element as strings on separate lines.