Convert a list of rules into 2 lists of integers

Question

If I have a list of n number of rules, what is a concise way of breaking the data into 2 lists of the first and second part of the rule?

This works, but seems like an unnecessary amount of code to me:

data = {
  1 -> 3, 1 -> 3, 1 -> 3, 2 -> 3, 2 -> 3, 2 -> 1, 
  3 -> 2, 3 -> 2, 3 -> 3, 4 -> 1, 4 -> 2, 4 -> 2
};

list1 = First[Partition[Flatten[data /. Rule -> List], 2, 2, 1, {}]~Flatten~{2}]

{1,1,1,2,2,2,3,3,3,4,4,4}

list2 = Last[Partition[Flatten[data /. Rule -> List], 2, 2, 1, {}]~Flatten~{2}]

{3,3,3,3,3,1,2,2,3,1,2,2}

Answer 1

This is the shortest I can think of:

{list1, list2} = Transpose[List @@@ data];

list1

{1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4}

list2

{3, 3, 3, 3, 3, 1, 2, 2, 3, 1, 2, 2}

Answer 2

data[[All, #]] & /@ {1, 2}

{{1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4}, {3, 3, 3, 3, 3, 1, 2, 2, 3, 1, 2, 2}}

Answer 3

data // Query[{Keys, Values}]

or Through@{Keys, Values}@data, or list1=Keys@data; list2=Values@data

Answer 4

user21 and Teake Nutma already posted the two methods I use most often. Of these I recommend Part as I believe it will be faster in general. Nevertheless these are hardly the only ways to accomplish this task. First, since the expression produced by List @@@ data will not be packed Thread may be faster than Transpose:

Thread[List @@@ data]

One could also thread over Rule, then replace the outer head with List:

List @@ Thread[data, Rule]

From Undocumented form for Extract we could also use:

Rest @ Extract[data, {{0}, {All, 1}, {All, 2}}]

---

Benchmarks

A BenchmarkPlot for all methods posted so far.

f1[a_] := a[[All, #]] & /@ {1, 2};
f2 = Transpose[# /. (a_ -> b_) :> {a, b}] &;
f3 = Transpose[List @@@ #] &;
f4 = Thread[List @@@ #] &;
f5 = List @@ Thread[#, Rule] &;
f6 = Rest@Extract[#, {{0}, {All, 1}, {All, 2}}] &;
f7 = Query[{Keys, Values}];
f8 = {Keys@#, Values@#} &

Needs["GeneralUtilities`"]
g[n_] := Rule @@@ RandomInteger[9, {n, 2}];

BenchmarkPlot[{f1, f2, f3, f4, f5, f6, f7, f8}, g, 2^Range[5, 20], "IncludeFits" -> True]

(click for larger)

• Once again Query has some crazy overhead and should be avoided when performance matters unless inputs are very large.

• Keys and Values are very fast when used apart from Query.

• List @@ Thread[data, Rule] is as fast as Keys and Values, and faster than Part and Extract which I did not expect.

• As expected Thread is slightly faster than Transpose with unpacked data. (f3 and f4)

Answer 5

{#1, #2} & @@@ data // Transpose

{{1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4}, {3, 3, 3, 3, 3, 1, 2, 2, 3, 1, 2, 2}}

Answer 6

You can also use HoldPattern:

data /.HoldPattern[a_ -> b_] :> {a, b} // Transpose
{{1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4}, {3, 3, 3, 3, 3, 1, 2, 2, 3, 1, 
  2, 2}}