limiting the number of combinations /permutations in python

• Last Update :
• Techknowledgy :

You need to use `itertools.islice`, like this

`itertools.islice(itertools.product( * big_list), 5000)`

It doesn't create the entire list in memory, but it returns an iterator which consumes the actual iterable lazily. You can convert that to a list like this

`list(itertools.islice(itertools.product( * big_list), 5000))`

You could create a tiny wrapper around `itertools.product`

```it = itertools.product( * big_list)
pg = (next(it) for _ in range(5000)) # generator expression```

`(next(it) for _ in range(5000))` returns a generator not capable of producing more than 5000 values. Convert it to `list` by using the `list` constructor

`pl = list(pg)`

or by wrapping the generator expression with square brackets (instead of round ones)

`pl = [next(it) for _ in range(5000)] # list comprehension`

Use any temporary variable and limit it

```    from itertools
import permutations
m = ['a', 'b', 'c', 'd']
per = permutations(m)
temp = 1
for i in list(per):
if temp <= 2: #2 is the limit set
print (i)
temp= temp + 1
else:
break```

Suggestion : 2

For what you are trying to do, what qualifies as a combination? Does a combination consist of 33 ones, 33 twos and 66 zeros, but in any order?,Letters are like there are 33 ones, 33 twos and 66 zeros amounting to total letters 132. If I do it manually, there will be a lot of combinations. To make it easy for computer I want to limit combinations no to 1000. Plz help. my_letters=[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2],… there will be a lot of combinations.,Technically, the different orders of the same numbers of each kind of object are known as permutations. Is this what is needed here?

Sorry Ali123, I have no idea what you are talking about here. Your
variable letters doesn’t have any letters in it, it is a list with a
single large number:

`11111111111111111111111111`

Let’s create 1000 combinations of letters, but to save space, we will display only 10 of those combinations.

```import random
combos = []
for k in range(1000):
letters = [random.randint(0, 1) for i in range(26)]
combo = "".join([chr(i + ord("A")) for i in range(26) if letters[i] == 1])
combos.append(combo)
for i in range(10):
print(combos[i])```

Output:

```BEFHJNXZ
ABCFGHIORUVW
BDEFKNQRSTYZ
ABCHKLMORSTUVWXY
EFKLMNOSUVWZ
CDEGHIJLMQVW
CDGHIKLMNOPRSTUVXZ
ABIJKOPQRSVXYZ
BCDEGIKMPTVWXY```

Suggestion : 3

In the above techniques to calculate permutations, we are including all the numbers or letters. There is a possibility to restrict the number of elements in the permutations.,Permutation mathematically refers to “the arrangement of certain numbers or letters”. The permutations() function in the itertools library does exactly that.,The permuatations() function takes an iterable argument, therefore in order to find out permutations of numbers, we need to pass the numbers as a list, set, or tuple.,In the above code snippet, the permutations() function is asked to arrange only 2 elements at a time from the list of numbers provided.

`import itertools`
```import itertools

st = "ABC"

per = itertools.permutations(st)

for val in per:
print( * val)```
```A B C
A C B
B A C
B C A
C A B
C B A```
`<itertools.permutations object at 0x7fc9abdd8308>`
```import itertools

values = [1, 2, 3]

per = itertools.permutations(values)

for val in per:
print( * val)```
```1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1```

Suggestion : 4

Last Updated : 19 Jul, 2022

Output:

```(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)```

Output:

```(1, 2)
(1, 3)
(2, 1)
(2, 3)
(3, 1)
(3, 2)```

Output:

```(1, 1)
(1, 2)
(1, 3)
(2, 2)
(2, 3)
(3, 3)```

Suggestion : 5

Permutation is the method of selecting elements from a set in different ways.,For example: the number of ways in which characters from yup can be selected are yup, ypu, uyp, upy, puy, pyu, and not selecting any.,The elements of words are swapped. In this way, we achieve all different combinations of characters.,In this example, recursion is used to find the permutations of a string yup.

Example 1: Using recursion

```def get_permutation(string, i = 0):

if i == len(string):
print("".join(string))

for j in range(i, len(string)):

words = [c
for c in string
]

# swap
words[i], words[j] = words[j], words[i]

get_permutation(words, i + 1)

print(get_permutation('yup'))```

Output

```yup
ypu
uyp
upy
puy
pyu
None```

Example 2: Using itertools

```from itertools
import permutations

words = [''.join(p) for p in permutations('pro')]

print(words)```