Clockwise matrix rotation

Question

The title pretty much describes it all. Given as input a \$n \times m\$ matrix and an integer \$i\$ create a complete function/program that returns the matrix \$i\$ times clockwise rotated by \$90^\circ\$.

Rules:

• as matrix you can use any convenient representation you like e.g. a list of lists etc...
• matrix values can be positive and/or negative integer numbers
• \$n\$ and \$m\$ are of course always positive integers between 1 and 10
• \$i\$ can be any valid integer which belongs in the following range: \${0...10^5}\$
• Standard code-golf rules & winning criteria apply but no "winning" answer will be chosen.

EDIT: I had to edit the initial question because for some programming languages it takes too long to compute the result for \$i\in\{0...10^7\}\$. There is a workaround to it but since it's a code-golf just make sure that it simply runs successfully for at least \$i\in\{0...10^5\}\$.

Some test cases:

==== example 1 ====
Input:
5
[[1, 3, 2, 30,],
 [4, 9, 7, 10,],
 [6, 8, 5, 25 ]]

Expected Output:
[[ 6  4  1],
 [ 8  9  3],
 [ 5  7  2],
 [25 10 30]]

==== example 2 ====
Input:
100
[[1]]

Expected Output:
[[1]]

==== example 3 ====
Input:
15
[[150,    3,  2],
 [  4, -940,  7],
 [  6, 8000,  5]]

Expected Output:
[[   2    7    5],
 [   3 -940 8000],
 [ 150    4    6]]

==== example 4 ====
Input:
40001
[[1, 3, 9]]

Expected Output:
[[1],
 [3],
 [9]]
```

Answer 1

APL (Dyalog Unicode), 7 bytes

⌽∘⍉⍣⎕⊢⎕

Try it online!

⎕ prompt for matrix expression from stdin

⊢ yield that

⎕ prompt for \$i\$ expression from stdin

⍣ do the following that many times

⍉ transpose

∘ and then

⌽ mirror

Answer 2

Pyth, 7 6 bytes

uC_GQE

Try it online!

-1 Thanks to @FryAmTheEggman

Rotates the matrix by reversing the order of rows and taking the transpose. Takes and returns lists of lists.

How it works

uC_GQE
u    E - Reduce the second input
  _G   - By reversing the order of rows
 C     - And transposing
    Q  - An amount of times equal to the first input  

Answer 3

J, 7 bytes

|:@|.^:

Try it online!

An adverb train. Right argument is the matrix, left argument is the repetition count.

How it works

|:@|.^:
     ^:  Repeat the function:
   |.      Reverse vertically
  @        and then
|:         Transpose
         Absent right argument to `^:`:
           bind to the left argument (repeat count)

Answer 4

Ruby, 39 bytes

->m,n{n.times{m=m.reverse.transpose};m}

Try it online!

Answer 5

K (oK), 6 bytes

(+|:)/

Try it online!

Answer 6

Japt -R, 2 bytes

zV

Try it

Rotate matrix by 90 degrees 2nd input times

Answer 7

Jelly, 4 bytes

Naive implementation. There might be a shorter way I'm not aware of.

ṚZ$¡

Try it online!

Answer 8

Python 2, 44 bytes

f=lambda A,i:i%4and f(zip(*A[::-1]),i-1)or A

Try it online!

Input/output is a list of tuples. (The %4 is a workaround for Python's recursion limit; could save a byte otherwise).

Answer 9

Haskell, 50 bytes

(!!).iterate(foldr(zipWith$flip(++).pure)e)
e=[]:e

Try it online!

Answer 10

05AB1E (legacy), 3 bytes

Føí

Takes \$i\$ as first input; matrix the second.

Try it online or verify all test cases.

Explanation:

F    # Loop the (implicit) input-integer amount of times:
 ø   #  Zip/transpose the matrix; swapping rows/columns
     #  (this will take the (implicit) input in the first iteration)
  í  #  Reverse each row
     # (after the loop, the resulting matrix is output implicitly)

NOTE: Uses the legacy version only because of performance. The last test case times out in the rewrite version. Both the legacy and rewrite versions would be the same, though.

Answer 11

JavaScript (ES6), 58 bytes

Takes input as (i)(matrix).

i=>g=m=>i--?g(m[0].map((_,x)=>m.map(r=>r[x]).reverse())):m

Try it online!

Note: The last test case was edited to prevent a recursion error. We can obviously use i--&3 (60 bytes) to support much larger values.

Answer 12

Octave, 17 bytes

Unfortunately rot90 rotates the input counterclockwise.

@(x,i)rot90(x,-i)

Try it online!

Answer 13

MATL, 5 3 bytes

-2 bytes thanks to @LuisMendo!

_X!

Try it online!

Answer 14

Java 8, 141 138 131 130 bytes

(m,i)->{for(int t[][],a,b,j;i-->0;m=t)for(t=new int[b=m[0].length][a=m.length],j=a*b;j-->0;)t[j%b][j/b]=m[a-j/b-1][j%b];return m;}

-7 bytes thanks to @OlivierGrégoire.

Try it online.

Code explanation:

(m,i)->{                 // Method with int-matrix and int parameters and int-matrix return
  for(int t[][],         //  Temp int-matrix as replacement
          a,b,           //  Temp integers used for the dimensions
          j;             //  Temp integer for the inner loop
      i-->0;             //  Loop the input `i` amount of times:
      m=t)               //    After every iteration: replace the input-matrix `m` with `t`
    for(t=new int[b=m[0].length][a=m.length],
                         //   Create a new temp-matrix `t` with dimensions `b` by `a`,
                         //   where `b` & `a` are the amount of columns & rows of matrix `m`
        j=a*b;           //   Set `j` to the product of these dimensions
        j-->0;)          //   And inner loop in the range [`j`, 0):
      t                  //  Replace the value in `t` at position:
       [j%b]             //   `j%b` (let's call this row A),
            [j/b]        //   `j/b` (let's call this column B)
        =m               //  And replace it with the value in `m` at position:
          [a-j/b-1]      //   `a-j/b-1` (which is the reversed column B as row,
                         //     so it both transposes and reverses at the same time),
                   [j%b];//   `j%b` (which is row A as column)
  return m;}             //  And finally return the new int-matrix

To save bytes, the inner loop is a single loop and uses j/a and j%a as cell positions. So a loop like this:

for(r=a;r-->0;)for(c=b;c-->0;)t[c][r]=m[b-r-1][c];

Has been golfed to this:

for(j=a*b;j-->0;)t[j%b][j/b]=m[a-j/b-1][j%b];

to save 5 bytes.

Answer 15

R, 64 bytes

r=function(x,i){o=x;n=0;while(n<i){o=t(apply(o,2,rev));n=n+1};o}

Try it online!

Not really efficient...

Uses rotation approach proposed by Matthew Lundberg

Answer 16

Pari/GP, 37 bytes

f(m,n)=for(i=1,n,m=Mat(Vecrev(m~)));m

Try it online!

Answer 17

Julia 1.0, 6 bytes

Kind of cheating, but Julia has a built in rotl90 function, that does exactly that.

rotl90

Try it online!

Answer 18

Mathematica, 32 bytes

a = {{3, 4, 5}, {5, 6, 7}, {8, 9, 10}, {11, 12, 13}};

Nest[Reverse /@ Transpose[#] &, a, i]