ArrayReshape in an almost rectangular way

Question

I want to make a list of many (say 1000) test instances for a geometry problem. The problem involves two line segments and a point. So I need

{
    (* first line *)     (*second line*)   (*point*)
  { {{x0,y0},{x1,y1}} , {{x2,y2},{x3,y3}} , {x4,y4} },
  ... (*1000 times*)
}

Now this is quite easy to achieve with

{#[[{1, 2}]], #[[{3, 4}]], #[[5]]} & /@ 
  RandomReal[{-100, 100}, {100, 5, 2}]

The Dimensions of that desired array are {1000,3,2}, which ignores the fact that the lines have extra depth while the point does not.

Is there a way to make this reshaping happen with ArrayReshape, or is it for strictly rectangular reshaping? Is there a clever way to use other functions like Thread, Transpose etc with their powerful options to do this?

I'll do some benchmarking for curiosity's sake.

---

I recently asked a similar question Thread Matrices, like image channels. With my wording, the most direct answer (restricted to Thread), isn't the best -- it's good to see plenty of votes for all the answers.

Answer 1

I might do something like this:

With[
  {n = 1000},
  Transpose[{RandomReal[{-100, 100}, {n, 2, 2}], 
    RandomReal[{-100, 100}, {n, 2, 2}], 
    RandomReal[{-100, 100}, {n, 2}]}]]

I don't think there's much savings in overhead by requiring that RandomReal only be called once.

Another approach that overgenerates the original data (but avoids a row-by-row re-partitioning):

MapAt[First, RandomReal[{-100, 100}, {1000, 3, 2, 2}], {All, 3}]

Answer 2

Alright I don't know how to make nice looking plots yet

but kglr's approach

Transpose[{#[[All, {1, 2}]], #[[All, {3, 4}]], #[[All, 5]]}] &@list

and lecicr's first approach that calls RandomReal three times are both fastest, presumably by a constant factor by the looks of it.

---

The big takeaway for me is that calling RandomReal three times instead of once is a tiny performance hit. The following code could be fleshed out into a super informative test, but here it is for now

dat = Table[With[{sampleparts = Differences@Round[Range[0, m] n/m]},
SeedRandom@102;
First@AbsoluteTiming[RandomReal[{-100, 100}, #] & /@ sampleparts]
], {n, 1, 500}, {m, 1, n}];

It divides n into m approximately equal sized chunks (e.g. 47=4+3+4+3+4+4+3+4+4+3+4+3+4) and then calls RandomReal to generate the total amount of numbers in all the different sizes of chunks (all in 1 chunk, 2 chunks, 3 chunks... up to n chunks of size 1). Then the code

ListPlot3D[PadRight[#, 500] & /@ dat, 
AxesLabel -> {"m roughly uniform chunks", "n total random numbers", 
"total time"}]

yields

You can see that around m=100 chunks there's a huge jump. Seeing this sort of plot for large numbers on a logloglog scale would be cool.