A Faster way to combine two Lists of different structures into one of a different structure [duplicate]

Question

I have the following two lists (each containing over 500,000 elements). Here is a sample:

lis1 = { {1.86582, 1.70162, 1.25256}, {1.82707, 1.29901, 1.10659}, 
  {1.76547, 1.21544, 1.09433}, {1.18306, 1.28322, 1.75524}, 
  {1.12555, 1.98011, 1.53359}, {1.10584, 1.12299, 1.88411}, 
  {1.83799, 1.5275, 1.76179}, {1.42352, 1.45163, 1.45318}, 
  {1.63669, 1.78145, 1.60307}, {1.61749, 1.44287, 1.57405} 
};

and

lis2 = {0.826095, 0.73286, 0.918137, 0.937434, 0.506525, 
        0.562795, 0.664915, 0.789321, 0.6559, 0.398447}

They both have equal Lengths. I want to combine both Lists to obtain a new list that looks like this

{ {1.86582, 1.70162, 1.25256, 0.826095}, 
{1.82707, 1.29901, 1.10659, 0.73286}, 
{1.76547, 1.21544, 1.09433, 0.918137}, 
{1.18306, 1.28322, 1.75524, 0.937434}, 
{1.12555, 1.98011, 1.53359, 0.506525}, 
{1.10584,1.12299, 1.88411, 0.562795}, 
{1.83799, 1.5275, 1.76179, 0.664915}, 
{1.42352, 1.45163, 1.45318, 0.789321}, 
{1.63669, 1.78145,1.60307, 0.6559}, 
{1.61749, 1.44287, 1.57405, 0.398447} }

That is, each element of the combined list contains the corresponding elements of lis1 and lis2, with the first three elements being from lis1 and the fourth element from lis2. Here is what I did to combine them in this fashion:

Transpose[{lis1, lis2}] //. {{a_, b_, c_}, d_} :> {a, b, c, d}

Is there a faster way to achieve this as my lists are huge ?

Answer 1

There is also Transpose :

Transpose @ Append[ Transpose[lis1], lis2] 

Transpose is a really fast approach, and you need to append only one list lis2. So this probably can be faster than Rojo's approach and :

Transpose @ Append[ Transpose[lis1], lis2] == Join[lis1, List /@ lis2, 2]

 True

Edit

Leonid Shifrin provided in the comments another neat approach :

Join[ large1, Transpose[{large2}], 2]

which appears to be even faster on one-core machines and sometimes on multi-core ones. Following his idea we can use this testing function :

test := ( large1 = RandomReal[{0, 2.}, {10^6, 3}];
          large2 = RandomReal[{0, 2.}, 10^6];
         { Do[ Join[ large1, List /@ large2, 2], {100}]// AbsoluteTiming //First,
           Do[ Transpose @ Append[ Transpose[large1], large2],
                {100} ] // AbsoluteTiming // First, 
           Do[ Join[ large1, Transpose[{large2}], 2], {100}]// AbsoluteTiming// First})

Here are some benchmarks :

0n Win 7 64 bit AMD Phenom II x6 2.8 GHz, V9_0 :

 test

{10.413086, 8.477539, 5.245117}

while RunnyKine on his machine :

Win 8 64bit Intel Core i7-2600 3.4GHz 16GB RAM, V9.0, got

test

{6.006038, 1.794012, 1.825212}

Mr.Wizard on v7.0, Win7-64, i5-2500K 8GB RAM:

test

{6.2400087, 2.5000035, 2.2700032}

on one-core old Pentium(R) 3.0 GHz 1GB RAM, V9.0

 test

{16.812500, 14.328125, 9.203125}

All the above benchmarks seem to suggest that Transpose remarkably accelerates on multi-core machines and then Transpose @ Append[ Transpose[lis1], lis2] might be faster than Leonid's solution.