Mfcttrf

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

Cathode rays and the cathode rays tube

How to avoid typing 'git' at the begining of every Git command

bash vs. zsh: What are the practical differences?

Why isn't Bash trap working if output is redirected to stdout?

Is Lambda Calculus purely syntactic?

Canada travel to US using Global Entry

Wizard clothing for warm weather

C++ logging library

How to find a better angle and distance for clicking picture of a distorted artwork to achieve 3D effect?

Does the new finding on "reversing a quantum jump mid-flight" rule out any interpretations of QM?

How far would a landing Airbus A380 go until it stops with no brakes?

Convert only certain words to lowercase

Rail-to-rail op-amp only reaches 90% of VCC, works sometimes, not everytime

Do you need to let the DM know when you are multiclassing?

The significance of kelvin as a unit of absolute temperature

Three questions

Do you have to have figures when playing D&D?

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

Why are ambiguous grammars bad?

Does putting salt first make it easier for attacker to bruteforce the hash?

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

Are the guests in Westworld forbidden to tell the hosts that they are robots?

Use 1 9 6 2 in this order to make 75

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 7 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 7 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 7 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 7 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 7 hours ago

kglrkglr

197k10222444

answered 7 hours ago

kglrkglr

197k10222444

answered 7 hours ago

kglrkglr

197k10222444