A totally different approach

urne = Range[10];
s4 = Subsets[urne, {4}];
s3 = Subsets[urne, {3}];
s2 = Subsets[urne, {2}];

cand = Reap[
  Do[
   x = s4[[i]];
   Do[
    y = s3[[j]];
    If[Intersection[x, y] == {},
     Do[
      z = s2[[k]];
      If[Intersection[x, z] == {} && Intersection[y, z] == {},
       Sow[{x, y, z}]],
      {k, 1, Length[s2]}]
     ],
    {j, 1, Length[s3]}],
   {i, 1, Length[s4]}]
  ]

Now you haver to get rid of Null and fill in the missing element, e.g.

cand1 = Flatten[Drop[cand, 1], 2]
Complement[urne, Flatten[cand1[[5]]]]

highschool text problem: " In how many ways can 10 numbered balls be distributed in four numbered compartments so that the first compartment contains 4, the second 3, the third 2 and the fourth 1 balls each (4+3+2+1=10)? The sequence of balls within the compartments be irrelevant."

Well, the answer is simple, 210×20×3×1=12600. A valid 4-tuple would be, for example:

( {1, 6, 9, 10}, {2, 3, 8}, {5, 7}, {4} )

Today i tried to build the list with 12600 such entries, and it involved a lot of MapThread, Thread, so i revisted this thread to check how we did things. I managed to produce the list but my coding feels awkward because i always worked with 2 lists at a time. The question is, is there a more elegant way of producing the output, maybe by feeding all four lists (sub4, sub3, sub2, rest2) at the same time in a single MapThread[Thread[]] statement?

del[from_List, this_List] := DeleteCases[from, Alternatives @@ this] ;
nUrne = Range[10] ;
sub4 = Subsets[nUrne, {4}] ; (*210 elements e.g. {1,2,3,4}*)
rest4 = del[nUrne, #] & /@ sub4 ; (* 210 elements e.g. {5,6,7,8,9,10}*)
sub3 = Subsets[#, {3}] & /@ rest4 ;
rest3 = MapThread[Function[{u, v}, del[u, #] & /@ v], {rest4, sub3}] ;
sub2 = MapAt[Subsets[#, {2}] &, rest3, {All, All}] ;
rest2 = MapThread[Function[{u, v}, del[u, #] & /@ v], {rest3, sub2}, 2] ;
sub2rest2 = MapThread[List, {sub2, rest2}, 3] ;
sub3sub2rest2 = MapThread[Thread[{##}, List, -1] &, {sub3, sub2rest2}, 2] ;
rest6 = MapAt[Sequence @@ # &, sub3sub2rest2, {All, All, All, 2}] ;
rest6neu = Flatten[#, 1] & /@ rest6 ;
almost = Flatten[MapThread[Thread[{##}, List, -1] &, {sub4, rest6neu}], 1] ;
finally = MapAt[Sequence @@ # &, almost, {All, 2}]

Heavily shorted output:

{{{1, 2, 3, 4}, {5, 6, 7}, {8, 9}, {10}}, {{1, 2, 3, 4}, {5, 6, 7}, {8, 10}, {9}},
 {{1, 2, 3, 4}, {5, 6, 7}, {9, 10}, {8}}, <···12593···> ,
 {{7, 8, 9, 10}, {3, 5, 6}, {2, 4}, {1}}, {{7, 8, 9, 10}, {4, 5, 6}, {1, 2}, {3}},
 {{7, 8, 9, 10}, {4, 5, 6}, {1, 3}, {2}}, {{7, 8, 9, 10}, {4, 5, 6}, {2, 3}, {1}}}

Thanks for your attention. In any case, this problem was a good beginner's exercise in juggling with Map, MapAt, Thread, MapThread and their combinations.

This quite nice example demonstrating what is invariant after Thread operation and powerful idea of functional programming in Wolfram Language.

Thread[f[{a, b, c}]] => {f[a],f[b],f[c]}
Thread[f[{a, b, c}, {x, y, z}]] => {f[a,x],f[b,y],f[c,z]}
Thread[f[{1,2,3,4},{{0,9},{8,7},{6,5}}],List,-1] => {f[{1,2,3,4},{0,9}],f[{1,2,3,4},{8,7}],f[{1,2,3,4},{6,5}]}

Thread outputs a list with the same length of the expanded part (or parts if their lengths are equal) from input. In your example p1 is treated as list of 3 and the output is a list of 6 items, therefore we do need something like nested iteration in your code and one level of Thread is not enough. In your output I feel it is safe to break down to three steps.

1. Pick up the first element from each list and generate a parent list (length of 3)
2. Then Thread the last two elements (each becomes length of 2)
3. Remove the outmost level of list to make it a list of 6 items (flatten the first level, same as your code)

MapThread function comes handy in the first task. Here is an example:

In[2]:= MapThread[f,{p1,p2,p3}]
Out[2]= {f[{a1,A1},{{a2,a3},{a4,a5}},{{A2,A3},{A4,A5}}],f[{b1,B1},{{b2,b3},{b4,b5}},{{B2,B3},{B4,B5}}],f[{c1,C1},{{c2,c3},{c4,c5}},{{C2,C3},{C4,C5}}]}

The result is very promising. Eventually, I can replace f withSlotSequnce + Thread[...,List,-2] to expand each element. The following code wraps up everything in one line to generate the desired result .

In[3]:= Flatten[MapThread[Thread[{##},List,-2]&,{p1,p2,p3}],1]
Out[3]= {{{a1,A1},{a2,a3},{A2,A3}},{{a1,A1},{a4,a5},{A4,A5}},{{b1,B1},{b2,b3},{B2,B3}},{{b1,B1},{b4,b5},{B4,B5}},{{c1,C1},{c2,c3},{C2,C3}},{{c1,C1},{c4,c5},{C4,C5}}}

I am very glad to be part of your learning experience with Wolfram Language through our discussion about your analysis on the playing card problem. I highly recommend enthusiastic users like you to join our daily study group for further growth

• Review: https://blog.wolfram.com/2020/11/10/online-enrichment-with-free-daily-study-groups/
• Featured videos: https://www.gotostage.com/channel/11c1f0c486db4070a2da5715ee76bd2c
• Wolfram U: https://www.wolfram.com/wolfram-u/

*Some playing card related resources:

• WFR playing cards: https://resources.wolframcloud.com/FunctionRepository/resources/PlayingCardGraphic
• Numberphile: https://community.wolfram.com/groups/-/m/t/1718762
• Numberphile: https://community.wolfram.com/groups/-/m/t/1909911

Thank you very much, this solves the op perfectly. I didn't understand the Thread documentation there, neither made it clear to me that a {-2} would solve my problem. The documentation doesn't show {-1} nor nested lists, like my example (this llp001). Maybe it's an idea to add my example to the documentation? Good practical/instructive examples in the documentation are valuable.

Thank you, almost there with your suggestion! Maybe a nested pure function is needed? I cannot improve In[184], my bad. Maybe you could edit the left side of In[184] such that it gives Out[3]? Would be very interesting to see how this can be done, i.e. going from In[3] to Out[3] without the Thread function.

In[184]:= Apply[f[#1] /@ #2 &, {{1, 2, 3, 4}, {{0, 9}, {8, 7}, {6, 5}}}]
Out[184]= {f[{1, 2, 3, 4}][{0, 9}], f[{1, 2, 3, 4}][{8, 7}], f[{1, 2, 3, 4}][{6, 5}]} (*ouch haha!*)

Btw, by wrapping all lists with Hold and ReleaseHold in my initial Thread approach, i get the output Out[3] as desired. Of course, Shenghui Yang's solution below is just perfect to solve the op (original post, original problem).