public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
List <RainDeer> raindeers = new List <RainDeer>();
//int time = int.Parse(reader.ReadLine());
int time = 2503;
while (!reader.EndOfStream)
{
var input = reader.ReadLine();
if (string.IsNullOrEmpty(input))
{
break;
}
var split = input.Split(' ');
var deer = new RainDeer()
{
Name = split[0],
Speed = int.Parse(split[3]),
RaceTime = int.Parse(split[6]),
RestTime = int.Parse(split[13])
};
raindeers.Add(deer);
}
long maxDistance = 0;
string winner = string.Empty;
foreach (var deer in raindeers)
{
var distance = CalculateDistance(deer, time);
if (distance > maxDistance)
{
maxDistance = distance;
winner = deer.Name;
}
WriteLine($"{deer.Name} traveled {distance} km.");
}
WriteLine();
WriteLine($"Winner: {winner} with {maxDistance} km.");
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
var input = reader.ReadLine();
HashSet <Point> visited = new HashSet <Point>();
Point p = new Point(0, 0);
visited.Add(p);
foreach (var move in input)
{
Point newP;
switch (move)
{
case '^':
p = new Point(p.X, p.Y - 1);
break;
case '<':
p = new Point(p.X - 1, p.Y);
break;
case '>':
p = new Point(p.X + 1, p.Y);
break;
case 'v':
p = new Point(p.X, p.Y + 1);
break;
default:
throw new InvalidOperationException();
}
visited.Add(p);
}
WriteLine(visited.Count());
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
var input = reader.ReadLine();
long suffix = 0;
var password = "******";
int found = 0;
while (found < 8)
{
var md5 = string.Empty;
while (!md5.StartsWith("00000"))
{
md5 = CalculateMD5($"{input}{suffix}");
//WriteLine($"[{i}] MD5 of {input}{suffix} = {md5}");
suffix++;
if (suffix % 100000 == 0)
{
int tmp = (int)(suffix / 100000);
int a = tmp / 10;
int b = tmp % 10;
WriteLine($"{found}/8 - {a}.{b}e6");
}
}
int pos = md5[5] - '0';
if (pos >= 0 && pos <= 7)
{
char chr = md5[6];
if (password[pos] == '_')
{
password = password.Substring(0, pos) + chr + password.Substring(pos + 1, 8 - pos - 1);
found++;
WriteLine(password);
}
}
}
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
var input = reader.ReadLine();
int lastLength = 0;
for (int i = 0; i < 50; i++)
{
Write($"{i+1} ");
InitProgressBar(input.Length);
var newString = new StringBuilder();
int idx = 0;
while (idx < input.Length)
{
char current = input[idx];
int counter = 0;
while (idx < input.Length && input[idx] == current)
{
idx++;
counter++;
}
newString.Append(counter.ToString());
newString.Append(current);
UpdateProgress(idx);
}
input = newString.ToString();
//WriteLine(input);
lastLength = newString.Length;
WriteLine();
}
WriteLine(lastLength);
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
var input = reader.ReadLine();
StringBuilder output = new StringBuilder();
for (int i = 0; i < input.Length; i++)
{
if (input[i] == '(')
{
int start = i + 1;
while (input[i] != ')')
{
i++;
}
int end = i;
i++;
string data = input.Substring(start, end - start);
var split = data.Split('x');
int letterCount = int.Parse(split[0]);
int repeatCount = int.Parse(split[1]);
for (int j = 0; j < repeatCount; j++)
{
output.Append(input.Substring(i, letterCount));
}
i += letterCount - 1;
}
else
{
output.Append(input[i]);
}
}
WriteLine($"{output.ToString()}: {output.Length}");
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
int passwordLength = 8;
List <Dictionary <char, int> > frequencies = new List <Dictionary <char, int> >();
for (int i = 0; i < passwordLength; i++)
{
frequencies.Add(new Dictionary <char, int>());
}
while (!reader.EndOfStream)
{
var input = reader.ReadLine();
if (string.IsNullOrEmpty(input))
{
break;
}
for (int i = 0; i < passwordLength; i++)
{
char idx = input[i];
if (!frequencies[i].ContainsKey(idx))
{
frequencies[i].Add(idx, 0);
}
frequencies[i][idx]++;
}
}
for (int i = 0; i < passwordLength; i++)
{
Write(frequencies[i].OrderBy(x => x.Value).First().Key);
}
WriteLine();
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
int totalArea = 0;
while (!reader.EndOfStream)
{
var input = reader.ReadLine();
if (string.IsNullOrEmpty(input))
{
break;
}
var dim = input.Split('x').Select(int.Parse).ToList();
List <int> sides = new List <int>();
sides.Add(dim[0] * dim[1]);
sides.Add(dim[0] * dim[2]);
sides.Add(dim[1] * dim[2]);
int smallest = int.MaxValue;
foreach (var s in sides)
{
if (smallest > s)
{
smallest = s;
}
}
var area = 2 * sides[0] + 2 * sides[1] + 2 * sides[2] + smallest;
totalArea += area;
}
WriteLine(totalArea);
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
int validTriangleCount = 0;
while (true)
{
List <List <int> > inputs = new List <List <int> >();
for (int i = 0; i < 3; i++)
{
var rawInput = reader.ReadLine();
if (string.IsNullOrEmpty(rawInput))
{
break;
}
inputs.Add(GetSides(rawInput).ToList());
}
if (inputs.Count < 3)
{
break;
}
for (int i = 0; i < 3; i++)
{
if (CheckTriangle(inputs[0][i], inputs[1][i], inputs[2][i]))
{
validTriangleCount++;
}
}
}
WriteLine($"# valid triangles: {validTriangleCount}");
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
var input = reader.ReadLine();
int lastLength = 0;
for (int i = 0; i < 40; i++)
{
string newString = string.Empty;
int idx = 0;
while (idx < input.Length)
{
char current = input[idx];
int counter = 0;
while (idx < input.Length && input[idx] == current)
{
idx++;
counter++;
}
newString += counter.ToString();
newString += current;
}
//WriteLine(newString);
input = newString;
lastLength = newString.Length;
}
WriteLine(lastLength);
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
string salt = ReadLine();
int keyToFind = int.Parse(ReadLine());
Solve(salt, keyToFind);
//WriteLine(Solve(salt));
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
Dictionary <string, Entity> entities = new Dictionary <string, Entity>();
while (!reader.EndOfStream)
{
var input = reader.ReadLine();
if (string.IsNullOrEmpty(input))
{
break;
}
ParseInput(input, entities);
}
while (Process(entities))
{
;
}
var output0 = entities["Output_0"];
var output1 = entities["Output_1"];
var output2 = entities["Output_2"];
WriteLine($"Output 0: {output0.Value}");
WriteLine($"Output 1: {output1.Value}");
WriteLine($"Output 2: {output2.Value}");
WriteLine();
WriteLine($"Multiplied: {output0.Value * output1.Value * output2.Value}");
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
var input = reader.ReadLine();
long suffix = 0;
var password = string.Empty;
for (int i = 0; i < 8; i++)
{
var md5 = string.Empty;
while (!md5.StartsWith("00000"))
{
md5 = CalculateMD5($"{input}{suffix}");
//WriteLine($"[{i}] MD5 of {input}{suffix} = {md5}");
suffix++;
if (suffix % 100000 == 0)
{
int tmp = (int)(suffix / 100000);
int a = tmp / 10;
int b = tmp % 10;
WriteLine($"{a}.{b}e6 - {i}/8");
}
}
password += md5[5];
}
WriteLine($"Password: {password}");
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
var input = reader.ReadLine();
ExpandResult result = Expand(input, 0, input.Length);
//WriteLine($"{result.ExpandedString}: {result.ExpandedLength}");
WriteLine($"{result.ExpandedLength}");
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
var input = reader.ReadLine();
do
{
input = Increase(input);
} while (!IsValid(input));
WriteLine(input);
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
var input = reader.ReadLine();
int sum = 0;
int counter = 0;
foreach (var c in input)
{
if (c == '(')
{
sum++;
}
if (c == ')')
{
sum--;
}
counter++;
if (sum == -1)
{
WriteLine(counter);
break;
}
}
}
public void Run(string[] args)
{
const int width = 50, height = 6;
bool[] display = new bool[width * height];
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
while (!reader.EndOfStream)
{
PrintDisplay(display, width, height);
var input = reader.ReadLine();
if (string.IsNullOrEmpty(input))
{
break;
}
var split = input.Split(' ');
if (split[0] == "rect")
{
var rectSize = split[1].Split('x');
int xx = int.Parse(rectSize[0]);
int yy = int.Parse(rectSize[1]);
for (int y = 0; y < yy; y++)
{
for (int x = 0; x < xx; x++)
{
display[y * width + x] = true;
}
}
}
else
{
int index = int.Parse(split[2].Split('=')[1]);
int offset = int.Parse(split[4]);
char c = split[1][0];
if (c == 'r')
{
int y = index;
for (int steps = 0; steps < offset; steps++)
{
bool b = display[y * width + width - 1];
for (int x = width - 1; x > 0; x--)
{
//WriteLine($"{y*width + x} {y*width + x - 1}");
display[y * width + x] = display[y * width + x - 1];
}
display[y * width] = b;
}
}
else
{
int x = index;
for (int steps = 0; steps < offset; steps++)
{
bool b = display[(height - 1) * width + x];
for (int y = height - 1; y > 0; y--)
{
//WriteLine($"{y*width + x} {y*width + x - 1}");
display[y * width + x] = display[(y - 1) * width + x];
}
display[x] = b;
}
}
}
WriteLine(input);
//ReadKey();
}
PrintDisplay(display, width, height);
int sum = 0;
for (int i = 0; i < width * height; i++)
{
if (display[i])
{
sum++;
}
}
WriteLine(sum);
}
public void Run(string[] args)
{
shortestPathLength = int.MaxValue;
shortestPath = null;
nodes = new Dictionary <string, Node>();
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
while (!reader.EndOfStream)
{
var input = reader.ReadLine();
if (string.IsNullOrEmpty(input))
{
break;
}
var split = input.Split(new [] { "to", "=" }, StringSplitOptions.None);
Node node1, node2;
var node1Tag = split[0].Trim();
var node2Tag = split[1].Trim();
if (!nodes.TryGetValue(node1Tag, out node1))
{
node1 = new Node(node1Tag.Trim());
nodes.Add(node1Tag, node1);
}
if (!nodes.TryGetValue(node2Tag, out node2))
{
node2 = new Node(node2Tag.Trim());
nodes.Add(node2Tag, node2);
}
node1.Neighbors.Add(node2, int.Parse(split[2]));
node2.Neighbors.Add(node1, int.Parse(split[2]));
}
/*
* foreach(var n in nodes.Values)
* {
* Write($"{n.Tag} | ");
* foreach(var neigh in n.Neighbors)
* {
* Write($"{neigh.Key.Tag}: {neigh.Value} | ");
* }
* WriteLine();
* }
*/
foreach (var n in nodes.Values)
{
List <string> visited = new List <string>();
visited.Add(n.Tag);
FindShortestPath(n, visited, 0, 0);
}
Write("Shortest path: ");
foreach (var s in shortestPath)
{
Write($"{s} -> ");
}
WriteLine($"\b\b\b({shortestPathLength})");
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
Dictionary <string, Person> people = new Dictionary <string, Person>();
while (!reader.EndOfStream)
{
var input = reader.ReadLine();
if (string.IsNullOrEmpty(input))
{
break;
}
var split = input.Split(' ');
string p1 = split[0];
string gainLose = split[2];
string happinessStr = split[3];
string p2 = split[10];
p2 = p2.Substring(0, p2.Length - 1);
int happiness = int.Parse(happinessStr);
if (gainLose == "lose")
{
happiness *= -1;
}
Person person;
if (!people.TryGetValue(p1, out person))
{
person = new Person(p1);
people.Add(p1, person);
}
person.HapinessModifier.Add(p2, happiness);
//WriteLine($"{p1} = {p2}: {(happiness > 0 ? '+' : ' ')}{happiness}");
}
string me = "Me";
Person mePerson = new Person(me);
foreach (var p in people.Values)
{
mePerson.HapinessModifier.Add(p.Name, 0);
p.HapinessModifier.Add(me, 0);
}
people.Add(mePerson.Name, mePerson);
Person pStart = people.First().Value;
List <string> visited = new List <string>();
visited.Add(pStart.Name);
//PrintPeople(people);
Permutate(people, visited);
WriteLine(maxHappiness);
PrintNeighborList(maxHappinessOrder);
}
public void Run(string[] args)
{
int matrixSize = 1000;
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
bool[] lights = new bool[matrixSize * matrixSize];
while (!reader.EndOfStream)
{
//PrintMatrix(lights);
var inputRaw = reader.ReadLine();
if (string.IsNullOrEmpty(inputRaw))
{
break;
}
Tuple <Operation, Point, Point> input;
try
{
input = ParseInput(inputRaw);
//WriteLine($"{input.Item1} [{input.Item2.X}, {input.Item2.Y}]::[{input.Item3.X}, {input.Item3.Y}]");
}
catch (System.Exception)
{
WriteLine("Invalid input, skipping");
continue;
}
var op = input.Item1;
var p1 = input.Item2;
var p2 = input.Item3;
int minX, minY;
int maxX, maxY;
if (p1.X > p2.X)
{
minX = p2.X;
maxX = p1.X;
}
else
{
minX = p1.X;
maxX = p2.X;
}
if (p1.Y > p2.Y)
{
minY = p2.Y;
maxY = p1.Y;
}
else
{
minY = p1.Y;
maxY = p2.Y;
}
for (int y = minY; y <= maxY; y++)
{
for (int x = minX; x <= maxX; x++)
{
int pos = y * matrixSize + x;
if (op == Operation.TurnOn)
{
lights[pos] = true;
}
else if (op == Operation.TurnOff)
{
lights[pos] = false;
}
else if (op == Operation.Toggle)
{
lights[pos] = !lights[pos];
}
}
}
}
var totalSize = matrixSize * matrixSize;
var lightsCount = 0;
for (int i = 0; i < totalSize; i++)
{
if (lights[i])
{
lightsCount++;
}
}
WriteLine(lightsCount);
}
public void Run(string[] args)
{
IReader reader;
string keypad =
"*******" +
"***1***" +
"**234**" +
"*56789*" +
"**ABC**" +
"***D***" +
"*******";
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
Point p = new Point {
X = 1, Y = 3
};
List <char> code = new List <char>();
while (!reader.EndOfStream)
{
var input = reader.ReadLine();
if (string.IsNullOrEmpty(input))
{
break;
}
foreach (var c in input)
{
Point newP = new Point {
X = p.X, Y = p.Y
};
switch (c.ToString().ToUpper()[0])
{
case 'D':
newP.Y++;
break;
case 'U':
newP.Y--;
break;
case 'L':
newP.X--;
break;
case 'R':
newP.X++;
break;
}
int newIndex = newP.Y * 7 + newP.X;
if (keypad[newIndex] != '*')
{
p = newP;
}
}
code.Add(keypad[p.Y * 7 + p.X]);
}
foreach (var c in code)
{
Console.Write(c);
}
Console.WriteLine();
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
var input = reader.ReadLine();
HashSet <Point> visited = new HashSet <Point>();
Point santa = new Point(0, 0);
Point roboSanta = new Point(0, 0);
visited.Add(santa);
bool roboSantaMoves = false;
foreach (var move in input)
{
int dX = 0, dY = 0;
switch (move)
{
case '^':
dY = -1;
break;
case '<':
dX = -1;
break;
case '>':
dX = 1;
break;
case 'v':
dY = 1;
break;
default:
throw new InvalidOperationException();
}
if (roboSantaMoves)
{
roboSanta = new Point(roboSanta.X + dX, roboSanta.Y + dY);
visited.Add(roboSanta);
roboSantaMoves = false;
}
else
{
santa = new Point(santa.X + dX, santa.Y + dY);
visited.Add(santa);
roboSantaMoves = true;
}
}
WriteLine(visited.Count());
}
public void Run(string[] args)
{
IReader reader;
if (args.Length > 0)
{
reader = new FileReader(args[0]);
}
else
{
reader = new ConsoleReader();
}
Point p = new Point {
X = 1, Y = 1
};
List <int> code = new List <int>();
while (!reader.EndOfStream)
{
var input = reader.ReadLine();
if (string.IsNullOrEmpty(input))
{
break;
}
foreach (var c in input)
{
switch (c.ToString().ToUpper()[0])
{
case 'D':
p.Y++;
if (p.Y > 2)
{
p.Y = 2;
}
break;
case 'U':
p.Y--;
if (p.Y < 0)
{
p.Y = 0;
}
break;
case 'L':
p.X--;
if (p.X < 0)
{
p.X = 0;
}
break;
case 'R':
p.X++;
if (p.X > 2)
{
p.X = 2;
}
break;
}
}
code.Add(p.Y * 3 + p.X + 1);
}
foreach (var c in code)
{
Console.Write(c);
}
Console.WriteLine();
}
