Open in App
Not now

# Active and Inactive cells after k Days

• Difficulty Level : Easy
• Last Updated : 05 Jul, 2022

Given a binary array of size n where n > 3. A true (or 1) value in the array means active and false (or 0) means inactive. Given a number k, the task is to find count of active and inactive cells after k days. After every day, status of i’th cell becomes active if left and right cells are not same and inactive if left and right cell are same (both 0 or both 1).

Since there are no cells before leftmost and after rightmost cells, the value cells before leftmost and after rightmost cells is always considered as 0 (or inactive).

Examples:

```Input  : cells[] = {1, 0, 1, 1}, k = 2
Output : Active cells = 3, Inactive cells = 1
After 1 day,  cells[] = {0, 0, 1, 1}
After 2 days, cells[] = {0, 1, 1, 1}

Input : cells[] = {0, 1, 0, 1, 0, 1, 0, 1},  k = 3
Output: Active Cells = 2 , Inactive Cells = 6
Explanation :
After 1 day, cells[] = {1, 0, 0, 0, 0, 0, 0, 0}
After 2 days, cells[] = {0, 1, 0, 0, 0, 0, 0, 0}
After 3 days, cells[] =  {1, 0, 1, 0, 0, 0, 0, 0}

Input : cells[] = {0, 1, 1, 1, 0, 1, 1, 0},  k = 4
Output: Active Cells = 3 , Inactive Cells = 5```

The only important thing is to make sure that we maintain a copy of given array because we need previous values to update for next day. Below are detailed steps.

1. First we copy the cells[] array into temp[] array and make changes in temp[] array according to given condition.
2. In the condition, it is given that if immediate left and right cell of i’th cell either inactive or active the next day i becomes inactive i.e; (cells[i-1] == 0 and cells[i+1] == 0) or (cells[i-1] == 1 and cells[i+1] == 1) then cells[i] = 0, these conditions can be applied using XOR of cells[i-1] and cells[i+1].
3. For 0’th index cell temp[0] = 0^cells[1] and for (n-1)’th index cell temp[n-1] = 0^cells[n-2].
4. Now for index 1 to n-2, do the following operation temp[i] = cells[i-1] ^ cells[i+1]
5. Repeat the process till k days are completed.

Following is the implementation of above steps.

## C++

 `// C++ program to count active and inactive cells after k` `// days` `#include` `using` `namespace` `std;`   `// cells[] - store current status of cells` `// n - Number of cells` `// temp[] - to perform intermediate operations` `// k - number of days` `// active - count of active cells after k days` `// inactive - count of active cells after k days` `void` `activeAndInactive(``bool` `cells[], ``int` `n, ``int` `k)` `{` `    ``// copy cells[] array into temp [] array` `    ``bool` `temp[n];` `    ``for` `(``int` `i=0; i

## Java

 `// Java program to count active and ` `// inactive cells after k days`   `class` `GFG {` `    `  `// cells[] - store current status ` `// of cells n - Number of cells` `// temp[] - to perform intermediate operations` `// k - number of days` `// active - count of active cells after k days` `// inactive - count of active cells after k days` `static` `void` `activeAndInactive(``boolean` `cells[], ` `                                 ``int` `n, ``int` `k)` `{` `    ``// copy cells[] array into temp [] array` `    ``boolean` `temp[] = ``new` `boolean``[n];` `    ``for` `(``int` `i = ``0``; i < n; i++)` `    ``temp[i] = cells[i];`   `    ``// Iterate for k days` `    ``while` `(k-- > ``0``) {` `        `  `    ``// Finding next values for corner cells` `    ``temp[``0``] = ``false` `^ cells[``1``];` `    ``temp[n - ``1``] = ``false` `^ cells[n - ``2``];`   `    ``// Compute values of intermediate cells` `    ``// If both cells active or inactive, then ` `    ``// temp[i]=0 else temp[i] = 1.` `    ``for` `(``int` `i = ``1``; i <= n - ``2``; i++)` `        ``temp[i] = cells[i - ``1``] ^ cells[i + ``1``];`   `    ``// Copy temp[] to cells[] for next iteration` `    ``for` `(``int` `i = ``0``; i < n; i++)` `        ``cells[i] = temp[i];` `    ``}`   `    ``// count active and inactive cells` `    ``int` `active = ``0``, inactive = ``0``;` `    ``for` `(``int` `i = ``0``; i < n; i++)` `    ``if` `(cells[i] == ``true``)` `        ``active++;` `    ``else` `        ``inactive++;`   `    ``System.out.print(``"Active Cells = "` `+ active + ``", "` `+ ` `                     ``"Inactive Cells = "` `+ inactive);` `}`   `// Driver code` `public` `static` `void` `main(String[] args) ` `{` `    ``boolean` `cells[] = {``false``, ``true``, ``false``, ``true``,` `                       ``false``, ``true``, ``false``, ``true``};` `    ``int` `k = ``3``;` `    ``int` `n = cells.length;` `    ``activeAndInactive(cells, n, k);` `}` `}`   `// This code is contributed by Anant Agarwal.`

## Python3

 `# Python program to count` `# active and inactive cells after k` `# days`   `# cells[] - store current` `# status of cells` `# n - Number of cells` `# temp[] - to perform` `# intermediate operations` `# k - number of days` `# active - count of active` `# cells after k days` `# inactive - count of active` `# cells after k days` `def` `activeAndInactive(cells,n,k):` `    `  `    ``# copy cells[] array into temp [] array` `    ``temp``=``[]` `    ``for` `i ``in` `range``(n``+``1``):` `        ``temp.append(``False``)` `    ``for` `i ``in` `range``(n):` `        ``temp[i] ``=` `cells[i]` ` `  `    ``# Iterate for k days` `    ``while` `(k >``0``):` `    `  `        ``# Finding next values for corner cells` `        ``temp[``0``]   ``=` `False``^cells[``1``]` `        ``temp[n``-``1``] ``=` `False``^cells[n``-``2``]` ` `  `        ``# Compute values of intermediate cells` `        ``# If both cells active or` `        ``# inactive, then temp[i]=0` `        ``# else temp[i] = 1.` `        ``for` `i ``in` `range``(``1``,n``-``2``+``1``):` `            ``temp[i] ``=` `cells[i``-``1``] ^ cells[i``+``1``]` ` `  `        ``# Copy temp[] to cells[]` `        ``# for next iteration` `        ``for` `i ``in` `range``(n):` `            ``cells[i] ``=` `temp[i]` `        ``k``-``=``1` `    `  `    ``# count active and inactive cells` `    ``active ``=` `0` `    ``inactive ``=` `0``;` `    ``for` `i ``in` `range``(n):` `        ``if``(cells[i] ``=``=` `True``):` `            ``active``+``=``1` `        ``else``:` `            ``inactive``+``=``1` ` `  `    ``print``(``"Active Cells ="``,active,``" , "` `          ``, ``"Inactive Cells ="``,` `           ``inactive)`   `# Driver code`   `cells ``=` `[``False``, ``True``, ``False``, ``True``,` `         ``False``, ``True``, ``False``, ``True``]` `k ``=` `3` `n ``=``len``(cells)`   `activeAndInactive(cells, n, k)`   `# This code is contributed` `# by Anant Agarwal.`

## C#

 `// C# program to count active and ` `// inactive cells after k days` `using` `System;`   `class` `GFG {` `    `  `// cells[] - store current status ` `// of cells n - Number of cells` `// temp[] - to perform intermediate ` `// operations k - number of days` `// active - count of active cells ` `// after k days inactive - count` `// of active cells after k days` `static` `void` `activeAndInactive(``bool` `[]cells, ` `                              ``int` `n, ``int` `k)` `{` `    `  `    ``// copy cells[] array into` `    ``// temp [] array` `    ``bool` `[]temp = ``new` `bool``[n];` `    ``for` `(``int` `i = 0; i < n; i++)` `    ``temp[i] = cells[i];`   `    ``// Iterate for k days` `    ``while` `(k-- > 0) {` `        `  `    ``// Finding next values ` `    ``// for corner cells` `    ``temp[0] = ``false` `^ cells[1];` `    ``temp[n - 1] = ``false` `^ cells[n - 2];`   `    ``// Compute values of intermediate cells` `    ``// If both cells active or inactive, then ` `    ``// temp[i]=0 else temp[i] = 1.` `    ``for` `(``int` `i = 1; i <= n - 2; i++)` `        ``temp[i] = cells[i - 1] ^ cells[i + 1];`   `    ``// Copy temp[] to cells[] ` `    ``// for next iteration` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``cells[i] = temp[i];` `    ``}`   `    ``// count active and inactive cells` `    ``int` `active = 0, inactive = 0;` `    ``for` `(``int` `i = 0; i < n; i++)` `    ``if` `(cells[i] == ``true``)` `        ``active++;` `    ``else` `        ``inactive++;`   `    ``Console.Write(``"Active Cells = "` `+ active + ``", "` `+ ` `                  ``"Inactive Cells = "` `+ inactive);` `}`   `// Driver code` `public` `static` `void` `Main() ` `{` `    ``bool` `[]cells = {``false``, ``true``, ``false``, ``true``,` `                    ``false``, ``true``, ``false``, ``true``};` `    ``int` `k = 3;` `    ``int` `n = cells.Length;` `    ``activeAndInactive(cells, n, k);` `}` `}`   `// This code is contributed by Nitin Mittal.`

## PHP

 ``

## Javascript

 ``

Output

`Active Cells = 2, Inactive Cells = 6`

Time complexity: O(N*K) where N is size of an array and K is number of days.
Auxiliary space: O(N)