Digamos que eu tenho a seguinte matriz (2D):

[[1,  2,  3,  4 ],
 [5,  6,  7,  8 ],
 [9,  10, 11, 12],
 [13, 14, 15, 16]]

Gire a matriz no sentido anti- R horário (não em incrementos de 90 graus, apenas um número por vez),

1  2  3  4             2 3   4  8         3   4   8  12
5  6  7  8    -->      1 7  11 12   -->   2  11  10  16 
9  10 11 12            5 6  10 16         1   7   6  15 
13 14 15 16            9 13 14 15         5   9  13  14

Exemplo completo:

Entrada:

2
[[1,  2,  3,  4 ],
 [5,  6,  7,  8 ],
 [9,  10, 11, 12],
 [13, 14, 15, 16]]

Saída:

[[3,  4,  8, 12],
 [2, 11, 10, 16],
 [1,  7,  6, 15],
 [5,  9, 13, 14]]

(espaços estranhos são para alinhar os números em boas colunas)

O "anel" externo da matriz gira 2 no sentido anti-horário e o interior direito também gira 2. Nesta matriz, existem apenas dois anéis.

Um exemplo com 1 "anel":

2
[[1, 2],
 [3, 4],
 [5, 6]]

Saída deve:

[[4, 6],
 [2, 5],
 [1, 3]]

Seu desafio é obter uma matriz e um número inteiro Re gerar a versão traduzida após as Rrotações.

A rotação de uma matriz 4x5 é representada pela seguinte figura:

Restrições:

• 2 ≤ M, N ≤ 100, onde M e N são as dimensões da matriz. É garantido que o mínimo de M e N seja par.
• 1 ≤ R ≤ 80, em que r é o número de rotações.
• A matriz sempre conterá números inteiros positivos.
• Os valores nem sempre são distintos.
• A entrada sempre deve ser como uma matriz 2D (se você não pode receber a entrada de tempo de execução como uma matriz 2D, basta encontrar outra maneira de obter entrada).

Outro caso de teste, com valores não distintos:

1
[[1, 1],
 [2, 2],
 [3, 3]]

Saídas:

[[1, 2],
 [1, 3],
 [2, 3]]

Isso é código-golfe , então a resposta mais curta vence!

Geléia , 39 38 36 35 bytes

ḢṚ;Ḣ€;Ṫ;Ṫ€Ṛ$,-ṙ\;"ß¹¡
FJ©ṁ¹Çy®ịFṁµ¡

Experimente online!

Oitava, 210 bytes

function M=F(M,R);f=@(z)[-z/2:-1 !eye(!!mod(z,2)) 1:z/2];t=angle(f([x y]=size(M))'+f(y)*i);B=!!M;B(2:x-1,2:y-1)=0;d=bwdist(B,'ch');[~,I]=sortrows([d(:) t(:)]);for k=0:max(d(:));M(h)=shift(M(h=I(d(I)==k)),R);end

Experimente no Octave Online!

Versão não destruída:

function M=F(M,R)
    [x y]=size(M);
    f=@(z)[-z/2:-1 !eye(!!mod(z,2)) 1:z/2];
    t=angle(f(x)'+f(y)*i);
    B=!!M;
    B(2:x-1,2:y-1)=0;
    d=bwdist(B,'chessboard');
    [~,I]=sortrows([d(:) t(:)]);
    for k=0:max(d(:))
        M(h)=shift(M(h=I(d(I)==k)),R);
    end
end
R=2;
M=randi(10,4,7)
F(M,R)

Explicação:

f=@(z)[-z/2:-1 !eye(!!mod(z,2)) 1:z/2]; 

Uma função que obtém um número e gera um intervalo que é ordenado e centralizado para a entrada 4 (par) gera -2 -1 1 2
para a entrada 5 (ímpar) gera -2.5 -1.5 0 1 2
apenas que deve ser ordenada e centralizada

f(x)'+f(y)*i    

uma matriz complexa gerada a partir de intervalos

(-2,-2.5) (-2,-1.5) (-2,0) (-2,1) (-2,2)
(-1,-2.5) (-1,-1.5) (-1,0) (-1,1) (-1,2)
(1,-2.5)  (1,-1.5)  (1,0)  (1,1)  (1,2)
(2,-2.5)  (2,-1.5)  (2,0)  (2,1)  (2,2)

t=angle(f(x)'+f(y)*i);                    

Converta coordenadas retangulares em polares e retorne ângulos para que, para cada ângulo, os anéis sejam classificados no sentido horário

-2.25  -2.50  3.14  2.68  2.36
-1.95  -2.16  3.14  2.36  2.03
-1.19  -0.98  0.00  0.79  1.11
-0.90  -0.64  0.00  0.46  0.79


B=!!M;
B(2:x-1,2:y-1)=0;

A seguinte matriz gerou

1   1   1   1   1
1   0   0   0   1
1   0   0   0   1
1   1   1   1   1

d=bwdist(B,'chessboard');

Calcula a transformação de distância de B usando a distância do tabuleiro de xadrez para gerar índices de anel

0   0   0   0   0
0   1   1   1   0
0   1   1   1   0
0   0   0   0   0               

para uma matriz 6 * 7, teremos a seguinte matriz

0   0   0   0   0   0   0
0   1   1   1   1   1   0
0   1   2   2   2   1   0
0   1   2   2   2   1   0
0   1   1   1   1   1   0
0   0   0   0   0   0   0   

[~,I]=sortrows([d(:) t(:)]);

classificação lexicográfica, primeiro com base no índice de toque e, em seguida, por ordem de ângulo (índices de elementos classificados retornados)

    for k=0:max(d(:))
        M(h)=shift(M(h=I(d(I)==k)),R);
    end

e, finalmente, deslocamento circular de cada anel.

Python 3, 292 288 bytes

_=eval
a=input().split()
b,a=int(a[0]),_("".join(a[1:]))[::-1]
c=len(a)
d=len(a[0])
e=range
f="int((i>=j and i+j<c-1)|2*(i>=c/2and i+d>j+c)|3*(i<c/2and i+j<d))"
l=[-1,1,0,0],[0,0,1,-1]
g=lambda x:[[x[i+l[0][_(f)]][j+l[1][_(f)]]for j in e(d)]for i in e(c)]
print(_("g("*b+"a"+")"*b)[::-1])

Recebe entrada com as novas linhas removidas, mas deixa um espaço após o número de incrementos para girá-lo.

Explicação:

Em vez de modelar a matriz como uma série de anéis concêntricos de acordo com a sugestão do OP, pode-se dividi-la em quatro regiões onde os elementos viajam para cima, baixo, direita ou esquerda durante uma única rotação. Esse é o objetivo da cadeia longa favaliada: determinar em qual região cada i,jcombinação se encaixa. Em seguida, o resultado disso é pesquisado duas vezes l, fornecendo o elemento que deve girar na posição i,jna próxima etapa. A função gque faz tudo isso e forma a nova matriz após uma única etapa é chamada repetidamente, avaliando uma string gerada contendo a representação de uma chamada de função aninhada.

Quando fiz isso originalmente, fiz acidentalmente a matriz girar no sentido horário em vez de no sentido anti-horário. Em vez de fazer uma correção adequada, adicionei duas cópias estrategicamente colocadas [::-1]para reverter a matriz antes e depois da rotação. Provavelmente estes poderiam ser jogados para ~ 280 276 bytes, mas estou com preguiça de fazer isso.

Além disso, esta é uma porta rápida e não testada de um programa Python 2 um pouco mais longo, então me perdoe se não funcionar corretamente. Aqui está o código Python 2, de qualquer maneira:

_=eval
a=raw_input().split()
b,a=int(a[0]),_("".join(a[1:]))[::-1]
c=len(a)
d=len(a[0])
e=xrange
f="int((i>=j and i+j<c-1)|2*(i>=c/2and i+d>j+c)|3*(i<c/2and i+j<d))"
l=[-1,1,0,0],[0,0,1,-1]
g=lambda x:[[x[i+l[0][_(f)]][j+l[1][_(f)]]for j in e(d)]for i in e(c)]
print _("g("*b+"a"+")"*b)[::-1]

EDIT: Golfed off 4 bytes, substituindo orpor |duas vezes. andinfelizmente não pode ser ajudado.

Perl, 330 328 bytes

sub f{($r,$m)=@_;$h=@m=@$m;for$s(0..(($w=$#{$m[0]})<--$h?$w:$h)/2-.5){@_=(@{$m[$s]}[@x=$s..($x=$w-$s)],(map$m[$_][$x],@y=1+$s..($y=$h-$s)-1),reverse(@{$m[$y]}[@x]),(map$m[$h-$_][$s],@y));push@_,shift
for 1..$r;@{$m[$s]}[@x]=map shift,@x;$m[$_][$x]=shift for@y;@{$m[$y]}[@x]=reverse map shift,@x;$m[$h-$_][$s]=shift for@y}@$m=@m}

Experimente em Ideone .

Ungolfed:

sub f {
    my ($r, $m) = @_;

    my @m = @$m;
    my $h = $#m;
    my $w = @{$m[0]} - 1;
    my $c = (($w < $h ? $w : $h) + 1) / 2 - 1;

    for my $s (0 .. $c) {
        my $x = $w - $s;
        my $y = $h - $s;
        my @x = $s .. $x;
        my @y = $s + 1 .. $y - 1;

        # One circle.
        @_ = (@{$m[$s]}[@x],
              (map { $m[$_][$x] } @y),
              reverse(@{$m[$y]}[@x]),
              (map { $m[$h - $_][$s] } @y));

        # Circular shift.
        push(@_, shift(@_)) for 1 .. $r;

        @{$m[$s]}[@x] = map { shift(@_) } @x;
        $m[$_][$x] = shift(@_) for @y;
        @{$m[$y]}[@x] = reverse(map { shift(@_) } @x);
        $m[$h - $_][$s] = shift(@_) for @y;
    }

    @$m = @m;
}