Method for splitting array into (element => remaining elements) pairs

Question

Given an array literal, I would like to create a hash where the keys are the elements from the array and the values are arrays containing the other / remaining elements.

Input:

[1, 2, 3]

Output:

{1=>[2, 3], 2=>[1, 3], 3=>[1, 2]}

It's easy if I introduce a variable:

arr = [1, 2, 3]
arr.map { |i| [i, arr - [i]] }.to_h

But with an array literal, the only solution I could come up with involves instance_exec or instance_eval, which seems hackish:

[1, 2, 3].instance_exec { map { |i| [i, self - [i]] } }.to_h

Am I overlooking a built-in method or an obvious solution? group_by, combination, permutation and partition don't seem to help.

unrelated, but since you don't pass any argument to block, why not `instance_eval`? — Andrey Deineko, May 08 '15 at 10:38
@Stefan between `instance_eval` and `instance_exec` - yes :) — Andrey Deineko, May 08 '15 at 10:44
@AndreyDeineko please enlighten me, it looks like I could use either one. — Stefan, May 08 '15 at 10:46
Indeed you could use either here. What I meant is I was used to seeing `instance_eval` when there is no need to pass args to the block, and `instance_exec` when there is. — Andrey Deineko, May 08 '15 at 10:48
It would for `[1, 2, 3].tap { |a| a.map { |i| [i, a - [i]] }.to_h }` — Aleksei Matiushkin, May 08 '15 at 11:54
Might the array contain dups? If so, and if you could use a variable, `arr=[1,1,2]; arr.map { |i| [i, arr - [i]] }.to_h #=> {1=>[2], 2=>[1, 1]}` is probably not what you want. You need something like what I've done in `#2` in my answer. — Cary Swoveland, Aug 08 '15 at 18:48
@CarySwoveland my array didn't contain duplicates, but a general solution should be able to handle that case, I think. — Stefan, Aug 08 '15 at 18:51
@mudasobwa, `tap`'s not permitted in golf? Even when putting? It's just a garden-variety method, so I say it's there for the taking, and it certainly can be used to advantage here. — Cary Swoveland, Aug 08 '15 at 19:50

score 6 · Accepted Answer · answered May 08 '15 at 10:51

6

I've come up with something like this:

[1,2,3].permutation.to_a.map{ |e| [e.shift, e] }.to_h

However this has a flaw: it assigns the same key many times, but since you don't care about the sequence of the elements inside this might be a "good enough" solution.

answered May 08 '15 at 10:51

Piotr Kruczek

2,384
11
18

1

That's a funny solution. – undur_gongor May 08 '15 at 10:57
Indeed, that's quite a creative approach :-) – Stefan May 08 '15 at 10:59
2

You can omit `to_a` and split the array with *: `[1,2,3].permutation.map { |k, *vs| [k, vs] }.to_h` – Stefan May 08 '15 at 11:19

score 2 · Answer 2 · edited May 23 '17 at 12:29

2

I got another idea. Here is this :

a = [1, 2, 3]
a.combination(2).with_object({}) { |ar, h| h[(a - ar).first] = ar }
# => {3=>[1, 2], 2=>[1, 3], 1=>[2, 3]}

A modified version of Piotr Kruczek .

[1,2,3].permutation.with_object({}) { |(k, *v), h| h[k] = v }
# => {1=>[3, 2], 2=>[3, 1], 3=>[2, 1]}

edited May 23 '17 at 12:29

Community

1
1

answered May 08 '15 at 11:32

Arup Rakshit

116,827
30
260
317

2

Combination is what I thought of at first, but the problem here is as a parameter you have to pass `a.length-1` and the whole point was not to assign the array to a variable :/ – Piotr Kruczek May 08 '15 at 11:35
@PiotrKruczek Ok.. I didn't read the full question.. So, If I assign it to a variable _life is easy_.. :) – Arup Rakshit May 08 '15 at 11:40

score 1 · Answer 3 · answered May 08 '15 at 11:06

1

I'd go with Piotr's solution, but for the fun of it, I have a different approach:

[1,2,3].inject([[],{}]) do |h_a, i|
  h_a[0] << i
  h_a[1].default_proc = ->(h,k){ h_a[0] - [k]}
  h_a
end.last

It's much more of a hack and less elegant, though.

answered May 08 '15 at 11:06

tessi

13,313
3
38
50

Although the default proc returns the correct values, I can't enumerate the `keys` or iterate the hash using `each`. – Stefan May 08 '15 at 11:33

score 1 · Answer 4 · edited May 23 '17 at 11:44

Here are three ways to use Object#tap. Is there an argument that prohibits its use?

All three methods work if the array contains dups; for example:

[1,2,2]....
   #=> {1=>[1, 2], 2=>[1, 1]}

#1

[1,2,2].tap do |a|
   a.replace(a.cycle.each_cons(a.size).first(a.size).map { |k,*v| [k,v] })
end.to_h
  #=> {1=>[2, 3], 2=>[3, 1], 3=>[1, 2]}

#2

[1,2,3].tap do |a|
  @h = a.map do |i|
    b = a.dup
    j = b.index(i)
    b.delete_at(j)
    [i,b]
  end.to_h
end
@h #=> {1=>[2, 3], 2=>[1, 3], 3=>[1, 2]}

#3

[1,2,3].map.with_index { |*e| e.reverse }.to_h.tap do |h|
  a = h.values
  h.replace(a.each_with_object({}) do |e,g|
    b = a.dup
    i = b.index(e)
    b.delete_at(i)
    g.update(e=>b)
  end)
end
 #=> {1=>[2, 3], 2=>[1, 3], 3=>[1, 2]}

Addendum

The code in the latter two methods can be simplified by using the much-needed method Array#difference, as defined it in my answer here. #3, for example, becomes:

[1,2,3].map.with_index { |*e| e.reverse }.to_h.tap do |h|
  a = h.values
  h.replace(a.each_with_object({}) { |e,g| g.update(e=>a.difference([e])) })
end
  #=> {1=>[2, 3], 2=>[1, 3], 3=>[1, 2]}

`tap` is definitely better than `instance_exec` / `instance_eval` ;) — Stefan, Aug 08 '15 at 18:54

score 1 · Answer 5 · answered Jan 13 '19 at 00:50

1

[1,2,3,4].each_with_object({}) do |n,h|
  h.each_key { |k| h[k] << n }
  h[n] = h.keys
end
  #=> {1=>[2, 3, 4], 2=>[1, 3, 4], 3=>[1, 2, 4], 4=>[1, 2, 3]}

answered Jan 13 '19 at 00:50

Cary Swoveland

106,649
6
63
100

Method for splitting array into (element => remaining elements) pairs

5 Answers5

Linked