C# Two lists to one list, LinQ

Question

Hello,
I have two lists and need a list as result. Is there a way to solve this with LinQ?
If so, how?

My attempts, it would be better maybe to load it into a dictionary, but how?

HashSet<Tuple<string, bool>> hsResultList = new HashSet<Tuple<string, bool>>();  
  
 for (int side = 0; side <= 2; side++)   // Side 1 and Side 2  
 {  
  
 foreach (var sB in CurrentPanel.ListSides[(int)side - 1].Boards )  
 {  
 var qryAlreadyInside = hsResultList.Where(x => x.Item1.Contains(sB.Index)).FirstOrDefault();  
 if ( qryAlreadyInside  == null )  
 hsResultList.Add(new Tuple<string, bool>(sB.Index, sB.Badmark));  

If the status is false in one list, the entire status must be false in the merged dictionary.

var dicSide1 = CurrentPanel.ListSides[0].ListSingleBoards.ToDictionary(x => x.Index, v => v.State);  
var dicSide2 = CurrentPanel.ListSides[1].ListSingleBoards.ToDictionary(x => x.Index, v => v.State);  
var dicResultSide1Side2Badmarks = dicSide1.Union(dicSide2.Where(k => !dicSide1.ContainsKey(k.Key))).ToDictionary(k => k.Key, v => v.Value);  
  
int badBoards = dicResultSide1Side2Badmarks.Where(x => x.Value == false).Count();  
int goodBoards = dicResultSide1Side2Badmarks.Where(x => x.Value == true).Count();  

Answer 1

You can also consider this method, merge them, and then group them to determine whether there is false in each group:

        public static void Main()  
        {  
            List<A> list1 = new List<A>() {  
            new A(){ Index = 1, State = false },  
            new A(){ Index = 2, State = false },  
            new A(){ Index = 3, State = true },  
            new A(){ Index = 4, State = false },  
            new A(){ Index = 5, State = false },  
        };  
            List<A> list2 = new List<A>() {  
            new A(){ Index = 1, State = false },  
            new A(){ Index = 2, State = true },  
            new A(){ Index = 3, State = true },  
            new A(){ Index = 4, State = false },  
            new A(){ Index = 5, State = false },  
            new A(){ Index = 6, State = true },  
            new A(){ Index = 7, State = false },  
        };  
            var list = list1.Concat(list2);  
  
            var re = from a in list  
                     group a by a.Index into g  
                     select new  
                     {  
                         Key = g.Key,  
                         Value = g.Where(x => x.State == false).Count() > 0 ? false : true  
                     };  
            Dictionary<int, bool> dict1 = re.ToDictionary(x => x.Key, y => y.Value);  
        }  

---

If the response is helpful, please click "Accept Answer" and upvote it.
Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread.

Answer 2

My take on this with LINQ: https://dotnetfiddle.net/RlLMHU

Answer 3

I'd do something like this:

using System;
using System.Collections.Generic;
using System.Linq;

namespace scratch
{
    class Program
    {
        static void Main(string[] args)
        {
            var listOne = new List<bool> { true, false, true, false, true, false, true, true };
            var listTwo = new List<bool> { false, true, true };
            var result = Merge(listOne, listTwo);
        }

        static List<bool> Merge(List<bool> one, List<bool> two)
        {
            var longer = one.Count > two.Count ? one : two;
            var shorter = one.Count > two.Count ? two : one;
            return longer
                .Select((item, ix) => ix >= shorter.Count ? item : item && shorter[ix])
                .ToList();
        }
    }
}

The merge method takes in two lists. First it finds the longer of the two, and does a logical AND on the two values or just takes the remaining values.

I don't think there is much reason to load these into a Dictionary first since you can always get values out of a arrays by index in constant time.

An extra concise version might look like this:

static List<bool> Merge2(List<bool> one, List<bool> two)
{
    return Enumerable.Range(0, Math.Max(one.Count, two.Count))
        .Select(ix =>
            (ix >= one.Count || one[ix])
            &&
            (ix >= two.Count || two[ix]))
        .ToList();
}

It does the same as above - but is a one-liner.

Answer 4

May be something simple,

var list1 = new List<A>()
{
    new A(){ Index = 1, State = false },
    new A(){ Index = 2, State = false },
    new A(){ Index = 3, State = true },
    new A(){ Index = 4, State = false },
    new A(){ Index = 5, State = false },
};

var list2 = new List<A>()
{
    new A(){ Index = 1, State = false },
    new A(){ Index = 2, State = true },
    new A(){ Index = 3, State = false },
    new A(){ Index = 4, State = false },
    new A(){ Index = 5, State = false },
    new A(){ Index = 6, State = true },
    new A(){ Index = 7, State = false },
};

List<A> leftList = list2;
List<A> rightList = list1;
if (list1.Count > list2.Count)
{
    leftList = list1;
    rightList = list2;
}

IEnumerable<A> finalList = leftList
    .Select(x =>
    {
        var matchingState = rightList.SingleOrDefault(y => y.Index == x.Index)?.State;
        var finalState = matchingState == null ? x.State : matchingState.Value && x.State;

        return new A
        {
            Index = x.Index,
            State = finalState
        };
    });

Output:

1 False
2 False
3 False
4 False
5 False
6 True
7 False

Answer 5

Another option:

using System;
using System.Collections.Generic;
using System.Linq;
using Newtonsoft.Json;

public class Program
{
    public static void Main()
    {
        var first = new List<Item>{new Item(1,false), new Item(2, false), new Item(3,true), new Item(4,false), new Item(5,false)};
        var second = new List<Item>{new Item(1,false), new Item(2,true), new Item(3,false), new Item(4,false), new Item(5,false), new Item(6,true), new Item(7,false)};

        // Pure LINQ
        var result = second.Zip(first, (firstItem, secondItem) => new Item(firstItem.Index,  firstItem.State && secondItem.State)).Concat(second.Skip(first.Count));

        Console.WriteLine(JsonConvert.SerializeObject(result));
    }

    private record Item(int Index, bool State);
}