Здравей,

Задачата може да се реши чрез един спомагателен списък - правилно си се ориентирал да събереш всички елементи, от един цял ред или една цяла колона но не ти трябват повече списъци:

• List<Integer> slider = new ArrayList();

Той се пълни по два начина в зависимост от посоката на въртене:

1. Right или Down се взимат елементите от съответният ред, или колона, на матрицата от 0 към length -> всеки взет елемент се слага със: slider.add(element)
2. Left или Up се взимат елементите от length - 1 към 0 (в обратен ред спреямо горното), всеки взет елемент се слага със slider.add(element) така в slider получаваш същото като по - горе но в обратен ред. (Можеш да се напълниш slider в обратен ред и по друг начин но в случея е по - разбираемо какво става)
3. slider и в двата случея се пълни от 0 към length със .add, а редът или колоната в матрицата се обхожда по различен начин

Сега следва да открием индекса от който трябва да започнем да презаписваме нашият спомагателен лист във оригиналната матрица:

1. Първо намираме реално колко движения трябва да се извършат: actual = totalNumberOfTurns % length (съответно length е на колоната или на реда завсичи от случая)
2. Ако по - горе сме напълнили slider със елемети от матрицата от 0 към length -> index = actual;
3. Ако сме го напълнили в обратен ред inex = length - actual - 1;

Сега вече имаме лист и индекс -> трябва да запишем вяка една стойност от slider във желаният ред/колона във матрицата като започнем от намереният index, случайте отново произлизат от това как сме напълнили спомагателният лист:

1. от 0 към length -> правим цикъл който започва от index за всяко преминаване се записва в matrix[index] = slider.get(next) // next е поредният елемент във slider -> в началото next = 0, когато next достигне slider.size() цикъла прекъсва, в края на всяка итерация -> next++, index++ , ако index достигне length се занулява index = 0 
2. от length - 1 към 0 -> правим същия цикъл като по горният но в случея в края на итерацията index-- и ако падне под 0 се приравнява към index = length - 1;

Край на хода -> списъкът е преписан в матрицата и може да бъде занулен (в случай че всеки ход използваш един и същи списък, по - лесно е всеки ход да си го оставиш да си прави нов с new).

Обобщение:
Може да се забележи че в случея използваме спомагателният списък като Queue<> -> винаги вадим елементите в реда в който сме ги сложили - от 0 към length -> а ги поставяме в матрицата в ред зависещ от текущата команда. В спомагателният списък елементите са в "норамален" или "обратен" ред -> този алгоритъм може да се оптимизира тук и там, но няма да е толкова праволенеен за обяснение. 
Надявам се си ме разбрал

Ето и едно решение -> ако не беше за време щеше да е с по - малко copy/paste :)

Здравей, 

Аз реших задачата по начин подобен на твоя. Когато трябва да местя ред или колона го пълня в един списък, взимам първата и втората част с sublist() и ги разменям.

List<Integer> firstHalf = lineRow.subList(0,lineRow.size()- turns);
List<Integer> secondHalf = lineRow.subList(lineRow.size() - turns, lineRow.size());
secondHalf.addAll(firstHalf);

После замествам съответния ред или колона с елементите от списъка secondhalf.

Метода sublist връща List, а не ArrayList.

List<E> subList(int fromIndex, int toIndex); 

Използвам това, за да местя надясно. Когато имам да местя наляво преобразувам броя ротации наляво в ротации на дясно.

Ето моето решение на задачата.

Според мен с тези листове си усложнявате излишно решенията. Shift-ване на елементи по X и Y най-лесно се прави с 2 вложени цикъла. Нещо като коментара на peter.petrov тук.

Темата е малко стара, но задачката е отново актуална в упражненията по курса Advanced C# Май 2016.

Качвам моето решение, като ротациите (по редове или колони) съм ги писал линейно. - КОД

Общо взето клонирам матрицата, обхождам с един цикъл по даденият/ата ред/колона намирам предварително крайната позиция на текущият елемент и го замествам в оригинлната матрица.

А това е формулата, която намира крайната позиция на даден елемент (сигурен съм, че има и не толкова идиотски начин):

UP :        (текущият ред + общия брой редове - (броя ходове % общия брой редове)) % общия брой редове

DOWN :  (текущият ред + общия брой редове + (броя ходове % общия брой редове)) % общия брой редове

LEFT :    (текущата колона + общия брой колони - (броя ходове % общия брой колони)) % общия брой колони

RIGHT:    (текущата колона + общия брой колони + (броя ходове % общия брой колони)) % общия брой колони

Някой ако има други идеи за линейно решение ще се радвам да ги видя. :)))

Като стана дума, аз два пъти съм я разписвал върпосната задача и двата пъти един и същ проблем имах и това беше последния тест .Tова е кода от втория ми път --->  http://pastebin.com/aQgYpxNG някой може ли да ми обясни защо при последния тест ми отпечатва само до 170 ел при положение че са 10 000 :D