C++ में इमेज स्मूथर (Image Smoother)

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

इसलिए, यदि इनपुट जैसा है:

तो आउटपुट होगा:

इसे हल करने के लिए, हम निम्नलिखित चरणों का पालन करेंगे:

• R := M की पंक्ति संख्या
• C := M की कॉलम संख्या
• d = { -1, 0, 1 } सरणी परिभाषित करें
• आकार (R x C) का एक 2D सरणी res परिभाषित करें
• i := 0 से R-1 तक लूप चलाएं:
  • j := 0 से C-1 तक लूप चलाएं:
    • sum := 0, count := 0
    • k := 0 से 2 तक लूप चलाएं:
      • l := 0 से 2 तक लूप चलाएं:
        • m := i + d[k], n := j + d[l]
        • यदि m >= 0 और m < R और n >= 0 और n < C, तो:
          • count को 1 से बढ़ाएं और sum = sum + M[m][n]
    • res[i][j] := sum / count
• res वापस करें

उदाहरण

बेहतर समझ के लिए निम्नलिखित कार्यान्वयन देखें:

#include <bits/stdc++.h> 
using namespace std; 
void print_vector(vector<vector<auto> > v){ 
    cout << "["; 
    for(int i = 0; i<v.size(); i++){ 
        cout << "["; 
        for(int j = 0; j <v[i].size(); j++){ 
            cout << v[i][j] << ", "; 
        } 
        cout << "],"; 
    } 
    cout << "]"<<endl; 
} 
class Solution { 
public: 
    vector<vector<int>> imageSmoother(vector<vector<int>>& M) { 
        int R = M.size(); 
        int C = M[0].size(); 
        vector<int> d{ -1, 0, 1 }; 
        vector<vector<int> > res(R, vector<int>(C, 0)); 
        for (int i = 0; i < R; ++i) { 
            for (int j = 0; j < C; ++j) { 
                int sum = 0, count = 0; 
                for (int k = 0; k < 3; ++k) { 
                    for (int l = 0; l < 3; ++l) { 
                        int m = i + d[k], n = j + d[l]; 
                        if (m >= 0 && m < R && n >= 0 && n < C) 
                            ++count, sum += M[m][n]; 
                    } 
                } 
                res[i][j] = sum / count; 
            } 
        } 
        return res; 
    } 
}; 
int main(){ 
    Solution ob; 
    vector<vector<int>> v = {{1,1,1},{1,0,1},{1,1,1}}; 
    print_vector(ob.imageSmoother(v)); 
}

इनपुट

{{1,1,1},{1,0,1},{1,1,1}}

आउटपुट

[[0, 0, 0, ],[0, 0, 0, ],[0, 0, 0, ],]