Crew Planner | C# Online Compiler

Crew Planner by Anonymous

using System;

namespace CrewPlanner
{
    internal static class Program
    {
        private enum CrewRole
        {
            Engineer,
            Tactical,
            Science,
            Commander,
            Medical,
            Civilian
        }

        private struct CrewMember
        {
            public string Name;
            public CrewRole Role;
        }

        private struct CrewClone
        {
            public CrewMember Member;
            public int Level;
        }

        private interface IMissionRequirement
        {
            bool Validate(CrewClone[] clones);
        }

        private abstract class MissionRequirement : IMissionRequirement
        {
            protected MissionRequirement() { }

            public abstract bool Validate(CrewClone[] clones);
        }

        private sealed class MinimumLevelSumRequirement : MissionRequirement
        {
            public int MininumLevelSum
            {
                get;
                init;
            }

            public MinimumLevelSumRequirement(int minimumLevelSum)
            {
                if (minimumLevelSum < 0)
                {
                    throw new ArgumentOutOfRangeException(nameof(minimumLevelSum), minimumLevelSum, "The value must be greater than or equal to zero.");
                }

                this.MininumLevelSum = minimumLevelSum;
            }

            public override bool Validate(CrewClone[] clones)
            {
                int currentSum = 0;
                for (int i = 0; i < clones.Length; ++i)
                {
                    currentSum += clones[i].Level;
                    if (currentSum >= this.MininumLevelSum)
                    {
                        return true;
                    }
                }

                return false;
            }
        }

        private sealed class MinimumCrewQuantityRequirement : MissionRequirement
        {
            public int MininumCrewQuantity
            {
                get;
                init;
            }

            public MinimumCrewQuantityRequirement(int minimumCrewQuantity)
            {
                if (minimumCrewQuantity < 0)
                {
                    throw new ArgumentOutOfRangeException(nameof(minimumCrewQuantity), minimumCrewQuantity, "The value must be greater than or equal to zero.");
                }

                this.MininumCrewQuantity = minimumCrewQuantity;
            }

            public override bool Validate(CrewClone[] clones)
            {
                return clones.Length >= this.MininumCrewQuantity;
            }
        }

        private sealed class MaximumCrewQuantityRequirement : MissionRequirement
        {
            public int MaximumCrewQuantity
            {
                get;
                init;
            }

            public MaximumCrewQuantityRequirement(int maximumCrewQuantity)
            {
                if (maximumCrewQuantity < 0)
                {
                    throw new ArgumentOutOfRangeException(nameof(maximumCrewQuantity), maximumCrewQuantity, "The value must be greater than or equal to zero.");
                }

                this.MaximumCrewQuantity = maximumCrewQuantity;
            }

            public override bool Validate(CrewClone[] clones)
            {
                return clones.Length <= this.MaximumCrewQuantity;
            }
        }

        private sealed class MinimumCrewRoleQuantityRequirement : MissionRequirement
        {
            public CrewRole Role
            {
                get;
                init;
            }

            public int MinimumQuantity
            {
                get;
                init;
            }

            public MinimumCrewRoleQuantityRequirement(CrewRole role, int minimumCrewQuantity)
            {
                if (minimumCrewQuantity < 0)
                {
                    throw new ArgumentOutOfRangeException(nameof(minimumCrewQuantity), minimumCrewQuantity, "The value must be greater than or equal to zero.");
                }

                this.Role = role;
                this.MinimumQuantity = minimumCrewQuantity;
            }

            public override bool Validate(CrewClone[] clones)
            {
                int currentQuantity = 0;
                for (int i = 0; i < clones.Length; ++i)
                {
                    if (this.Role == clones[i].Member.Role)
                    {
                        if (++currentQuantity >= this.MinimumQuantity)
                        {
                            return true;
                        }
                    }
                }

                return false;
            }
        }

        private sealed class Mission
        {
            private readonly MissionRequirement[] requirements;

            public string Name
            {
                get;
                init;
            }

            public Mission(string name, MissionRequirement[] requirements)
            {
                if (name is null)
                {
                    throw new ArgumentNullException(nameof(name));
                }

                if (requirements is null)
                {
                    throw new ArgumentNullException(nameof(requirements));
                }

                this.requirements = requirements;

                this.Name = name;
            }

            public bool IsCrewValid(CrewClone[] crewClones)
            {
                if (crewClones is null)
                {
                    throw new ArgumentNullException(nameof(crewClones));
                }

                for (int i = 0; i < this.requirements.Length; ++i)
                {
                    if (!this.requirements[i].Validate(crewClones))
                    {
                        return false;
                    }
                }

                return true;
            }

            public int[] GetValidCrewIndices(CrewClone[] crewClones)
            {
                // TODO: Implement this method.
                throw new NotImplementedException();
            }
        };

        private static void Main()
        {
            CrewMember[] members = new CrewMember[]
            {
                new CrewMember() { Name = "Alan", Role = CrewRole.Engineer },
                new CrewMember() { Name = "Nancy", Role = CrewRole.Engineer },
                new CrewMember() { Name = "Margaret", Role = CrewRole.Tactical },
                new CrewMember() { Name = "Frederick", Role = CrewRole.Tactical },
                new CrewMember() { Name = "Charlie", Role = CrewRole.Science },
                new CrewMember() { Name = "Lewis", Role = CrewRole.Science },
                new CrewMember() { Name = "John", Role = CrewRole.Civilian },
                new CrewMember() { Name = "Karen", Role = CrewRole.Civilian },
                new CrewMember() { Name = "Shirley", Role = CrewRole.Commander },
                new CrewMember() { Name = "Etienne", Role = CrewRole.Commander },
                new CrewMember() { Name = "Chris", Role = CrewRole.Medical },
                new CrewMember() { Name = "James", Role = CrewRole.Medical }
            };

            CrewClone[] availableClones = new CrewClone[]
            {
                new CrewClone() { Member = members[0], Level = 1 },
                new CrewClone() { Member = members[2], Level = 1 },
                new CrewClone() { Member = members[4], Level = 1 },
                new CrewClone() { Member = members[6], Level = 1 },
                new CrewClone() { Member = members[8], Level = 1 },
            };

            MissionRequirement[] requirements = new MissionRequirement[]
            {
                new MinimumLevelSumRequirement(4),
                new MinimumCrewQuantityRequirement(2),
                new MaximumCrewQuantityRequirement(4),
                new MinimumCrewRoleQuantityRequirement(CrewRole.Commander, 1),
                new MinimumCrewRoleQuantityRequirement(CrewRole.Engineer, 1)
            };

            Mission mission = new Mission("The first mission", requirements);

            int[] crewIndices = mission.GetValidCrewIndices(availableClones);

            CrewClone[] crewClones = new CrewClone[crewIndices.Length];
            for (int i = 0; i < crewClones.Length; ++i)
            {
                crewClones[i] = availableClones[crewIndices[i]];
            }

            if (mission.IsCrewValid(crewClones))
            {
                Console.WriteLine("Passed. Selected a valid crew.");
            }
            else
            {
                Console.WriteLine("Failed. Selected an invalid crew.");
            }
        }
    }
}

​x
 
using System;
​
namespace CrewPlanner
{
    internal static class Program
    {
        private enum CrewRole
        {
            Engineer,
            Tactical,
            Science,
            Commander,
            Medical,
            Civilian
        }
​
        private struct CrewMember
        {
            public string Name;
            public CrewRole Role;
        }
​
        private struct CrewClone
        {
            public CrewMember Member;
            public int Level;
        }
​
        private interface IMissionRequirement
        {
            bool Validate(CrewClone[] clones);
        }
​
        private abstract class MissionRequirement : IMissionRequirement
        {
            protected MissionRequirement() { }
​
            public abstract bool Validate(CrewClone[] clones);
        }
​
        private sealed class MinimumLevelSumRequirement : MissionRequirement
        {
            public int MininumLevelSum
            {
                get;
                init;
            }
​
            public MinimumLevelSumRequirement(int minimumLevelSum)
            {
                if (minimumLevelSum < 0)
                {
                    throw new ArgumentOutOfRangeException(nameof(minimumLevelSum), minimumLevelSum, "The value must be greater than or equal to zero.");
                }
​
                this.MininumLevelSum = minimumLevelSum;
            }
​
            public override bool Validate(CrewClone[] clones)
            {
                int currentSum = 0;
                for (int i = 0; i < clones.Length; ++i)
                {
                    currentSum += clones[i].Level;
                    if (currentSum >= this.MininumLevelSum)
                    {
                        return true;
                    }
                }
​
                return false;
            }
        }
​
        private sealed class MinimumCrewQuantityRequirement : MissionRequirement
        {
            public int MininumCrewQuantity
            {
                get;
                init;
            }
​
            public MinimumCrewQuantityRequirement(int minimumCrewQuantity)
            {
                if (minimumCrewQuantity < 0)
                {
                    throw new ArgumentOutOfRangeException(nameof(minimumCrewQuantity), minimumCrewQuantity, "The value must be greater than or equal to zero.");
                }
​
                this.MininumCrewQuantity = minimumCrewQuantity;
            }
​
            public override bool Validate(CrewClone[] clones)
            {
                return clones.Length >= this.MininumCrewQuantity;
            }
        }
​
        private sealed class MaximumCrewQuantityRequirement : MissionRequirement
        {
            public int MaximumCrewQuantity
            {
                get;
                init;
            }
​
            public MaximumCrewQuantityRequirement(int maximumCrewQuantity)
            {
                if (maximumCrewQuantity < 0)
                {
                    throw new ArgumentOutOfRangeException(nameof(maximumCrewQuantity), maximumCrewQuantity, "The value must be greater than or equal to zero.");
                }
​
                this.MaximumCrewQuantity = maximumCrewQuantity;
            }
​
            public override bool Validate(CrewClone[] clones)
            {
                return clones.Length <= this.MaximumCrewQuantity;
            }
        }
​
        private sealed class MinimumCrewRoleQuantityRequirement : MissionRequirement
        {
            public CrewRole Role
            {
                get;
                init;
            }
​
            public int MinimumQuantity
            {
                get;
                init;
            }
​
            public MinimumCrewRoleQuantityRequirement(CrewRole role, int minimumCrewQuantity)
            {
                if (minimumCrewQuantity < 0)
                {
                    throw new ArgumentOutOfRangeException(nameof(minimumCrewQuantity), minimumCrewQuantity, "The value must be greater than or equal to zero.");
                }
​
                this.Role = role;
                this.MinimumQuantity = minimumCrewQuantity;
            }
​
            public override bool Validate(CrewClone[] clones)
            {
                int currentQuantity = 0;
                for (int i = 0; i < clones.Length; ++i)
                {
                    if (this.Role == clones[i].Member.Role)
                    {
                        if (++currentQuantity >= this.MinimumQuantity)
                        {
                            return true;
                        }
                    }
                }
​
                return false;
            }
        }
​
        private sealed class Mission
        {
            private readonly MissionRequirement[] requirements;
​
            public string Name
            {
                get;
                init;
            }
​
            public Mission(string name, MissionRequirement[] requirements)
            {
                if (name is null)
                {
                    throw new ArgumentNullException(nameof(name));
                }
​
                if (requirements is null)
                {
                    throw new ArgumentNullException(nameof(requirements));
                }
​
                this.requirements = requirements;
​
                this.Name = name;
            }
​
            public bool IsCrewValid(CrewClone[] crewClones)
            {
                if (crewClones is null)
                {
                    throw new ArgumentNullException(nameof(crewClones));
                }
​
                for (int i = 0; i < this.requirements.Length; ++i)
                {
                    if (!this.requirements[i].Validate(crewClones))
                    {
                        return false;
                    }
                }
​
                return true;
            }
​
            public int[] GetValidCrewIndices(CrewClone[] crewClones)
            {
                // TODO: Implement this method.
                throw new NotImplementedException();
            }
        };
​
        private static void Main()
        {
            CrewMember[] members = new CrewMember[]
            {
                new CrewMember() { Name = "Alan", Role = CrewRole.Engineer },
                new CrewMember() { Name = "Nancy", Role = CrewRole.Engineer },
                new CrewMember() { Name = "Margaret", Role = CrewRole.Tactical },
                new CrewMember() { Name = "Frederick", Role = CrewRole.Tactical },
                new CrewMember() { Name = "Charlie", Role = CrewRole.Science },
                new CrewMember() { Name = "Lewis", Role = CrewRole.Science },
                new CrewMember() { Name = "John", Role = CrewRole.Civilian },
                new CrewMember() { Name = "Karen", Role = CrewRole.Civilian },
                new CrewMember() { Name = "Shirley", Role = CrewRole.Commander },
                new CrewMember() { Name = "Etienne", Role = CrewRole.Commander },
                new CrewMember() { Name = "Chris", Role = CrewRole.Medical },
                new CrewMember() { Name = "James", Role = CrewRole.Medical }
            };
​
            CrewClone[] availableClones = new CrewClone[]
            {
                new CrewClone() { Member = members[0], Level = 1 },
                new CrewClone() { Member = members[2], Level = 1 },
                new CrewClone() { Member = members[4], Level = 1 },
                new CrewClone() { Member = members[6], Level = 1 },
                new CrewClone() { Member = members[8], Level = 1 },
            };
​
            MissionRequirement[] requirements = new MissionRequirement[]
            {
                new MinimumLevelSumRequirement(4),
                new MinimumCrewQuantityRequirement(2),
                new MaximumCrewQuantityRequirement(4),
                new MinimumCrewRoleQuantityRequirement(CrewRole.Commander, 1),
                new MinimumCrewRoleQuantityRequirement(CrewRole.Engineer, 1)
            };
​
            Mission mission = new Mission("The first mission", requirements);
​
            int[] crewIndices = mission.GetValidCrewIndices(availableClones);
​
            CrewClone[] crewClones = new CrewClone[crewIndices.Length];
            for (int i = 0; i < crewClones.Length; ++i)
            {
                crewClones[i] = availableClones[crewIndices[i]];
            }
​
            if (mission.IsCrewValid(crewClones))
            {
                Console.WriteLine("Passed. Selected a valid crew.");
            }
            else
            {
                Console.WriteLine("Failed. Selected an invalid crew.");
            }
        }
    }
}

Console Calculator in C#
------------------------

Type a number and press Enter:

Cached Result
Last Run:	9:31:14 pm
Compile:	0.11s
Execute:	0s
Memory:	32kb
CPU:	0s

View IL Code