माना कि हमें एक सरल प्रोग्राम लिखना है जो मैट्रिक्स को बदल देता है। प्रत्येक तत्व अपने पड़ोसी-तत्वों का योग होना चाहिए।
मैट्रिक्स के किनारों को देखते हुए ऐसा करने के लिए "सही" (यानी सबसे आम, सबसे अच्छा पठनीयता, सबसे प्रभावी) तरीका क्या है?
इसे प्राप्त करने के दो स्पष्ट स्पष्ट तरीके जो मैं सोच सकता हूं:
- पहले कोनों (4 अलग लाइनों) को संभालें, शेष किनारों को करने के लिए 4 छोरों का उपयोग करें, फिर बाकी के लिए मानक लूप का उपयोग करें
- पूरे मैट्रिक्स के लिए एक लूप का उपयोग करें
if"अगर हम बीच में हैं या नहीं यह जाँच करने के लिए" यह एक किनारे मामला है।
पहले वाला तेज है (मुझे लगता है), लेकिन यह थोड़े मुझे इसके लिए 4 लाइनें और 5 छोरों के लिए बंद दिखता है।
वहाँ एक और अधिक सुंदर तरीका है? मैंने इसे C ++ के रूप में टैग किया है क्योंकि मैं वर्तमान में C ++ में कोडिंग कर रहा हूं और मुझे लग रहा है कि टर्नरी ऑपरेटर है ?: एक प्यारा समाधान लिखने के लिए काम में आने वाला है।
बोनस अंक अगर आपके समाधान के लिए tweaked किया जा सकता हैएक अधिक जटिल नियम (न केवल एक अप / राइट / लेफ्ट / डाउन सेल को देख रहा है, लेकिन यदि आप "एक निश्चित प्रकार की पुनरावृत्ति कर रहे हैं)। यकीन नहीं है कि यह बहुत कुछ बदल देगा, हालांकि।
उत्तर:
जवाब के लिए 2 № 1इसके बारे में जाने का एक सुंदर तरीका है, एक बड़े मैट्रिक्स का उपयोग करना। यदि आपके मैट्रिक्स में NxM तत्व हैं, तो एक अस्थायी (N + 2) x (M + 2) मैट्रिक्स बनाएं, इसे शून्य से भरें और फिर अपने मानों को इस तरह कॉपी करें:
अस्थायी (i + 1, j + 1) <- मूल (i, j)
अब आपके पास वास्तव में अपना मूल मैट्रिक्स हैइसके चारों ओर शून्य-बाहर किनारा। अब आप अस्थायी मैट्रिक्स में सभी गैर-किनारे कोशिकाओं के सभी पड़ोसियों की राशि की सुरक्षित रूप से गणना कर सकते हैं। परिणाम वह मैट्रिक्स होगा जो आप मूल रूप से देख रहे थे।
नोट - यह आपके द्वारा प्रस्तावित सीधे-आगे के पांच-लूप-समाधान की तुलना में कम कुशल होगा।