আমি আরও কিছু বিশদ যুক্ত করতে চাই। এই উত্তরে, মূল ধারণাগুলি পুনরাবৃত্তি হয়, গতি ধীর এবং ইচ্ছাকৃতভাবে পুনরাবৃত্তি হয়। এখানে প্রদত্ত সমাধানটি সর্বাধিক সিনট্যাক্টিক্যালি কমপ্যাক্ট নয়, তবে এটি তাদের জন্য যারা ম্যাট্রিক্স ঘূর্ণন কী এবং ফলাফলটি বাস্তবায়ন কী তা শিখতে চান implementation
প্রথমত, একটি ম্যাট্রিক্স কি? এই উত্তরের উদ্দেশ্যে, একটি ম্যাট্রিক্স কেবল একটি গ্রিড যেখানে প্রস্থ এবং উচ্চতা একই the দ্রষ্টব্য, ম্যাট্রিক্সের প্রস্থ এবং উচ্চতা আলাদা হতে পারে তবে সরলতার জন্য এই টিউটোরিয়ালটি সমান প্রস্থ এবং উচ্চতা সহ কেবল ম্যাট্রিককে বিবেচনা করে ( বর্গ ম্যাট্রিক্স ) । এবং হ্যাঁ, ম্যাট্রিক্স হ'ল ম্যাট্রিক্সের বহুবচন।
উদাহরণ ম্যাট্রিকগুলি হ'ল: 2 × 2, 3 × 3 বা 5 × 5। অথবা, আরও সাধারণভাবে, N × N। একটি 2 × 2 ম্যাট্রিক্সের 4 স্কোয়ার থাকবে কারণ 2 × 2 = 4। একটি 5 × 5 ম্যাট্রিক্সের 25 স্কোয়ার থাকবে কারণ 5 × 5 = 25। প্রতিটি বর্গকে একটি উপাদান বা এন্ট্রি বলা হয়। আমরা .নীচের চিত্রগুলিতে একটি পিরিয়ড ( ) সহ প্রতিটি উপাদানকে উপস্থাপন করব :
2 × 2 ম্যাট্রিক্স
. .
. .
3 × 3 ম্যাট্রিক্স
. . .
. . .
. . .
4 × 4 ম্যাট্রিক্স
. . . .
. . . .
. . . .
. . . .
সুতরাং, ম্যাট্রিক্সকে ঘোরানোর অর্থ কী? আসুন একটি 2 × 2 ম্যাট্রিক্স নিন এবং প্রতিটি উপাদানগুলিতে কিছু নম্বর রাখুন যাতে ঘূর্ণনটি লক্ষ করা যায়:
0 1
2 3
এটি 90 ডিগ্রি ঘোরানো আমাদের দেয়:
2 0
3 1
আমরা গাড়ীর স্টিয়ারিং হুইল ঘুরিয়ে দেওয়ার মতো করে আক্ষরিকভাবে পুরো ম্যাট্রিক্সটি একবার ডানদিকে পরিণত করেছিলাম। এটি ম্যাট্রিক্সকে তার ডানদিকে "টিপ" দেওয়ার কথা ভাবতে সহায়তা করতে পারে। পাইথনে আমরা একটি ফাংশন লিখতে চাই, এটি একটি ম্যাট্রিক্স নেয় এবং একবার ডানে ঘুরবে। ফাংশনের স্বাক্ষরটি হবেন:
def rotate(matrix):
# Algorithm goes here.
ম্যাট্রিক্স দ্বি-মাত্রিক অ্যারে ব্যবহার করে সংজ্ঞায়িত করা হবে:
matrix = [
[0,1],
[2,3]
]
সুতরাং প্রথম সূচীর অবস্থানটি সারিটি অ্যাক্সেস করে। দ্বিতীয় সূচক অবস্থানটি কলামটি অ্যাক্সেস করে:
matrix[row][column]
আমরা ম্যাট্রিক্স মুদ্রণের জন্য একটি ইউটিলিটি ফাংশনটি সংজ্ঞায়িত করব।
def print_matrix(matrix):
for row in matrix:
print row
ম্যাট্রিক্স ঘোরানোর একটি পদ্ধতি হ'ল এটি একবারে একটি স্তর করা। কিন্তু একটি স্তর কি? একটি পেঁয়াজ ভাবেন। পেঁয়াজের স্তরগুলি যেমন প্রতিটি স্তর সরানো হয় তেমনি আমরা কেন্দ্রের দিকে এগিয়ে যাই move অন্যান্য উপমা হ'ল ক ম্যাট্রিওস্কা পুতুল বা পাস-দ্য পার্সেলের একটি খেলা।
একটি ম্যাট্রিক্সের প্রস্থ এবং উচ্চতা সেই ম্যাট্রিক্সের স্তরগুলির সংখ্যা নির্ধারণ করে। প্রতিটি স্তরের জন্য পৃথক চিহ্ন ব্যবহার করা যাক:
একটি 2 × 2 ম্যাট্রিক্সের 1 স্তর রয়েছে
. .
. .
একটি 3 × 3 ম্যাট্রিক্সের 2 স্তর রয়েছে
. . .
. x .
. . .
একটি 4 × 4 ম্যাট্রিক্সের 2 স্তর রয়েছে
. . . .
. x x .
. x x .
. . . .
একটি 5 × 5 ম্যাট্রিক্সে 3 স্তর রয়েছে
. . . . .
. x x x .
. x O x .
. x x x .
. . . . .
একটি 6 × 6 ম্যাট্রিক্সে 3 স্তর রয়েছে
. . . . . .
. x x x x .
. x O O x .
. x O O x .
. x x x x .
. . . . . .
একটি 7 × 7 ম্যাট্রিক্সে 4 স্তর রয়েছে
. . . . . . .
. x x x x x .
. x O O O x .
. x O - O x .
. x O O O x .
. x x x x x .
. . . . . . .
আপনি লক্ষ করতে পারেন যে ম্যাট্রিক্সের প্রস্থ এবং উচ্চতা এক এক করে বৃদ্ধি করা সর্বদা স্তরগুলির সংখ্যা বৃদ্ধি করে না। উপরের ম্যাট্রিকগুলি গ্রহণ করা এবং স্তরগুলি এবং মাত্রাগুলিগুলিকে টেবুলেট করা, আমরা দেখতে পাচ্ছি প্রস্থ এবং উচ্চতার প্রতি দুটি বর্ধনের জন্য একবার স্তরগুলির সংখ্যা বৃদ্ধি পায়:
+-----+--------+
| N×N | Layers |
+-----+--------+
| 1×1 | 1 |
| 2×2 | 1 |
| 3×3 | 2 |
| 4×4 | 2 |
| 5×5 | 3 |
| 6×6 | 3 |
| 7×7 | 4 |
+-----+--------+
তবে, সমস্ত স্তর ঘোরানোর প্রয়োজন হয় না। আবর্তনের আগে এবং পরে একটি 1 × 1 ম্যাট্রিক্স একই। কেন্দ্রের 1 × 1 স্তরটি সার্বক্ষণিক ঘূর্ণনের আগে এবং পরে সর্বদা একই রকম হয়, সামগ্রিক ম্যাট্রিক্স যত বড়ই নয়:
+-----+--------+------------------+
| N×N | Layers | Rotatable Layers |
+-----+--------+------------------+
| 1×1 | 1 | 0 |
| 2×2 | 1 | 1 |
| 3×3 | 2 | 1 |
| 4×4 | 2 | 2 |
| 5×5 | 3 | 2 |
| 6×6 | 3 | 3 |
| 7×7 | 4 | 3 |
+-----+--------+------------------+
এন mat এন ম্যাট্রিক্স দেওয়া, আমরা কীভাবে স্তর ঘোরানোর জন্য প্রয়োজনীয় স্তরগুলি প্রোগ্রামের মাধ্যমে নির্ধারণ করতে পারি? আমরা যদি প্রস্থ বা উচ্চতাটিকে দুটি দ্বারা বিভক্ত করি এবং বাকী অংশটিকে উপেক্ষা করি আমরা নিম্নলিখিত ফলাফলগুলি পাই।
+-----+--------+------------------+---------+
| N×N | Layers | Rotatable Layers | N/2 |
+-----+--------+------------------+---------+
| 1×1 | 1 | 0 | 1/2 = 0 |
| 2×2 | 1 | 1 | 2/2 = 1 |
| 3×3 | 2 | 1 | 3/2 = 1 |
| 4×4 | 2 | 2 | 4/2 = 2 |
| 5×5 | 3 | 2 | 5/2 = 2 |
| 6×6 | 3 | 3 | 6/2 = 3 |
| 7×7 | 4 | 3 | 7/2 = 3 |
+-----+--------+------------------+---------+
কিভাবে লক্ষ করুন N/2 স্তরগুলি ঘোরানো দরকার তার সংখ্যার সাথে মেলে? কখনও কখনও ঘূর্ণনযোগ্য স্তরগুলির সংখ্যা ম্যাট্রিক্সের মোট স্তরগুলির চেয়ে কম হয়। এটি ঘটে যখন অন্তঃস্থল স্তরটি কেবলমাত্র একটি উপাদান (যেমন একটি 1 × 1 ম্যাট্রিক্স) নিয়ে গঠিত হয় এবং তাই ঘোরানোর প্রয়োজন হয় না। এটি কেবল উপেক্ষা করা হয়।
নিঃসন্দেহে একটি ম্যাট্রিক্স ঘোরানোর জন্য আমাদের ফাংশনটিতে এই তথ্যটির প্রয়োজন হবে, তাই এখনই এটি যুক্ত করুন:
def rotate(matrix):
size = len(matrix)
# Rotatable layers only.
layer_count = size / 2
এখন আমরা জানি স্তরগুলি কী এবং কীভাবে স্তরগুলি ঘোরানোর প্রয়োজন তা নির্ধারণ করতে, আমরা কীভাবে একটি স্তরকে আলাদা করব যাতে আমরা এটি ঘোরান? প্রথমত, আমরা বাইরেরতম স্তর থেকে অভ্যন্তরীণতম স্তর পর্যন্ত একটি ম্যাট্রিক্স পরিদর্শন করি। একটি 5 × 5 ম্যাট্রিক্সে মোট তিনটি স্তর রয়েছে এবং দুটি স্তর রয়েছে যা ঘোরানোর প্রয়োজন:
. . . . .
. x x x .
. x O x .
. x x x .
. . . . .
প্রথমে কলামগুলি দেখুন। বাহ্যতম স্তরকে সংজ্ঞায়িত করে কলামগুলির অবস্থান, ধরে নেওয়া আমরা 0 থেকে গণনা করছি, 0 এবং 4:
+--------+-----------+
| Column | 0 1 2 3 4 |
+--------+-----------+
| | . . . . . |
| | . x x x . |
| | . x O x . |
| | . x x x . |
| | . . . . . |
+--------+-----------+
0 এবং 4 হ'ল বহিরাগত স্তরের সারিগুলির অবস্থানও।
+-----+-----------+
| Row | |
+-----+-----------+
| 0 | . . . . . |
| 1 | . x x x . |
| 2 | . x O x . |
| 3 | . x x x . |
| 4 | . . . . . |
+-----+-----------+
প্রস্থ এবং উচ্চতা সমান হওয়ায় এটি সর্বদা ক্ষেত্রে হবে। সুতরাং আমরা মাত্র দুটি মান (চারটি নয়) দিয়ে একটি স্তরের কলাম এবং সারি অবস্থান নির্ধারণ করতে পারি।
দ্বিতীয় স্তরের দিকে অগ্রসর হওয়া, কলামগুলির অবস্থান 1 এবং 3 And এবং হ্যাঁ, আপনি এটি অনুমান করেছিলেন, এটি সারিগুলির জন্য একই। পরবর্তী স্তরের দিকে যাওয়ার সময় আমাদের সারি এবং কলামের অবস্থান বৃদ্ধি এবং হ্রাস উভয়ই ছিল তা বোঝা গুরুত্বপূর্ণ।
+-----------+---------+---------+---------+
| Layer | Rows | Columns | Rotate? |
+-----------+---------+---------+---------+
| Outermost | 0 and 4 | 0 and 4 | Yes |
| Inner | 1 and 3 | 1 and 3 | Yes |
| Innermost | 2 | 2 | No |
+-----------+---------+---------+---------+
সুতরাং, প্রতিটি স্তরটি পরিদর্শন করতে, আমরা উভয় বাড়ানো এবং হ্রাসকারী কাউন্টারগুলির সাথে একটি লুপ চাই যা বাহিরের স্তর থেকে শুরু করে ভেতরের দিকে অগ্রসর হওয়া প্রতিনিধিত্ব করে। আমরা এটিকে আমাদের 'স্তর লুপ' বলব।
def rotate(matrix):
size = len(matrix)
layer_count = size / 2
for layer in range(0, layer_count):
first = layer
last = size - first - 1
print 'Layer %d: first: %d, last: %d' % (layer, first, last)
# 5x5 matrix
matrix = [
[ 0, 1, 2, 3, 4],
[ 5, 6, 6, 8, 9],
[10,11,12,13,14],
[15,16,17,18,19],
[20,21,22,23,24]
]
rotate(matrix)
ঘোরানো দরকার এমন কোনও স্তরগুলির (সারি এবং কলাম) অবস্থানের উপরের কোডটি লুপ করে।
Layer 0: first: 0, last: 4
Layer 1: first: 1, last: 3
আমাদের কাছে এখন প্রতিটি স্তরের সারি এবং কলামের অবস্থান সরবরাহকারী একটি লুপ রয়েছে। ভেরিয়েবলগুলি firstএবং lastপ্রথম এবং শেষ সারি এবং কলামগুলির সূচী অবস্থান সনাক্ত করে। আমাদের সারি এবং কলামের সারণীতে ফিরে উল্লেখ:
+--------+-----------+
| Column | 0 1 2 3 4 |
+--------+-----------+
| | . . . . . |
| | . x x x . |
| | . x O x . |
| | . x x x . |
| | . . . . . |
+--------+-----------+
+-----+-----------+
| Row | |
+-----+-----------+
| 0 | . . . . . |
| 1 | . x x x . |
| 2 | . x O x . |
| 3 | . x x x . |
| 4 | . . . . . |
+-----+-----------+
সুতরাং আমরা একটি ম্যাট্রিক্স এর স্তর মাধ্যমে নেভিগেট করতে পারেন। এখন আমাদের একটি স্তরের মধ্যে নেভিগেট করার একটি উপায় প্রয়োজন যাতে আমরা সেই স্তরটির চারপাশে উপাদানগুলি স্থানান্তর করতে পারি। দ্রষ্টব্য, উপাদানগুলি কখনই এক স্তর থেকে অন্য স্তরটিতে 'লাফায়' না, তবে তারা তাদের নিজ স্তরের মধ্যে চলে move
প্রতিটি উপাদানকে একটি স্তরে ঘোরানো পুরো স্তরটি ঘোরায়। ম্যাট্রিক্সে সমস্ত স্তর ঘোরানো পুরো ম্যাট্রিক্সকে ঘোরায়। এই বাক্যটি অত্যন্ত গুরুত্বপূর্ণ, সুতরাং এগিয়ে যাওয়ার আগে দয়া করে এটি বোঝার জন্য যথাসাধ্য চেষ্টা করুন।
এখন, আমাদের আসলে চলমান উপাদানগুলির একটি উপায় প্রয়োজন, অর্থাত প্রতিটি উপাদান ঘোরানো, এবং পরবর্তীকালে স্তর এবং শেষ পর্যন্ত ম্যাট্রিক্স। সরলতার জন্য, আমরা একটি 3x3 ম্যাট্রিক্সে ফিরব - যার একটি ঘূর্ণনযোগ্য স্তর রয়েছে।
0 1 2
3 4 5
6 7 8
আমাদের স্তর লুপটি প্রথম এবং শেষ কলামগুলির সূচি পাশাপাশি প্রথম এবং শেষ সারিগুলি সরবরাহ করে:
+-----+-------+
| Col | 0 1 2 |
+-----+-------+
| | 0 1 2 |
| | 3 4 5 |
| | 6 7 8 |
+-----+-------+
+-----+-------+
| Row | |
+-----+-------+
| 0 | 0 1 2 |
| 1 | 3 4 5 |
| 2 | 6 7 8 |
+-----+-------+
আমাদের ম্যাট্রিক্স সবসময় বর্গ কারণ, আমরা শুধু দুটি ভেরিয়েবল প্রয়োজন, firstএবং lastযেহেতু সূচক অবস্থানের সারি এবং কলামের জন্য একই।
def rotate(matrix):
size = len(matrix)
layer_count = size / 2
# Our layer loop i=0, i=1, i=2
for layer in range(0, layer_count):
first = layer
last = size - first - 1
# We want to move within a layer here.
প্রথম এবং শেষের ভেরিয়েবলগুলি ম্যাট্রিক্সের চারটি কোণগুলির জন্য সহজেই ব্যবহার করা যেতে পারে। এটি কারণ কোণগুলি তাদের নিজস্ব বিবিধ ক্রম ব্যবহার করে সংজ্ঞায়িত করা যেতে পারে firstএবং last(সেই পরিবর্তনকের কোনও বিয়োগ, যোগ বা অফসেট ছাড়াই):
+---------------+-------------------+-------------+
| Corner | Position | 3x3 Values |
+---------------+-------------------+-------------+
| top left | (first, first) | (0,0) |
| top right | (first, last) | (0,2) |
| bottom right | (last, last) | (2,2) |
| bottom left | (last, first) | (2,0) |
+---------------+-------------------+-------------+
এই কারণে, আমরা আমাদের ঘূর্ণনটি বাইরের চার কোণে শুরু করি - আমরা প্রথমে সেগুলি ঘোরাব। এর সাথে তাদের হাইলাইট করা যাক *।
* 1 *
3 4 5
* 7 *
আমরা একে অদলবদল করতে চান *সঙ্গে *এটা ডানদিকে। সুতরাং আসুন একটি প্রিন্ট আউট করা আমাদের কোণগুলি কেবলমাত্র বিভিন্ন ক্রিয়াকলাপগুলি firstএবং এর ব্যবহার করে সংজ্ঞায়িত করা যেতে পারে last:
def rotate(matrix):
size = len(matrix)
layer_count = size / 2
for layer in range(0, layer_count):
first = layer
last = size - first - 1
top_left = (first, first)
top_right = (first, last)
bottom_right = (last, last)
bottom_left = (last, first)
print 'top_left: %s' % (top_left)
print 'top_right: %s' % (top_right)
print 'bottom_right: %s' % (bottom_right)
print 'bottom_left: %s' % (bottom_left)
matrix = [
[0, 1, 2],
[3, 4, 5],
[6, 7, 8]
]
rotate(matrix)
আউটপুট হওয়া উচিত:
top_left: (0, 0)
top_right: (0, 2)
bottom_right: (2, 2)
bottom_left: (2, 0)
এখন আমরা আমাদের লেয়ার লুপের মধ্যে থেকে প্রতিটি কোণকে খুব সহজেই অদলবদল করতে পারি:
def rotate(matrix):
size = len(matrix)
layer_count = size / 2
for layer in range(0, layer_count):
first = layer
last = size - first - 1
top_left = matrix[first][first]
top_right = matrix[first][last]
bottom_right = matrix[last][last]
bottom_left = matrix[last][first]
# bottom_left -> top_left
matrix[first][first] = bottom_left
# top_left -> top_right
matrix[first][last] = top_left
# top_right -> bottom_right
matrix[last][last] = top_right
# bottom_right -> bottom_left
matrix[last][first] = bottom_right
print_matrix(matrix)
print '---------'
rotate(matrix)
print_matrix(matrix)
কোণ ঘোরার আগে ম্যাট্রিক্স:
[0, 1, 2]
[3, 4, 5]
[6, 7, 8]
কোণ ঘোরার পরে ম্যাট্রিক্স:
[6, 1, 0]
[3, 4, 5]
[8, 7, 2]
গ্রেট! আমরা ম্যাট্রিক্সের প্রতিটি কোণকে সাফল্যের সাথে ঘোরালাম। তবে, আমরা প্রতিটি স্তরের মাঝখানে উপাদানগুলি ঘোরানো হয়নি। স্পষ্টতই আমাদের একটি স্তর মধ্যে পুনরাবৃত্তি একটি উপায় প্রয়োজন।
সমস্যাটি হল, আমাদের ফাংশনটিতে এখন পর্যন্ত একমাত্র লুপ (আমাদের স্তর লুপ) প্রতিটি পুনরাবৃত্তির পরবর্তী স্তরটিতে চলে আসে। যেহেতু আমাদের ম্যাট্রিক্সের কেবল একটি ঘূর্ণনযোগ্য স্তর রয়েছে তাই স্তর কোণটি কেবল কোণগুলি ঘোরার পরে প্রস্থান করে। আসুন দেখে নেওয়া যাক বৃহত্তর, 5 × 5 ম্যাট্রিক্সের সাথে কী ঘটে (যেখানে দুটি স্তর ঘোরানো দরকার)। ফাংশন কোড বাদ দেওয়া হয়েছে, তবে এটি উপরের মতোই রয়েছে:
matrix = [
[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24]
]
print_matrix(matrix)
print '--------------------'
rotate(matrix)
print_matrix(matrix)
আউটপুটটি হ'ল:
[20, 1, 2, 3, 0]
[ 5, 16, 7, 6, 9]
[10, 11, 12, 13, 14]
[15, 18, 17, 8, 19]
[24, 21, 22, 23, 4]
আশ্চর্য হওয়া উচিত নয় যে বাইরেরতম স্তরটির কোণগুলি ঘোরানো হয়েছে, তবে, আপনি পরবর্তী স্তরটির (কোণার) কোণগুলিও ঘোরানো হয়েছে তা লক্ষ্য করতে পারেন। এইবার বুঝতে পারছি. আমরা স্তরগুলির মাধ্যমে নেভিগেট করার জন্য এবং প্রতিটি স্তরের কোণগুলিকে ঘোরানোর জন্য কোড লিখেছি। এটি অগ্রগতির মতো অনুভব করে তবে দুর্ভাগ্যক্রমে আমাদের অবশ্যই এক পদক্ষেপ নিতে হবে। পূর্ববর্তী (বাহ্যিক) স্তরটি পুরোপুরি ঘোরানো না হওয়া পর্যন্ত এটি পরবর্তী স্তরটির দিকে চলে যাওয়ার খুব ভাল নয়। অর্থাৎ স্তরের প্রতিটি উপাদান ঘোরানো না হওয়া পর্যন্ত। কেবল কোণগুলি ঘোরানো হবে না!
একটা গভীর শ্বাস নাও. আমাদের আরেকটি লুপ দরকার। নেস্টেড লুপটি আর কম নয়। নতুন, নেস্টেড লুপটি একটি স্তরটির মধ্যে নেভিগেট করার জন্য firstএবং lastভেরিয়েবলগুলি, এবং একটি অফসেট ব্যবহার করবে । আমরা এই নতুন লুপটিকে আমাদের 'এলিমেন্ট লুপ' বলব। এলিমেন্ট লুপটি প্রতিটি সারিটি উপরের সারিতে বরাবর, প্রতিটি উপাদানকে ডান পাশের নীচে, প্রতিটি উপাদান নীচের সারি বরাবর এবং প্রতিটি উপাদান বাম দিকে উপস্থাপন করবে।
- শীর্ষ সারিতে অগ্রসর হওয়ার জন্য কলাম সূচকটি বাড়ানো দরকার।
- ডানদিকে নিচে চলতে সারি সূচকটি বাড়ানো দরকার।
- নীচে বরাবর পিছনে সরে যাওয়ার জন্য কলাম সূচি হ্রাস করতে হবে।
- বাম দিকে উপরে উঠতে সারি সূচকে হ্রাস করতে হবে।
এটি জটিল মনে হচ্ছে, তবে এটি সহজ হয়েছে কারণ উপরেরটি অর্জনের জন্য আমরা যত বার বৃদ্ধি পেয়েছি এবং হ্রাস পেয়েছি তার সংখ্যা ম্যাট্রিক্সের চারটি পাশেই একই রয়েছে। উদাহরণ স্বরূপ:
- উপরের সারিতে 1 টি উপাদান সরান।
- 1 এলিমেন্টটি ডান দিক থেকে সরান।
- নীচের সারি বরাবর 1 উপাদান পিছনে সরান।
- বাম দিকে 1 উপাদান সরান।
এর অর্থ হল আমরা সঙ্গে একযোগে একটি একক পরিবর্তনশীল ব্যবহার করতে পারেন firstএবং lastএকটি স্তর মধ্যে সরাতে ভেরিয়েবল। এটি উল্লেখ করতে সহায়তা করতে পারে যে উপরের সারিটি পেরিয়ে ডানদিকে নীচে উভয়কে বাড়ানো দরকার। নীচে বাম দিকে এবং উপরের দিকে পিছনে সরানোর সময় উভয় হ্রাস প্রয়োজন।
def rotate(matrix):
size = len(matrix)
layer_count = size / 2
# Move through layers (i.e. layer loop).
for layer in range(0, layer_count):
first = layer
last = size - first - 1
# Move within a single layer (i.e. element loop).
for element in range(first, last):
offset = element - first
# 'element' increments column (across right)
top_element = (first, element)
# 'element' increments row (move down)
right_side = (element, last)
# 'last-offset' decrements column (across left)
bottom = (last, last-offset)
# 'last-offset' decrements row (move up)
left_side = (last-offset, first)
print 'top: %s' % (top)
print 'right_side: %s' % (right_side)
print 'bottom: %s' % (bottom)
print 'left_side: %s' % (left_side)
এখন আমাদের কেবল শীর্ষটি ডান পাশের, নীচে থেকে ডানদিকে, নীচে বাম দিকে এবং বাম দিকটি শীর্ষে নির্ধারিত করতে হবে। এই সব একসাথে রাখা আমরা পেতে:
def rotate(matrix):
size = len(matrix)
layer_count = size / 2
for layer in range(0, layer_count):
first = layer
last = size - first - 1
for element in range(first, last):
offset = element - first
top = matrix[first][element]
right_side = matrix[element][last]
bottom = matrix[last][last-offset]
left_side = matrix[last-offset][first]
matrix[first][element] = left_side
matrix[element][last] = top
matrix[last][last-offset] = right_side
matrix[last-offset][first] = bottom
ম্যাট্রিক্স দেওয়া:
0, 1, 2
3, 4, 5
6, 7, 8
আমাদের rotateফাংশন এর ফলাফল:
6, 3, 0
7, 4, 1
8, 5, 2