Linq - Exercise 1

Linq To Object - Exercise 1

/*  
 * Replace every 'TODO' * comment with the appropriate code to pass the tests * AND fulfill the requirements in the comments. * For all your code, don't use any loops, but Linq only to complete the tasks. */  
// Create a set of elements first holding 1.000 objects of type Person.  
// The IDs range from 0 to 999 and the items are shuffled.  
var elements = Enumerable.Range(0, 1_000)  
    .OrderBy(n => Random.Shared.Next())  
    .Select(n => new Person { Id = n })  
    .ToList();  
  
// Find the highest ID  
int id = default;  
// TODO  
Assert("Find highest ID", id == 999);  
  
// Find the element with the highest ID by choosing the element with the ID selected above  
Person person = new Person();  
// TODO  
Assert("Find element with highest ID", person.Id == 999);  
  
// Find the element with the highest ID by using the MaxBy method  
Person person2 = new Person();  
// TODO  
Assert("Find element with highest ID with MaxBy", person2.Id == 999);  
  
// Find the element with the highest ID by using the Aggregate method  
Person person3 = new Person();  
// TODO  
Assert("Find element with highest ID with Aggregate", person3.Id == 999);  
  
// Group elements by even/odd IDs  
IEnumerable<Person> peopleWithEvenIds = Enumerable.Empty<Person>();  
IEnumerable<Person> peopleWithOddIds = Enumerable.Empty<Person>();  
// TODO  
Assert("Group even/odd elements", peopleWithEvenIds.Count() == peopleWithOddIds.Count() && peopleWithEvenIds.Any());  
  
// Let's create a second set of elements of type Person.  
// This time the IDs range from 500 to 1.499,  
// meaning the list overlaps with the first set of people.  
var elements2 = Enumerable.Range(500, 1_000)  
    .OrderBy(n => Random.Shared.Next())  
    .Select(n => new Person { Id = n })  
    .ToList();  
  
// Find intersection of elements and elements2 via their IDs  
IEnumerable<Person> intersection = Enumerable.Empty<Person>();  
// TODO  
Assert("Find intersection",  
    intersection.Count() == 500  
    && intersection.Min(p => p.Id) == 500  
    && intersection.Max(p => p.Id) == 999);  
  
// Find union of elements and elements2 via their IDs, removing duplicates  
IEnumerable<Person> personUnion = Enumerable.Empty<Person>();  
// TODO  
Assert("Find union",  
    personUnion.Count() == 1_500  
    && personUnion.DistinctBy(p => p.Id).Count() == 1_500);  
  
// Let's create another set of elements.  
// This time it's objects of type Items.  
// A Person can own an Item. If so the Item's OwnerId will be equal to the Owner's ID.  
var items = Enumerable.Range(0, 1_500_000)  
    .Select(n => new Item   
{   
Id = n,   
OwnerId = Random.Shared.Next(1_499)   
    })  
    .ToList();  
  
// Make sure that every owner ID in items is an existing ID in the union of elements and elements2  
var condition = false /*TODO*/;  
Assert("Verify OwnerIds exist",   
    condition);  
  
// Join Items with their owners using a Linq Query Expression (from ... in ... join ...)  
IEnumerable<ItemMapping> itemMappings1 = Enumerable.Empty<ItemMapping>();  
// TODO  
Assert("Join tables with Linq Query Expression", itemMappings1.Count() == 1_500);  
  
// Join Items with their owners using Linq with Lambda Expressions  
IEnumerable<ItemMapping> itemMappings2 = Enumerable.Empty<ItemMapping>();  
// TODO  
Assert("Join tables with Lambda Expressions", itemMappings2.Count() == 1_500);  
  
// Make sure both approaches yield the same result  
Assert("Verify Join approaches yield same result", false /* TODO */);  
  
// Make sure the results are correct,  
// meaning an ItemMapping should only contain items  
// where the OwnerId matches the owner inside the same mapping.  
Assert("Verify Join yields correct result", false /* TODO */);  
  
// Use SelectMany to select all items from the itemMappings1 into one Enumerable  
IEnumerable<Item> selectedItemsFromMappings = Enumerable.Empty<Item>();  
// TODO  
Assert("Use select many to flatten results", selectedItemsFromMappings.DistinctBy(i => i.Id).Count() == 1_500_000);  
  
  
  
var families = new List<Family>  
{  
    new Family  
    {  
        ClanName = "Mighty Maniacs",  
        MonthlyIncome = new List<decimal>  
        {            10,  
            20  
        }  
    },    new Family  
    {  
        ClanName = "Humble Humans",  
        MonthlyIncome = new List<decimal>  
        {            50,  
            70  
        }  
    }};  
  
decimal result = families  
    .Where(f => f.ClanName.Contains("Humans"))  
    .Select(f => f.MonthlyIncome.Sum())  
    .Average();  
  
decimal result2 = families  
    .Where(f => f.ClanName.Contains("Humans"))  
    .Average(f => f.MonthlyIncome.Sum());  
  
  
////////////////////////////////////////////////////  
/// Predefined Methods and classes.  
/// Do not change!  
////////////////////////////////////////////////////  
static void Assert(string description, bool condition)  
{  
    if (condition)  
    {        Console.WriteLine($"PASSED - {description}");  
    }    else  
    {  
        Console.Error.WriteLine($"FAIL - {description}");  
    }}  
class Person  
{  
    public int Id { get; set; }  
    public string Name { get => $"Person {Id}"; }  
}  
class Family  
{  
    public string ClanName { get; set; }  
    public IEnumerable<decimal> MonthlyIncome { get; set; }  
}  
  
class FamilyMember  
{  
    public string Name { get; set; }  
}  
  
class Item  
{  
    public int Id { get; set; }  
    public string Name { get => $"Item {Id}"; }  
    public int OwnerId { get; set; }  
}  
  
class ItemMapping  
{  
    public Person Owner { get; set; }  
    public IList<Item> Items { get; set; }  
}