मुझे यकीन नहीं है कि इस एल्गोरिदम प्रश्न के साथ कैसे आगे बढ़ना है।

एक छवि के ग्रे स्केल का प्रतिनिधित्व करने वाले 2 डी पूर्णांक मैट्रिक्स एम को देखते हुए, आपको प्रत्येक सेल के ग्रे स्केल को सभी 8 आसपास की कोशिकाओं का औसत ग्रे स्केल (गोल नीचे) बनाने के लिए एक आसान डिजाइन करने की आवश्यकता है। यदि किसी सेल में आसपास की 8 से कम कोशिकाएं हैं, तो जितना हो सके उतने का उपयोग करें।

उदाहरण 1:

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

Output:
[[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]

व्याख्या:

बिंदु (0, 0), (0, 2), (2, 0), (2, 2) के लिए: मंजिल(3/4) = मंजिल(0.75) = 0

बिंदु के लिए (0, 1), (1, 0), (1, 2), (2, 1): मंजिल(5 / 6) = मंजिल(0.83333333) = 0

बिंदु (1, 1) के लिए: मंजिल(8/9) = मंजिल(0.88888889) = 0

नोट: दिए गए मैट्रिक्स में मान [0, 255] की सीमा में है। दिए गए मैट्रिक्स की लंबाई और चौड़ाई [1, 150] की सीमा में है।

प्रशन:

मेरे कार्यान्वयन तर्क में समस्या आ रही है: मैं सभी पड़ोसियों की जांच करने की कोशिश कर रहा हूं मुझे लगता है कि मैं अपने तर्क के दायरे में हूं, लेकिन मुझे त्रुटि मिलती है Uncaught TypeError: Cannot read property '0' of undefined

मैंने जो कोड अब तक लिखा है:

const imageSmoother = (M) => {
    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

            if (rows >= 0 && rows < M.length &&
                cols >= 0 && cols < M[0].length) {
                //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 (M[rows + 1][cols] !== undefined) {
                    val += M[rows + 1][cols]
                    neighborsCount++
                }
                //check above
                if (M[rows - 1][cols] !== undefined) {
                    val += M[rows - 1][cols]
                    neighborsCount++
                }
                //check diagonal top left
                if (M[rows - 1][cols - 1] !== undefined) {
                    val += M[rows - 1][cols - 1]
                    neighborsCount++
                }
                //check diagonal bottom right
                if (M[rows + 1][cols + 1] !== undefined) {
                    val += M[rows + 1][cols + 1]
                    neighborsCount++
                }
                //check diagonal bottom left
                if (M[rows + 1][cols - 1] !== undefined) {
                    val += M[rows + 1][cols - 1]
                    neighborsCount++
                }
                //check diagonal top right
                if (M[rows - 1][cols + 1] !== undefined) {
                    val += M[rows - 1][cols + 1]
                    neighborsCount++
                }
                console.log(val, neighborsCount);
            }

        }
    }
}

परीक्षण मामला नीचे है:

console.log(imageSmoother([[1, 1, 1],
[1, 0, 1],
[1, 1, 1]])) // [[0, 0, 0],
            //   [0, 0, 0],
            //   [0, 0, 0]]
1
Altaf 22 मई 2020, 04:44

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]]
3
rb612 22 मई 2020, 05:11
मुझे अब प्रश्न की बेहतर समझ है, लेकिन मुझे तर्क को लागू करने में परेशानी हो रही है, मैंने अपने संशोधित प्रश्न में कोड पोस्ट किया है, क्या आपके पास कोई सुझाव है?
 – 
Altaf
22 मई 2020, 22:28

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

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
}
0
Altaf 23 मई 2020, 00:26