public static void Main(string[] args)
{
var dragonCount = int.Parse(Console.ReadLine());
var dragons = new Dictionary <string, HashSet <Dragon> >();
for (int i = 0; i < dragonCount; i++)
{
var data = Console.ReadLine().Split(' ');
var dragon = new Dragon(data[1], data[0], data[2], data[3], data[4]);
if (!dragons.ContainsKey(dragon.Type))
{
dragons.Add(dragon.Type, new HashSet <Dragon>());
}
dragons[dragon.Type].Remove(dragon);
dragons[dragon.Type].Add(dragon);
}
var output = new StringBuilder();
foreach (var pair in dragons)
{
var sb = new StringBuilder();
var totalDamage = 0D;
var totalHealth = 0D;
var totalArmor = 0D;
pair.Value
.OrderBy(dr => dr.Name)
.ToList()
.ForEach(dr =>
{
sb.Append("-").Append(dr.ToString()).Append(Environment.NewLine);
totalDamage += dr.Damage;
totalHealth += dr.Health;
totalArmor += dr.Armor;
});
var count = pair.Value.Count;
output.Append($"{pair.Key}::({totalDamage / count:F2}/{totalHealth / count:F2}/{totalArmor / count:F2})").Append(Environment.NewLine);
output.Append(sb);
}
Console.Write(output);
}
static void Main(string[] args)
{
int n = int.Parse(Console.ReadLine());
Dictionary <string, List <Dragon> > dragons = new Dictionary <string, List <Dragon> >();
for (int i = 0; i < n; i++)
{
string[] inputArgs = Console.ReadLine().Split();
string type = inputArgs[0];
string name = inputArgs[1];
int damage = 0;
int health = 0;
int armor = 0;
CheckForNullParameters(inputArgs, out damage, out health, out armor);
Dragon current = new Dragon(name, damage, health, armor);
if (!dragons.ContainsKey(type))
{
List <Dragon> curr = new List <Dragon>();
curr.Add(current);
dragons.Add(type, curr);
}
else
{
bool isFound = false;
isFound = CheckNameInTheList(dragons, type, name, current, isFound);
if (!isFound)
{
dragons[type].Add(current);
}
}
}
PrintStatisticsDragons(dragons);
}
public static void NewStats(this Dragon dragon, double damage, double health, double armor)
{
dragon.Damage = damage;
dragon.Health = health;
dragon.Armor = armor;
}
private static bool CheckNameInTheList(Dictionary <string, List <Dragon> > dragons, string type, string name, Dragon current, bool isFound)
{
foreach (var item in dragons[type])
{
if (item.Name == name)
{
dragons[type].Remove(item);
dragons[type].Add(current);
isFound = true;
break;
}
}
return(isFound);
}
public static void Main()
{
Dictionary <string, Dictionary <string, Dragon> > dragons = new Dictionary <string, Dictionary <string, Dragon> >();
int dragonsCount = int.Parse(Console.ReadLine());
for (int i = 0; i < dragonsCount; i++)
{
string[] userInput = Console.ReadLine().Split();
string type = userInput[0];
string name = userInput[1];
string inputDamage = userInput[2];
string inputHealth = userInput[3];
string inputArmor = userInput[4];
Dragon currentDragon = new Dragon {
Name = name
};
if (!inputDamage.Equals("null"))
{
currentDragon.Damage = int.Parse(inputDamage);
}
if (!inputHealth.Equals("null"))
{
currentDragon.Health = int.Parse(inputHealth);
}
if (!inputArmor.Equals("null"))
{
currentDragon.Armor = int.Parse(inputArmor);
}
if (!dragons.ContainsKey(type))
{
dragons.Add(type, new Dictionary <string, Dragon>());
dragons[type].Add(name, currentDragon);
}
else
{
if (!dragons[type].ContainsKey(name))
{
dragons[type].Add(name, new Dragon());
dragons[type][name] = currentDragon;
}
else
{
dragons[type][name] = currentDragon;
}
}
}
foreach (KeyValuePair <string, Dictionary <string, Dragon> > dragon in dragons)
{
double averageDamage = CalcAvgDragonProperty(dragons, dragon.Key, "Damage");
double averageHealth = CalcAvgDragonProperty(dragons, dragon.Key, "Health");
double averageArmor = CalcAvgDragonProperty(dragons, dragon.Key, "Armor");
Console.WriteLine("{0}::({1:F2}/{2:F2}/{3:F2})", dragon.Key, averageDamage, averageHealth, averageArmor);
// All dragons of type "Red" for example:
var dragonsOfThisType = dragons[dragon.Key].Values.Select(d => d).OrderBy(n => n.Name);
foreach (Dragon dragonOfType in dragonsOfThisType)
{
Console.WriteLine($"-{dragonOfType.Name} -> damage: {dragonOfType.Damage}, health: {dragonOfType.Health}, armor: {dragonOfType.Armor}");
}
}
}
static void Main()
{
Dictionary <string, List <Dragon> > dragonByType = new Dictionary <string, List <Dragon> >();
List <Dragon> dragons = new List <Dragon>();
int count = int.Parse(Console.ReadLine());
for (int i = 0; i < count; i++)
{
//{type} {name} {damage} {health} {armor}
string[] dragonInfo = Console.ReadLine().Split();
string type = dragonInfo[0];
string name = dragonInfo[1];
string damage = dragonInfo[2];
string health = dragonInfo[3];
string armor = dragonInfo[4];
int dragonIndex = GetDragonIndex(dragons, type, name);
if (dragonIndex < 0)
{
Dragon dragon = new Dragon(type, name, damage, health, armor);
dragons.Add(dragon);
}
else
{
dragons[dragonIndex].UpdateDragon(damage, health, armor);
}
}
for (int i = 0; i < dragons.Count; i++)
{
if (!dragonByType.ContainsKey(dragons[i].Type))
{
dragonByType.Add(dragons[i].Type, new List <Dragon> {
dragons[i]
});
}
else
{
dragonByType[dragons[i].Type].Add(dragons[i]);
}
}
Dictionary <string, List <Dragon> > ordered = dragonByType
.ToDictionary(x => x.Key, x => x.Value.OrderBy(y => y.Name).ToList());
foreach (var kvp in ordered)
{
double avgDamage = 0.0;
double avgHealth = 0.0;
double avgArmor = 0.0;
int counter = 0;
foreach (var dragon in kvp.Value)
{
avgDamage += dragon.Damage;
avgHealth += dragon.Health;
avgArmor += dragon.Armor;
counter++;
}
avgDamage /= counter;
avgHealth /= counter;
avgArmor /= counter;
//{Type}::({damage}/{health}/{armor})
Console.WriteLine($"{kvp.Key}::({avgDamage:f2}/{avgHealth:f2}/{avgArmor:f2})");
foreach (var dragon in kvp.Value)
{
Console.WriteLine(dragon);
}
}
}
static void Main()
{
double n = double.Parse(Console.ReadLine());
List<Dragon> dragones = new List<Dragon>();
for (double i = 0; i < n; i++)
{
string[] commandArgs = Console.ReadLine().Split(new char[] { ' ' },
StringSplitOptions.RemoveEmptyEntries);
Dragon dragon = CreateDragon(commandArgs);
if (!dragones.Any(d=>d.Name==dragon.Name && d.Type==dragon.Type))
{
dragones.Add(dragon);
}
else
{
var rem = dragones.FirstOrDefault(d => d.Name == dragon.Name && d.Type == dragon.Type);
if (commandArgs[2] != "null")
{
dragon.Damage = double.Parse(commandArgs[2]);
}
else
{
dragon.Damage = 45;
}
if (commandArgs[3] != "null")
{
dragon.Health = double.Parse(commandArgs[3]);
}
else
{
dragon.Health = 250;
}
if (commandArgs[4] != "null")
{
dragon.Armor = double.Parse(commandArgs[4]);
}
else
{
dragon.Armor = 10;
}
}
foreach (string typee in dragones.Select(d => d.Type).Distinct().ToList())
{
var averageDmg = dragones.Where(d => d.Type == typee).Average(d => d.Damage);
var averageHealth = dragones.Where(d => d.Type == typee).Average(d => d.Health);
var averageArmor = dragones.Where(d => d.Type == typee).Average(d => d.Armor);
Console.WriteLine($"{typee}::({averageDmg:f2}/{averageHealth:f2}/{averageArmor:f2})");
foreach (var dragon in dragones.Where(d => d.Type == typee).OrderBy(e => e.Name))
{
Console.WriteLine($"-{dragon.Name} -> damage: {dragon.Damage}, health: {dragon.Health}, armor: {dragon.Armor}");
}
}
}
