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

लिस्ट को टुकड़ों में बाँटें

एक सूची को एक निश्चित आकार के क्रमागत समूहों में काटें, और यदि ज़रूरत हो तो अंतिम समूह छोटा हो सकता है.

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

  • लिस्ट में तय आकार की छलाँगों से चलना
  • ऐसे टुकड़े लेना जिनमें आख़िरी छोटा हो सकता है
  • पेजिंग या बैच के लिए डेटा का समूह बनाना

समस्या

नियत-आकार के खंडों में डेटा को विभाजित करना वह तरीका है जिससे प्रोग्राम परिणामों को पृष्ठों में बाँटते हैं, डेटाबेस लिखाईयों को बैच करते हैं, या डेटा को पैकेटों में भेजते हैं.

एक सूची और एक chunk size दिया गया है, सूची को ठीक size मानों वाले क्रमागत chunks में, क्रम बनाए रखते हुए, काटें. अंतिम chunk में जो भी बचा हो वह होगा और वह छोटा हो सकता है.

Implement split_into_chunks(values, size).

इनपुट

values: विभाजित की जाने वाली सूची.

size: chunk का आकार.

आउटपुट

chunks की सूची लौटाएँ. एक खाली सूची से कोई chunks नहीं बनते.

सीमाएँ

0 ≤ मानों की संख्या ≤ 10,000

1 ≤ size ≤ 10,000

उदाहरण

उदाहरण 1
इनपुट:
values = [1, 2, 3, 4, 5, 6, 7]
size = 3

अपेक्षित आउटपुट:
expected = [
    [1, 2, 3],
    [4, 5, 6],
    [7]
]
इनपुट:
std::vector<long long> values = {1, 2, 3, 4, 5, 6, 7};
long long size = 3;

अपेक्षित आउटपुट:
std::vector<std::vector<long long>> expected = {
    {1, 2, 3},
    {4, 5, 6},
    {7}
};
इनपुट:
long[] values = new long[] {1, 2, 3, 4, 5, 6, 7};
long size = 3;

अपेक्षित आउटपुट:
long[][] expected = new long[][] {
    new long[] {1, 2, 3},
    new long[] {4, 5, 6},
    new long[] {7}
};

व्याख्या

3 के समूह: [1, 2, 3] और [4, 5, 6], और बचा हुआ 7 एक अंतिम, छोटा chunk बनाता है.

उदाहरण 2
इनपुट:
values = [8, 9]
size = 5

अपेक्षित आउटपुट:
expected = [
    [8, 9]
]
इनपुट:
std::vector<long long> values = {8, 9};
long long size = 5;

अपेक्षित आउटपुट:
std::vector<std::vector<long long>> expected = {
    {8, 9}
};
इनपुट:
long[] values = new long[] {8, 9};
long size = 5;

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

व्याख्या

size सूची से बड़ा है, इसलिए सब कुछ एक ही chunk में आ जाता है: [[8, 9]].

कैसे हल करें

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

संकेत 1

शुरुआती स्थितियाँ 0, size, 2·size वगैरह हैं।

संकेत 2

हर शुरुआती स्थिति से start + size तक का टुकड़ा लें।

संकेत 3

आख़िरी टुकड़ा छोटा हो सकता है, और खाली लिस्ट से कोई टुकड़ा नहीं बनता।

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

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

संदर्भ

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

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

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

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

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

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