Пример #1
0
        static void Main()
        {
            Animal max = new Dog("Max", 3, Gender.Male);
            Animal duke = new Dog("Duke", 1, Gender.Male);
            Animal fluffy = new Dog("Fluffy", 6, Gender.Male);
            Animal wink = new Dog("Wink", 3, Gender.Male);
            Animal abby = new Frog("Abby", 1, Gender.Female);
            Animal boogy = new Frog("Boogy", 2, Gender.Male);
            Animal pookie = new Frog("Pookie", 6, Gender.Female);
            Animal hermit = new Frog("Hermit", 2, Gender.Male);
            Animal abbey = new Kitten("Abbey", 1, Gender.Female);
            Animal panda = new Kitten("Panda", 1, Gender.Female);
            Animal ravi = new Tomcat("Ravi", 3, Gender.Male);
            Animal lexus = new Tomcat("Lexus", 9, Gender.Male);
            Animal biggie = new Cat("Biggie", 7, Gender.Male);
            Animal fig = new Cat("Fig", 7, Gender.Male);

            Animal[] animals = new Animal[] { max, duke, fluffy, wink, abby, boogy, pookie, hermit, abbey, panda, ravi, lexus, biggie, fig };

            var groupedAnimals =
                from an in animals
                group an by new { GroupName = an.GetType().Name } into grp
                select new
                {
                    GroupName = grp.Key.GroupName,
                    AverageAge = grp.Average(an => an.Age)
                };

            foreach (var animal in groupedAnimals)
            {
                Console.WriteLine("Group: {0} | Average Age: {1:F2}", animal.GroupName, animal.AverageAge);
            }
        }
Пример #2
0
        static void Main()
        {
            Animal[] animals = new Animal[10]
            {   new Cat("Pesho", 2, "male"),
                new Kitten("Penka", 3),
                new Tomcat("Gosho", 1),
                new Frog("Mitko", 3, "male"),
                new Dog("Goran", 2, "male"),
                new Dog("Dimitrichka", 2, "female"),
                new Cat("Ani", 1, "female"),
                new Frog("Geri", 4, "female"),
                new Tomcat("Pesho", 5),
                new Kitten("Marta", 6) };

            animals.ToList().ForEach(Console.WriteLine);
            Console.WriteLine();

            animals
                .GroupBy(animal => animal.GetType().Name)
                .Select(group => new
                {
                    AnimalName = group.Key,
                    AverageAge = group.Average(a => a.Age)
                })
                .OrderByDescending(group => group.AverageAge)
                .ToList()
                .ForEach(group => Console.WriteLine("{0}'s average age is: {1}", group.AnimalName, group.AverageAge));
        }
Пример #3
0
        static void Main()
        {
            var scooby = new Dog("Scooby", 2, 'm');
            var frogy = new Frog("Frogy", 0.5, 'm');
            var tommy = new Cat("Tommy", 1, 'm');
            var kitty = new Kitten("Kitty", 0.8, 'f');
            var speedy = new Tomcat("Speedy", 1.5, 'f');
            var spark = new Dog("Spark", 3, 'm');
            var carmit = new Frog("Carmit", 1, 'm');
            var jenny = new Kitten("Jenny", 1.2, 'f');

            var animals = new Animal[] { scooby, spark, frogy, tommy, kitty, speedy };
            var differentAnimals = new Animal[] { tommy, kitty, carmit, jenny };

            foreach (var animal in animals)
            {
                Console.Write(animal);
                animal.ProduceSound();
                Console.WriteLine();
            }

            var groupedAnimals =
                from anim in animals
                group anim by (anim is Cat) ? typeof (Cat) : anim.GetType()
                into g
                select new {GroupName = g.Key, AverageAge = g.ToList().Average(an => an.Age)};

            foreach (var animal in groupedAnimals)
            {
                Console.WriteLine("{0} - average age: {1:N2}", animal.GroupName.Name, animal.AverageAge);
            }
        }
Пример #4
0
        static void Main(string[] args)
        {
            Animal[] animals = new Animal[10]
            {
                new Cat("Ivanka", 10, "Female"),
                new Dog("Doge",12,"Male"),
                new Frog("Jabcho",15,"Male"),
                new Kitten("Gergina",8),
                new Tomcat("Goshko",6),
                new Cat("Dragan",1,"Male"),
                new Dog("Dogina",4,"Female"),
                new Frog("Jabka",9,"Female"),
                new Kitten("Dora",19),
                new Tomcat("Tom", 20)
            };
            animals.ToList().ForEach(Console.WriteLine);
            Console.ReadKey();

            animals.GroupBy(animal => animal.GetType().Name).Select(group => new
            {
                AnimalName = group.Key,
                AverageAge = group.Average(age => age.Age)
            })
                .OrderBy(group => group.AverageAge)
                .ToList()
                .ForEach(group => Console.WriteLine($"{group.AnimalName}'s average age is: {group.AverageAge}"));
        }
Пример #5
0
 public static void Print(Animal[] animals)
 {
     foreach (var animal in animals)
     {
         Console.WriteLine(animal);
     }
 }
Пример #6
0
        static void Main(string[] args)
        {
            Dog Sharo = new Dog(10, "Sharo", Sex.Male, "bao lau");
            Console.WriteLine(Sharo);
            Animal[] Animals = new Animal[] {

            new Tomcat(15, "Маци", "miau"),
            new Tomcat(11, "Котан", "miau miau"),
            new Tomcat(1, "Джери", "bau miau"),

            };

            Cat[] cats = new Cat[]
            {
            new PussyCat(1, "Мац", "bau miau"),
            new Tomcat(2, "Тим", "bau miau"),

            };

            Console.WriteLine("# Animals");
            foreach (Animal animal in Animals)
                Console.WriteLine(animal);

            Console.WriteLine("# Average");
            Console.WriteLine(Animals.Average(animal => animal.age));
            Console.WriteLine(cats.Average(cat => cat.age));
        }
        static void Main()
        {
            // create some animals from each class and print them
            Dog dog = new Dog("Sharo", 3, Gender.Male);
            Console.WriteLine(dog);
            dog.FetchStick();

            Console.WriteLine();

            Frog frog = new Frog("Kermit", 33, Gender.Male);
            Console.WriteLine(frog);
            frog.Jump();

            Console.WriteLine();

            Kitten kitty = new Kitten("Kitty", 1);
            Console.WriteLine(kitty);
            kitty.Cry();

            Console.WriteLine();

            Tomcat tomcat = new Tomcat("Tom", 12);
            Console.WriteLine(tomcat);
            tomcat.Piss();

            Console.WriteLine();

            // create an array of Animals
            Animal[] animals = new Animal[]
            {
                new Dog("Rex",3, Gender.Male),
                new Frog("Kekerica", 1, Gender.Female),
                new Kitten("Pisi", 1),
                new Tomcat("Tom",2),
                new Dog("Erik", 4, Gender.Male),
                new Frog("Penka", 1, Gender.Female),
                new Kitten("Jasmin", 2),
                new Tomcat("Kolio",6),
                new Dog("Bender",2, Gender.Male),
                new Frog("Ginka", 6, Gender.Female),
                new Kitten("Tedy", 1),
                new Tomcat("Muncho",4),
            };

            // calculate the aveage age of each animal and print them 
            var averageAge =
                from an in animals
                group an by new { GroupName = an.GetType().Name } into gr
                select new
                {
                    GroupName = gr.Key.GroupName,
                    AvarageAge = gr.Average(an => an.Age)
                };

            foreach (var animal in averageAge)
            {
                Console.WriteLine(String.Format("Group: {0}, AvarageAge: {1:0.00}.", animal.GroupName, animal.AvarageAge));
            }
        }
Пример #8
0
 public static double AverageAge(Animal[] animals)
 {
     double ages = 0;
     for (int i = 0; i < animals.Length; i++)
     {
         ages += animals[i].Age;
     }
     return ages / animals.Length;
 }
Пример #9
0
 public static double Average(Animal[] array)
 {
     double sum = 0;
     for (int i = 0; i < array.Length; i++)
     {
         sum = sum + array[i].Age;
     }
     return sum / array.Length;
 }
        private static IEnumerable<Tuple<string, double>> GetAverageAges(Animal[] animals)
        {
            var averageAges =
                from animal in animals
                group animal by animal.GetType() into animalType
                select new Tuple<string, double>(animalType.Key.Name, animalType.Average(a => a.Age));

            return averageAges;
        }
        static void Main()
        {
            // Attention! - No animals were harmed during these tests

            Console.Title = "Animals";

            var dog = new Dog("Gosho", 3, Gender.Male);
            Console.WriteLine(dog);
            dog.FetchStick();
            Console.Write(Environment.NewLine);

            var frog = new Frog("Masha", 16, Gender.Female);
            Console.WriteLine(frog);
            frog.Transform();
            Console.Write(Environment.NewLine);

            var kitty = new Kitten("Maca", 0);
            Console.WriteLine(kitty);
            kitty.MeltYourHeart();
            Console.Write(Environment.NewLine);

            var tomcat = new Tomcat("Tom", 4);
            Console.WriteLine(tomcat);
            tomcat.Piss();
            Console.Write(Environment.NewLine);

            var animals = new Animal[]
            {
                new Dog("Freya", 1, Gender.Female),
                new Dog("Sharo", 4, Gender.Male),
                new Frog("Penka", 20, Gender.Female),
                new Frog("Fred", 32, Gender.Male),
                new Kitten("Merlin", 1),
                new Kitten("Shusia", 0),
                new Tomcat("Felix",6),
                new Tomcat("Silvester", 5),
            };

            var averageAge = from an in animals
                group an by new
                {
                    GroupName = an.GetType().Name
                }
                into gender select new
                {
                    gender.Key.GroupName,
                    AvarageAge = gender.Average(an => an.Age)
                };

            foreach (var animal in averageAge)
            {
                Console.WriteLine(String.Format("Group: {0}, AvarageAge: {1:0.00}.", animal.GroupName, animal.AvarageAge));
            }

            // And what does the Fox say? Oh, no foxes here...
        }
Пример #12
0
        public static double Average(Animal[] animal)
        {
            double sum = 0;
            foreach (var an in animal)
            {
                sum += an.Age;
            }

            return sum / animal.Length;
        }
Пример #13
0
 static double AverageAge(Animal[] animls)
 {
     double overalAge = 0;
     int count = 0;
     foreach (var animal in animls)
     {
         count++;
         overalAge = overalAge + animal.Age;
     }
     return overalAge / count;
 }
Пример #14
0
        static double AverageAge(Animal[] animalList)
        {
            double average = 0;

            foreach (var animal in animalList)
            {
                average += animal.Age;
                //average = average + animal.Age;
            }

            return average / animalList.Length;
        }
Пример #15
0
        static void Main()
        {
            Animal[] dogArray = new Animal[5];
            dogArray[0] = new Dog("Sharo", 4, "male");
            dogArray[1] = new Dog("Rex", 1, "male");
            dogArray[2] = new Dog("Lasi", 10, "male");
            dogArray[3] = new Dog("Djinka", 3, "female");
            dogArray[4] = new Dog("Princess", 2, "female");

            foreach (var animal in dogArray)
            {
                Console.WriteLine(animal);
            }

            var dogArrayAvg = dogArray.Average(d => d.Age);
            Console.WriteLine("Average dog age: {0:F2}{1}",dogArrayAvg, Environment.NewLine);
            Console.WriteLine();


            Cat[] catArray = new Cat[5];
            catArray[0] = new Kitten("Mici", 3);
            catArray[1] = new Tomcat("Tom", 5);
            catArray[2] = new Kitten("Grozdanka", 2);
            catArray[3] = new Tomcat("Grozdan", 10);
            catArray[4] = new Kitten("Micana", 7);

            foreach (var cat in catArray)
            {
                Console.WriteLine(cat);
            }

            var catArrayAvg = catArray.Average(c => c.Age);
            Console.WriteLine("Average cat age: {0:F2}{1}",catArrayAvg, Environment.NewLine);
            Console.WriteLine();


            Frog[] frogArray = new Frog[5];
            frogArray[0] = new Frog("Kyrmit", 4, "male");
            frogArray[1] = new Frog("Kyrmita", 2, "female");
            frogArray[2] = new Frog("Kyrmin", 6, "male");
            frogArray[3] = new Frog("Kyrmina", 3, "female");
            frogArray[4] = new Frog("Kyrtin", 8, "male");

            foreach (var frog in frogArray)
            {
                Console.WriteLine(frog);
            }

            var frogArrayAvg = frogArray.Average(f => f.Age);
            Console.WriteLine("Average frog age: {0:F2}{1}", frogArrayAvg, Environment.NewLine);
            Console.WriteLine();
        }
Пример #16
0
 public static string GetAnimalKind(Animal animal)
 {
     string kind = "";
     if (animal.GetType().BaseType.Name == "Animal")
     {
         kind = animal.GetType().Name;
     }
     else
     {
         kind = animal.GetType().BaseType.Name;
     }
     return kind;
 }
        static void Main(string[] args)
        {
            Dog[] dogs = { new Dog("Dog1", 1, 'm'),
                         new Dog("Dog2", 4, 'f'),
                         new Dog("Dog3", 2, 'f')};

            Cat[] cats = { new Cat("Cat1", 6, 'f'),
                         new Kitten("Cat2", 3),
                         new Tomcat("Cat3", 2)};

            Frog[] frogs = { new Frog("Frog1", 1, 'm'),
                         new Frog("Frog2", 3, 'f'),
                         new Frog("Frog3", 2, 'm')};

            Animal[] animals = new Animal[dogs.Length + cats.Length + frogs.Length];
            int ind = 0;

            foreach (Dog dog in dogs)
            {
                Console.Write("{0} and I say: ", dog.Introduce());
                dog.ProduceSound();
                animals[ind] = dog;
                ind++;
            }

            foreach (Cat cat in cats)
            {
                Console.Write("{0} and I say: ", cat.Introduce());
                cat.ProduceSound();
                animals[ind] = cat;
                ind++;
            }

            foreach (Frog frog in frogs)
            {
                Console.Write("{0} and I say: ", frog.Introduce());
                frog.ProduceSound();
                animals[ind] = frog;
                ind++;
            }

            Console.WriteLine("The Average Age of the dogs is: {0:0.00}", Animal.AverageAge(dogs));
            Console.WriteLine("The Average Age of the cats is: {0:0.00}", Animal.AverageAge(cats));
            Console.WriteLine("The Average Age of the frogs is: {0:0.00}", Animal.AverageAge(frogs));
            Console.WriteLine("The Average Age of the animals is: {0:0.00}", Animal.AverageAge(animals));
        }
Пример #18
0
 static void Main()
 {
     var animals = new Animal[]
     {
         new Dog("Miro", 2, "male"),
         new Dog("Laila", 5, "female"),
         new Cat("Kotka", 3, "male"),
         new Cat("Murla", 7, "female"),
         new Frog("Kraker", 4, "male"),
         new Frog("Angelica", 6, "female"),
         new Tomcat("Tom", 1),
         new Tomcat("Frank", 1),
         new Kitten("Sashka", 1),
         new Kitten("Igrivka", 1)
     };
     int totalAnimalAge = 0;
     foreach (var animal in animals.OfType<Dog>())
     {
         totalAnimalAge += animal.Age;
     }
     Console.WriteLine("Average age of animals of type Dog is " + (totalAnimalAge / 2));
     totalAnimalAge = 0;
     foreach (var animal in animals.OfType<Cat>())
     {
         totalAnimalAge += animal.Age;
     }
     Console.WriteLine("Average age of animals of type Cat is " + ((totalAnimalAge - 4) / 2));
     totalAnimalAge = 0;
     foreach (var animal in animals.OfType<Frog>())
     {
         totalAnimalAge += animal.Age;
     }
     Console.WriteLine("Average age of animals of type Frog is " + (totalAnimalAge / 2));
     totalAnimalAge = 0;
     foreach (var animal in animals.OfType<Tomcat>())
     {
         totalAnimalAge += animal.Age;
     }
     Console.WriteLine("Average age of animals of type Tomcat is " + (totalAnimalAge / 2));
     totalAnimalAge = 0;
     foreach (var animal in animals.OfType<Kitten>())
     {
         totalAnimalAge += animal.Age;
     }
     Console.WriteLine("Average age of animals of type Kitten is " + (totalAnimalAge / 2));
 }
Пример #19
0
        public static void Main()
        {
            // Create couple of different Animals and add to array
            var animals = new Animal[9]
            { 
                new Dog("Sharo", 10, Gender.Male),
                new Dog("Baro", 4, Gender.Male),
                new Dog("Ceca", 5, Gender.Female),
                new Dog("Tochka", 7,  Gender.Female),
                new Frog("Kvaki", 54, Gender.Female),
                new Frog("To", 9, Gender.Male),
                new Kitten("Tomka", 2),
                new Tomcat("Tom", 10),
                new Tomcat("Slon", 12)
            };

            // Print the average age per Animal type using LINQ 
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("Average age calculation using method based on LINQ");
            Console.ForegroundColor = ConsoleColor.White;
            foreach (var animal in AverageAgeLinq(animals))
            {
                Console.WriteLine("Average age for {0}s is: {1}", animal.Key, animal.Value);
            }

            // Print the average age per Animal type using Extension methods
            Console.WriteLine();
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("Average age calculation using method based on extension methods");
            Console.ForegroundColor = ConsoleColor.White;
            foreach (var animal in AverageAgeExt(animals))
            {
                Console.WriteLine("Average age for {0}s is: {1}", animal.Key, animal.Value);
            }

            // Print the average age per Animal type using normal C# language methods
            Console.WriteLine();
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("Average age calculation using method based on C# language methods/operators");
            Console.ForegroundColor = ConsoleColor.White;
            foreach (var animal in AverageAge(animals))
            {
                Console.WriteLine("Average age for {0}s is: {1}", animal.Key, animal.Value);
            }
        }
Пример #20
0
        static void Main(string[] args)
        {
            Animal[] animals = new Animal[5];
            animals[0]=new Cat("Mac",10,Gender.Male);
            animals[1]=new Kitten("Max",2);
            animals[2]=new Kitten("Missi",1);
            animals[3]=new Frog("Kermit",3,Gender.Male);
            animals[4]=new Frog("Tom",5,Gender.Male);
            animals.ToList();

            foreach (var animal in animals)
            {
                Console.WriteLine(animal);
                animal.ProduceSoun();
            }

             animals.GroupBy(t=>t.GetType().Name)
                .Select(group=>new {AnimalName=group.Key,AvarageAge=group.Average(a=>a.Age)})
                .ToList()
                .ForEach(group=>Console.WriteLine("{0}{1}",group.AnimalName,group.AvarageAge));
        }
Пример #21
0
        static void Main()
        {
            Tomcat tom = new Tomcat("Tom", 12);
            Console.WriteLine(tom);
            Kitten kitty = new Kitten("Kitty", 3);
            Console.WriteLine(kitty);
            Console.WriteLine();

            List<ISound> listAnimals = new List<ISound>();
            listAnimals.Add(new Cat("Pepi", 3, "female"));
            listAnimals.Add(new Frog("Kurmit", 10, "male"));
            listAnimals.Add(new Dog("Sharo", 5, "male"));
            listAnimals.Add(new Cat("Jorko", 6, "male"));
            listAnimals.Add(new Dog("Balkan", 10, "male"));
            listAnimals.Add(kitty);
            listAnimals.Add(tom);
            foreach (var animal in listAnimals)
            {
                Console.WriteLine(animal + " " + animal.MakeSound());
            }

            Console.WriteLine();

            Animal[] animals = new Animal[]
            {
                new Cat("Pepi", 3, "female"),
                new Frog("Kurmit", 10, "male"),
                new Dog("Sharo", 5, "male"),
                new Cat("Jorko", 6, "male"),
                new Cat("Tom",12,"male")
            };

               Console.WriteLine(Animal.GetAvaregeAge(animals));

               var ages =
               (from animal in animals
                where animal.GetType() == typeof(Cat)
                select animal.age).Average();
               Console.WriteLine(ages);
        }
Пример #22
0
        static void Main()
        {
            var animals = new Animal[]
            {
                new Dog("Belcho", 13, Gender.Male),
                new Cat("Buzlio", 9, Gender.Female),
                new Frog("Fizz", 1, Gender.Male),
                new Kitten("Darcy", 5),
                new Tomcat("Tommy", 3)
            };

            animals.ToList().ForEach(Console.WriteLine);
            Console.WriteLine();

            var animalsBygroups = animals.GroupBy(GetAnimalKind,
                (g, a) => new { kind = g, averagAge = a.Average(animal => animal.Age) });

            foreach (var animalGroup in animalsBygroups)
            {
                Console.WriteLine("The average age of {0}s is {1:f2} years.", animalGroup.kind, animalGroup.averagAge);
            }
        }
        static void Main(string[] args)
        {
            var noisyCreatures = new ISound[]
            {
            new Dog(5, "Rex", "male"),
            new Frog(49, "Kermit", "male"),
            new Dog(15, "Stella", "female"),
            new Tomcat(8, "Hoho"),
            new Kitten(5, "Cleopatra"),
            new Dog(3, "Ceaser", "male"),
            new Kitten(6, "Joro"),
            new Tomcat(7, "Borko"),
            new Dog(13,"Sharo", "male")
            };
            var animals = new Animal[]
            {
            new Dog(5, "Rex", "male"),
            new Frog(49, "Kermit", "male"),
            new Dog(15, "Stella", "female"),
            new Tomcat(8, "Hoho"),
            new Kitten(5, "Cleopatra"),
            new Dog(3, "Ceaser", "male"),
            new Kitten(6, "Joro"),
            new Tomcat(7, "Borko"),
            new Dog(13,"Sharo", "male")
            };

            foreach (var noisyCreature in noisyCreatures)
            {
                noisyCreature.MakeSound();
            }

            var averageAges = GetAverageAges(animals);
            foreach (var item in averageAges)
            {
                Console.WriteLine(item.Item1 + " " + item.Item2);
            }
        }
Пример #24
0
        static void Main()
        {
            Animal[] animals = new Animal[10]
            {
                new Dog("Sharo",12,true),
                new Dog("Rex",10,true),
                new Cat("Puffy",8,false),
                new Cat("Tom",5,true),
                new Frog("Jaba",3,true),
                new Frog("Princes-Frog",22,false),
                new Tomcat("Garfield",13),
                new Tomcat("Gaspar",9),
                new Kitten("Shely",7),
                new Kitten("Cherry",9)
            };

            //foreach (var item in animals)
            //{
            //    item.ProduceSound();
            //}

            //animals.ToList().ForEach(Console.WriteLine);
            //Console.WriteLine();

            animals
                .GroupBy(animal => animal.GetType().Name)
                .Select(group => new
                {
                    AnimalName = group.Key,
                    AverageAge = group.Average(a => a.Age)
                }
                )
                .OrderBy(group => group.AverageAge)
                .ToList()
                .ForEach(group => Console.WriteLine("{0}'s average age is: {1}",group.AnimalName,group.AverageAge));
        }
Пример #25
0
 public static double AverageAge(Animal[] list)
 {
     return list.Average(animal => animal.Age);
 }
Пример #26
0
        static void Main(string[] args)
        {
            Dog dog = new Dog("Pesho", 3, Gender.Male);
            Console.WriteLine(dog);
            dog.FetchStick();

            Console.WriteLine();

            Frog frog = new Frog("Peter", 33, Gender.Male);
            Console.WriteLine(frog);
            frog.Jump();

            Console.WriteLine();

            Kitten kitty = new Kitten("Ioio", 1);
            Console.WriteLine(kitty);
            kitty.Cry();

            Console.WriteLine();

            Tomcat tomcat = new Tomcat("Gogo", 12);
            Console.WriteLine(tomcat);
            tomcat.Piss();

            Console.WriteLine();

            // create an array of Animals
            Animal[] animals = new Animal[]
            {
                new Dog("Ares",3, Gender.Male),
                new Frog("Mitko", 1, Gender.Female),
                new Kitten("Mac", 1),
                new Tomcat("Cotka",2),
                new Dog("Saires", 4, Gender.Male),
                new Frog("Stilian", 1, Gender.Female),
                new Kitten("Ioio", 2),
                new Tomcat("Antony",6),
                new Dog("Roy",2, Gender.Male),
                new Frog("Angelina", 6, Gender.Female),
                new Kitten("Alex", 1),
                new Tomcat("Mecjo",4),
            };

            // calculate the aveage age of each animal and print them 
            var averageAge =
                from an in animals
                group an by new { GroupName = an.GetType().Name } into gr
                select new
                {
                    GroupName = gr.Key.GroupName,
                    AvarageAge = gr.Average(an => an.Age)
                };

            foreach (var animal in averageAge)
            {
                Console.WriteLine(String.Format("Group: {0}, AvarageAge: {1:0.00}.", animal.GroupName, animal.AvarageAge));
            }
        }
Пример #27
0
 static IEnumerable AverageAgeByKind(Animal[] arrAnimals)
 {
     return arrAnimals.GroupBy(a => a.GetType().Name).Select(k => new { AnimalType = k.Key, AverageAge = k.Average(a => a.Age)});
 }
Пример #28
0
 public static double AverageAge(Animal[] animalsArr)
 {
     return animalsArr.Average(x => x.Age);
 }
Пример #29
0
 public void attack(Animal animal)
 {
 }
 public static double AverageAge(Animal[] animals)
 {
     return animals.Average(animal => animal.Age);
 }