How to take specific element from the first list , second list and those specific element add into third list[C#]

Question

1.00/5 (1 vote)

See more:

I want to result like below :

List<string> a1=new List<string>(){"a","b","c","d"};

List<string> a2=new List<string>(){"1","2","3"};

Output : a1b2c3d

Please help how to achieve without using inbuilt function.

What I have tried:

I am new to this please help me in this

Posted 15-Jul-23 7:39am

MS2023

Updated 16-Jul-23 5:21am

Andre Oosthuizen

v2

Add a Solution

Comments

PIEBALDconsult 15-Jul-23 13:58pm

Well, I mean, you'll _have_ to use some built-in methods no matter what you do.
But have a look at a for loop.

Patrice T 15-Jul-23 23:30pm

Just handling lists imply using built functions.
Show your work so far.

3 solutions

Solution 3

I decided to do some benchmarking after Andre's post. The results were very interesting.

As mentioned in my comment to Andre, I thought that Span would be faster than Richards's solution. After seeing the results I wanted to find a faster solution. You can see that I used Richard's as a base and managed to find a faster solution - managed to improve it by 18.5% faster with FastMergeImmutableArraysWithStringBuilder benchmark.

Here are the results with my test system information:

BenchmarkDotNet v0.13.6, Windows 11 (10.0.22621.1992/22H2/2022Update/SunValley2)
AMD Ryzen 7 3700X, 1 CPU, 16 logical and 8 physical cores
.NET SDK 7.0.304
  [Host]     : .NET 7.0.9 (7.0.923.32018), X64 RyuJIT AVX2
  DefaultJob : .NET 7.0.9 (7.0.923.32018), X64 RyuJIT AVX2

|                                      Method |     N |         Mean |        Error |       StdDev |       Median |
|-------------------------------------------- |------ |-------------:|-------------:|-------------:|-------------:|
|                        MergeListsToListJoin |   100 |   2,466.4 ns |     47.69 ns |     56.77 ns |   2,452.9 ns |
|                      MergeListsToListConcat |   100 |   3,570.6 ns |     30.59 ns |     28.61 ns |   3,570.4 ns |
|                        MergeListsToSpanJoin |   100 |   2,018.7 ns |     37.14 ns |     32.92 ns |   2,011.2 ns |
|                      MergeListsToSpanConcat |   100 |   1,483.6 ns |     29.16 ns |     33.58 ns |   1,482.4 ns |
|                MergeListsToReadOnlySpanJoin |   100 |   1,910.5 ns |     33.62 ns |     31.45 ns |   1,899.6 ns |
|              MergeListsToReadOnlySpanConcat |   100 |   1,498.6 ns |     15.89 ns |     14.87 ns |   1,498.7 ns |
|                 MergeListsWithStringBuilder |   100 |   1,155.8 ns |     20.46 ns |     19.14 ns |   1,150.9 ns |
|                MergeArraysWithStringBuilder |   100 |   1,060.7 ns |     21.14 ns |     40.74 ns |   1,052.7 ns |
|       MergeImmutableArraysWithStringBuilder |   100 |   1,123.6 ns |     22.23 ns |     46.40 ns |   1,119.0 ns |
|   FastMergeImmutableArraysWithStringBuilder |   100 |     975.4 ns |     16.24 ns |     14.40 ns |     976.2 ns |
| FasterMergeImmutableArraysWithStringBuilder |   100 |   1,007.5 ns |     20.08 ns |     46.55 ns |   1,022.3 ns |
|                        MergeListsToListJoin |  1000 |  22,157.8 ns |    288.08 ns |    269.47 ns |  22,144.4 ns |
|                      MergeListsToListConcat |  1000 |  34,887.5 ns |    683.79 ns |    839.76 ns |  35,055.0 ns |
|                        MergeListsToSpanJoin |  1000 |  20,063.4 ns |    399.40 ns |    373.60 ns |  19,969.5 ns |
|                      MergeListsToSpanConcat |  1000 |  15,156.6 ns |    229.77 ns |    214.93 ns |  15,171.1 ns |
|                MergeListsToReadOnlySpanJoin |  1000 |  20,002.7 ns |    260.86 ns |    244.01 ns |  19,975.9 ns |
|              MergeListsToReadOnlySpanConcat |  1000 |  15,598.0 ns |    297.16 ns |    305.16 ns |  15,628.4 ns |
|                 MergeListsWithStringBuilder |  1000 |  15,263.7 ns |    656.26 ns |  1,934.99 ns |  15,856.0 ns |
|                MergeArraysWithStringBuilder |  1000 |  12,504.3 ns |    284.62 ns |    821.20 ns |  12,430.0 ns |
|       MergeImmutableArraysWithStringBuilder |  1000 |  12,729.6 ns |    254.12 ns |    495.65 ns |  12,858.3 ns |
|   FastMergeImmutableArraysWithStringBuilder |  1000 |  10,811.3 ns |    170.85 ns |    151.46 ns |  10,802.3 ns |
| FasterMergeImmutableArraysWithStringBuilder |  1000 |  11,378.8 ns |    225.61 ns |    582.37 ns |  11,648.3 ns |
|                        MergeListsToListJoin | 10000 | 522,580.8 ns | 10,395.54 ns | 11,971.52 ns | 525,432.2 ns |
|                      MergeListsToListConcat | 10000 | 655,883.7 ns | 12,753.81 ns | 13,646.43 ns | 660,786.4 ns |
|                        MergeListsToSpanJoin | 10000 | 351,701.7 ns |  4,842.52 ns |  4,529.69 ns | 351,433.6 ns |
|                      MergeListsToSpanConcat | 10000 | 306,222.2 ns |  4,471.00 ns |  4,182.18 ns | 305,097.5 ns |
|                MergeListsToReadOnlySpanJoin | 10000 | 344,782.7 ns |  4,458.88 ns |  4,170.83 ns | 344,936.2 ns |
|              MergeListsToReadOnlySpanConcat | 10000 | 302,246.1 ns |  3,425.33 ns |  3,036.46 ns | 302,369.6 ns |
|                 MergeListsWithStringBuilder | 10000 | 266,227.9 ns |  5,220.39 ns |  5,802.45 ns | 267,154.6 ns |
|                MergeArraysWithStringBuilder | 10000 | 262,338.4 ns |  5,076.62 ns |  5,431.92 ns | 264,012.8 ns |
|       MergeImmutableArraysWithStringBuilder | 10000 | 257,863.5 ns |  4,833.98 ns |  5,172.31 ns | 257,541.0 ns |
|   FastMergeImmutableArraysWithStringBuilder | 10000 | 250,550.6 ns |  4,957.86 ns |  5,901.98 ns | 252,194.0 ns |
| FasterMergeImmutableArraysWithStringBuilder | 10000 | 248,685.6 ns |  4,842.27 ns |  5,181.18 ns | 249,153.2 ns |

Side Note: as Span is a Ref Struct I cannot set as a private field, so I have to get the reference to an array in the method itself - see code below.

Here is the Benchmark code used:

C#

using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

public class Program
{
    static void Main()
        => BenchmarkRunner.Run<Benchmark>();
}

//[RankColumn]
//[MemoryDiagnoser]
public class Benchmark
{
// Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
#pragma warning disable CS8618 
    private List<string> a1List;
    private List<string> a2List;
    private string[] a1Array;
    private string[] a2Array;
    private string[] a1ImmutableArray;
    private string[] a2ImmutableArray;
#pragma warning restore CS8618

    [Params(100, 1000, 10000)]
    public int N;

    [GlobalSetup]
    public void GlobalSetup()
    {
        a1List = new List<string>(N);
        a2List = new List<string>(N);
        a1Array = new string[N];
        a2Array = new string[N];
        a1ImmutableArray = new string[N];
        a2ImmutableArray = new string[N];

        for (int i = 0; i < N; i++)
        {
            a1List.Add($"a{i}");
            a2List.Add($"{i + 1}");
            a1Array[i] = $"a{i}";
            a2Array[i] = $"{i + 1}";
            a1ImmutableArray[i] = $"a{i}";
            a2ImmutableArray[i] = $"{i + 1}";
        }
    }

    [Benchmark]
    public string MergeListsToListJoin()
    {
        List<string> combined = new();

        int maxLength = Math.Max(a1List.Count, a2List.Count);

        for (int i = 0; i < maxLength; i++)
        {
            combined.Add(a1List[i]);

            if (i < a2List.Count)
                combined.Add(a2List[i]);
        }

        return string.Join("", combined);
    }

    [Benchmark]
    public string MergeListsToListConcat()
    {
        List<string> combined = new();

        int maxLength = Math.Max(a1List.Count, a2List.Count);

        for (int i = 0; i < maxLength; i++)
        {
            combined.Add(a1List[i]);

            if (i < a2List.Count)
                combined.Add(a2List[i]);
        }

        return string.Concat(combined);
    }

    [Benchmark]
    public string MergeListsToSpanJoin()
    {
        Span<string> a1Span = a1Array.AsSpan();
        Span<string> a2Span = a2Array.AsSpan();

        int maxLength = Math.Max(a1Span.Length, a2Span.Length);

        string[] combined = new string[maxLength * 2];
        Span<string> combinedSpan = combined.AsSpan();

        for (int i = 0, j = 0; i < maxLength; i++, j += 2)
        {
            combinedSpan[j] = a1Span[i];

            if (i < a2Span.Length)
                combinedSpan[j + 1] = a2Span[i];
        }

        return string.Join("", combined);
    }

    [Benchmark]
    public string MergeListsToSpanConcat()
    {
        Span<string> a1Span = a1Array.AsSpan();
        Span<string> a2Span = a2Array.AsSpan();

        int maxLength = Math.Max(a1Span.Length, a2Span.Length);

        string[] combined = new string[maxLength * 2];
        Span<string> combinedSpan = combined.AsSpan();

        for (int i = 0, j = 0; i < maxLength; i++, j += 2)
        {
            combinedSpan[j] = a1Span[i];

            if (i < a2Span.Length)
                combinedSpan[j + 1] = a2Span[i];
        }

        return string.Concat(combined);
    }

    [Benchmark]
    public string MergeListsToReadOnlySpanJoin()
    {
        ReadOnlySpan<string> a1Span = a1Array.AsSpan();
        ReadOnlySpan<string> a2Span = a2Array.AsSpan();

        int maxLength = Math.Max(a1Span.Length, a2Span.Length);

        string[] combined = new string[maxLength * 2];
        Span<string> combinedSpan = combined.AsSpan();

        for (int i = 0, j = 0; i < maxLength; i++, j += 2)
        {
            combinedSpan[j] = a1Span[i];

            if (i < a2Span.Length)
                combinedSpan[j + 1] = a2Span[i];
        }

        return string.Join("", combined);
    }

    [Benchmark]
    public string MergeListsToReadOnlySpanConcat()
    {
        ReadOnlySpan<string> a1Span = a1Array.AsSpan();
        ReadOnlySpan<string> a2Span = a2Array.AsSpan();

        int maxLength = Math.Max(a1Span.Length, a2Span.Length);

        string[] combined = new string[maxLength * 2];
        Span<string> combinedSpan = combined.AsSpan();

        for (int i = 0, j = 0; i < maxLength; i++, j += 2)
        {
            combinedSpan[j] = a1Span[i];

            if (i < a2Span.Length)
                combinedSpan[j + 1] = a2Span[i];
        }

        return string.Concat(combined);
    }

    [Benchmark]
    public string MergeListsWithStringBuilder()
    {
        StringBuilder output = new();

        for (int i = 0; i < a1List.Count; ++i)
        {
            output.Append(a1List[i]);

            if (i < a2List.Count)
                output.Append(a2List[i]);
        }

        return output.ToString();
    }

    [Benchmark]
    public string MergeArraysWithStringBuilder()
    {
        StringBuilder output = new();

        for (int i = 0; i < a1Array.Length; ++i)
        {
            output.Append(a1Array[i]);

            if (i < a2Array.Length)
                output.Append(a2Array[i]);
        }

        return output.ToString();
    }

    [Benchmark]
    public string MergeImmutableArraysWithStringBuilder()
    {
        StringBuilder output = new();

        for (int i = 0; i < a1ImmutableArray.Length; ++i)
        {
            output.Append(a1ImmutableArray[i]);

            if (i < a2ImmutableArray.Length)
                output.Append(a2ImmutableArray[i]);
        }

        return output.ToString();
    }

    [Benchmark]
    public string FastMergeImmutableArraysWithStringBuilder()
    {
        StringBuilder output = new();

        ref string item1 = ref MemoryMarshal.GetArrayDataReference(a1ImmutableArray);
        ref string item2 = ref MemoryMarshal.GetArrayDataReference(a2ImmutableArray);

        for (int i = 0; i < a1ImmutableArray.Length; ++i)
        {
            output.Append(Unsafe.Add(ref item1, i));

            if (i < a2ImmutableArray.Length)
                output.Append(Unsafe.Add(ref item2, i));
        }

        return output.ToString();
    }

    [Benchmark]
    public string FasterMergeImmutableArraysWithStringBuilder()
    {
        StringBuilder output = new();

        ref string start1 = ref MemoryMarshal.GetArrayDataReference(a1ImmutableArray);
        ref string end1 = ref Unsafe.Add(ref start1, a1ImmutableArray.Length);

        ref string start2 = ref MemoryMarshal.GetArrayDataReference(a2ImmutableArray);
        ref string end2 = ref Unsafe.Add(ref start2, a2ImmutableArray.Length);

        while (Unsafe.IsAddressLessThan(ref start1, ref end1))
        {
            output.Append(start1);
            start1 = ref Unsafe.Add(ref start1, 1);

            if (Unsafe.IsAddressLessThan(ref start2, ref end2))
            {
                output.Append(start2);
                start2 = ref Unsafe.Add(ref start2, 1);
            }
        }

        return output.ToString();
    }
}

NOTE: I did my best to keep each solution as close to identical as possible to ensure a fair comparison.

I'll be interested to see if someone has a faster solution.

UPDATE

Here is one of the fastest benchmarks working with the OP's data:

C#

using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;

string[] a1ImmutableArray = { "a", "b", "c", "d" };
string[] a2ImmutableArray = { "1", "2", "3" };

StringBuilder output = new();

ref string start1 = ref MemoryMarshal.GetArrayDataReference(a1ImmutableArray);
ref string end1 = ref Unsafe.Add(ref start1, a1ImmutableArray.Length);

ref string start2 = ref MemoryMarshal.GetArrayDataReference(a2ImmutableArray);
ref string end2 = ref Unsafe.Add(ref start2, a2ImmutableArray.Length);

while (Unsafe.IsAddressLessThan(ref start1, ref end1))
{
    output.Append(start1);
    start1 = ref Unsafe.Add(ref start1, 1);

    if (Unsafe.IsAddressLessThan(ref start2, ref end2))
    {
        output.Append(start2);
        start2 = ref Unsafe.Add(ref start2, 1);
    }
}

Console.WriteLine(output.ToString());

Enjoy!

Posted 16-Jul-23 5:21am

Graeme_Grant

Updated 16-Jul-23 11:06am

v4

Comments

Richard MacCutchan 16-Jul-23 11:31am

Given what time of night it must be over there that is more than just excellent work. But I will need a lot of (day)time to read and understand it.

Graeme_Grant 16-Jul-23 11:42am

1:41am, it's early. Yep, there is a little bit there to unpack. All code tested with the OP's data to make sure that there are no invalid pointers.

Post the code into a new .Net 7 console app, add the BenchmarkDotNet Nuget package, and run.

Richard MacCutchan 16-Jul-23 12:21pm

Thanks, I may well give it a try.

Richard MacCutchan 17-Jul-23 5:42am

Well I tried that and it all worked straight off, very impressive. And that package certainly appears to be quite a useful one; something else fro me to learn all about.

Graeme_Grant 17-Jul-23 5:51am

Glad that you like it. Yeah, BenchmarkDotNet is handy.

Andre Oosthuizen 16-Jul-23 14:20pm

Same here, excellent work done, need to run through it though. I think, as per your remark, way over the head of the OP though, this is what code should be, not a "copy and paste - hope it works 5 lines of code" mash-up. With a 18.5% increased performance, wow...

Graeme_Grant 16-Jul-23 17:03pm

Thanks. The last 2 are very non-conventional but effective. Get either of them slightly wrong and you are in a world of pointer pain!

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Richard MacCutchan · Accepted Answer · 2023-07-15T10:23:00

Solution 1

Something like:

C#

StringBuilder output = new StrinBuilder();
for (int i = 0; i < a1.Count; ++i)
{
    output.Append(a1[i]);
    if (i < a2.Count)
    {
        output.Append(a2[i]);
    }
}
Console.WriteLine(output);

Also, note this will not produce the correct output if a2 contains more elements than a1. See Graeme's solution below for a sample that takes that into account.

Posted 15-Jul-23 10:23am

Richard MacCutchan

Updated 16-Jul-23 3:13am

v3

Comments

Graeme_Grant 16-Jul-23 8:47am

Just looked and Lists do not use Length, They use Count.

Richard MacCutchan 16-Jul-23 8:57am

Thanks, I didn't bother to check before I posted it; probably had my Java head on by mistake.

Graeme_Grant 16-Jul-23 9:37am

I did some benchmarking and found some interesting results. I'll post it as a new solution to avoid my original as it compares more than one method.

Graeme_Grant 16-Jul-23 11:22am

posted Solution #3

Graeme_Grant · Accepted Answer · 2023-07-15T13:28:00

Solution 2

Just for fun, I asked ChatGpt the following:

merge lists to create combined values in a new list using c#:
List<string> a1=new List<string>(){"a","b","c","d"};
List<string> a2=new List<string>(){"1","2","3"};
Output should be: a1b2c3d

The answer it gave was:

C#

List<string> a1 = new List<string>() { "a", "b", "c", "d" };
List<string> a2 = new List<string>() { "1", "2", "3" };
List<string> combinedList = new List<string>();

int maxLength = Math.Max(a1.Count, a2.Count);

for (int i = 0; i < maxLength; i++)
{
    if (i < a1.Count)
        combinedList.Add(a1[i]);

    if (i < a2.Count)
        combinedList.Add(a2[i]);
}

string result = string.Join("", combinedList);
Console.WriteLine(result); // Output: a1b2c3d

This is one time it gave a right answer. However, be warned, the output is as good as the input. Even then, it can still get it wrong (most of the time).

Posted 15-Jul-23 13:28pm

Graeme_Grant

Comments

Andre Oosthuizen 16-Jul-23 4:46am

It is a great tool if you have a general idea of what the code should look like or function as. I have noticed that if you hit it with a hammer a few turns it actually turns out very good code, hammering being questioning it a few times, try to compile the given example code, test it and then confirm.

I think the secret lies in the way or form it gets asked a question/given an instruction, the same as Googling. I have a 'Jack-Of-All-Trades' in different languages but a masters degree in Googling... :)

As a matter of interest I asked ChatGPT, using the above 2 solutions (yeah I know, a fully debatable subject on its own...) - Using C#, I have the following two blocks of code, which one will run - 1) the fastest. 2) use the least performance?. 3) be the most effiecent? Note: I did not do any tests myself based on the return, just for interest sake.

Return, I used Block1 as Graeme's code(ChatGPT), and Block2 as Richard's code -
Quote:Block 2 will run faster and use less performance compared to Block 1.

In Block 1, you are using a List<string> to combine the elements from two lists (a1 and a2) into a single list (combinedList). The code iterates over the length of the longer list (maxLength) and checks if the current index is within the bounds of each list before adding the element to the combinedList. Finally, it uses string.Join to concatenate the elements in combinedList into a single string.

In Block 2, you are using a StringBuilder (output) to build the combined string directly. The code iterates over the length of a1 and adds each element to the output. It also checks if the current index is within the bounds of a2 and adds its corresponding element. Finally, it prints the output using Console.WriteLine.

Block 2 is more efficient because it eliminates the need for an additional list (combinedList). It directly builds the string using StringBuilder, which is more efficient for concatenating multiple strings compared to repeatedly appending to a List<string>. Additionally, it does not involve the overhead of checking list bounds for every iteration, as it directly uses the lengths of a1 and a2 in the loop condition.

Just proof taht ChatGPT does not always return the best answer, you need to hammer it!!!

Graeme_Grant 16-Jul-23 7:17am

Yes, not optimal but that was not the exercise. If I wanted performant, I would have asked ChatGPT to use Spans. That would do better than StringBuilder and use less memory, and way too much for the OP. I also mentioned how hit and miss ChatGPT is, more miss than hit.

Richard MacCutchan 16-Jul-23 7:42am

I beat the AI system, ha ha!

Graeme_Grant 16-Jul-23 11:22am

See my new Solution #3 😉

Andre Oosthuizen 16-Jul-23 14:17pm

"I beat the AI system, ha ha!" LOL~