Hello! In this post, we will solve a coding test problem using the C# language. The topic is ‘Jumong’s Command’. This problem simulates the situation where Jumong issues commands and implements an algorithm to handle them efficiently. I will explain in detail how to solve the problem and implement the code.<\/p>\n
Jumong gives commands to warriors before each battle. Each warrior performs their duties according to the commands they receive. The warriors interpret Jumong’s commands as follows:<\/p>\n
Jumong has N warriors and M commands. The commands are given in the following format:<\/p>\n
\n 1. ATTACK A B \/\/ Warrior A attacks warrior B\n 2. DEFENSE A \/\/ Warrior A assumes a defensive posture\n 3. RETREAT A \/\/ Warrior A retreats\n <\/pre>\nIf a warrior successfully performs their duty, the result should output ‘SUCCESS’, and if they fail, it should output ‘FAIL’. Warriors do not perform commands if they lose interest before executing the command. Interest decreases over time. If a warrior is in a situation where they cannot perform the command, ‘FAIL’ should be printed.<\/p>\n
Input Format<\/h2>\n
The input is given in the following format:<\/p>\n
\n N (number of warriors)\n M (number of commands)\n Interest decay rate (0 ~ 1)\n Commands (M commands)\n <\/pre>\nOutput Format<\/h2>\n
The results are printed for each command. The results are listed in the same order as the commands.<\/p>\n
Approach to the Problem<\/h2>\n
This problem requires an algorithm to process the given commands and determine whether each warrior can perform the commands. To solve the problem, I will consider the following steps:<\/p>\n
\n
- Create a data structure to store the warriors and command lists.<\/li>\n
- Assume that each warrior initially has 100% interest.<\/li>\n
- Decrease the warrior’s interest according to the given interest decay rate, and process each command while updating their status.<\/li>\n
- Record success or failure based on the results of the commands.<\/li>\n<\/ol>\n
Implementation<\/h2>\n
Code Example<\/h3>\n
The following is a C# implementation based on the above approach:<\/p>\n
\nusing System;\nusing System.Collections.Generic;\n\nnamespace JumongCommand\n{\n class Warrior\n {\n public int Id { get; set; }\n public double Interest { get; set; }\n\n public Warrior(int id)\n {\n Id = id;\n Interest = 1.0; \/\/ 100% interest\n }\n }\n\n class Program\n {\n static void Main(string[] args)\n {\n int N = int.Parse(Console.ReadLine());\n int M = int.Parse(Console.ReadLine());\n double interestDecayRate = double.Parse(Console.ReadLine());\n\n Listwarriors = new List ();\n for (int i = 1; i <= N; i++)\n {\n warriors.Add(new Warrior(i));\n }\n\n List results = new List ();\n for (int i = 0; i < M; i++)\n {\n string command = Console.ReadLine();\n string[] parts = command.Split(' ');\n\n if (parts[0] == \"ATTACK\")\n {\n int attackerId = int.Parse(parts[1]);\n int targetId = int.Parse(parts[2]);\n ProcessAttack(warriors, results, attackerId, targetId);\n }\n else if (parts[0] == \"DEFENSE\")\n {\n int defenderId = int.Parse(parts[1]);\n ProcessDefense(warriors, results, defenderId);\n }\n else if (parts[0] == \"RETREAT\")\n {\n int retreatId = int.Parse(parts[1]);\n ProcessRetreat(warriors, results, retreatId);\n }\n\n \/\/ Apply interest decay\n foreach (var warrior in warriors)\n {\n warrior.Interest -= interestDecayRate;\n if (warrior.Interest < 0)\n warrior.Interest = 0;\n }\n }\n\n foreach (var result in results)\n {\n Console.WriteLine(result);\n }\n }\n\n static void ProcessAttack(List warriors, List results, int attackerId, int targetId)\n {\n var attacker = warriors[attackerId - 1];\n var target = warriors[targetId - 1];\n\n if (attacker.Interest > 0)\n {\n results.Add(\"SUCCESS\");\n }\n else\n {\n results.Add(\"FAIL\");\n }\n }\n\n static void ProcessDefense(List warriors, List results, int defenderId)\n {\n var defender = warriors[defenderId - 1];\n\n if (defender.Interest > 0)\n {\n results.Add(\"SUCCESS\");\n }\n else\n {\n results.Add(\"FAIL\");\n }\n }\n\n static void ProcessRetreat(List warriors, List results, int retreatId)\n {\n var retreatingWarrior = warriors[retreatId - 1];\n\n if (retreatingWarrior.Interest > 0)\n {\n results.Add(\"SUCCESS\");\n }\n else\n {\n results.Add(\"FAIL\");\n }\n }\n }\n}\n<\/code><\/pre>\n Code Explanation<\/h2>\n
The code defines a ‘Warrior’ class to manage the state of each warrior. Each warrior has a unique ID and a current interest as properties. The main program reads the warrior list and command list in order and calls separate methods to process each command, updating the results.<\/p>\n
Verification of Results<\/h3>\n
After the commands are completed, the result list is printed to confirm the final success or failure results. This is a simple implementation of how warriors execute commands and manage resources.<\/p>\n
Test Cases<\/h2>\n
We can create several test cases to check if it works properly.<\/p>\n
Example Input<\/h3>\n
\n5\n3\n0.1\nATTACK 1 2\nDEFENSE 3\nRETREAT 4\n<\/pre>\nExpected Results<\/h3>\n
\nSUCCESS\nSUCCESS\nSUCCESS\n<\/pre>\nBy testing various inputs in this manner, we can check if the algorithm correctly responds to all situations.<\/p>\n
Conclusion<\/h2>\n
In this post, we explored the process of solving the ‘Jumong’s Command’ problem. Understanding the structure and implementation of the algorithm, as well as building the logic for processing various commands, was important. I hope you continue to improve your skills through more algorithm problems. Thank you!<\/p>\n
<\/body><\/p>\n","protected":false},"excerpt":{"rendered":"