Veuillez traduire cette méthode Python en Ruby

Question

Quelle serait la traduction correcte de la méthode Python suivante en Ruby ?

def uniqueCombinations(self, items, n):
    """ 
    items: liste d'éléments
    n: nombre dans un groupe
    """
    if n == 0:
        yield []
    else:
        for i in range(len(items)-n+1):
            for cc in uniqueCombinations(items[i+1:],n-1):
                yield [items[i]]+cc

Ce que je veux faire, c'est appeler

uniqueCombinations(['01', '02', '03'], 2)

et obtenir

[['01', '02'], ['01', '03'], ['02', '03']]

Voici ce que j'ai jusqu'à présent.

def uniq_c(items, n)
  if n == 0
    yield []
  else
    puts items.inspect
    range_max = items.length-n+1
    for i in (0...range_max)
      u = uniq_c(items[(i+1)..-1], n-1) { |x| x }
      u.each do |cc|
        yield [items[i]] + cc
      end
    end
  end
end

mais j'obtiens ceci :

in `+': can't convert Fixnum into Array (TypeError)

Answer 1

rendement [articles[i]] + cc

Vous essayez de concaténer un tableau ([articles[i]]) et un nombre entier (cc). Vous pourriez plutôt tous les deux les convertir en tableau ou utiliser la méthode << pour ajouter cc à [articles[i]].

rendement [articles[i]] << cc

Answer 2

À partir de Ruby 1.8.7, la classe Array propose une méthode pour retourner des combinaisons :

irb> ['01', '02', '03'].combination(2).to_a => [["01", "02"], ["01", "03"], ["02", "03"]]

Answer 3

Tout d'abord, il serait préférable de le faire en tant que méthode de la classe Array.

Deuxièmement, vous pouvez corriger votre erreur en changeant [items[i]] + cc en [items[i]] + [cc].

Troisièmement, voici une implémentation différente que j'avais sous la main, voyez ce que vous en pensez. Elle crée un tableau de permutations représentées par des indices, puis attribue à chaque indice sa valeur.

class Array
  def combinations(n)
    perms = []
    a = (0...n).to_a
    while perms.push a.dup
      break if a.increment!(a.length - 1, self.length-1).nil?
    end
    perms.map {|p| p.map {|i| self[i]} }
  end
  def increment!(i, max)
    self[i] += 1
    while self[i] > max
      return nil if i <= 0
      return nil if self.increment!(i - 1, max).nil?
      self[i] = self[i - 1] + 1
    end
    self.dup
  end
end

[1,2,3].combinations 3 # => [[1, 2, 3]]
[1,2,3].combinations 2 # => [[1, 2], [1, 3], [2, 3]]
[1,2,3].combinations 1 # => [[1], [2], [3]]
[:foo,:bar,:baz,:quux,:wibble].combinations 3
# => [[:foo, :bar, :baz],
#     [:foo, :bar, :quux],
#     [:foo, :bar, :wibble],
#     [:foo, :baz, :quux],
#     [:foo, :baz, :wibble],
#     [:foo, :quux, :wibble],
#     [:bar, :baz, :quux],
#     [:bar, :baz, :wibble],
#     [:bar, :quux, :wibble],
#     [:baz, :quux, :wibble]]