Ttdfjt

How do credit card companies know what type of business I'm paying for?

How to address players struggling with simple controls?

First occurrence in the Sixers sequence

Using roof rails to set up hammock

Harmonic Series Phase Difference?

Print the new site header

Fibonacci sequence and other metallic sequences emerged in the form of fractions

Why can't I craft scaffolding in Minecraft 1.14?

What kind of chart is this?

What is the context for Napoleon's quote "[the Austrians] did not know the value of five minutes"?

How to avoid offending original culture when making conculture inspired from original

Is a sequel allowed to start before the end of the first book?

How to write a nice frame challenge?

Operator currying: how to convert f[a,b][c,d] to a+c,b+d?

Digital signature that is only verifiable by one specific person

Does knowing the surface area of all faces uniquely determine a tetrahedron?

Time at 1G acceleration to travel 100 000 light years

I'm yearning in grey

In a Fish that is not a Fish

How "fast" do astronomical events occur?

When is the phrase "j'ai bon" used?

You may find me... puzzling

I have found ports on my Samsung smart tv running a display service. What can I do with it?

how to find which software is doing ssh connection?

Generate certain list from two lists

Best way to apply a list of functions to a list of values?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

4

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 Jun 9 at 19:46

user64494

3,96821323

asked Jun 9 at 19:44

YaofengYaofeng

796

$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
  Jun 9 at 19:51
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 22:40
  
  

  
  
  
  

add a comment | 

4

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 Jun 9 at 19:46

user64494

3,96821323

asked Jun 9 at 19:44

YaofengYaofeng

796

$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
  Jun 9 at 19:51
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 22:40
  
  

  
  
  
  

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 Jun 9 at 19:46

user64494

3,96821323

asked Jun 9 at 19:44

YaofengYaofeng

796

$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 Jun 9 at 19:46

user64494

3,96821323

asked Jun 9 at 19:44

YaofengYaofeng

796

share|improve this question

edited Jun 9 at 19:46

user64494

3,96821323

asked Jun 9 at 19:44

YaofengYaofeng

796

edited Jun 9 at 19:46

user64494

3,96821323

edited Jun 9 at 19:46

user64494

3,96821323

asked Jun 9 at 19:44

YaofengYaofeng

796

asked Jun 9 at 19:44

YaofengYaofeng

796

2 Answers
2

active

oldest

votes

5

$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]

See here for a discussion of the Through[#1[#2]]& operator.

share|improve this answer

edited Jun 10 at 11:24

answered Jun 9 at 19:51

RomanRoman

11.3k11944

$endgroup$

• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  A good code is a commented code. Comments are useful to both readers and authors.
  $endgroup$
  – user64494
  Jun 9 at 19:52
  
  

  
  
  
  


• 
  
  
  

  
  4
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 20:32
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 22:12
  

  
  
  
  

add a comment | 

5

$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 Jun 10 at 1:04

answered Jun 9 at 21:02

kglrkglr

198k10223450

$endgroup$

• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  Yes that's what I was looking for! Thanks. Prefix it with Join@@ to match the spec.
  $endgroup$
  – Roman
  Jun 9 at 21:05
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 22:19
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 22:37
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 22:48
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  Although I think your Thread[Insert[##,3]] method is the most poetic, it's also the most brittle: Inserting first and Threading second makes the assumption that none of the elements of the lists in l1 are themselves lists. Example: with l1 = "Mn", "Mn1", 1., "B", 1.4, "Al", "Al1", 1., "B", 1.4 this method throws a Thread::tdlen. To be more robust it's probably advisable to Thread first and Insert second, as in your second method.
  $endgroup$
  – Roman
  Jun 10 at 7:55
  
  

  
  
  
  

 | 
show 1 more 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

5

$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]

See here for a discussion of the Through[#1[#2]]& operator.

share|improve this answer

edited Jun 10 at 11:24

answered Jun 9 at 19:51

RomanRoman

11.3k11944

$endgroup$

• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  A good code is a commented code. Comments are useful to both readers and authors.
  $endgroup$
  – user64494
  Jun 9 at 19:52
  
  

  
  
  
  


• 
  
  
  

  
  4
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 20:32
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 22:12
  

  
  
  
  

add a comment | 

5

$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]

See here for a discussion of the Through[#1[#2]]& operator.

share|improve this answer

edited Jun 10 at 11:24

answered Jun 9 at 19:51

RomanRoman

11.3k11944

$endgroup$

• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  A good code is a commented code. Comments are useful to both readers and authors.
  $endgroup$
  – user64494
  Jun 9 at 19:52
  
  

  
  
  
  


• 
  
  
  

  
  4
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 20:32
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 22:12
  

  
  
  
  

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]

See here for a discussion of the Through[#1[#2]]& operator.

share|improve this answer

edited Jun 10 at 11:24

answered Jun 9 at 19:51

RomanRoman

11.3k11944

$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 Jun 10 at 11:24

answered Jun 9 at 19:51

RomanRoman

11.3k11944

answered Jun 9 at 19:51

RomanRoman

11.3k11944

answered Jun 9 at 19:51

RomanRoman

11.3k11944

5

$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 Jun 10 at 1:04

answered Jun 9 at 21:02

kglrkglr

198k10223450

$endgroup$

• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  Yes that's what I was looking for! Thanks. Prefix it with Join@@ to match the spec.
  $endgroup$
  – Roman
  Jun 9 at 21:05
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 22:19
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 22:37
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 22:48
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  Although I think your Thread[Insert[##,3]] method is the most poetic, it's also the most brittle: Inserting first and Threading second makes the assumption that none of the elements of the lists in l1 are themselves lists. Example: with l1 = "Mn", "Mn1", 1., "B", 1.4, "Al", "Al1", 1., "B", 1.4 this method throws a Thread::tdlen. To be more robust it's probably advisable to Thread first and Insert second, as in your second method.
  $endgroup$
  – Roman
  Jun 10 at 7:55
  
  

  
  
  
  

 | 
show 1 more comment

5

$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 Jun 10 at 1:04

answered Jun 9 at 21:02

kglrkglr

198k10223450

$endgroup$

• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  Yes that's what I was looking for! Thanks. Prefix it with Join@@ to match the spec.
  $endgroup$
  – Roman
  Jun 9 at 21:05
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 22:19
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 22:37
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $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
  Jun 9 at 22:48
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  Although I think your Thread[Insert[##,3]] method is the most poetic, it's also the most brittle: Inserting first and Threading second makes the assumption that none of the elements of the lists in l1 are themselves lists. Example: with l1 = "Mn", "Mn1", 1., "B", 1.4, "Al", "Al1", 1., "B", 1.4 this method throws a Thread::tdlen. To be more robust it's probably advisable to Thread first and Insert second, as in your second method.
  $endgroup$
  – Roman
  Jun 10 at 7:55
  
  

  
  
  
  

 | 
show 1 more 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 Jun 10 at 1:04

answered Jun 9 at 21:02

kglrkglr

198k10223450

$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 Jun 10 at 1:04

answered Jun 9 at 21:02

kglrkglr

198k10223450

answered Jun 9 at 21:02

kglrkglr

198k10223450

answered Jun 9 at 21:02

kglrkglr

198k10223450