Mdthbs

Print "N NE E SE S SW W NW"

Can the removal of a duty-free sales trolley result in a measurable reduction in emissions?

Make Gimbap cutter

How to befriend someone who doesn't like to talk?

What is the logic behind charging tax _in the form of money_ for owning property when the property does not produce money?

Is there a DSLR/mirorless camera with minimal options like a classic, simple SLR?

Why are ambiguous grammars bad?

Confused with atmospheric pressure equals plastic balloon’s inner pressure

Do you really need a KDF when you have a PRF?

What is the reason for setting flaps 1 on the ground at high temperatures?

The origin of the Russian proverb about two hares

Grep Match and extract

I've been given a project I can't complete, what should I do?

That's not my X, its Y is too Z

Generate certain list from two lists

So a part of my house disappeared... But not because of a chunk resetting

How (un)safe is it to ride barefoot?

How can powerful telekinesis avoid violating Newton's 3rd Law?

Is it okay to have a sequel start immediately after the end of the first book?

Wizard clothing for warm weather

noalign caused by multirow and colors

Is Dumbledore a human lie detector?

How to get depth and other lengths of a font?

Canada travel to US using Global Entry

Generate certain list from two lists

Distributing elements across a list of listsHow to find the distance of two lists?One to Many Lists MergePattern matching - comparing two listsContract two listsMatching the order of a master list of lists from a random list of listsEfficiently exchange elements between two listsJoining 100 lists to make one big listSelecting cases from a list based on two conditionsRagged Transpose

3

1

$begingroup$

I have two lists.

l1={

    {"Mn", "Mn1", 1., "B", 1.4}, 

    {"Al", "Al1", 1., "B", 1.4}

   };



l2={

   {{1, 1, 0.}, {11, 11, 0.}},



   {{2, 2, 0.}, {22, 22, 0.}, {222, 222, 0.}}

   }

This is a short version of the lists. The two lists always have the same Length so that their level-1 elements have a one-to-one relation. However, the elements of l2 can have varying Length as shown here.

I'd like to generate a new list as follows.

l3=

{

    {"Mn", "Mn1", {1, 1, 0.}, 1., "B", 1.4},

    {"Mn", "Mn1", {11, 11, 0.}, 1., "B", 1.4},



    {"Al", "Al1", {2, 2, 0.}, 1., "B", 1.4},

    {"Al", "Al1", {22, 22, 0.}, 1., "B", 1.4},

    {"Al", "Al1", {222, 222, 0.}, 1., "B", 1.4}

}

I think MapThread might be the direction to go, but I cannot think of any function to obtain the result. I'm not stick to MapThread. Any function that can do the job is okay as long as it's a vertorization method since that's what MMA favors.

Thank you.

list-manipulation

share|improve this question

edited 8 hours ago

user64494

3,97111323

asked 8 hours ago

YaofengYaofeng

746

$endgroup$

• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  Can you elaborate your receipt for l3 in detail? I understand nothing. BTW, the notation "l" is not good: compare with "I" and "1".
  $endgroup$
  – user64494
  8 hours ago
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @user64494, it's really difficult for me to think of a good way to describe the format of l3 for English isn't my first language. That's why I use newlines to separate elements of l1 and l2 and change values of l2 to 1,11 and 2, 22, 222 for clarity. Maybe you could help me with that. But I think the answers provided understood my need and returns the desired format of l3. Also, I appreciate the suggestions of l1/2/3 may not be a good variable name. Thanks.
  $endgroup$
  – Yaofeng
  5 hours ago
  
  
  

  
  
  
  

add a comment | 

3

1

$begingroup$

I have two lists.

l1={

    {"Mn", "Mn1", 1., "B", 1.4}, 

    {"Al", "Al1", 1., "B", 1.4}

   };



l2={

   {{1, 1, 0.}, {11, 11, 0.}},



   {{2, 2, 0.}, {22, 22, 0.}, {222, 222, 0.}}

   }

This is a short version of the lists. The two lists always have the same Length so that their level-1 elements have a one-to-one relation. However, the elements of l2 can have varying Length as shown here.

I'd like to generate a new list as follows.

l3=

{

    {"Mn", "Mn1", {1, 1, 0.}, 1., "B", 1.4},

    {"Mn", "Mn1", {11, 11, 0.}, 1., "B", 1.4},



    {"Al", "Al1", {2, 2, 0.}, 1., "B", 1.4},

    {"Al", "Al1", {22, 22, 0.}, 1., "B", 1.4},

    {"Al", "Al1", {222, 222, 0.}, 1., "B", 1.4}

}

I think MapThread might be the direction to go, but I cannot think of any function to obtain the result. I'm not stick to MapThread. Any function that can do the job is okay as long as it's a vertorization method since that's what MMA favors.

Thank you.

list-manipulation

share|improve this question

edited 8 hours ago

user64494

3,97111323

asked 8 hours ago

YaofengYaofeng

746

$endgroup$

• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  Can you elaborate your receipt for l3 in detail? I understand nothing. BTW, the notation "l" is not good: compare with "I" and "1".
  $endgroup$
  – user64494
  8 hours ago
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @user64494, it's really difficult for me to think of a good way to describe the format of l3 for English isn't my first language. That's why I use newlines to separate elements of l1 and l2 and change values of l2 to 1,11 and 2, 22, 222 for clarity. Maybe you could help me with that. But I think the answers provided understood my need and returns the desired format of l3. Also, I appreciate the suggestions of l1/2/3 may not be a good variable name. Thanks.
  $endgroup$
  – Yaofeng
  5 hours ago
  
  
  

  
  
  
  

add a comment | 

$begingroup$

I have two lists.

l1={

    {"Mn", "Mn1", 1., "B", 1.4}, 

    {"Al", "Al1", 1., "B", 1.4}

   };



l2={

   {{1, 1, 0.}, {11, 11, 0.}},



   {{2, 2, 0.}, {22, 22, 0.}, {222, 222, 0.}}

   }

This is a short version of the lists. The two lists always have the same Length so that their level-1 elements have a one-to-one relation. However, the elements of l2 can have varying Length as shown here.

I'd like to generate a new list as follows.

l3=

{

    {"Mn", "Mn1", {1, 1, 0.}, 1., "B", 1.4},

    {"Mn", "Mn1", {11, 11, 0.}, 1., "B", 1.4},



    {"Al", "Al1", {2, 2, 0.}, 1., "B", 1.4},

    {"Al", "Al1", {22, 22, 0.}, 1., "B", 1.4},

    {"Al", "Al1", {222, 222, 0.}, 1., "B", 1.4}

}

I think MapThread might be the direction to go, but I cannot think of any function to obtain the result. I'm not stick to MapThread. Any function that can do the job is okay as long as it's a vertorization method since that's what MMA favors.

Thank you.

list-manipulation

share|improve this question

edited 8 hours ago

user64494

3,97111323

asked 8 hours ago

YaofengYaofeng

746

$endgroup$

l1={

    {"Mn", "Mn1", 1., "B", 1.4}, 

    {"Al", "Al1", 1., "B", 1.4}

   };



l2={

   {{1, 1, 0.}, {11, 11, 0.}},



   {{2, 2, 0.}, {22, 22, 0.}, {222, 222, 0.}}

   }

l3=

{

    {"Mn", "Mn1", {1, 1, 0.}, 1., "B", 1.4},

    {"Mn", "Mn1", {11, 11, 0.}, 1., "B", 1.4},



    {"Al", "Al1", {2, 2, 0.}, 1., "B", 1.4},

    {"Al", "Al1", {22, 22, 0.}, 1., "B", 1.4},

    {"Al", "Al1", {222, 222, 0.}, 1., "B", 1.4}

}

share|improve this question

edited 8 hours ago

user64494

3,97111323

asked 8 hours ago

YaofengYaofeng

746

share|improve this question

edited 8 hours ago

user64494

3,97111323

asked 8 hours ago

YaofengYaofeng

746

edited 8 hours ago

user64494

3,97111323

edited 8 hours ago

user64494

3,97111323

asked 8 hours ago

YaofengYaofeng

746

asked 8 hours ago

YaofengYaofeng

746

2 Answers
2

active

oldest

votes

3

$begingroup$

Yes you can use MapThread:

l3 = Join @@ MapThread[Function[{x, y}, Insert[x, #, 3] & /@ y], {l1, l2}]

Here's a more esoteric version that builds lists of mapping operators from l2 and then applies them to the elements of l1:

l3 = Join @@ MapThread[Through[#1[#2]] &, {Map[Insert[#, 3] &, l2, {2}], l1}]

The function Through[#1[#2]]& looks very general and useful: does it have a canonical name?

share|improve this answer

edited 6 hours ago

answered 8 hours ago

RomanRoman

10.5k11741

$endgroup$

• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  A good code is a commented code. Comments are useful to both readers and authors.
  $endgroup$
  – user64494
  8 hours ago
  
  
  

  
  
  
  


• 
  
  
  

  
  3
  

  
  
  
  
  
  

  
  $begingroup$
  @user64494 I expect some effort from the reader: the analysis and exegesis of other people's code snippets is a great learning tool. Give a man a fish and you feed him for a day; teach a man to fish and you feed him for a lifetime.
  $endgroup$
  – Roman
  7 hours ago
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @Roman, I like the 1st solution you provided because that's what I can remember in brain once I learn it. I was struggling with Part, but yours enlightened me. I'll need to understand better the Through approach. First time I heard of this function. Thanks.
  $endgroup$
  – Yaofeng
  5 hours ago
  

  
  
  
  

add a comment | 

3

$begingroup$

You can also MapThread the function Thread[Insert[#, #2, 3]] & on the pair of lists {l1,l2}:

Join @@ MapThread[Thread[Insert[#, #2, 3]] &, {l1, l2}]

{{Mn, Mn1, {1, 1, 0.}, 1., B, 1.4}, {Mn, Mn1, {11, 11, 0.}, 1., B, 1.4},

{Al, Al1, {2, 2, 0.}, 1., B, 1.4}, {Al, Al1, {22, 22, 0.}, 1., B, 1.4}, {Al, Al1, {222, 222, 0.}, 1., B, 1.4}}

Alternatively, use the MapThread/Thread combination to create pairings appended with 3 and apply Insert to the resulting triples:

Join @@ Apply[Insert, 

  MapThread[Thread[{##, 3}, List, {2}] &, {l1, l2}], 

 {2}]

same result

share|improve this answer

edited 2 hours ago

answered 6 hours ago

kglrkglr

197k10222444

$endgroup$

• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  Yes that's what I was looking for! Thanks. Prefix it with Join@@ to match the spec.
  $endgroup$
  – Roman
  6 hours ago
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @kglr, I never think of using Thread function before reading your answer. It's a little bit difficult for me to appreciate the mechanism of Thread. It's written "threads" f over any lists that appear in args in MMA's help page. But elements of l1 and l2 are both lists. I think Insert plays a role here so that the function only threads over element of l2. Am I understanding correctly? Thanks
  $endgroup$
  – Yaofeng
  5 hours ago
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @Yaofeng, you are right for the first one. In the second, the second and third arguments of Thread controls what to thread over and in which positions.
  $endgroup$
  – kglr
  5 hours ago
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @kglr, I compared the AbsoluteTiming for your Thread solution and Roman's Function solution. Yours is faster. Although it's not intuitive for me at the moment, but I guess that's the direction for me to go, in line with MMA's vectorization. Thanks again!
  $endgroup$
  – Yaofeng
  5 hours ago
  

  
  
  
  

add a comment | 

Your Answer

StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "387"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);

StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});

function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: false,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: null,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});


}
});

draft saved

draft discarded

Sign up or log in

StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});

Sign up using Google

Sign up using Facebook

Sign up using Email and Password

Post as a guest

Name

Email

Required, but never shown

StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f200024%2fgenerate-certain-list-from-two-lists%23new-answer', 'question_page');
}
);

Post as a guest

Name

Email

Required, but never shown

3

$begingroup$

Yes you can use MapThread:

l3 = Join @@ MapThread[Function[{x, y}, Insert[x, #, 3] & /@ y], {l1, l2}]

Here's a more esoteric version that builds lists of mapping operators from l2 and then applies them to the elements of l1:

l3 = Join @@ MapThread[Through[#1[#2]] &, {Map[Insert[#, 3] &, l2, {2}], l1}]

The function Through[#1[#2]]& looks very general and useful: does it have a canonical name?

share|improve this answer

edited 6 hours ago

answered 8 hours ago

RomanRoman

10.5k11741

$endgroup$

• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  A good code is a commented code. Comments are useful to both readers and authors.
  $endgroup$
  – user64494
  8 hours ago
  
  
  

  
  
  
  


• 
  
  
  

  
  3
  

  
  
  
  
  
  

  
  $begingroup$
  @user64494 I expect some effort from the reader: the analysis and exegesis of other people's code snippets is a great learning tool. Give a man a fish and you feed him for a day; teach a man to fish and you feed him for a lifetime.
  $endgroup$
  – Roman
  7 hours ago
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @Roman, I like the 1st solution you provided because that's what I can remember in brain once I learn it. I was struggling with Part, but yours enlightened me. I'll need to understand better the Through approach. First time I heard of this function. Thanks.
  $endgroup$
  – Yaofeng
  5 hours ago
  

  
  
  
  

add a comment | 

3

$begingroup$

Yes you can use MapThread:

l3 = Join @@ MapThread[Function[{x, y}, Insert[x, #, 3] & /@ y], {l1, l2}]

Here's a more esoteric version that builds lists of mapping operators from l2 and then applies them to the elements of l1:

l3 = Join @@ MapThread[Through[#1[#2]] &, {Map[Insert[#, 3] &, l2, {2}], l1}]

The function Through[#1[#2]]& looks very general and useful: does it have a canonical name?

share|improve this answer

edited 6 hours ago

answered 8 hours ago

RomanRoman

10.5k11741

$endgroup$

• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  A good code is a commented code. Comments are useful to both readers and authors.
  $endgroup$
  – user64494
  8 hours ago
  
  
  

  
  
  
  


• 
  
  
  

  
  3
  

  
  
  
  
  
  

  
  $begingroup$
  @user64494 I expect some effort from the reader: the analysis and exegesis of other people's code snippets is a great learning tool. Give a man a fish and you feed him for a day; teach a man to fish and you feed him for a lifetime.
  $endgroup$
  – Roman
  7 hours ago
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @Roman, I like the 1st solution you provided because that's what I can remember in brain once I learn it. I was struggling with Part, but yours enlightened me. I'll need to understand better the Through approach. First time I heard of this function. Thanks.
  $endgroup$
  – Yaofeng
  5 hours ago
  

  
  
  
  

add a comment | 

$begingroup$

Yes you can use MapThread:

l3 = Join @@ MapThread[Function[{x, y}, Insert[x, #, 3] & /@ y], {l1, l2}]

Here's a more esoteric version that builds lists of mapping operators from l2 and then applies them to the elements of l1:

l3 = Join @@ MapThread[Through[#1[#2]] &, {Map[Insert[#, 3] &, l2, {2}], l1}]

The function Through[#1[#2]]& looks very general and useful: does it have a canonical name?

share|improve this answer

edited 6 hours ago

answered 8 hours ago

RomanRoman

10.5k11741

$endgroup$

l3 = Join @@ MapThread[Function[{x, y}, Insert[x, #, 3] & /@ y], {l1, l2}]

l3 = Join @@ MapThread[Through[#1[#2]] &, {Map[Insert[#, 3] &, l2, {2}], l1}]

share|improve this answer

edited 6 hours ago

answered 8 hours ago

RomanRoman

10.5k11741

answered 8 hours ago

RomanRoman

10.5k11741

answered 8 hours ago

RomanRoman

10.5k11741

3

$begingroup$

You can also MapThread the function Thread[Insert[#, #2, 3]] & on the pair of lists {l1,l2}:

Join @@ MapThread[Thread[Insert[#, #2, 3]] &, {l1, l2}]

{{Mn, Mn1, {1, 1, 0.}, 1., B, 1.4}, {Mn, Mn1, {11, 11, 0.}, 1., B, 1.4},

{Al, Al1, {2, 2, 0.}, 1., B, 1.4}, {Al, Al1, {22, 22, 0.}, 1., B, 1.4}, {Al, Al1, {222, 222, 0.}, 1., B, 1.4}}

Alternatively, use the MapThread/Thread combination to create pairings appended with 3 and apply Insert to the resulting triples:

Join @@ Apply[Insert, 

  MapThread[Thread[{##, 3}, List, {2}] &, {l1, l2}], 

 {2}]

same result

share|improve this answer

edited 2 hours ago

answered 6 hours ago

kglrkglr

197k10222444

$endgroup$

• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  Yes that's what I was looking for! Thanks. Prefix it with Join@@ to match the spec.
  $endgroup$
  – Roman
  6 hours ago
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @kglr, I never think of using Thread function before reading your answer. It's a little bit difficult for me to appreciate the mechanism of Thread. It's written "threads" f over any lists that appear in args in MMA's help page. But elements of l1 and l2 are both lists. I think Insert plays a role here so that the function only threads over element of l2. Am I understanding correctly? Thanks
  $endgroup$
  – Yaofeng
  5 hours ago
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @Yaofeng, you are right for the first one. In the second, the second and third arguments of Thread controls what to thread over and in which positions.
  $endgroup$
  – kglr
  5 hours ago
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @kglr, I compared the AbsoluteTiming for your Thread solution and Roman's Function solution. Yours is faster. Although it's not intuitive for me at the moment, but I guess that's the direction for me to go, in line with MMA's vectorization. Thanks again!
  $endgroup$
  – Yaofeng
  5 hours ago
  

  
  
  
  

add a comment | 

3

$begingroup$

You can also MapThread the function Thread[Insert[#, #2, 3]] & on the pair of lists {l1,l2}:

Join @@ MapThread[Thread[Insert[#, #2, 3]] &, {l1, l2}]

{{Mn, Mn1, {1, 1, 0.}, 1., B, 1.4}, {Mn, Mn1, {11, 11, 0.}, 1., B, 1.4},

{Al, Al1, {2, 2, 0.}, 1., B, 1.4}, {Al, Al1, {22, 22, 0.}, 1., B, 1.4}, {Al, Al1, {222, 222, 0.}, 1., B, 1.4}}

Alternatively, use the MapThread/Thread combination to create pairings appended with 3 and apply Insert to the resulting triples:

Join @@ Apply[Insert, 

  MapThread[Thread[{##, 3}, List, {2}] &, {l1, l2}], 

 {2}]

same result

share|improve this answer

edited 2 hours ago

answered 6 hours ago

kglrkglr

197k10222444

$endgroup$

• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  Yes that's what I was looking for! Thanks. Prefix it with Join@@ to match the spec.
  $endgroup$
  – Roman
  6 hours ago
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @kglr, I never think of using Thread function before reading your answer. It's a little bit difficult for me to appreciate the mechanism of Thread. It's written "threads" f over any lists that appear in args in MMA's help page. But elements of l1 and l2 are both lists. I think Insert plays a role here so that the function only threads over element of l2. Am I understanding correctly? Thanks
  $endgroup$
  – Yaofeng
  5 hours ago
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @Yaofeng, you are right for the first one. In the second, the second and third arguments of Thread controls what to thread over and in which positions.
  $endgroup$
  – kglr
  5 hours ago
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @kglr, I compared the AbsoluteTiming for your Thread solution and Roman's Function solution. Yours is faster. Although it's not intuitive for me at the moment, but I guess that's the direction for me to go, in line with MMA's vectorization. Thanks again!
  $endgroup$
  – Yaofeng
  5 hours ago
  

  
  
  
  

add a comment | 

$begingroup$

You can also MapThread the function Thread[Insert[#, #2, 3]] & on the pair of lists {l1,l2}:

Join @@ MapThread[Thread[Insert[#, #2, 3]] &, {l1, l2}]

{{Mn, Mn1, {1, 1, 0.}, 1., B, 1.4}, {Mn, Mn1, {11, 11, 0.}, 1., B, 1.4},

{Al, Al1, {2, 2, 0.}, 1., B, 1.4}, {Al, Al1, {22, 22, 0.}, 1., B, 1.4}, {Al, Al1, {222, 222, 0.}, 1., B, 1.4}}

Alternatively, use the MapThread/Thread combination to create pairings appended with 3 and apply Insert to the resulting triples:

Join @@ Apply[Insert, 

  MapThread[Thread[{##, 3}, List, {2}] &, {l1, l2}], 

 {2}]

same result

share|improve this answer

edited 2 hours ago

answered 6 hours ago

kglrkglr

197k10222444

$endgroup$

Join @@ MapThread[Thread[Insert[#, #2, 3]] &, {l1, l2}]

Join @@ Apply[Insert, 

  MapThread[Thread[{##, 3}, List, {2}] &, {l1, l2}], 

 {2}]

share|improve this answer

edited 2 hours ago

answered 6 hours ago

kglrkglr

197k10222444

answered 6 hours ago

kglrkglr

197k10222444

answered 6 hours ago

kglrkglr

197k10222444