2. félév 1. óra (otthon)

namespace ZooApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //Cage[] cages = new Cage[5];

            //cages[0] = new Cage(5);
            //cages[0].Add(new Animal("Kormos", true, 20, Species.Dog));
            //cages[0].Add(new Animal("Mici", false, 320, Species.Panda));
            //cages[0].Add(new Animal("Kajás", true, 40, Species.Dog));
            //cages[0].Add(new Animal("Killer", true, 3, Species.Dog));
            //cages[0].Add(new Animal("Kaller", true, 5, Species.Dog));

            //cages[1] = new Cage(3);
            //cages[1].Add(new Animal("Nóri", false, 4, Species.Rabbit));
            //cages[1].Add(new Animal("Marcsi", false, 320, Species.Panda));
            //cages[1].Add(new Animal("Nándi", true, 4, Species.Rabbit));

            //cages[2] = new Cage(5);
            //cages[2].Add(new Animal("Kolbász", true, 40, Species.Dog));
            //cages[2].Add(new Animal("Kati", false, 13, Species.Dog));
            //cages[2].Add(new Animal("Karesz", true, 15, Species.Dog));

            //cages[3] = new Cage(5);
            //cages[3].Add(new Animal("Nindzsa", true, 2, Species.Rabbit));
            //cages[3].Add(new Animal("Nyami", false, 12, Species.Rabbit));
            //cages[3].Add(new Animal("Kicsi", false, 10, Species.Dog));
            //cages[3].Add(new Animal("Norbi", true, 5, Species.Rabbit));
            //cages[3].Add(new Animal("Krumpli", true, 10, Species.Dog));

            //Console.WriteLine("4.ben nyulak db: " + cages[3].Count(Species.Rabbit));
            //Console.WriteLine("2.ban hím panda: " + (cages[1].DoesExist(Species.Panda, true) ? "van" : "nincs"));

            //Animal[] dogsInFirstCage = cages[0].CollectAll(Species.Dog);
            //foreach (Animal currentAnimal in dogsInFirstCage)
            //{
            //    if (currentAnimal == null)
            //        break;

            //    Console.WriteLine(currentAnimal.Name);
            //}

            //Console.WriteLine("1.ben kutyák avg tömege: " + cages[0].AverageWeight(Species.Dog));

            //Console.WriteLine("4.ben azonos faj, különböző nem: " + (cages[3].DoesExistSameSpeciesOppositeSex() ? "van" : "nincs"));

            ////Cage mostDogsCage = MaxCageWith(cages, Species.Dog);
            ////Console.WriteLine(mostDogsCage.ToString());

            //Animal newAnimal = Animal.Parse("Kormos,male,20,Dog");


            //Cage newCage = Cage.CreateFrom("./files/cage1.txt");
            //Console.WriteLine(newCage.ToString());

            Cage[] cages = LoadCages(args[0]);
        }

        static Cage[] LoadCages(string path)
        {
            string[] fileNames = Directory.GetFiles(path, "*.txt");

            Cage[] result = new Cage[fileNames.Length];
            for (int i = 0; i < fileNames.Length; i++)
            {
                result[i] = Cage.CreateFrom(fileNames[i]);
            }

            return result;
        }

        static int Count(Animal[] animals)
        {
            int count = 0;

            foreach (Animal currentAnimal in animals)
            {
                if (currentAnimal == null) break;

                count++;
            }

            return count;
        }

        static Cage MaxCageWith(Cage[] cages, Species species)
        {
            if (cages.Length == 0) return null;

            int maxIndex = 0;
            int maxValue = Count(cages[0].CollectAll(species));

            for (int i = 1; i < cages.Length; i++)
            {
                int currentValue = Count(cages[i].CollectAll(species));
                if (currentValue > maxValue)
                {
                    maxIndex = i;
                    maxValue = currentValue;
                }
            }

            return cages[maxIndex];
        }
    }
}

---------------------------------------
Osztályok
---------------------------------------

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ZooApp
{
    enum Species
    {
        Dog,
        Panda,
        Rabbit
    }

    internal class Animal
    {
        string name;
        bool isMale;
        int weight;
        Species species;

        public string Name => name;
        public bool IsMale => isMale;

        public int Weight => weight;
        public Species Species => species;

        Animal() {}

        public Animal(string name, bool isMale, int weight, Species species)
        {
            this.name = name;
            this.isMale = isMale;
            this.weight = weight;
            this.species = species;
        }

        private string SpeciesToString()
        {
            switch (species)
            {
                case Species.Dog: return "kutya";
                case Species.Panda: return "panda";
                case Species.Rabbit: return "nyúl";
                default: return string.Empty;
            }
        }
        public override string ToString()
        {
            return $"{name} ({(isMale ? "hím" : "nőstény")}, {weight} kg, {SpeciesToString()})";
        }

        public static Animal Parse(string input)
        {
            Animal result = new Animal();

            string[] items = input.Split(',');
            result.name = items[0];
            result.isMale = items[1] == "male";
            result.weight = int.Parse(items[2]);
            result.species = (Species)Enum.Parse(typeof(Species), items[3]);

            return result;
        }
    }
}

---------------------------------------

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ZooApp
{
    internal class Cage
    {
        static int  maxSize = 10;
        Animal[] animals;
        int count = 0;

        public Cage(int size = 10)
        {
            animals = new Animal[size <= 10 ? size : maxSize]; //ternary operator

            //if (size <= 10)
            //{
            //    animals = new Animal[size];
            //}
            //else
            //{
            //    animals = new Animal[maxSize];
            //}
        }

        public bool Add(Animal newAnimal)
        {
            if (count == animals.Length) return false; //early exit

            animals[count] = newAnimal;
            count++;
            return true;

            //if (count != animals.Length)
            //{
            //    animals[count] = newAnimal;
            //    count++;
            //    return true;
            //}
            //return false;
        }

        private int Search(string name)
        {
            for (int i = 0; i < count; i++)
            {
                if (animals[i].Name == name)
                {
                    return i;
                }
            }

            return animals.Length;
        }

        public bool Remove(Animal animal)
        {
            int index = Search(animal.Name);

            if (index == animals.Length) return false;

            animals[index] = null;

            for (int i = index+1; i < count; i++)
            {
                animals[i - 1] = animals[i];
            }

            animals[count - 1] = null;
            count--;

            return true;
        }

        public int Count(Species species)
        {
            int speciesCount = 0;

            for (int i = 0; i < count; i++)
            {
                if (animals[i].Species == species)
                {
                    speciesCount++;
                }
            }

            return speciesCount;
        }

        public bool DoesExist(Species species, bool isMale)
        {
            for (int i = 0; i < count; i++)
            {
                if (animals[i].Species == species && animals[i].IsMale == isMale)
                {
                    return true;
                }
            }
            return false;
        }

        public Animal[] CollectAll(Species species)
        {
            Animal[] result = new Animal[count];
            int speciesCount = 0;

            for (int i = 0; i < count; i++)
            {
                if (animals[i].Species == species)
                {
                    result[speciesCount] = animals[i];
                    speciesCount++;
                }
            }

            return result;
        }

        public double AverageWeight(Species species)
        {
            double sum = 0;
            int speciesCount = 0;

            Animal[] animalsWithSpecifiedSpecies = CollectAll(species);

            foreach (Animal currentAnimal in animalsWithSpecifiedSpecies)
            {
                if (currentAnimal == null) break;

                sum += currentAnimal.Weight;
                speciesCount++;
            }

            return speciesCount == 0 ? 0.0 : sum/speciesCount;
        }

        public bool DoesExistSameSpeciesOppositeSex()
        {
            foreach (Species currentSpecies in Enum.GetValues(typeof(Species)))
            {
                Animal[] sameSpeciesAnimals = CollectAll(currentSpecies);

                bool isMale = false;
                bool isFemale = false;

                foreach (Animal currentAnimal in sameSpeciesAnimals)
                {
                    if (currentAnimal == null) break;

                    if (currentAnimal.IsMale) isMale = true;
                    else isFemale = true;

                    if (isMale && isFemale) return true;
                }
            }

            return false;
        }

        public override string ToString()
        {
            StringBuilder stringBuilder = new StringBuilder();

            foreach (Animal currentAnimal in animals)
            {
                if (currentAnimal == null) break;

                stringBuilder.AppendLine(currentAnimal.ToString());
            }

            return stringBuilder.ToString();
        }

        public static Cage CreateFrom(string fileName)
        {
            if (!File.Exists(fileName)) return null;

            Cage result = new Cage();

            using (StreamReader sr = new StreamReader(fileName))
            {
                while (!sr.EndOfStream)
                {
                    result.Add(Animal.Parse(sr.ReadLine()));
                }
            }

            return result;
        }
    }
}