获取python中排列的总数

Question

Okay i have written a function/method in which I do some operations after a certain if condition is failed mostly but only 1-2 times it will be true.

Here is my code:

def solve_current_level(self):
    self.remaining_possibilities = list(self.remaining_possibilities)
    if len(self.remaining_possibilities) > 10 ** 6:
        #self.reduce_weapon_options()
        pass

    guess = list(random.choice(self.remaining_possibilities))
    response = self.client.solve_level(self.current_level.levelNum, guess)

    if 'roundsLeft' in response:
        self.reset_remaining_possibilities()
        return None
    elif 'response' not in response:
        return response

    self.remaining_possibilities=[possibility for possibility in self.remaining_possibilities if game.Game_evaluate(guess, list(possibility)) == response['response']]
    return None

Now the problem happens when very large permutations is generated and then converted into a list to check if the length is over 10**6 then do something else and come back. This is my current solution but issue is when it gets very huge script gets killed. I converted this piece of code from ruby and in ruby one can get the size of enumerator without converting to list as well and this issue never happens there.

Here is the code in ruby:

def solve_current_level
  reduce_weapon_options if @remaining_possibilities.size > 10 ** 6
  if !@remaining_possibilities.kind_of?(Array)
    @remaining_possibilities = @remaining_possibilities.to_a
  end

  guess = @remaining_possibilities.sample
  response = @client.solve_level(@current_level.levelNum, guess)

  if response['roundsLeft']
    reset_remaining_possibilities
    return Nil
  elsif !response['response']
    return response
  end

  @remaining_possibilities.select! do |possibility|
    Game.evaluate(guess, possibility) == response['response']
  end
  return Nil
end

Now you see in ruby code the length of permutations is calculated before it is converted to array/hash to continue processing and if the number is bigger than 10**6 then it calls another method "reduce_weapon_options". While in python there is not way to get the length of generator without converting to list before everything, I need it to work that way as at this moment when i get some bigger range with big size, it stucks and gets killed by my server. I cannot extend ram as I need to use less ram exactly like ruby and i absolutely want to avoid

self.remaining_possibilities = list(self.remaining_possibilities)

this in python before if condition is passed/failed.

NOTE: I am using itertools.permutations to calculate permutations that later gets saved in "self.remaining_possibilities"

Here is that code both in python and ruby:

return (0...@numWeapons).to_a.permutation(@numGladiators)
(THIS RETURNS AN ENUMERATOR OBJECT)

return it.permutations(range(0, self.numWeapons), self.numGladiators)
(THIS RETURNS A GENERATOR OBJECT)

Answer 1

The simplest way to solve this is probably to calculate the number of permutations generated, using the permutations formula, which can be defined as:

from math import factorial
def nPr(n, r):
    return int(factorial(n)/factorial(n-r))

This, however, requires that this data is available or that the length is passed along from the place where the original permutations generator was created. If this is not the case, for some reason, it is possible to use itertools.tee() to generate a second generator from the first, and use it only for counting:

def solve_current_level(self):
    self.remaining_possibilities, perm_count = itertools.tee(self.remaining_possibilities)
    # exhausting the 'teed' generator, leaving the 'original' intact:
    num_perm = sum(1 for _ in perm_count)
    if num_perm > 10 ** 6:
        #self.reduce_weapon_options()
        pass
    # here we can still use self.remaining_possibilities
    .
    .
    .

Since you are already using itertools this is not a too heavy solution, I guess, but it still requires you to go through the whole list. The memory footprint is considerably smaller, though.