# Find a permutation such that number of indices for which gcd(p[i], i) > 1 is exactly K

• Last Updated : 05 May, 2021

Given two integers N and K, the task is to find a permutation of integers from the range [1, N] such that the number of indices (1-based indexing) where gcd(p[i], i) > 1 is exactly K. Print -1 if such permutation is not possible.

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: N = 4, K = 3
Output: 1 2 3 4
gcd(1, 1) = 1
gcd(2, 2) = 2
gcd(3, 3) = 3
gcd(4, 4) = 4
Therefore, there are exactly 3 indices where gcd(p[i], i) > 1

Input: N = 1, K = 1
Output: -1

Approach: A couple of observations can be made here:

1. gcd(i, i + 1) = 1
2. gcd(1, i) = 1
3. gcd(i, i) = i

Since gcd of 1 with any other number is always going to be one, K can almost be N – 1. Consider the permutation where p[i] = i, The number of indices where gcd(p[i], i) > 1 will be N – 1. Notice that swapping 2 continuous elements (excluding 1) will reduce the count of such indices by exactly 2. And swapping with 1 will reduce the count by exactly 1.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to print the required permutation``void` `printPermutation(``int` `n, ``int` `k)``{` `    ``// Not possible``    ``if` `(k >= n || (n % 2 == 0 && k == 0)) {``        ``cout << -1;``        ``return``;``    ``}``    ``int` `per[n + 1], i;` `    ``// Initial permutation``    ``for` `(i = 1; i <= n; i++)``        ``per[i] = i;` `    ``// Indices for which gcd(p[i], i) > 1``    ``// in the initial permutation``    ``int` `cnt = n - 1;``    ``i = 2;``    ``while` `(i < n) {` `        ``// Reduce the count by 2``        ``if` `(cnt - 1 > k) {``            ``swap(per[i], per[i + 1]);``            ``cnt -= 2;``        ``}` `        ``// Reduce the count by 1``        ``else` `if` `(cnt - 1 == k) {``            ``swap(per, per[i]);``            ``cnt--;``        ``}``        ``else``            ``break``;``        ``i += 2;``    ``}` `    ``// Print the permutation``    ``for` `(i = 1; i <= n; i++)``        ``cout << per[i] << ``" "``;``}` `// Driver code``int` `main()``{``    ``int` `n = 4, k = 3;``    ``printPermutation(n, k);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{` `// Function to print the required permutation``    ``static` `void` `printPermutation(``int` `n, ``int` `k)``    ``{` `        ``// Not possible``        ``if` `(k >= n || (n % ``2` `== ``0` `&& k == ``0``))``        ``{``            ``System.out.print(-``1``);``            ``return``;``        ``}``        ``int` `per[] = ``new` `int``[n + ``1``], i;` `        ``// Initial permutation``        ``for` `(i = ``1``; i <= n; i++)``        ``{``            ``per[i] = i;``        ``}` `        ``// Indices for which gcd(p[i], i) > 1``        ``// in the initial permutation``        ``int` `cnt = n - ``1``;``        ``i = ``2``;``        ``while` `(i < n)``        ``{` `            ``// Reduce the count by 2``            ``if` `(cnt - ``1` `> k)``            ``{``                ``swap(per, i, i + ``1``);``                ``cnt -= ``2``;``            ``}``            ` `            ``// Reduce the count by 1``            ``else` `if` `(cnt - ``1` `== k)``            ``{``                ``swap(per, ``1``, i);``                ``cnt--;``            ``}``            ``else``            ``{``                ``break``;``            ``}``            ``i += ``2``;``        ``}` `        ``// Print the permutation``        ``for` `(i = ``1``; i <= n; i++)``        ``{``            ``System.out.print(per[i] + ``" "``);``        ``}``    ``}` `    ``static` `int``[] swap(``int``[] arr, ``int` `i, ``int` `j)``    ``{``        ``int` `temp = arr[i];``        ``arr[i] = arr[j];``        ``arr[j] = temp;``        ``return` `arr;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``4``, k = ``3``;``        ``printPermutation(n, k);``    ``}``}` `/* This code contributed by PrinciRaj1992 */`

## Python3

 `# Python3 implementation of the approach` `# Function to print the required permutation``def` `printPermutation(n, k):` `    ``# Not possible``    ``if` `(k >``=` `n ``or` `(n ``%` `2` `=``=` `0` `and``                   ``k ``=``=` `0``)):``        ``print``(``-``1``);``        ``return``;``    ``per ``=` `[``0``] ``*` `(n ``+` `1``);` `    ``# Initial permutation``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``per[i] ``=` `i;` `    ``# Indices for which gcd(p[i], i) > 1``    ``# in the initial permutation``    ``cnt ``=` `n ``-` `1``;``    ``i ``=` `2``;``    ``while` `(i < n):` `        ``# Reduce the count by 2``        ``if` `(cnt ``-` `1` `> k):``            ` `            ``t ``=` `per[i];``            ``per[i] ``=` `per[i ``+` `1``];``            ``per[i ``+` `1``] ``=` `t;``            ` `            ``# swap(per[i], per[i + 1]);``            ``cnt ``-``=` `2``;` `        ``# Reduce the count by 1``        ``elif` `(cnt ``-` `1` `=``=` `k):``            ` `            ``# swap(per, per[i]);``            ``t ``=` `per[``1``];``            ``per[``1``] ``=` `per[i];``            ``per[i] ``=` `t;``            ``cnt ``-``=` `1``;``        ``else``:``            ``break``;``        ``i ``+``=` `2``;` `    ``# Print the permutation``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``print``(per[i], end ``=` `" "``);` `# Driver code``n ``=` `4``;``k ``=` `3``;``printPermutation(n, k);` `# This code is contributed by mits`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `    ``// Function to print the required permutation``    ``static` `void` `printPermutation(``int` `n, ``int` `k)``    ``{` `        ``// Not possible``        ``if` `(k >= n || (n % 2 == 0 && k == 0))``        ``{``            ``Console.Write(-1);``            ``return``;``        ``}``        ``int` `[]per = ``new` `int``[n + 1] ;``        ``int` `i ;` `        ``// Initial permutation``        ``for` `(i = 1; i <= n; i++)``        ``{``            ``per[i] = i;``        ``}` `        ``// Indices for which gcd(p[i], i) > 1``        ``// in the initial permutation``        ``int` `cnt = n - 1;``        ``i = 2;``        ``while` `(i < n)``        ``{` `            ``// Reduce the count by 2``            ``if` `(cnt - 1 > k)``            ``{``                ``swap(per, i, i + 1);``                ``cnt -= 2;``            ``}``            ` `            ``// Reduce the count by 1``            ``else` `if` `(cnt - 1 == k)``            ``{``                ``swap(per, 1, i);``                ``cnt--;``            ``}``            ``else``            ``{``                ``break``;``            ``}``            ``i += 2;``        ``}` `        ``// Print the permutation``        ``for` `(i = 1; i <= n; i++)``        ``{``            ``Console.Write(per[i] + ``" "``);``        ``}``    ``}` `    ``static` `int``[] swap(``int``[] arr, ``int` `i, ``int` `j)``    ``{``        ``int` `temp = arr[i];``        ``arr[i] = arr[j];``        ``arr[j] = temp;``        ``return` `arr;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `n = 4, k = 3;``        ``printPermutation(n, k);``    ``}``}` `/* This code contributed by Ryuga */`

## PHP

 `= ``\$n` `|| (``\$n` `% 2 == 0 &&``                     ``\$k` `== 0))``    ``{``        ``echo` `-1;``        ``return``;``    ``}``    ``\$per``[``\$n` `+ 1] = ``array``();``    ``\$i``;` `    ``// Initial permutation``    ``for` `(``\$i` `= 1; ``\$i` `<= ``\$n``; ``\$i``++)``        ``\$per``[``\$i``] = ``\$i``;` `    ``// Indices for which gcd(p[i], i) > 1``    ``// in the initial permutation``    ``\$cnt` `= ``\$n` `- 1;``    ``\$i` `= 2;``    ``while` `(``\$i` `< ``\$n``)``    ``{` `        ``// Reduce the count by 2``        ``if` `(``\$cnt` `- 1 > ``\$k``)``        ``{``            ` `            ``list(``\$per``[``\$i``],``                 ``\$per``[``\$i` `+ 1]) = ``array``(``\$per``[``\$i` `+ 1],``                                       ``\$per``[``\$i``]);``            ``//swap(per[i], per[i + 1]);``            ``\$cnt` `-= 2;``        ``}` `        ``// Reduce the count by 1``        ``else` `if` `(``\$cnt` `- 1 == ``\$k``)``        ``{``            ` `            ``// swap(per, per[i]);``            ``list(``\$per``,``                 ``\$per``[``\$i``]) = ``array``(``\$per``[``\$i``],``                                   ``\$per``);``            ``\$cnt``--;``        ``}``        ``else``            ``break``;``        ``\$i` `+= 2;``    ``}` `    ``// Print the permutation``    ``for` `(``\$i` `= 1; ``\$i` `<= ``\$n``; ``\$i``++)``        ``echo` `\$per``[``\$i``], ``" "``;``}` `// Driver code``\$n` `= 4;``\$k` `= 3;``printPermutation(``\$n``, ``\$k``);` `// This code is contributed by ajit.``?>`

## Javascript

 ``
Output:
`1 2 3 4`

Time Complexity: O(N)

My Personal Notes arrow_drop_up