Arrays 如何使用Ruby根据另一个数组对一个数组进行排序
有两个阵列:Arrays 如何使用Ruby根据另一个数组对一个数组进行排序,arrays,ruby,sorting,Arrays,Ruby,Sorting,有两个阵列: A = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] B = [3, 4, 1, 5, 2, 6] 我想对B进行排序,以便对a中存在的B的所有元素按照数组a中的顺序进行排序 所需的排序结果将是 B #=> [1, 2, 3, 4, 5, 6] 我已经试过了 B = B.sort_by { |x| A.index } 但它不起作用 这个问题与可能的重复问题不同,因为它涉及对应数组中是否存在元素,并且此处不存在散列。我将首先检查A中存在B中的哪些元素:
A = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
B = [3, 4, 1, 5, 2, 6]
我想对B
进行排序,以便对a
中存在的B
的所有元素按照数组a
中的顺序进行排序
所需的排序结果将是
B #=> [1, 2, 3, 4, 5, 6]
我已经试过了
B = B.sort_by { |x| A.index }
但它不起作用
这个问题与可能的重复问题不同,因为它涉及对应数组中是否存在元素,并且此处不存在散列。我将首先检查A中存在B中的哪些元素:
B & A
然后对其进行排序:
(B & A).sort_by { |e| A.index(e) }
我将首先检查A中存在B中的哪些元素:
B & A
然后对其进行排序:
(B & A).sort_by { |e| A.index(e) }
它非常有效:
▶ A = [1,3,2,6,4,5,7,8,9,10]
▶ B = [3,4,1,5,2,6]
▶ B.sort_by &A.method(:index)
#⇒ [1, 3, 2, 6, 4, 5]
如果B
中可能存在A
中不存在的元素,请使用以下方法:
▶ B.sort_by { |e| A.index(e) || Float::INFINITY }
它非常有效:
▶ A = [1,3,2,6,4,5,7,8,9,10]
▶ B = [3,4,1,5,2,6]
▶ B.sort_by &A.method(:index)
#⇒ [1, 3, 2, 6, 4, 5]
如果B
中可能存在A
中不存在的元素,请使用以下方法:
▶ B.sort_by { |e| A.index(e) || Float::INFINITY }
首先考虑“<代码> b>代码>的每一个元素都在<代码> A<代码>中,与问题的例子一样:
A = [1,2,3,4,5,6,7,8,9,10]
B = [3,6,1,5,1,2,1,6]
可以编写以下代码,它只需要一次通过a
(构造g
1)和一次通过B
g = A.each_with_object({}) { |n,h| h[n] = 1 }
#=> {1=>1, 2=>1, 3=>1, 4=>1, 5=>1, 6=>1, 7=>1, 8=>1, 9=>1, 10=>1}
B.each_with_object(g) { |n,h| h[n] += 1 }.flat_map { |k,v| [k]*(v-1) }
#=> [1, 1, 1, 2, 3, 5, 6, 6]
如果不能保证B
的所有元素都在A
中,并且任何不在排序数组末尾的元素,可以稍微更改g
的计算
g = (A + (B-A)).each_with_object({}) { |n,h| h[n] = 1 }
这需要再次通过A和B
比如说,
A = [2,3,4,6,7,8,9]
而B
保持不变。那么
g = (A + (B-A)).each_with_object({}) { |n,h| h[n] = 1 }
#=> {2=>1, 3=>1, 4=>1, 6=>1, 7=>1, 8=>1, 9=>1, 1=>1, 5=>1}
B.each_with_object(g) { |n,h| h[n] += 1 }.flat_map { |k,v| [k]*(v-1) }
#=> [2, 3, 6, 6, 1, 1, 1, 5]
这个解决方案演示了Ruby v1.9中对哈希属性进行的有争议的更改的价值:哈希将保证保持密钥插入顺序
< P> 1,我希望可以写<代码> G.A.Apple([1)] totoh < /C>,但是DOC不能保证返回的散列中的密钥与在<代码> A/<代码>中的顺序相同。 < P>首先考虑“<代码> B <代码>的每一个元素都在<代码> A<代码>中,如问题的例子:
A = [1,2,3,4,5,6,7,8,9,10]
B = [3,6,1,5,1,2,1,6]
可以编写以下代码,它只需要一次通过a
(构造g
1)和一次通过B
g = A.each_with_object({}) { |n,h| h[n] = 1 }
#=> {1=>1, 2=>1, 3=>1, 4=>1, 5=>1, 6=>1, 7=>1, 8=>1, 9=>1, 10=>1}
B.each_with_object(g) { |n,h| h[n] += 1 }.flat_map { |k,v| [k]*(v-1) }
#=> [1, 1, 1, 2, 3, 5, 6, 6]
如果不能保证B
的所有元素都在A
中,并且任何不在排序数组末尾的元素,可以稍微更改g
的计算
g = (A + (B-A)).each_with_object({}) { |n,h| h[n] = 1 }
这需要再次通过A和B
比如说,
A = [2,3,4,6,7,8,9]
而B
保持不变。那么
g = (A + (B-A)).each_with_object({}) { |n,h| h[n] = 1 }
#=> {2=>1, 3=>1, 4=>1, 6=>1, 7=>1, 8=>1, 9=>1, 1=>1, 5=>1}
B.each_with_object(g) { |n,h| h[n] += 1 }.flat_map { |k,v| [k]*(v-1) }
#=> [2, 3, 6, 6, 1, 1, 1, 5]
这个解决方案演示了Ruby v1.9中对哈希属性进行的有争议的更改的价值:哈希将保证保持密钥插入顺序
1我希望人们可以把g=A.product([1])写到,但是doc不能保证返回的散列中的键的顺序与
A
中的键的顺序相同。看起来没有必要像我在回答中所做的那样进行检查:)答案很好。虽然B中的元素不在A中,但它失败。尝试从A
中删除元素3
,效果很好!谢谢你,直到你在A中没有来自B的元素。@radubogdan好捕获,更新。我不认为您在A
元素中删除不可抗拒元素的决定是可以的。看起来没有必要像我在回答中那样进行检查:)答案很好。虽然对于B中不在A中的元素,它失败了。尝试从A
中删除元素3
,效果很好!谢谢你,直到你在A中没有来自B的元素。@radubogdan好捕获,更新。我不认为您在A
元素中删除不可抗拒元素的决定是正确的。“存在于数组A中的B元素”-不存在于数组A中的元素如何?可能重复的元素?我已经就可能重复的@WandMaker“存在于数组A中的B元素”发表了我的评论–A中不存在的元素如何?可能的重复我已经对可能的重复@WandMakerIf发表了我的评论B
的每个元素都在A
中,这个解决方案肯定是最优雅的。@mudasobwa,我做了一些可能会让你感兴趣的更改。如果B
的每个元素都在A
中,这个解决方案绝对是最优雅的。@mudasobwa,我做了一些可能让你感兴趣的更改。