Question

想象一下，我有5本不同的书籍books = ['a','b','c','d','e']，我想让它在3个孩子kids = [k1,k2,k3]之间分享。我使用zip和循环函数来执行此操作，比如说

books.zip(kids.cycle)

以便输出

{"a"=>"k1", "b"=>"k2", "c"=>"k3", "d"=>"k1", "e"=>"k2"}

第二天，我还有另外4本书，books = ['f','g','h','i']，这次我想在第二天同样的3个孩子中分发这些书，即。所有3个孩子在第二天结束时应该分别有3本书。

如何实现这个目标？

Answer 1

假设您将输出存储在变量中，您可以执行kids.rotate!，直到kids数组从下一个应该接收书籍的孩子开始。

之后，您可以再次执行相同的zip操作。

books = ['f','g','h','i']
books.zip(kids.cycle)

http://ruby-doc.org/core-2.2.0/Array.html#method-i-rotate

Answer 2

如果books = ['a','b','c','d','e']和kids = [k1,k2,k3]然后books2 = ['f','g','h','i']

您可以执行以下操作

(books + books2).zip(kids.cycle)

结果将如下：

=> [["a", "marc"], ["b", "frank"], ["c", "melisa"], ["d", "marc"], ["e", "frank"], ["f", "melisa"], ["g", "marc"], ["h", "frank"], ["i", "melisa"]]

Answer 3

首先，您需要考虑将用于存储输入和输出数据的结构以及一些中间数据（如果需要）。

使用哈希和数组，您可以实现任意复杂的结构。但是，将来使用OOP范例将数据封装在类中通常是有利可图的。

使用哈希和数组，它可能如下所示：

#init data with your input
kids = ['Alice', 'Bob', 'Kate']
books_over_days = [
  [ 'book1', 'book2', 'book3'],
  [ 'book4', 'book5']
]

#init data for storing your output
kids_to_books = {}
kids.each {|kid| kids_to_books[kid] = []}

books_over_days.each do |books|
  kids.each {|kid| kids_to_books[kid] << books.sample}    
end 

puts kids_to_books.inspect

您可以使用一些封装和类来以不同方式编写它+某些书籍生成器，以便动态生成数据而不是静态地声明数据。它可能看起来像这样

class Kid
  attr_reader :books, :name
  def initialize(name)
    @name = name
    @books = []
  end

  def add_book(book)
    @books << book
  end
end

Book = Struct.new(:name)

class BooksGenerator
  attr_reader :books
 def initialize(factor)
    @books = []
    @factor = factor
  end

  def generate
    0.upto(Random.rand(@factor)) {|e| @books << "book#{Random.rand(@factor*@factor)}"}
    @books.uniq!
  end
end

days_n = 3

generator = BooksGenerator.new(5)
kids = [Kid.new("Alice"), Kid.new("Bob"), Kid.new("Kate")]
days_n.times do
  generator.generate
  kids.each { |k| k.add_book(generator.books.sample)}
end

puts kids.inspect

如果没有更多细节，很难再说些什么。

Ruby程序可以平等地在孩子之间分发书籍

3 个答案: