Ruby 将阵列拆分为新阵列（每个阵列具有唯一的名称）

我试图将数组切分为大小相等的四舍五入数组，并将每个部分保存到相应的变量中

每个_切片用于抓取n个大小的块的方法。但是，我想不出一个方法：

迭代每个块的子索引 为每个数组创建一个新数组，并为每个数组指定一个唯一的名称

letters = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n"]

   def groups_of_five(array)
   split_array = array.each_slice(5).to_a

   #something like the following:
   #array(n) = Array[split_array.each {|x| x}]

   end 
end

我希望的产出是：

groups_of_five(letters)
=> array1: ["a,"b","c","d","e"]
=> array2: ["f","g","h","i","j"]
=> array3: ["k","l","m","n"]

将每个_切片与索引相结合，您将拥有所需的一切：

letters.each_slice(5).with_index(1) do |group, index| 
  puts "array#{index}: #{group.inspect}"
end

输出为：

array1: ["a", "b", "c", "d", "e"]
array2: ["f", "g", "h", "i", "j"]
array3: ["k", "l", "m", "n"]

在大于1.8的Ruby版本中，不再可能动态地设置局部变量，因此，如果您想分配给变量，它必须是实例变量，或者您可以输出哈希

以下内容将创建实例变量：

def groups_of_five(array)
  array.each_slice(5).with_index(1) do |group, index| 
    instance_variable_set "@array#{index}".to_sym, group
  end
end

groups_of_five(letters)
puts @array1 #=> ["a", "b", "c", "d", "e"]
puts @array2 #=> ["f", "g", "h", "i", "j"]
puts @array3 #=> ["k", "l", "m", "n"]

或者这将输出一个散列：

def groups_of_five(array)
  hash = {}
  array.each_slice(5).with_index(1) do |group, index| 
    hash["array#{index}".to_sym] = group
  end
  hash
end

hash = groups_of_five(letters)
puts hash[:array1] #=> ["a", "b", "c", "d", "e"]
puts hash[:array2] #=> ["f", "g", "h", "i", "j"]
puts hash[:array3] #=> ["k", "l", "m", "n"]

将每个_切片与索引相结合，您将拥有所需的一切：

letters.each_slice(5).with_index(1) do |group, index| 
  puts "array#{index}: #{group.inspect}"
end

输出为：

array1: ["a", "b", "c", "d", "e"]
array2: ["f", "g", "h", "i", "j"]
array3: ["k", "l", "m", "n"]

在大于1.8的Ruby版本中，不再可能动态地设置局部变量，因此，如果您想分配给变量，它必须是实例变量，或者您可以输出哈希

以下内容将创建实例变量：

def groups_of_five(array)
  array.each_slice(5).with_index(1) do |group, index| 
    instance_variable_set "@array#{index}".to_sym, group
  end
end

groups_of_five(letters)
puts @array1 #=> ["a", "b", "c", "d", "e"]
puts @array2 #=> ["f", "g", "h", "i", "j"]
puts @array3 #=> ["k", "l", "m", "n"]

或者这将输出一个散列：

def groups_of_five(array)
  hash = {}
  array.each_slice(5).with_index(1) do |group, index| 
    hash["array#{index}".to_sym] = group
  end
  hash
end

hash = groups_of_five(letters)
puts hash[:array1] #=> ["a", "b", "c", "d", "e"]
puts hash[:array2] #=> ["f", "g", "h", "i", "j"]
puts hash[:array3] #=> ["k", "l", "m", "n"]

---

如果您正在寻找一个散列结构来从组\u或组\u中返回，下面是解决方案

def groups_of_five(array)
   split_array = letters.each_slice(5).to_a
   split_array.reduce({}){ |i,a|
       index = split_array.index(a) + 1
       i["array#{index}"] = a; i
   }
end

# groups_of_five(letters)
#=> {"array1"=>["a", "b", "c", "d", "e"], "array2"=>["f", "g", "h", "i", "j"], "array3"=>["k", "l", "m", "n"]}

---

如果您正在寻找一个散列结构来从组\u或组\u中返回，下面是解决方案

def groups_of_five(array)
   split_array = letters.each_slice(5).to_a
   split_array.reduce({}){ |i,a|
       index = split_array.index(a) + 1
       i["array#{index}"] = a; i
   }
end

# groups_of_five(letters)
#=> {"array1"=>["a", "b", "c", "d", "e"], "array2"=>["f", "g", "h", "i", "j"], "array3"=>["k", "l", "m", "n"]}

您可以这样做：

def group_em(a,n)
  arr = a.dup
  (1..(arr.size.to_f/n).ceil).each_with_object({}) { |i,h|
    h["array#{i}"] = arr.shift(n) }
end

group_em(letters,1)
  #=> {"array1"=>["a"], "array2"=>["b"],...,"array14"=>["n"]} 
group_em(letters,2)
  #=> {"array1"=>["a", "b"], "array2"=>["c", "d"],...,"array7"=>["m", "n"]} 
group_em(letters,5)
  #=> {"array1"=>["a", "b", "c", "d", "e"],
  #    "array2"=>["f", "g", "h", "i", "j"],
  #    "array3"=>["k", "l", "m", "n"]} 

一种变体是：

def group_em(arr,n)
  (1..(arr.size.to_f/n).ceil).zip(arr.each_slice(n).to_a)
    .each_with_object({}) { |(i,a),h| h["array#{i}"]=>a) }
end

您可以这样做：

def group_em(a,n)
  arr = a.dup
  (1..(arr.size.to_f/n).ceil).each_with_object({}) { |i,h|
    h["array#{i}"] = arr.shift(n) }
end

group_em(letters,1)
  #=> {"array1"=>["a"], "array2"=>["b"],...,"array14"=>["n"]} 
group_em(letters,2)
  #=> {"array1"=>["a", "b"], "array2"=>["c", "d"],...,"array7"=>["m", "n"]} 
group_em(letters,5)
  #=> {"array1"=>["a", "b", "c", "d", "e"],
  #    "array2"=>["f", "g", "h", "i", "j"],
  #    "array3"=>["k", "l", "m", "n"]} 

一种变体是：

def group_em(arr,n)
  (1..(arr.size.to_f/n).ceil).zip(arr.each_slice(n).to_a)
    .each_with_object({}) { |(i,a),h| h["array#{i}"]=>a) }
end

---

你想从五个字母组中得到一个散列结构，比如{array1:[a，b，c，d，e]，array2:[f，g，h，i，j]}对吗？你想从五个字母组中得到一个散列结构，比如{array1:[a，b，c，d，e]，array2:[f，g，h，i，j]}对吗？太棒了，谢谢。现在来了解发生了什么！我喜欢使用组和索引。早些时候我称之为小组，但似乎是一个更明确的惯例。我想我不清楚这是如何创建新阵列的。我看到它是新的线条。但是这些是真实的数组吗？更新了几个新的例子。我个人会选择最后一个散列输出选项。您可以使用_index1进行写入，使索引从1开始。这不是每个索引的选项。谢谢@CarySwoveland，我不知道有这个。我会更新我的答案。谢谢@CarySwoveland。我仍然有点好奇这是如何创建新阵列的。声明中有我没有看到的诡计吗？谢谢你帮助一个初学者。太棒了，谢谢你。现在来了解发生了什么！我喜欢使用组和索引。早些时候我称之为小组，但似乎是一个更明确的惯例。我想我不清楚这是如何创建新阵列的。我看到它是新的线条。但是这些是真实的数组吗？更新了几个新的例子。我个人会选择最后一个散列输出选项。您可以使用_index1进行写入，使索引从1开始。这不是每个索引的选项。谢谢@CarySwoveland，我不知道有这个。我会更新我的答案。谢谢@CarySwoveland。我仍然有点好奇这是如何创建新阵列的。声明中有我没有看到的诡计吗？谢谢你帮助一个初学者。