Powiedzmy, że mam następującą macierz (2D):

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

Obróć matrycę w kierunku przeciwnym do ruchu wskazówek zegara R (nie w przyrostach 90 stopni, tylko o 1 liczbę za każdym razem),

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

Ukończony przykład:

Wkład:

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

Wydajność:

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

(dziwne spacje mają wyrównać liczby w ładnych kolumnach)

Zewnętrzny „pierścień” matrycy obraca się 2 przeciwnie do ruchu wskazówek zegara, a wewnętrzny prawy również obraca 2. W tej matrycy są tylko dwa pierścienie.

Przykład z 1 „pierścieniem”:

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

Powinien generować:

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

Wyzwanie polega na przyjęciu macierzy i liczby całkowitej Roraz wygenerowaniu przetłumaczonej wersji po Rrotacji.

Obrót matrycy 4x5 jest reprezentowany przez następujący rysunek:

Ograniczenia:

• 2 ≤ M, N ≤ 100, gdzie M i N są wymiarami macierzy. Gwarantuje się, że minimum M i N będzie parzyste.
• 1 ≤ R ≤ 80, gdzie r jest liczbą obrotów.
• Macierz będzie zawsze zawierała dodatnie liczby całkowite.
• Wartości nie zawsze są wyraźne.
• Dane wejściowe powinny być zawsze w postaci tablicy 2D (jeśli nie możesz wziąć danych wykonawczych jako tablicy 2D, musisz po prostu znaleźć inny sposób na uzyskanie danych wejściowych).

Kolejny przypadek testowy z nierozróżnialnymi wartościami:

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

Wyjścia:

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

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź!

Galaretka , 39 38 36 35 bajtów

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

Wypróbuj online!

Oktawa, 210 bajtów

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

Wypróbuj w Octave Online!

Wersja bez golfa:

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)

Wyjaśnienie:

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

Funkcja, która pobiera liczbę i generuje zakres, który jest uporządkowany i wyśrodkowany dla wejścia 4 (parzysty) generuje -2 -1 1 2
dla wejścia 5 (nieparzysty) generuje -2.5 -1.5 0 1 2
tylko to, że powinien być uporządkowany i wyśrodkowany

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

złożona macierz wygenerowana z zakresów

(-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);                    

Konwertuj współrzędne prostokątne na biegunowe i zwracaj kąty, aby dla każdego kąta pierścienia były sortowane przeciwnie do ruchu wskazówek zegara

-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;

Wygenerowano następującą macierz

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

d=bwdist(B,'chessboard');

Oblicza transformatę odległości B za pomocą odległości szachownicy w celu wygenerowania wskaźników pierścienia

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

dla macierzy 6 * 7 będziemy mieli następującą macierz

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(:)]);

sortowanie leksykograficzne najpierw na podstawie indeksu pierścieniowego, a następnie według kolejności kątów (zwrócone wskaźniki posortowanych elementów)

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

i wreszcie okrągłe przesunięcie każdego pierścienia.

Python 3, 292 288 bajtów

_=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])

Pobiera dane wejściowe z usuniętymi znakami nowej linii, ale pozostawia spację po liczbie przyrostów, aby ją obrócić.

Wyjaśnienie:

Zamiast modelować macierz jako serię koncentrycznych pierścieni zgodnie z sugestią PO, można zamiast tego podzielić ją na cztery regiony, w których elementy poruszają się w górę, w dół, w prawo lub w lewo podczas jednego obrotu. Jest to celem długiego sprawdzonego ciągu f: określenie regionu, do którego należy każda i,jkombinacja. Następnie wynik jest dwukrotnie sprawdzany l, dając element, który musi obrócić się w odpowiedniej pozycji i,jw następnym kroku. Funkcja, gktóra wykonuje to wszystko i tworzy nową macierz po jednym kroku, jest następnie wywoływana wielokrotnie przez sprawdzenie wygenerowanego ciągu zawierającego reprezentację zagnieżdżonego wywołania funkcji.

Kiedy zrobiłem to pierwotnie, przypadkowo spowodowałem, że matryca obraca się zgodnie z ruchem wskazówek zegara zamiast w kierunku przeciwnym do ruchu wskazówek zegara. Zamiast zrobić właściwą poprawkę, dodałem dwie strategicznie umieszczone kopie, [::-1]aby odwrócić matrycę przed i po rotacji. Prawdopodobnie można je oddzielić do ~ 280 276 bajtów, ale jestem zbyt leniwy, aby to zrobić.

Jest to także szybki, niesprawdzony port z nieco dłuższego programu w języku Python 2, więc wybacz mi, jeśli nie działa całkiem dobrze. W każdym razie oto kod Python 2:

_=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]

Edycja: golfed od 4 bajtów, zastępując orw |dwukrotnie. andnie można niestety pomóc.

Perl, 330 328 bajtów

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}

Wypróbuj na Ideone .

Nie golfowany:

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;
}