हमें एक पॉजिटिव इंटीजर n दिया गया है और केवल O(1) एक्स्ट्रा स्पेस का उपयोग करके क्लॉकवाइज दिशा में n x n का स्पाइरल मैट्रिक्स बनाना है।
स्पाइरल मैट्रिक्स एक मैट्रिक्स है जो स्पाइरल की तरह काम करता है जो एक सर्कल के मूल से शुरू होकर क्लॉकवाइज फैशन में घूमता है। इसलिए कार्य O(1) स्पेस का उपयोग करके मैट्रिक्स को स्पाइरल फॉर्म में प्रिंट करना है जो 2 → 4 → 6 → 8 → 10 → 12 → 14 → 16 → 18 से शुरू होता है।
नीचे स्पाइरल मैट्रिक्स का उदाहरण दिया गया है:
उदाहरण
इनपुट: 3 आउटपुट: 18 16 14 4 2 12 6 8 10
अनलिमिटेड स्पेस के साथ कोड हल करना आसान हो जाता है लेकिन यह कुशल नहीं है क्योंकि बेस्ट प्रोग्राम या कोड वह है जो मेमोरी और समय दोनों में कुशल हो। इसलिए स्पाइरल ऑर्डर बनाए रखने के लिए चार लूप उपयोग किए जाते हैं, प्रत्येक मैट्रिक्स के शीर्ष, दाएं, नीचे और बाएं कोने के लिए। लेकिन अगर हम मैट्रिक्स को दो भागों में विभाजित करें यानी ऊपरी दाएं और निचले बाएं तो हम सीधे कॉन्सेप्ट का उपयोग कर सकते हैं।
ऊपरी दाएं आधे के लिए,
mat[i][j] = (n-2*x)*(n-2*x) - (i-x) - (j-x)
निचले बाएं आधे के लिए,
mat[i][j] = (n-2*x-2)*(n-2*x-2) + (i-x) + (j-x)
नोट - हम 2 के गुणक के लिए मैट्रिक्स प्रिंट करने का प्रोग्राम लिख रहे हैं
एल्गोरिदम
int spiralmatrix(int n)
शुरुआत
चरण 1: i, j, a, b, x घोषित करें
चरण 2: i = 0 से n तक i++ लूप
j = 0 से n तक j++ लूप
(i
उदाहरण
#include <stdio.h>
// n x n स्पाइरल मैट्रिक्स के लिए
int spiralmatrix(int n){
int i, j, a, b, x; // x वह लेयर स्टोर करता है जिसमें (i, j)वां एलिमेंट मौजूद है
for ( i = 0; i < n; i++){
for ( j = 0; j < n; j++){
// चार इनपुट में न्यूनतम ढूंढें
a = ((i < j ? i : j));
b = ((n-1-i) < (n-1-j) ? (n-1-i) : (n-1-j));
x = a < b ? a : b;
// ऊपरी दाएं आधे के लिए
if (i <= j)
printf("%d\t ", 2 * ((n-2*x)*(n-2*x) - (i-x) - (j-x)));
// निचले बाएं आधे के लिए
else
printf("%d\t ", 2*((n-2*x-2)*(n-2*x-2) + (i-x) + (j-x)));
}
printf("\n");
}
}
int main(int argc, char const *argv[]){
int n = 3;
spiralmatrix(n);
return 0;
}
आउटपुट
यदि हम उपरोक्त प्रोग्राम चलाते हैं तो यह निम्नलिखित आउटपुट उत्पन्न करेगा:
18 16 14
4 2 12
6 8 10
