जावास्क्रिप्ट में 2डी मैट्रिक्स एल्गोरिथम प्रश्न को नहीं समझना

आइए आपको सही दिशा में स्थापित करने के लिए एक साथ दो कदम चलें। हम निम्नलिखित मैट्रिक्स से शुरू करते हैं:

Input:
[[1, 1, 1],
[1, 0, 1],
[1, 1, 1]]

हम जो करने की कोशिश कर रहे हैं वह दी गई प्रविष्टि और उसके पड़ोसियों को देखें।

उदाहरण के लिए, चलिए ऊपरी-बाएँ संख्या से शुरू करते हैं: 1, जिसे मैं स्पष्टता के लिए हाइलाइट करने के लिए चारों ओर उद्धरण डालूंगा।

[['1', 1, 1],
[1, 0, 1],
[1, 1, 1]]

3 पड़ोसी हैं जो "स्पर्श" (आसन्न) हैं - एक सीधे दाईं ओर, एक सीधे नीचे, और एक विकर्ण दाईं ओर और नीचे:

[['1', "1", 1],
["1", "0", 1],
[1, 1, 1]]

वे हमें हाइलाइट की गई संख्याओं पर विचार करने और उन्हें एक साथ औसत करने और फिर अंत में गोल करने के लिए कह रहे हैं।

तो औसत लेने के लिए, हम 1) पड़ोसियों को + खुद जोड़ेंगे, 2) हमारे द्वारा जोड़ी गई संख्याओं से विभाजित करें (देखें सूत्र माध्य के लिए), और फिर 3) जैसे ही प्रश्न पूछेगा (फर्श) हम राउंड डाउन करेंगे।

(1+1+1+0) / 4 = 0.75

अब नीचे गोल करते हैं:

floor(0.75) = 0.

तो ऊपरी बाएँ हाथ की कोशिका 0 होनी चाहिए।

फिर आप इसे हर नंबर के लिए करेंगे। यह स्पष्ट करने के लिए कि "स्पर्श" से मेरा क्या मतलब है, इस सेल के लिए गणना करने के लिए अगला कदम होगा:

[[1, '1', 1],
[1, 0, 1],
[1, 1, 1]]

जिसके निम्नलिखित 5 पड़ोसी हैं (स्वयं सहित 6):

[["1", '1', "1"],
 ["1", "0", "1"],
 [1, 1, 1]]

यह सबसे अच्छा समाधान है, मैं इसके साथ आ सकता हूं। सुनिश्चित नहीं है कि कोई बेहतर तरीका है, लेकिन ऐसा लगता है कि यह काम करता है:

const imageSmoother = (M) => {
    let result = Array(M.length)
    for (let i = 0; i < result.length; i++) {
        result[i] = Array(M[0].length)
    }

    for (let rows = 0; rows < M.length; rows++) {
        for (let cols = 0; cols < M[0].length; cols++) {
            let val = M[rows][cols]
            let neighborsCount = 0

            //check right
            if (M[rows][cols + 1] !== undefined) {
                val += M[rows][cols + 1]
                neighborsCount++
            }
            //check left
            if (M[rows][cols - 1] !== undefined) {
                val += M[rows][cols - 1]
                neighborsCount++
            }
            //check bottom
            if (Array.isArray(M[rows + 1]) && M[rows + 1][cols] !== undefined) {
                val += M[rows + 1][cols]
                neighborsCount++
            }
            //check above
            if (M[rows - 1] && M[rows - 1][cols] !== undefined) {
                val += M[rows - 1][cols]
                neighborsCount++
            }
            //check diagonal top left
            if (M[rows - 1] && M[rows - 1][cols - 1] !== undefined) {
                val += M[rows - 1][cols - 1]
                neighborsCount++
            }
            //check diagonal bottom right
            if (M[rows + 1] && M[rows + 1][cols + 1] !== undefined) {
                val += M[rows + 1][cols + 1]
                neighborsCount++
            }
            //check diagonal bottom left
            if (M[rows + 1] && M[rows + 1][cols - 1] !== undefined) {
                val += M[rows + 1][cols - 1]
                neighborsCount++
            }
            //check diagonal top right
            if (M[rows - 1] && M[rows - 1][cols + 1] !== undefined) {
                val += M[rows - 1][cols + 1]
                neighborsCount++
            }
            result[rows][cols] = Math.floor(val / (neighborsCount + 1))
        }
    }
    return result
}