# Active and Inactive cells after k Days

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).

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

 ` `

Output:

```Active Cells = 2 , Inactive Cells = 6
```

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.

My Personal Notes arrow_drop_up

Improved By : nitin mittal, vt_m

Article Tags :
Practice Tags :

6

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.