सभी चुनौतियाँ
मध्यम 0 हल किए गए 0% स्वीकृति

Box Blur (इमेज को धुँधला करना)

हर pixel को उसके 3 x 3 पड़ोस के round किए गए औसत से बदलकर grayscale image को धुँधला कीजिए।

आप क्या सीखेंगे

  • Grid के किसी cell के 3 x 3 पड़ोसियों पर जाना
  • Grid से बाहर वाले पड़ोसियों को छोड़ना
  • नतीजे नए grid में लिखना ताकि मूल मान न मिटें

समस्या

Box blur हर pixel को उसके और उसके पड़ोसियों के औसत से बदलकर image को नरम बनाता है। यहाँ image 0 से 255 तक के चमक मानों का grid है। हर pixel के लिए उसे केंद्र में रखकर 3 x 3 का खाना लीजिए और उस खाने के सिर्फ़ उन pixels का औसत निकालिए जो image के अंदर हैं: बीच में 9 pixels, किनारे पर 6, कोने में 4 (और सिर्फ़ 1 पंक्ति या 1 कॉलम चौड़ी image में इससे भी कम)। हमेशा मूल मानों का औसत लीजिए, उन मानों का नहीं जिन्हें आप पहले ही धुँधला कर चुके हैं।

औसत को सबसे नज़दीकी पूर्ण संख्या तक round कीजिए, ठीक आधा होने पर ऊपर की ओर। सिर्फ़ पूर्णांकों से, योग s और गिनती c वाले खाने के लिए यह (2 × s + c) / (2 × c) है, integer division के साथ।

box_blur(pixels) लिखिए।

इनपुट

pixels: image, हर पंक्ति के लिए एक list। सभी पंक्तियों की लंबाई बराबर है।

आउटपुट

धुँधली image उसी आकार के grid के रूप में लौटाइए। खाली image के लिए खाली grid लौटाइए।

सीमाएँ

0 ≤ पंक्तियाँ ≤ 50, कम से कम एक पंक्ति हो तो 1 ≤ हर पंक्ति में pixels ≤ 50

0 ≤ हर pixel ≤ 255

उदाहरण

उदाहरण 1
इनपुट:
pixels = [
    [10, 20, 30],
    [40, 50, 60],
    [70, 80, 90]
]

अपेक्षित आउटपुट:
expected = [
    [30, 35, 40],
    [45, 50, 55],
    [60, 65, 70]
]
इनपुट:
std::vector<std::vector<long long>> pixels = {
    {10, 20, 30},
    {40, 50, 60},
    {70, 80, 90}
};

अपेक्षित आउटपुट:
std::vector<std::vector<long long>> expected = {
    {30, 35, 40},
    {45, 50, 55},
    {60, 65, 70}
};
इनपुट:
long[][] pixels = new long[][] {
    new long[] {10, 20, 30},
    new long[] {40, 50, 60},
    new long[] {70, 80, 90}
};

अपेक्षित आउटपुट:
long[][] expected = new long[][] {
    new long[] {30, 35, 40},
    new long[] {45, 50, 55},
    new long[] {60, 65, 70}
};

व्याख्या

कोने वाला 10, मान 10, 20, 40, 50 का औसत लेकर 30 बनता है। केंद्र सभी नौ मानों का औसत लेकर 50 बनता है। ऊपर बीच वाला 10, 20, 30, 40, 50, 60 का औसत लेकर 35 बनता है।

उदाहरण 2
इनपुट:
pixels = [
    [0, 255]
]

अपेक्षित आउटपुट:
expected = [
    [128, 128]
]
इनपुट:
std::vector<std::vector<long long>> pixels = {
    {0, 255}
};

अपेक्षित आउटपुट:
std::vector<std::vector<long long>> expected = {
    {128, 128}
};
इनपुट:
long[][] pixels = new long[][] {
    new long[] {0, 255}
};

अपेक्षित आउटपुट:
long[][] expected = new long[][] {
    new long[] {128, 128}
};

व्याख्या

हर pixel के खाने में दोनों pixels आते हैं, और (0 + 255) / 2 = 127.5 ऊपर की ओर round होकर 128 बनता है, इसलिए [[128, 128]]।

कैसे हल करें

पहले खुद कोशिश करें, फिर एक-एक करके संकेत खोलें।

संकेत 1

हर pixel के आसपास पंक्ति और कॉलम के −1 से 1 तक के offsets पर loop चलाइए।

संकेत 2

गिनिए कि कितने पड़ोसी grid के अंदर हैं, क्योंकि किनारों और कोनों पर कम होते हैं।

संकेत 3

मूल grid से पढ़िए और अलग नतीजे वाले grid में लिखिए।

अपेक्षित जटिलता

समय O(rows × columns), अतिरिक्त स्थान O(rows × columns)

संदर्भ

यह चुनौती CodeUtility के लिए अनुकूलित की गई है। ऊपर दिए गए स्टेटमेंट और सीमाओं का पालन करें।

हर कोडर का सबसे अच्छा पास हुआ समाधान। तेज़, कम मेमोरी वाले और बेहतर रेटिंग वाले समाधान ऊपर रहते हैं।

अभी कोई पास हुआ समाधान नहीं है। इसे हल करें और पहला स्थान पाएँ।

दूसरों से सीखें

समुदाय समाधान

अभी तक कोई प्रकाशित समाधान नहीं। पहला साझा करने के लिए इस चुनौती को हल करें।