 # Python | All permutations of a string in lexicographic order without using recursion

Examples :

`  Input:  python  Output:  hnopty hnopyt hnotpy hnotyp hnoypt ...... ytpnho ytpnoh ytpohn ytponh  Input:  xyz  Output:  xyz xzy yxz yzx zxy zyx `

Method 1:
Usage default libraries for permutations of itertools functions.
The permutation function will create all permutations of a given string, and then we sort the result to get the desired result.

 ` from ` ` itertools ` ` import ` ` permutations ` ` `  ` def ` ` lexicographical_permutation (` ` str ` `): ` ` perm ` ` = ` ` sorted ` ` (`` .join (chars) ` ` for ` ` chars ` ` in ` ` permutations (` ` str ` `)) `   ` for ` ` x ` ` in perm: ```` print (x)   str = `abc` lexicographical_permutation ( str ) ```

Output:

` abc acb bac bca cab cba `

Method 2:

• First, we create a loop that will run n! links, where n — the length of the string, since there will be n! Permutations.
• Each iteration prints a line and finds the next large lexicographic permutation to be printed in the next iteration.
• The next higher permutation is found as:
• Let the line be called str, find the smallest index i so that all elements in str [i… end] are in descending order.
• If str [i… end] is the entire sequence, i.e. i == 0, then str is the tallest permutation. So we just flip the entire line to get the smallest permutation, which we think is the next permutation.
• If i & gt; 0, then we return str [i… end].
• Then we look for the smallest element in str [i… end] that is greater than str [i — 1], and change its position to str [i — 1].
• This is the next permutation.
•  ` # library import ` ` from ` ` math ` ` import ` ` factorial `   ` def ` ` lexicographical_permutations (` ` str ` `): `   ` # will be n! permutations where n = len (seq) ` ` for ` ` p ` ` in ` ` range ` ` (factorial (` ` len ` ` (` ` str ` `))) : ` ` print ` ` (``. join (` ` str ` `)) `   ` i ` ` = ` ` len ` ` (` ` str ` `) - 1 ````   # find me such that str [i:] is the largest sequence with # items in descending lexicographic order while i & gt;  0 and str [i - 1 ] & gt;  str [i]:  i - = 1   # reverse str [i:]   str [i:] = reversed ( str [i:])      if i & gt;  0 :   q = i # find q such that str [q] is the smallest element # in str [p:] such that str [q] & gt; str [i - 1] while str [i - 1 ] & gt;  str [q]:  q + = 1   # swp str [i - 1] and str [q]   temp = str [i - 1 ]  str [i - 1 ] = str [q]   str [q] = temp     s = `abcd` s = list (s) s.sort () lexicographical_permutations (s) ```

Output:

` abcd abdc acbd acdb adbc adcb bacd badc bcad bcda bdac bdca cabd cadb cbad cbda cdab cdba dabc dacb dbac dbca dcab dcba `