示例#1
0
        private static List <Legion> AddNewLegionInfo(List <Legion> legions, string[] input)
        {
            int    lastActivity = Convert.ToInt32(input[0]);
            string legionName   = input[1];
            string soldierType  = input[2];
            int    soldierCount = Convert.ToInt32(input[3]);

            if (!legions.Exists(l => l.Name.Equals(legionName)))
            {
                Legion newLegion = new Legion
                {
                    Name         = legionName,
                    LastActivity = lastActivity,
                    Soldiers     = new Dictionary <string, long> {
                    }
                };

                legions.Add(newLegion);
            }

            Legion legion = legions.Where(l => l.Name.Equals(legionName)).First();

            if (lastActivity > legion.LastActivity)
            {
                legion.LastActivity = lastActivity;
            }

            if (!legion.Soldiers.ContainsKey(soldierType))
            {
                legion.Soldiers.Add(soldierType, 0);
            }

            legion.Soldiers[soldierType] += soldierCount;

            return(legions);
        }
        public static void Main()
        {
            var n       = int.Parse(Console.ReadLine());
            var legions = new Dictionary <string, Legion>();

            for (int i = 0; i < n; i++)
            {
                var line = Console.ReadLine()
                           .Split(new char[] { '=', '-', '>', ':', ' ' }, StringSplitOptions.RemoveEmptyEntries);
                var lastActivity = int.Parse(line[0]);
                var legionName   = line[1];
                var soldierType  = line[2];
                var soldierCount = int.Parse(line[3]);

                if (!legions.ContainsKey(legionName))
                {
                    legions[legionName] = new Legion()
                    {
                        Activity    = 0,
                        SoldierType = new Dictionary <string, int>()
                    };
                }
                if (!legions[legionName].SoldierType.ContainsKey(soldierType))
                {
                    legions[legionName].SoldierType.Add(soldierType, soldierCount);
                    if (legions[legionName].Activity < lastActivity)
                    {
                        legions[legionName].Activity = lastActivity;
                    }
                }
                else
                {
                    legions[legionName].SoldierType[soldierType] += soldierCount;
                    if (legions[legionName].Activity < lastActivity)
                    {
                        legions[legionName].Activity = lastActivity;
                    }
                }
            }
            var query            = Console.ReadLine();
            var queryActivity    = 0;
            var querySoldierType = string.Empty;

            if (query.Contains("\\"))
            {
                var queries = query.Split('\\');
                queryActivity    = int.Parse(queries[0]);
                querySoldierType = queries[1];
                var result = legions.Values[querySoldierType];

                foreach (var item in result)
                {
                }

                //foreach (var legion in result.OrderByDescending(l => l.Value.SoldierType.Values.Sum()))
                //{
                //    if (legion.Value.Activity < queryActivity)
                //    {

                //    }
                //}
            }
            else
            {
                querySoldierType = query;
                foreach (var legion in legions.OrderByDescending(a => a.Value.Activity))
                {
                    if (legion.Value.SoldierType.ContainsKey(querySoldierType))
                    {
                        Console.WriteLine($"{legion.Value.Activity} : {legion.Key}");
                    }
                }
            }
        }
示例#3
0
        public static void Main(string[] args)
        {
            List <Legion> legions = new List <Legion>();

            var n = long.Parse(Console.ReadLine());

            for (long i = 0; i < n; i++)
            {
                var inputArgs = Console.ReadLine().Split(new string[] { " = ",
                                                                        " -> ", ":" }, StringSplitOptions.RemoveEmptyEntries);

                long   activity = long.Parse(inputArgs[0]);
                string legion   = inputArgs[1];
                string soldier  = inputArgs[2];
                long   count    = long.Parse(inputArgs[3]);


                if (!legions.Any(l => l.Name == legion))
                {
                    Legion currentLegion = new Legion()
                    {
                        Activity = activity,
                        Name     = legion,
                        Soldiers = new Dictionary <string, long>()
                    };

                    currentLegion.Soldiers.Add(soldier, count);

                    legions.Add(currentLegion);
                }

                else
                {
                    Legion currentLegion = legions.FirstOrDefault(l => l.Name == legion);
                    if (currentLegion.Activity < activity)
                    {
                        currentLegion.Activity = activity;
                    }

                    if (!currentLegion.Soldiers.ContainsKey(soldier))
                    {
                        currentLegion.Soldiers.Add(soldier, count);
                    }
                    else
                    {
                        currentLegion.Soldiers[soldier] += count;
                    }
                }
            }

            var printArgs = Console.ReadLine().Split('\\');

            if (printArgs.Length > 1)
            {
                long   activity = long.Parse(printArgs[0]);
                string soldier  = printArgs[1];

                Dictionary <string, long> rem = new Dictionary <string, long>();

                foreach (var legion in legions
                         .Where(l => l.Activity < activity)
                         .Where(l => l.Soldiers.ContainsKey(soldier)))

                {
                    rem.Add(legion.Name, legion.Soldiers[soldier]);
                }

                foreach (var item in rem.OrderByDescending(k => k.Value))
                {
                    Console.WriteLine($"{item.Key} -> {item.Value}");
                }
            }
            else
            {
                string soldier = printArgs[0];

                Dictionary <string, long> rem = new Dictionary <string, long>();

                foreach (var legion in legions.Where(l => l.Soldiers.ContainsKey(soldier)))
                {
                    rem.Add(legion.Name, legion.Activity);
                }
                foreach (var item in rem.OrderByDescending(p => p.Value))
                {
                    Console.WriteLine($"{item.Value} -> {item.Key}");
                }
            }
        }
示例#4
0
        static void Main(string[] args)
        {
            int           n       = int.Parse(Console.ReadLine());
            List <Legion> legions = new List <Legion>();

            for (int i = 0; i < n; i++)
            {
                string   input  = Console.ReadLine();
                string[] tokens = input.Split(new string[] { " = ", " -> ", ":" },
                                              StringSplitOptions.RemoveEmptyEntries);

                int    lastActivity  = int.Parse(tokens[0]);
                string legionName    = tokens[1];
                string soldierType   = tokens[2];
                int    soldiersCount = int.Parse(tokens[3]);

                if (legions.Select(l => l.LegionName).Contains(legionName))
                {
                    foreach (var item in legions.Where(l => l.LegionName == legionName))
                    {
                        if (item.LastActivity < lastActivity)
                        {
                            item.LastActivity = lastActivity;
                        }

                        if (!item.SoldiersTypeData.ContainsKey(soldierType))
                        {
                            item.SoldiersTypeData.Add(soldierType, 0);
                        }

                        item.SoldiersTypeData[soldierType] += soldiersCount;
                    }
                }
                else
                {
                    Legion legion = new Legion(legionName, lastActivity, soldierType, soldiersCount);
                    legions.Add(legion);
                }
            }

            string[] printTokens = Console.ReadLine().Split('\\');

            if (printTokens.Length == 2)
            {
                int    maxActivity       = int.Parse(printTokens[0]);
                string wantedSoldierType = printTokens[1];

                foreach (var item in legions.Where(l => l.SoldiersTypeData.ContainsKey(wantedSoldierType))
                         .OrderByDescending(l => l.SoldiersTypeData[wantedSoldierType]))
                {
                    if (item.LastActivity < maxActivity)
                    {
                        Console.WriteLine($"{item.LegionName} -> {item.SoldiersTypeData[wantedSoldierType]}");
                    }
                }
            }
            else
            {
                string wantedSoldierType = printTokens[0];

                foreach (var item in legions.Where(l => l.SoldiersTypeData.ContainsKey(wantedSoldierType))
                         .OrderByDescending(l => l.LastActivity))
                {
                    Console.WriteLine($"{item.LastActivity} : {item.LegionName}");
                }
            }
        }
        static void Main(string[] args)
        {
            Dictionary <string, Legion> legions = new Dictionary <string, Legion>();
            int           N     = int.Parse(Console.ReadLine());
            List <string> types = new List <string>();

            for (int i = 0; i < N; i++)
            {
                string[] input         = Console.ReadLine().Split(new char[] { '=', '-', '>', ':' }, StringSplitOptions.RemoveEmptyEntries);
                long     activity      = long.Parse(input[0]);
                string   legionName    = input[1].Trim();
                string   soldierType   = input[2].Trim();
                long     soldierAmount = long.Parse(input[3]);
                Legion   curLeg        = new Legion();


                if (!legions.ContainsKey(legionName))
                {
                    curLeg.Activity     = activity;
                    curLeg.typeAndCount = new Dictionary <string, long>();
                    curLeg.typeAndCount.Add(soldierType, soldierAmount);
                    legions.Add(legionName, curLeg);
                    if (!types.Contains(soldierType))
                    {
                        types.Add(soldierType);
                    }
                }
                else
                {
                    if (activity > legions[legionName].Activity)
                    {
                        legions[legionName].Activity = activity;
                    }
                    if (legions[legionName].typeAndCount.ContainsKey(soldierType))
                    {
                        legions[legionName].typeAndCount[soldierType] = legions[legionName].typeAndCount[soldierType] + soldierAmount;
                    }
                    else
                    {
                        legions[legionName].typeAndCount.Add(soldierType, soldierAmount);
                    }
                }
            }
            string outputType = Console.ReadLine();
            Regex  pat        = new Regex(@"^\d+\\[^=:->]+$");

            if (pat.IsMatch(outputType))
            {
                string wantedType = outputType.Substring(outputType.IndexOf("\\") + 1);


                if (types.Contains(wantedType))
                {
                    Dictionary <string, Legion> prefixed = new Dictionary <string, Legion>();
                    long maxActivity = long.Parse(outputType.Substring(0, outputType.IndexOf("\\")));
                    foreach (var item in legions)
                    {
                        if (item.Value.typeAndCount.ContainsKey(wantedType))
                        {
                            prefixed.Add(item.Key, item.Value);
                        }
                    }
                    foreach (var leg in prefixed.OrderByDescending(x => x.Value.typeAndCount[wantedType]))
                    {
                        if (leg.Value.Activity < maxActivity && leg.Value.typeAndCount.ContainsKey(wantedType))
                        {
                            Console.WriteLine(leg.Key + " -> " + leg.Value.typeAndCount[wantedType]);
                        }
                    }
                }
            }
            else
            {
                string wanted = outputType.Trim();
                if (types.Contains(wanted))
                {
                    foreach (var leg in legions.OrderByDescending(x => x.Value.Activity))
                    {
                        if (leg.Value.typeAndCount.ContainsKey(wanted))
                        {
                            Console.WriteLine(leg.Value.Activity + " : " + leg.Key);
                        }
                    }
                }
            }
        }
示例#6
0
        static void Main(string[] args)
        {
            int    n       = int.Parse(Console.ReadLine());
            var    legions = new Dictionary <string, Legion>();
            string input   = String.Empty;

            for (int i = 0; i < n; i++)
            {
                input = Console.ReadLine();
                string[] tokens = input.Split(new[] { " = ", " -> ", ":" }, StringSplitOptions.RemoveEmptyEntries);

                string legionName   = tokens[1];
                int    activity     = int.Parse(tokens[0]);
                string soldierType  = tokens[2];
                long   soldierCount = long.Parse(tokens[3]);

                if (!legions.ContainsKey(legionName))
                {
                    legions[legionName]          = new Legion();
                    legions[legionName].Activity = activity;
                    legions[legionName].Soldiers.Add(soldierType, soldierCount);
                }
                else
                {
                    if (legions[legionName].Activity < activity)
                    {
                        legions[legionName].Activity = activity;
                    }

                    if (!legions[legionName].Soldiers.ContainsKey(soldierType))
                    {
                        legions[legionName].Soldiers.Add(soldierType, soldierCount);
                    }
                    else
                    {
                        legions[legionName].Soldiers[soldierType] += soldierCount;
                    }
                }
            }

            input = Console.ReadLine();
            Regex patternwithActivity = new Regex(@"\d+\\.");

            if (patternwithActivity.IsMatch(input))
            {
                string[] arr = input.Split('\\');
                int      aboveAllowedActivity = int.Parse(arr[0]);
                string   type = arr[1];

                var soldiers = legions.Where(x => x.Value.Activity < aboveAllowedActivity &&
                                             x.Value.Soldiers.ContainsKey(type)).
                               OrderByDescending(x => x.Value.Soldiers[type]);


                foreach (var soldier in soldiers)
                {
                    Console.WriteLine($"{soldier.Key} -> {soldier.Value.Soldiers[type]}");
                }
            }
            else
            {
                var soldiers = legions.Where(x => x.Value.Soldiers.ContainsKey(input))
                               .OrderByDescending(x => x.Value.Activity);

                foreach (var soldier in soldiers)
                {
                    Console.WriteLine($"{soldier.Value.Activity} : {soldier.Key}");
                }
            }
        }