Skip to content
Related Articles
Count number of 1s in the array after N moves
• Last Updated : 27 May, 2021

Given an array of size N in which initially all the elements are 0(zero). The task is to count the number of 1’s in the array after performing N moves on the array as explained:
In each move (starting from 1 to N) the element at the position of the multiple of the move number is changed from 0 to 1 or 1 to 0.
Move 1: Change the element at position at 1, 2, 3, …
Move 2: Change the element at position at 2, 4, 6, …
Move 3: Change the element at position at 3, 6, 9, …
Count the elements whose value is 1 after performing N moves.

Note: Consider that the array is 1-indexed.

Example:
Input: N = 5, arr[] = {0, 0, 0, 0, 0}
Output: 2
Explanation
Move 1: {1, 1, 1, 1, 1}
Move 2: {1, 0, 1, 0, 1}
Move 3: {1, 0, 0, 0, 1}
Move 4: {1, 0, 0, 1, 1}
Move 5: {1, 0, 0, 1, 0}
Total numbers of 1’s after 5 moves = 2.

Input: N = 10, arr[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
Output: 3

Naive approach: Iterate for the number of moves and for each move traverse the elements from Move number to N and check whether the position is multiple of move number or not. If it is multiple of move number then change the element at that position i.e. If it is 0 change it to 1 and if it is 1 change it to 0.

Below is the implementation of above approach:

## C++

 `// C++ implementation of the above approach` `#include ` `using` `namespace` `std;` `// Function to count number of 1's in the``// array after performing N moves``int` `countOnes(``int` `arr[], ``int` `N)``{``    ``for` `(``int` `i = 1; i <= N; i++) {``        ``for` `(``int` `j = i; j <= N; j++) {` `            ``// If index is multiple of move number``            ``if` `(j % i == 0) {``                ``if` `(arr[j - 1] == 0)``                    ``arr[j - 1] = 1; ``// Convert 0 to 1``                ``else``                    ``arr[j - 1] = 0; ``// Convert 1 to 0``            ``}``        ``}``    ``}` `    ``int` `count = 0;` `    ``// Count number of 1's``    ``for` `(``int` `i = 0; i < N; i++)``        ``if` `(arr[i] == 1)``            ``count++; ``// count number of 1's` `    ``return` `count;``}` `// Driver Code``int` `main()``{``    ``int` `N = 10; ``// Initialize array size` `    ``// Initialize all elements to 0``    ``int` `arr = { 0 };` `    ``int` `ans = countOnes(arr, N);` `    ``cout << ans;` `    ``return` `0;``}`

## Java

 `// Java implementation of the above approach` `class` `GFG``{` `    ``// Function to count number of 1's in the``    ``// array after performing N moves``    ``static` `int` `countOnes(``int` `arr[], ``int` `N)``    ``{``        ``for` `(``int` `i = ``1``; i <= N; i++)``        ``{``            ``for` `(``int` `j = i; j <= N; j++)``            ``{` `                ``// If index is multiple of move number``                ``if` `(j % i == ``0``)``                ``{``                    ``if` `(arr[j - ``1``] == ``0``)``                    ``{``                        ``arr[j - ``1``] = ``1``; ``// Convert 0 to 1``                    ``}``                    ``else``                    ``{``                        ``arr[j - ``1``] = ``0``; ``// Convert 1 to 0``                    ``}``                ``}``            ``}``        ``}` `        ``int` `count = ``0``;` `        ``// Count number of 1's``        ``for` `(``int` `i = ``0``; i < N; i++)``        ``{``            ``if` `(arr[i] == ``1``)``            ``{``                ``count++; ``// count number of 1's``            ``}``        ``}``        ``return` `count;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``10``; ``// Initialize array size` `        ``// Initialize all elements to 0``        ``int` `arr[] = ``new` `int``[``10``];` `        ``int` `ans = countOnes(arr, N);` `        ``System.out.println(ans);``    ``}``}` `// This code contributed by Rajput-Ji`

## Python3

 `# Python3 implementation of the above approach` `# Function to count number of 1's in the``# array after performing N moves``def` `countOnes(arr, N):``    ``for` `i ``in` `range``(``1``, N ``+` `1``, ``1``):``        ``for` `j ``in` `range``(i, N ``+` `1``, ``1``):``            ``# If index is multiple of move number``            ``if` `(j ``%` `i ``=``=` `0``):``                ``if` `(arr[j ``-` `1``] ``=``=` `0``):``                    ``arr[j ``-` `1``] ``=` `1` `# Convert 0 to 1``                ``else``:``                    ``arr[j ``-` `1``] ``=` `0` `# Convert 1 to 0` `    ``count ``=` `0` `    ``# Count number of 1's``    ``for` `i ``in` `range``(N):``        ``if` `(arr[i] ``=``=` `1``):``            ``count ``+``=` `1` `# count number of 1's` `    ``return` `count` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``N ``=` `10` `# Initialize array size` `    ``# Initialize all elements to 0``    ``arr ``=` `[``0` `for` `i ``in` `range``(``10``)]` `    ``ans ``=` `countOnes(arr, N)` `    ``print``(ans)` `# This code is contributed by``# Surendra_Gangwar`

## C#

 `// C# implementation of the above approach``using` `System;``    ` `class` `GFG``{` `    ``// Function to count number of 1's in the``    ``// array after performing N moves``    ``static` `int` `countOnes(``int` `[]arr, ``int` `N)``    ``{``        ``for` `(``int` `i = 1; i <= N; i++)``        ``{``            ``for` `(``int` `j = i; j <= N; j++)``            ``{` `                ``// If index is multiple of move number``                ``if` `(j % i == 0)``                ``{``                    ``if` `(arr[j - 1] == 0)``                    ``{``                        ``arr[j - 1] = 1; ``// Convert 0 to 1``                    ``}``                    ``else``                    ``{``                        ``arr[j - 1] = 0; ``// Convert 1 to 0``                    ``}``                ``}``            ``}``        ``}` `        ``int` `count = 0;` `        ``// Count number of 1's``        ``for` `(``int` `i = 0; i < N; i++)``        ``{``            ``if` `(arr[i] == 1)``            ``{``                ``count++; ``// count number of 1's``            ``}``        ``}``        ``return` `count;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `N = 10; ``// Initialize array size` `        ``// Initialize all elements to 0``        ``int` `[]arr = ``new` `int``;` `        ``int` `ans = countOnes(arr, N);` `        ``Console.WriteLine(ans);``    ``}``}` `/* This code contributed by PrinciRaj1992 */`

## Javascript

 ``
Output:
`3`

Time Complexity: O(N2)

Efficient Approach: The efficient approach is based on a greedy approach. It is basically based on the below pattern.
While we do this for N = 1, 2, 3, 4, 5, … it is found that the answer required is the total number of perfect squares from 1 to n (both inclusive).
Hence, Answer = Total number of perfect squares from 1 to N

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach` `#include ` `using` `namespace` `std;` `// Function to count number of perfect squares``int` `perfectSquares(``int` `a, ``int` `b)``{``    ``// Counting number of perfect squares``    ``// between a and b``    ``return` `(``floor``(``sqrt``(b)) - ``ceil``(``sqrt``(a)) + 1);``}` `// Function to count number of 1s in``// array after N moves``int` `countOnes(``int` `arr[], ``int` `n)``{``    ``return` `perfectSquares(1, n);``}` `// Driver Code``int` `main()``{``    ``// Initialize array size``    ``int` `N = 10;` `    ``// Initialize all elements to 0``    ``int` `arr = { 0 };` `    ``cout << countOnes(arr, N);` `    ``return` `0;``}`

## Java

 `// Java implementation of the above approach``import` `java.io.*;` `class` `GFG {` `    ``// Function to count number of perfect squares``    ``static` `double` `perfectSquares(``int` `a, ``int` `b)``    ``{``        ``// Counting number of perfect squares``        ``// between a and b``        ``return` `(Math.floor(Math.sqrt(b)) - Math.ceil(Math.sqrt(a)) + ``1``);``    ``}` `    ``// Function to count number of 1s in``    ``// array after N moves``    ``static` `double` `countOnes(``int` `arr[], ``int` `n)``    ``{``        ``return` `perfectSquares(``1``, n);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``// Initialize array size``        ``int` `N = ``10``;` `        ``// Initialize all elements to 0``        ``int` `arr[] = { ``0` `};` `        ``System.out.println(countOnes(arr, N));``    ``}``}` `// This code is contributed by jit_t.`

## Python3

 `# Python3 implementation of the above approach``from` `math ``import` `sqrt, ceil, floor;` `# Function to count number of perfect squares``def` `perfectSquares(a, b) :``    ` `    ``# Counting number of perfect squares``    ``# between a and b``    ``return` `(floor(sqrt(b)) ``-``             ``ceil(sqrt(a)) ``+` `1``);` `# Function to count number of 1s in``# array after N moves``def` `countOnes(arr, n) :` `    ``return` `perfectSquares(``1``, n);` `# Driver Code``if` `__name__ ``=``=` `"__main__"` `:` `    ``# Initialize array size``    ``N ``=` `10``;` `    ``# Initialize all elements to 0``    ``arr ``=` `[``0``] ``*` `10``;` `    ``print``(countOnes(arr, N));` `# This code is contributed by Ankit Rai`

## C#

 `// C# implementation of the above approach``using` `System;` `class` `GFG {` `    ``// Function to count number of perfect squares``    ``static` `double` `perfectSquares(``int` `a, ``int` `b)``    ``{``        ``// Counting number of perfect squares``        ``// between a and b``        ``return` `(Math.Floor(Math.Sqrt(b)) - Math.Ceiling(Math.Sqrt(a)) + 1);``    ``}` `    ``// Function to count number of 1s in``    ``// array after N moves``    ``static` `double` `countOnes(``int``[] arr, ``int` `n)``    ``{``        ``return` `perfectSquares(1, n);``    ``}` `    ``// Driver Code``    ``static` `public` `void` `Main()``    ``{``        ``// Initialize array size``        ``int` `N = 10;` `        ``// Initialize all elements to 0``        ``int``[] arr = { 0 };` `        ``Console.WriteLine(countOnes(arr, N));``    ``}``}` `// This code is contributed by JitSalal.`

## PHP

 ``

## Javascript

 ``
Output:
`3`

Time Complexity: O(log(log N))

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 industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up