Related Articles
Generate a circular permutation with number of mismatching bits between pairs of adjacent elements exactly 1
• Last Updated : 04 Mar, 2021

Given two integers N and S, the task is to find a circular permutation of numbers from the range [0, 2(N – 1)], starting with S such that the count of mismatching bits between any pair of adjacent numbers is one.

Examples:

Input: N = 2, S = 3
Output: [3, 2, 0, 1]
Explanation:
The binary representation of numbers 3, 2, 0 and 1 are “11”, “10”, “01” and “00” respectively.
Therefore, arranging them in the order [3, 2, 0, 1] ensures that the number of bit differences between each pair of adjacent elements (circular) is 1.

Input: N = 3, S = 2
Output: [2, 6, 7, 5, 4, 0, 1, 3]

Approach: The given problem can be solved based on the following observations:

• A simple observation is that the numbers in the range [2i, 2i + 1 – 1] can be obtained in their natural order by placing ‘1’s before each number in the range [0, 2i – 1].
• Therefore, the problem can be solved recursively by adding ‘1’ before each number before 2i – 1th index and reverse it before appending the new numbers to permutation.

Follow the steps below to solve the problem:

• Initialize a list, say res, to stores the required permutation.
• Initialize an integer, say index, to store the position of S in the permutation starting with 0.
• Iterate over the range [0, N – 1] and traverse the array res[] in reverse order and check if the sum of the current number and 2i is S or not. If found to be true, then update index with the current index of res and append the current number + 2i in the list res.
• Rotate the list res[] by index positions.
• After completing the above steps, print the list res[] as the answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the permutation of` `// integers from a given range such that` `// number of mismatching bits between` `// pairs of adjacent elements is 1` `vector<``int``> circularPermutation(``int` `n, ``int` `start)` `{` `    `  `    ``// Initialize an arrayList to` `    ``// store the resultant permutation` `    ``vector<``int``> res = {0};` `    ``vector<``int``> ret;` `    `  `    ``// Store the index of rotation` `    ``int` `index = -1;` `    `  `    ``// Iterate over the range [0, N - 1]` `    ``for``(``int` `k = 0, add = 1 << k; k < n;` `            ``k++, add = 1 << k) ` `    ``{` `    `  `        ``// Traverse all the array elements` `        ``// up to (2 ^ k)-th index in reverse` `        ``for` `(``int` `i = res.size() - 1;` `                 ``i >= 0; i--)` `        ``{` `        `  `            ``// If current element is S` `            ``if` `(res[i] + add == start)` `                ``index = res.size();` `                `  `            ``res.push_back(res[i] + add);` `        ``}` `    ``}` `    `  `    ``// Check if S is zero` `    ``if` `(start == 0)` `        ``return` `res;` `    `  `    ``// Rotate the array by index` `    ``// value to the left` `    ``while` `(ret.size() < res.size())` `    ``{` `        ``ret.push_back(res[index]);` `        ``index = (index + 1) % res.size();` `    ``}` `    ``return` `ret;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 2, S = 3;` `    ``vector<``int``> print = circularPermutation(N, S);` `    ``cout << ``"["``;` `    ``for``(``int` `i = 0; i < print.size() - 1; i++ )` `    ``{` `        ``cout << print[i] << ``", "``;` `    ``}` `    ``cout << print[print.size() - 1] << ``"]"``;` `    `  `    ``return` `0;` `}`   `// This code is contributed by susmitakundugoaldanga`

## Java

 `// Java program for the above approach`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to find the permutation of` `    ``// integers from a given range such that` `    ``// number of mismatching bits between` `    ``// pairs of adjacent elements is 1` `    ``public` `static` `List circularPermutation(` `        ``int` `n, ``int` `start)` `    ``{` `        ``// Initialize an arrayList to` `        ``// store the resultant permutation` `        ``List res = ``new` `ArrayList<>(List.of(``0``)),` `                      ``ret = ``new` `ArrayList<>();`   `        ``// Store the index of rotation` `        ``int` `index = -``1``;`   `        ``// Iterate over the range [0, N - 1]` `        ``for` `(``int` `k = ``0``, add = ``1` `<< k; k < n;` `             ``k++, add = ``1` `<< k) {`   `            ``// Traverse all the array elements` `            ``// up to (2 ^ k)-th index in reverse` `            ``for` `(``int` `i = res.size() - ``1``;` `                 ``i >= ``0``; i--) {`   `                ``// If current element is S` `                ``if` `(res.get(i) + add == start)` `                    ``index = res.size();`   `                ``res.add(res.get(i) + add);` `            ``}` `        ``}`   `        ``// Check if S is zero` `        ``if` `(start == ``0``)` `            ``return` `res;`   `        ``// Rotate the array by index` `        ``// value to the left` `        ``while` `(ret.size() < res.size()) {` `            ``ret.add(res.get(index));` `            ``index = (index + ``1``) % res.size();` `        ``}`   `        ``return` `ret;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``2``, S = ``3``;`   `        ``System.out.println(` `            ``circularPermutation(N, S));` `    ``}` `}`

## Python3

 `# Python3 program for the above approach`   `# Function to find the permutation of` `# integers from a given range such that` `# number of mismatching bits between` `# pairs of adjacent elements is 1` `def` `circularPermutation(n, start):` `  `  `    ``# Initialize an arrayList to` `    ``# store the resultant permutation` `    ``res ``=` `[``0``]` `    ``ret ``=` `[]`   `    ``# Store the index of rotation` `    ``index, add ``=` `-``1``, ``1`   `    ``# Iterate over the range [0, N - 1]` `    ``for` `k ``in` `range``(n):` `        ``add ``=` `1``<

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG` `{`   `  ``// Function to find the permutation of` `  ``// integers from a given range such that` `  ``// number of mismatching bits between` `  ``// pairs of adjacent elements is 1` `  ``public` `static` `List<``int``> circularPermutation(` `    ``int` `n, ``int` `start)` `  ``{`   `    ``// Initialize an arrayList to` `    ``// store the resultant permutation` `    ``List<``int``> res = ``new` `List<``int``>(){0};` `    ``List<``int``> ret = ``new` `List<``int``>();`   `    ``// Store the index of rotation` `    ``int` `index = -1;`   `    ``// Iterate over the range [0, N - 1]` `    ``for` `(``int` `k = 0, add = 1 << k; k < n;` `         ``k++, add = 1 << k) ` `    ``{`   `      ``// Traverse all the array elements` `      ``// up to (2 ^ k)-th index in reverse` `      ``for` `(``int` `i = res.Count - 1;` `           ``i >= 0; i--)` `      ``{`   `        ``// If current element is S` `        ``if` `(res[i] + add == start)` `          ``index = res.Count;` `        ``res.Add(res[i] + add);` `      ``}` `    ``}`   `    ``// Check if S is zero` `    ``if` `(start == 0)` `      ``return` `res;`   `    ``// Rotate the array by index` `    ``// value to the left` `    ``while` `(ret.Count < res.Count)` `    ``{` `      ``ret.Add(res[index]);` `      ``index = (index + 1) % res.Count;` `    ``}` `    ``return` `ret;` `  ``}`   `  ``// Driver Code` `  ``static` `public` `void` `Main ()` `  ``{` `    ``int` `N = 2, S = 3;` `    ``List<``int``> print = circularPermutation(N, S);` `    ``Console.Write(``"["``);` `    ``for``(``int` `i = 0; i < print.Count - 1; i++ )` `    ``{` `      ``Console.Write(print[i] + ``", "``);` `    ``}` `    ``Console.Write(print[print.Count-1] + ``"]"``);` `  ``}` `}`   `// This code is contributed by avanitrachhadiya2155`

Output:

`[3, 2, 0, 1]`

Time Complexity: O(N2)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :