Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Golang program to compute all the permutations of the string
In the Go programming language, strings are a built-in data type that represents sequences of characters. They are defined using double quotes (") and can contain any valid Unicode characters. A permutation of a string is a distinct string with the same characters but a different ordering of the characters. For instance, the words "abcd" and "dabc" are combinations of one another. Here, in this program we will explore method to find permutation of string and print the output on the console using print statement in Golang.
Syntax
func append(slice, element_1, element_2…, element_N) []T
The append function is used to add values to an array slice. It takes number of arguments. The first argument is the array to which we wish to add the values followed by the values to add. The function then returns the final slice of array containing all the values.
func len(v Type) int
The len() function is used to get the length of a any parameter. It takes one parameter as the data type variable whose length we wish to find and returns the integer value which is the length of the variable.
Algorithm
Step 1 − Create a package main and declare fmt(format package) package in the program where main produces executable Examples and fmt helps in formatting input and output.
Step 2 − The input list, its length, and a pointer to an array of integer slices that contains the permutations are passed to the heapPermutation function by the main function.
Step 3 − The heapPermutation function verifies that the list's length is 1. If it is, we have fixed all of the list's components, making the present list a permutation. As a result, it adds the current list to the permutation slice.
Step 4 − If the list's length is more than 1, the function enters a loop in which it continuously calls itself with the list's n-1 entries.
Step 5 − The last element of the list is swapped with each of the preceding components inside the loop using a nested loop.
Step 6 − The current permutation is then added to the permutations slice by the function.
Step 7 − The function then determines whether the list's length is even or odd using an if statement. If it is odd, it will swap the first element with the final element; if it is even, it will swap the element at the ith index with the last element.
Step 8 − After that, the function repeats the aforementioned procedure for each element in the list.
Step 9 − Following the generation of all possible permutations, the function returns the slice of permutations.
Step 10 − The permutation will be printed on the console using fmt.Println() function where ln means new line.
Step 11 − This approach has an O(n!) time complexity since there are n! permutations for a list of length n. Since all the permutations must be stored in the slice, the space complexity is also O(n!). Due to its non-recursive nature, this strategy may be more effective for big inputs than recursive approaches because it prevents stack overflow errors.
Example
Here we creates all lexicographically ordered permutations of a given list using the Heap's algorithm.
package main
import (
"fmt"
)
func heapPermutation(mystr []int, n int, permutations *[][]int) {
if n == 1 {
*permutations = append(*permutations, append([]int{}, mystr...))
return
}
for i := 0; i < n; i++ { //calculate the permutation using heap
heapPermutation(mystr, n-1, permutations)
if n%2 == 0 {
mystr[i], mystr[n-1] = mystr[n-1], mystr[i]
} else {
mystr[0], mystr[n-1] = mystr[n-1], mystr[0]
}
}
}
func main() {
mystr := []int{10, 20, 30} //create a slice with numbers whose permutation is to be calculated
fmt.Println("The elements of string are:", mystr)
permutations := [][]int{}
heapPermutation(mystr, len(mystr), &permutations)
fmt.Println("The permutations of string presented here is:")
fmt.Println(permutations) //print the permutations
}
Output
The elements of string are: [10 20 30] The permutations of string presented here is: [[10 20 30] [20 10 30] [30 10 20] [10 30 20] [20 30 10] [30 20 10]]
Conclusion
We executed the program of finding permutations of a string using one example. In the particular example we used heap algorithm to Carry on the execution. The program gave as expected output.
595 Views
