मध्यम 0 हल किए गए 0% स्वीकृति

Game of Life Step

Advance Conway's Game of Life by one generation.

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

  • हर सेल के जीवित पड़ोसी गिनना
  • ग्रिड को बदले बिना नियम लागू करना
  • एक पीढ़ी का सिमुलेशन करना

समस्या

Each cell is alive (1) or dead (0) and has up to 8 neighbors. In the next generation a live cell survives with 2 or 3 live neighbors, and a dead cell becomes alive with exactly 3. Cells outside the grid are dead. All cells update at the same time.

Implement next_generation(grid).

Input

grid: A rectangular grid of 0s and 1s.

Output

Return the next generation.

सीमाएँ

0 ≤ rows, columns ≤ 200

उदाहरण

उदाहरण 1
इनपुट:
grid = [
    [0, 1, 0],
    [0, 1, 0],
    [0, 1, 0]
]

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

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

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

व्याख्या

The vertical "blinker" turns horizontal: the center survives and its left and right neighbors are born, filling the middle row.

उदाहरण 2
इनपुट:
grid = [
    [1, 1],
    [1, 1]
]

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

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

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

व्याख्या

Every cell of the 2×2 block has 3 neighbors, so the block stays the same.

कैसे हल करें

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

संकेत 1

हर cell एक साथ बदलती है, इसलिए next state original grid से निकालें, partially updated values से नहीं.

संकेत 2

हर cell के live neighbors गिनें और survival और birth rules लगाकर नया grid बनाएं.

संकेत 3

किनारे वाली cells के बाहर वाले neighbors को dead मानें, और किसी cell की अपनी state को neighbor न गिनें.

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

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

संदर्भ

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

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

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

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