# Active and Inactive cells after k Days

• Difficulty Level : Easy
• Last Updated : 07 Apr, 2021

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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

```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^cells 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 = ``false` `^ cells;``    ``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`