我如何在红宝石中按不等排序？

Question

我看到这篇文章使用了排序比较器，但是我如何按不等排序

ruby's <=> operator and sort method

我有一条短信

猫 猫 猫 猫 猫 狗 狗 狗 狗 狗 堆 堆 堆 堆 堆 星星 星星 星星 星星 星星 列表 列表 列表 列表 列表

使用逻辑，当 b1 等于 a b2 时，将 b2 放在最后，但当 b1 不等于 b2 时，将 b2 放在 b1 旁边

获取

猫 狗 堆 星星 列表 猫 狗 堆 星星 列表 猫 狗 堆 星星 列表 猫 狗 堆 星星 列表 猫 狗 堆 星星 列表

请帮我解决这个问题

Answer 1

如果您的数组中的元素分布均匀（不一定已排序）。

arr = ['a','a','a','b','b','b','c','c','c']
arr.uniq * arr.uniq.size #=> ["a", "b", "c", "a", "b", "c", "a", "b", "c"]

---

^{警告：如果未排序，则在uniq 期间遇到的第一个唯一元素确定最终的数组排序。}

除了 cmets，还有一个更强大的解决方案：

arr = ['a','a','a','b','b','b','c','c','c','d','d','d']
enum = arr.uniq.cycle
enum.take(arr.size)
#=> ["a", "b", "c", "d", "a", "b", "c", "d", "a", "b", "c", "d"]

Answer 2

我没有看到使用 <=> 比较的解决方案。

但这里有一种方法：

使用Enumerable#chunk，您可以将相同的值组合在一起（如果数组已排序；否则您可以使用group_by）。

然后，您选择根据其值拆分的组，然后转置该数组并将这些值重新连接在一起。

长话短说，

 array.chunk{ |a| a }.map{ |k, v| v }.transpose.flatten

将为您示例中的数据做正确的事情。

请注意，为了使transpose 工作，组必须包含相同数量的元素。

编辑：

这是由工程师在 cmets 中建议的一个更好的版本，即使组的大小不同，它也能正常工作：

array.chunk(&:itself).map(&:last).inject { |memo, e| memo.zip(e) }.flatten

Answer 3

你可以这样做：

arr.group_by {|w| w}.values.transpose.flatten

仅当所有组的单词数相同时才有效。如果您的组的字数不同，则不清楚您在寻找什么。

如果您希望组由最短长度组定义，您可以这样做：

na=arr.group_by {|w| w}.values
len=na.map {|l| l.length}.min
na.map {|l| l[0...len] }.transpose.flatten

如果您想使用sort 算法，您可能希望按照装饰、排序、取消装饰（AKA DSU 或Schwartzian transform）的方式执行一些操作，如下所示：

> arr=['cat']*4+['dog']*3+['list']*2+["star"]
> arr.group_by {|w| w}                     # all same words together
      .values                              # only the sepate lists of words
      .map {|l| l.each_with_index          # enumerate those so that we have [0, word]..[n, word]
      .map {|e,i| [i,e]}}.flatten(1)       # remove one level of nesting
      .sort                                # sort first on the number then on the word
      .map {|l| l[1]}                      # remove the number
["cat", "dog", "list", "star", "cat", "dog", "list", "cat", "dog", "cat"]

这将允许不同长度的词组与较长的组结束朝向数组的前面。

Answer 4

满足实际要求的逻辑：

使用逻辑，当 b1 等于 a b2 时，将 b2 放在最后，但当 b1 不等于 b2 时，将 b2 放在 b1 旁边

你可以使用老式的递归

def process(arr)
  arr.each_with_index.each_cons(2) do |a,b| 
    if a.first == b.first then 
      arr << arr.delete_at(b.last)
      process(arr)
    end
  end
  arr
end

此方法与描述的完全一样。如果a == b 则b 被移动到列表的末尾并重新处理整个列表直到没有a == b 的事件

另一种解决方案，它将输出列表长度基于列表中出现最少的元素并且不需要排序，只要唯一元素在列表中的位置是可接受的排序

def repeat_unordered_list(arr)
  arr.group_by(&:itself).to_a.tap do |a|
    min_elements = a.min_by{|_,v| v.size}.last.size
    a.replace(a.map(&:first) * min_elements)
  end
end 

Example(s)