# Find the final string after flipping bits at the indices that are multiple of prime factors of array elements

• Last Updated : 30 Nov, 2021

Given a binary string S of size N and an array arr[] of M integers, the task is to find the final string after flipping the characters at indices which are multiple of the prime factors of all the array elements. Note that this problem uses 1-based indexing.

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: S = “000000”, arr[] = {2, 4, 6}
Output: 011100
Explanation:

1. The prime factors of 2 are {2}. Therefore string after flipping the values of all the indices that are multiple of 2 is S = “010101”.
2. The prime factors of 4 are {2}. Therefore string after flipping the values of all the indices that are multiple of 2 is S = “000000”.
3. The prime factors of 6 are {2, 3}. Therefore string after flipping the values of all the indices that are multiple of 2 is S = “010101” and the string after flipping the values of all the indices that are multiple of 3 is S = “011100”.

Input: S = “001100”, arr[] = {2, 3, 5}
Output: 010010

Approach: The given problem can be solved with the help of the Sieve of Eratosthenes by storing the frequency of primes factors of all the array elements. It can be observed that the prime factors with even frequencies will not contribute to flipping. Therefore, the resultant string can be obtained by flipping the bits of indices that are multiple of prime factors with odd frequency. Follow the steps below to solve the given problem:

• Create a function getFactorization(), which returns all the prime factors of any number.
• Initialize an array, frequency[] that stores the frequency of all the distinct prime factors of all elements of the array arr[].
• Traverse the given array arr[] and for each array element arr[i], find the prime factor of it using getFactorization( arr[i] ) and increment the frequency of the prime factors in the frequency[] array.
• For all odd values of frequency[i] in the array, iterate through all the factors of i and flip the bits of respective indices in the given string S.
• The string stored in S is the required string.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include "bits/stdc++.h"` `using` `namespace` `std;`   `#define MAXN 100001`   `// Stores smallest prime factor` `int` `spf[MAXN];`   `// Function to find the smallest prime` `// factor for every number till MAXN` `void` `sieve()` `{` `    ``spf = 1;`   `    ``// Marking smallest prime factor for` `    ``// every number to be itself` `    ``for` `(``int` `i = 2; i < MAXN; i++)` `        ``spf[i] = i;`   `    ``// Separately marking spf for every` `    ``// even number as 2` `    ``for` `(``int` `i = 4; i < MAXN; i += 2)` `        ``spf[i] = 2;`   `    ``for` `(``int` `i = 3; i * i < MAXN; i++) {`   `        ``// Checking if i is prime` `        ``if` `(spf[i] == i) {`   `            ``// Marking SPF for all numbers` `            ``// divisible by i` `            ``for` `(``int` `j = i * i;` `                 ``j < MAXN; j += i) {` `                ``if` `(spf[j] == j)` `                    ``spf[j] = i;` `            ``}` `        ``}` `    ``}` `}`   `// Function to find all the distinct prime` `// factors of the given number x` `vector<``int``> getFactorization(``int` `x)` `{` `    ``vector<``int``> ret;`   `    ``// Find the prime factors for X` `    ``while` `(x != 1) {`   `        ``ret.push_back(spf[x]);`   `        ``// Find the spf[] of x` `        ``int` `value = spf[x];`   `        ``while` `(x % value == 0)` `            ``x = x / value;` `    ``}`   `    ``// Return the prime factors for x` `    ``return` `ret;` `}`   `// Function to find string after flipping` `// the characters at indices of prime` `// factors of array elements arr[]` `string flipString(string S, ``int` `arr[],` `                  ``int` `M)` `{` `    ``// Precalculating Smallest Prime Factor` `    ``sieve();`   `    ``// Stores the frequency of each` `    ``// prime factor` `    ``int` `frequency[MAXN] = { 0 };`   `    ``// Iterate over all elements of` `    ``// the array arr[]` `    ``for` `(``int` `i = 0; i < M; i++) {`   `        ``// Stores prime factors of arr[i]` `        ``vector<``int``> primeFactors` `            ``= getFactorization(arr[i]);`   `        ``// Increment the frequency of all` `        ``// prime factors of arr[i]` `        ``for` `(``auto``& factors : primeFactors) {` `            ``frequency[factors]++;` `            ``frequency[factors] %= 2;` `        ``}` `    ``}`   `    ``int` `N = S.length();`   `    ``// Iterate over all elements of` `    ``// the array frequency[]` `    ``for` `(``int` `i = 0; i < MAXN; i++) {`   `        ``// If frequency[i] is odd` `        ``if` `(frequency[i] & 1) {`   `            ``// Flip bits of all indices` `            ``// that are multiple of i` `            ``for` `(``int` `j = i; j <= N; j += i) {` `                ``S[j - 1] = (S[j - 1]` `                                    ``== ``'1'` `                                ``? ``'0'` `                                ``: ``'1'``);` `            ``}` `        ``}` `    ``}`   `    ``// Return Answer` `    ``return` `S;` `}`   `// Driver Code` `int` `main()` `{` `    ``string S = ``"000000"``;` `    ``int` `arr[] = { 2, 4, 6 };` `    ``int` `M = ``sizeof``(arr) / ``sizeof``(arr);`   `    ``cout << flipString(S, arr, M);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.ArrayList;` `import` `java.util.Arrays;`   `class` `GFG {`   `    ``public` `static` `int` `MAXN = ``100001``;`   `    ``// Stores smallest prime factor` `    ``public` `static` `int``[] spf = ``new` `int``[MAXN];`   `    ``// Function to find the smallest prime` `    ``// factor for every number till MAXN` `    ``public` `static` `void` `sieve() {` `        ``spf[``1``] = ``1``;`   `        ``// Marking smallest prime factor for` `        ``// every number to be itself` `        ``for` `(``int` `i = ``2``; i < MAXN; i++)` `            ``spf[i] = i;`   `        ``// Separately marking spf for every` `        ``// even number as 2` `        ``for` `(``int` `i = ``4``; i < MAXN; i += ``2``)` `            ``spf[i] = ``2``;`   `        ``for` `(``int` `i = ``3``; i * i < MAXN; i++) {`   `            ``// Checking if i is prime` `            ``if` `(spf[i] == i) {`   `                ``// Marking SPF for all numbers` `                ``// divisible by i` `                ``for` `(``int` `j = i * i; j < MAXN; j += i) {` `                    ``if` `(spf[j] == j)` `                        ``spf[j] = i;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Function to find all the distinct prime` `    ``// factors of the given number x` `    ``public` `static` `ArrayList getFactorization(``int` `x) {` `        ``ArrayList ret = ``new` `ArrayList();`   `        ``// Find the prime factors for X` `        ``while` `(x != ``1``) {`   `            ``ret.add(spf[x]);`   `            ``// Find the spf[] of x` `            ``int` `value = spf[x];`   `            ``while` `(x % value == ``0``)` `                ``x = x / value;` `        ``}`   `        ``// Return the prime factors for x` `        ``return` `ret;` `    ``}`   `    ``// Function to find string after flipping` `    ``// the characters at indices of prime` `    ``// factors of array elements arr[]` `    ``public` `static` `String flipString(String S, ``int` `arr[], ``int` `M) {` `        ``// Precalculating Smallest Prime Factor` `        ``sieve();`   `        ``// Stores the frequency of each` `        ``// prime factor` `        ``int``[] frequency = ``new` `int``[MAXN];`   `        ``Arrays.fill(frequency, ``0``);`   `        ``// Iterate over all elements of` `        ``// the array arr[]` `        ``for` `(``int` `i = ``0``; i < M; i++) {`   `            ``// Stores prime factors of arr[i]` `            ``ArrayList primeFactors = getFactorization(arr[i]);`   `            ``// Increment the frequency of all` `            ``// prime factors of arr[i]` `            ``for` `(``int` `factors : primeFactors) {` `                ``frequency[factors]++;` `                ``frequency[factors] %= ``2``;` `            ``}` `        ``}`   `        ``int` `N = S.length();`   `        ``// Iterate over all elements of` `        ``// the array frequency[]` `        ``for` `(``int` `i = ``0``; i < MAXN; i++) {`   `            ``// If frequency[i] is odd` `            ``if` `((frequency[i] & ``1``) > ``0``) {`   `                ``// Flip bits of all indices` `                ``// that are multiple of i` `                ``for` `(``int` `j = i; j <= N; j += i)` `                ``{` `                  `  `                    ``// S.replace(S.charAt(j - 1), (S.charAt(j - 1) == '1' ? '0' : '1'));` `                    ``S = S.substring(``0``, j - ``1``) + (S.charAt(j - ``1``) == ``'1'` `? ``'0'` `: ``'1'``) + S.substring(j);` `                ``}` `            ``}` `        ``}`   `        ``// Return Answer` `        ``return` `S;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String args[]) {` `        ``String S = ``"000000"``;` `        ``int` `arr[] = { ``2``, ``4``, ``6` `};` `        ``int` `M = arr.length;`   `        ``System.out.println(flipString(S, arr, M));` `    ``}` `}`   `// This code is contributed by gfgking.`

## Python3

 `# Python program for the above approach` `MAXN ``=` `100001`   `# Stores smallest prime factor` `spf ``=` `[``0``] ``*` `MAXN `   `# Function to find the smallest prime` `# factor for every number till MAXN` `def` `sieve():` `    ``spf[``1``] ``=` `1`   `    ``# Marking smallest prime factor for` `    ``# every number to be itself` `    ``for` `i ``in` `range``(``2``, MAXN):` `        ``spf[i] ``=` `i`   `    ``# Separately marking spf for every` `    ``# even number as 2` `    ``for` `i ``in` `range``(``4``, MAXN, ``2``):` `        ``spf[i] ``=` `2`   `    ``i ``=` `3` `    ``while``(i ``*` `8` `< MAXN):` `        ``i ``+``=` `1`   `        ``# Checking if i is prime` `        ``if` `(spf[i] ``=``=` `i):`   `            ``# Marking SPF for all numbers` `            ``# divisible by i` `            ``for` `j ``in` `range``(i ``*` `i, MAXN, i):` `                ``if` `(spf[j] ``=``=` `j):` `                    ``spf[j] ``=` `i` `        `    `# Function to find all the distinct prime` `# factors of the given number x` `def` `getFactorization (x):` `    ``ret ``=` `[]`   `    ``# Find the prime factors for X` `    ``while` `(x !``=` `1``):`   `        ``ret.append(spf[x])`   `        ``# Find the spf[] of x` `        ``value ``=` `spf[x]`   `        ``while` `(x ``%` `value ``=``=` `0``):` `            ``x ``=` `x ``/``/` `value`   `    ``# Return the prime factors for x` `    ``return` `ret`   `# Function to find string after flipping` `# the characters at indices of prime` `# factors of array elements arr[]` `def` `flipString (S, arr, M):`   `    ``# Precalculating Smallest Prime Factor` `    ``sieve();`   `    ``# Stores the frequency of each` `    ``# prime factor` `    ``frequency ``=` `[``0``] ``*` `MAXN`   `    ``# Iterate over all elements of` `    ``# the array arr[]` `    ``for` `i ``in` `range``(``0``, M):`   `        ``# Stores prime factors of arr[i]` `        ``primeFactors ``=` `getFactorization(arr[i])`   `        ``# Increment the frequency of all` `        ``# prime factors of arr[i]` `        ``for` `factors ``in` `primeFactors :` `            ``frequency[factors] ``+``=` `1` `            ``frequency[factors] ``%``=` `2` `        `    `    ``N ``=` `len``(S)`   `    ``# Iterate over all elements of` `    ``# the array frequency[]` `    ``for` `i ``in` `range``(``0``, MAXN):`   `        ``# If frequency[i] is odd` `        ``if` `(frequency[i] & ``1``):`   `            ``# Flip bits of all indices` `            ``# that are multiple of i` `            ``for` `j ``in` `range``(i, N ``+` `1``, i):` `                ``S[j ``-` `1``] ``=` `(``'0'` `if` `S[j ``-` `1``] ``=``=` `'1'` `else` `'1'``)` `            `  `    ``# Return Answer` `    ``return` `S`   `# Driver Code` `S ``=` `"000000"` `S ``=` `list``(S)` `arr ``=` `[``2``, ``4``, ``6``]` `M ``=` `len``(arr)`   `print``("".join(flipString(S, arr, M)))`   `# This code is contributed by gfgking.`

## C#

 `// C# program for the above approach`   `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{`   `    ``public` `static` `int` `MAXN = 100001;`   `    ``// Stores smallest prime factor` `    ``public` `static` `int``[] spf = ``new` `int``[MAXN];`   `    ``// Function to find the smallest prime` `    ``// factor for every number till MAXN` `    ``public` `static` `void` `sieve()` `    ``{` `        ``spf = 1;`   `        ``// Marking smallest prime factor for` `        ``// every number to be itself` `        ``for` `(``int` `i = 2; i < MAXN; i++)` `            ``spf[i] = i;`   `        ``// Separately marking spf for every` `        ``// even number as 2` `        ``for` `(``int` `i = 4; i < MAXN; i += 2)` `            ``spf[i] = 2;`   `        ``for` `(``int` `i = 3; i * i < MAXN; i++)` `        ``{`   `            ``// Checking if i is prime` `            ``if` `(spf[i] == i)` `            ``{`   `                ``// Marking SPF for all numbers` `                ``// divisible by i` `                ``for` `(``int` `j = i * i; j < MAXN; j += i)` `                ``{` `                    ``if` `(spf[j] == j)` `                        ``spf[j] = i;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Function to find all the distinct prime` `    ``// factors of the given number x` `    ``public` `static` `List<``int``> getFactorization(``int` `x)` `    ``{` `        ``List<``int``> ret = ``new` `List<``int``>();`   `        ``// Find the prime factors for X` `        ``while` `(x != 1)` `        ``{`   `            ``ret.Add(spf[x]);`   `            ``// Find the spf[] of x` `            ``int` `value = spf[x];`   `            ``while` `(x % value == 0)` `                ``x = x / value;` `        ``}`   `        ``// Return the prime factors for x` `        ``return` `ret;` `    ``}`   `    ``// Function to find string after flipping` `    ``// the characters at indices of prime` `    ``// factors of array elements arr[]` `    ``public` `static` `String flipString(String S, ``int``[] arr, ``int` `M)` `    ``{` `        ``// Precalculating Smallest Prime Factor` `        ``sieve();`   `        ``// Stores the frequency of each` `        ``// prime factor` `        ``int``[] frequency = ``new` `int``[MAXN];`   `        ``Array.Fill(frequency, 0);`   `        ``// Iterate over all elements of` `        ``// the array arr[]` `        ``for` `(``int` `i = 0; i < M; i++)` `        ``{`   `            ``// Stores prime factors of arr[i]` `            ``List<``int``> primeFactors = getFactorization(arr[i]);`   `            ``// Increment the frequency of all` `            ``// prime factors of arr[i]` `            ``foreach` `(``int` `factors ``in` `primeFactors)` `            ``{` `                ``frequency[factors]++;` `                ``frequency[factors] %= 2;` `            ``}` `        ``}`   `        ``int` `N = S.Length;`   `        ``// Iterate over all elements of` `        ``// the array frequency[]` `        ``for` `(``int` `i = 0; i < MAXN; i++)` `        ``{`   `            ``// If frequency[i] is odd` `            ``if` `((frequency[i] & 1) > 0)` `            ``{`   `                ``// Flip bits of all indices` `                ``// that are multiple of i` `                ``for` `(``int` `j = i; j <= N; j += i)` `                ``{`   `                    ``// S.replace(S.charAt(j - 1), (S.charAt(j - 1) == '1' ? '0' : '1'));` `                    ``S = S.Substring(0, j - 1) + (S[j - 1] == ``'1'` `? ``'0'` `: ``'1'``) + S.Substring(j);` `                ``}` `            ``}` `        ``}`   `        ``// Return Answer` `        ``return` `S;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``String S = ``"000000"``;` `        ``int``[] arr = { 2, 4, 6 };` `        ``int` `M = arr.Length;`   `        ``Console.Write(flipString(S, arr, M));` `    ``}` `}`   `// This code is contributed by Saurabh Jaiswal`

## Javascript

 ``

Output:

`011100`

Time Complexity: O(N*log N + K*log K), where K is the maximum integer in the array arr[].
Auxiliary Space: O(K)

My Personal Notes arrow_drop_up
Recommended Articles
Page :