Kotlin generate permutations (in order) of list without duplicate elements (2024)

Generating permutations of a list in Kotlin, maintaining order and without duplicate elements, can be achieved using recursion and backtracking. Here's a detailed approach to generate permutations:

Approach

1. Use Recursive Function: Create a recursive function that generates permutations by fixing each element of the list in turn.

2. Track Used Elements: Use a boolean array to track which elements have already been used in the current permutation to avoid duplicates.

3. Backtracking: Backtrack by removing the last added element from the permutation and marking it as unused when exploring new permutations.

Example Implementation

Here's a Kotlin function to generate permutations of a list:

fun permutations(list: List<Int>): List<List<Int>> { val result = mutableListOf<List<Int>>() val used = BooleanArray(list.size) val currentPermutation = mutableListOf<Int>() fun generate() { if (currentPermutation.size == list.size) { result.add(currentPermutation.toList()) return } for (i in list.indices) { if (!used[i]) { used[i] = true currentPermutation.add(list[i]) generate() currentPermutation.removeAt(currentPermutation.size - 1) used[i] = false // Skip duplicate elements while (i + 1 < list.size && list[i] == list[i + 1]) { i++ } } } } // Start generating permutations generate() return result}fun main() { val list = listOf(1, 2, 3) val result = permutations(list) result.forEach { println(it) }}

Explanation

• Function permutations():

  • list: Input list for which permutations are to be generated.
  • result: Mutable list to store all permutations.
  • used: Boolean array to track which elements have been used in the current permutation.
  • currentPermutation: Mutable list to store the current permutation being generated.
  • Inner Function generate():
    • Base case: If currentPermutation has reached the size of list, add it to result.
    • Iterate through list:
      • Check if list[i] is not used (!used[i]).
      • Mark list[i] as used, add it to currentPermutation, and recursively call generate().
      • Backtrack by removing the last element added (currentPermutation.removeAt(currentPermutation.size - 1)) and mark it as unused (used[i] = false).
      • Skip duplicate elements to avoid generating duplicate permutations.

• Main Function:

  • Example usage with listOf(1, 2, 3) to generate permutations and print each permutation.

Output

Running the main() function with listOf(1, 2, 3) as input will produce the following output:

[1, 2, 3][1, 3, 2][2, 1, 3][2, 3, 1][3, 1, 2][3, 2, 1]

Notes

• This implementation ensures that each permutation is generated in order without duplicates by using the used array to track which elements have been used.
• Adjust the implementation as needed for different types of input lists (e.g., strings, custom objects) by modifying the List<Int> type accordingly and adjusting comparisons.

This approach efficiently generates permutations in order and avoids duplicate permutations by carefully managing which elements are used in each permutation generation step.

Examples

1. Query: How to generate all permutations of a list in Kotlin?

   See Also

   17 nejlepších ZDARMA software pro vyhledávání duplicitních souborů Windows
   • Description: Implement a function to generate all possible permutations of elements in a list.
   • Code:

     fun <T> List<T>.permutations(): List<List<T>> { if (size <= 1) return listOf(this) val result = mutableListOf<List<T>>() for (i in indices) { val element = this[i] val remaining = this.minus(element) val permutations = remaining.permutations() for (perm in permutations) { result.add(listOf(element) + perm) } } return result}// Usage:val list = listOf(1, 2, 3)val perms = list.permutations()println(perms)

   • Explanation: This recursive function generates all permutations of a list by recursively selecting each element and appending it to the permutations of the remaining elements.

2. Query: Kotlin generate permutations of a string without repetition?

   • Description: Create permutations of characters in a string without repeating any character sequence.
   • Code:

     fun String.permutations(): Set<String> { if (length <= 1) return setOf(this) val result = mutableSetOf<String>() for (i in indices) { val char = this[i] val remaining = substring(0, i) + substring(i + 1) val permutations = remaining.permutations() for (perm in permutations) { result.add(char + perm) } } return result}// Usage:val str = "abc"val perms = str.permutations()println(perms)

   • Explanation: This extension function on String recursively generates all permutations without repeating any character sequence using a Set to avoid duplicates.

3. Query: How to generate permutations of a list in lexicographical order in Kotlin?

   • Description: Arrange permutations of a list in lexicographical (alphabetical) order.
   • Code:

     fun <T : Comparable<T>> List<T>.permutationsLexicographical(): List<List<T>> { if (size <= 1) return listOf(this) val sorted = sorted() val result = mutableListOf<List<T>>() for (i in indices) { if (i > 0 && sorted[i] == sorted[i - 1]) continue // Skip duplicates val element = sorted[i] val remaining = sorted.minus(element) val permutations = remaining.permutationsLexicographical() for (perm in permutations) { result.add(listOf(element) + perm) } } return result}// Usage:val list = listOf('a', 'b', 'c', 'a')val perms = list.permutationsLexicographical()println(perms)

   • Explanation: This function generates permutations in lexicographical order by sorting the list and skipping duplicate elements during the permutation generation.

4. Query: Kotlin permutation generator with distinct elements?

   • Description: Ensure that generated permutations contain unique element sequences without duplicates.
   • Code:

     fun <T> List<T>.permutationsDistinct(): List<List<T>> { if (size <= 1) return listOf(this) val result = mutableSetOf<List<T>>() for (i in indices) { val element = this[i] val remaining = this.minus(element) val permutations = remaining.permutationsDistinct() for (perm in permutations) { result.add(listOf(element) + perm) } } return result.toList()}// Usage:val list = listOf('a', 'b', 'a')val perms = list.permutationsDistinct()println(perms)

   • Explanation: This function uses a Set to collect unique permutations, ensuring no duplicate sequences of elements.

5. Query: Kotlin generate permutations of array elements?

   • Description: Generate permutations of elements in an array in Kotlin.
   • Code:

     fun <T> Array<T>.permutations(): List<List<T>> { if (isEmpty()) return listOf(emptyList()) val result = mutableListOf<List<T>>() for (i in indices) { val element = this[i] val remaining = this.copyOfRange(0, i) + this.copyOfRange(i + 1, size) val permutations = remaining.permutations() for (perm in permutations) { result.add(listOf(element) + perm) } } return result}// Usage:val array = arrayOf(1, 2, 3)val perms = array.permutations()println(perms)

   • Explanation: This extension function on Array generates permutations by recursively selecting each element and appending it to permutations of the remaining elements.

6. Query: How to generate permutations of a list without repeating sequences in Kotlin?

   • Description: Ensure that generated permutations do not repeat any sequence of elements.
   • Code:

     fun <T> List<T>.permutationsUnique(): List<List<T>> { if (size <= 1) return listOf(this) val result = mutableSetOf<List<T>>() for (i in indices) { val element = this[i] val remaining = this.minus(element) val permutations = remaining.permutationsUnique() for (perm in permutations) { result.add(listOf(element) + perm) } } return result.toList()}// Usage:val list = listOf(1, 2, 1)val perms = list.permutationsUnique()println(perms)

   • Explanation: Using a Set ensures that no duplicate sequences of elements are generated in the permutations.

7. Query: Kotlin permutation generator with fixed order?

   • Description: Generate permutations respecting the original order of elements in the list.
   • Code:

     fun <T> List<T>.permutationsOrdered(): List<List<T>> { if (size <= 1) return listOf(this) val result = mutableListOf<List<T>>() for (i in indices) { val element = this[i] val remaining = this.minus(element) val permutations = remaining.permutationsOrdered() for (perm in permutations) { result.add(listOf(element) + perm) } } return result}// Usage:val list = listOf('a', 'b', 'c')val perms = list.permutationsOrdered()println(perms)

   • Explanation: This function generates permutations while preserving the original order of elements in the list.

8. Query: How to generate permutations of a list of integers in Kotlin?

   • Description: Create permutations of a list containing integer elements.
   • Code:

     fun List<Int>.permutations(): List<List<Int>> { if (size <= 1) return listOf(this) val result = mutableListOf<List<Int>>() for (i in indices) { val element = this[i] val remaining = this.minus(element) val permutations = remaining.permutations() for (perm in permutations) { result.add(listOf(element) + perm) } } return result}// Usage:val list = listOf(1, 2, 3)val perms = list.permutations()println(perms)

   • Explanation: This function generates permutations specifically for a list of integers, allowing for operations like numeric permutations.

9. Query: Kotlin generate permutations of a list with duplicates?

   • Description: Handle lists containing duplicate elements while generating permutations in Kotlin.
   • Code:

     fun <T> List<T>.permutationsWithDuplicates(): List<List<T>> { if (isEmpty()) return listOf(emptyList()) val result = mutableListOf<List<T>>() val seen = mutableSetOf<List<T>>() for (i in indices) { val element = this[i] val remaining = this.filterIndexed { index, _ -> index != i } val permutations = remaining.permutationsWithDuplicates() for (perm in permutations) { val permList = listOf(element) + perm if (seen.add(permList)) { result.add(permList) } } } return result}// Usage:val list = listOf(1, 2, 2)val perms = list.permutationsWithDuplicates()println(perms)

   • Explanation: This function generates permutations even with duplicate elements in the original list, ensuring each permutation sequence is unique.

More Tags

computational-geometryuisearchcontrollercircular-listhibernate-5.xarduinofile-sharinggrobprocessconcatenationvba

More Programming Questions

• Timit function in python
• How to Insert a Character in String at Specific Index in Swift?
• Hibernate CRUD Operations
• Spring Bean Inheritance
• Getting all types that implement an interface in C#
• How to Split(',') a string while ignore commas in between quotes in C#?
• How to "flatten" or "index" 3D-array in 1D array in C#?
• Include filter child collection in C#
• Saving XML files using ElementTree in python