public static void solve()
{
var input = InputLoader.loadAsStringArray("10");
List <Asteroid> asteroids = load(input);
for (int i = 0; i < asteroids.Count; i++)
{
for (int j = 0; j < asteroids.Count; j++)
{
if (i != j)
{
asteroids[i].asteroidSight.Add(getSlope(asteroids[i], asteroids[j]));
}
}
}
var best = 0;
foreach (var asteroid in asteroids)
{
best = Math.Max(best, asteroid.asteroidSight.Count);
}
Console.WriteLine(best);
}
public static void solve()
{
var input = InputLoader.loadAsStringArray("12");
var regex = new Regex("<x=(.+), y=(.+), z=(.+)>");
var moons = new List <Moon>();
foreach (var line in input)
{
MatchCollection matches = regex.Matches(line);
var moon = new Moon();
moon.x = int.Parse(matches[0].Groups[1].Value);
moon.y = int.Parse(matches[0].Groups[2].Value);
moon.z = int.Parse(matches[0].Groups[3].Value);
moons.Add(moon);
}
for (var step = 0; step < 1000; step++)
{
// Apply gravity.
for (var i = 0; i < moons.Count - 1; i++)
{
for (var j = i + 1; j < moons.Count; j++)
{
var gravityX = moons[i].x <moons[j].x ? 1 : moons[i].x> moons[j].x ? -1 : 0;
moons[i].vx += gravityX;
moons[j].vx -= gravityX;
var gravityY = moons[i].y <moons[j].y ? 1 : moons[i].y> moons[j].y ? -1 : 0;
moons[i].vy += gravityY;
moons[j].vy -= gravityY;
var gravityZ = moons[i].z <moons[j].z ? 1 : moons[i].z> moons[j].z ? -1 : 0;
moons[i].vz += gravityZ;
moons[j].vz -= gravityZ;
}
}
// Apply velocity
foreach (var moon in moons)
{
moon.x += moon.vx;
moon.y += moon.vy;
moon.z += moon.vz;
}
}
var sum = 0;
foreach (var moon in moons)
{
sum += (Math.Abs(moon.x) + Math.Abs(moon.y) + Math.Abs(moon.z)) * (Math.Abs(moon.vx) + Math.Abs(moon.vy) + Math.Abs(moon.vz));
}
Console.WriteLine(sum);
}
public static void solve()
{
var input = InputLoader.loadAsStringArray("03");
var wire1Inputs = input[0].Split(",");
var wire2Inputs = input[1].Split(",");
var wire1 = new Wire();
var wire2 = new Wire();
var wire1Path = new Dictionary <Tuple <int, int>, bool>();
wire1.move(wire1Inputs, (int x, int y) =>
{
if (!wire1Path.ContainsKey(Tuple.Create(x, y)))
{
wire1Path.Add(Tuple.Create(x, y), true);
}
});
var closest = Int32.MaxValue;
wire2.move(wire2Inputs, (int x, int y) =>
{
if (wire1Path.ContainsKey(Tuple.Create(x, y)))
{
closest = Math.Min(closest, Math.Abs(x) + Math.Abs(y));
}
});
Console.WriteLine(closest);
}
public static void solve()
{
var input = InputLoader.loadAsStringArray("14");
var recipies = parse(input);
Dictionary <string, int> availableIngredients = new Dictionary <string, int>();
var fuelCount = 0;
var fuelAmountPerIteration = 1000;
var ore = 1000000000000;
while (true)
{
var cost = getOreCost(recipies, availableIngredients, fuelAmountPerIteration, "FUEL");
if (cost > ore)
{
if (fuelAmountPerIteration > 1)
{
fuelAmountPerIteration /= 2;
continue;
}
break;
}
ore -= cost;
fuelCount += fuelAmountPerIteration;
}
Console.WriteLine(fuelCount);
}
public static void solve()
{
var input = InputLoader.loadAsStringArray("06");
var planets = load(input);
var you = planets["YOU"];
var san = planets["SAN"];
LinkedList <string> youAncestors = new LinkedList <string>();
for (var current = you.orbitsAround; current != null; current = current.orbitsAround)
{
youAncestors.AddFirst(current.id);
}
LinkedList <string> sanAncestors = new LinkedList <string>();
for (var current = san.orbitsAround; current != null; current = current.orbitsAround)
{
sanAncestors.AddFirst(current.id);
}
var currentYou = youAncestors.First;
var currentSan = sanAncestors.First;
while (currentYou != null && currentSan != null)
{
if (currentYou.Value != currentSan.Value)
{
break;
}
currentYou = currentYou.Next;
currentSan = currentSan.Next;
}
var distanceToYou = 0;
for (; currentYou != null; currentYou = currentYou.Next)
{
distanceToYou++;
}
var distanceToSan = 0;
for (; currentSan != null; currentSan = currentSan.Next)
{
distanceToSan++;
}
Console.WriteLine(distanceToSan + distanceToYou);
}
public static void solve()
{
var input = InputLoader.loadAsStringArray("14");
var recipies = parse(input);
Dictionary <string, int> availableIngredients = new Dictionary <string, int>();
var cost = getOreCost(recipies, availableIngredients, 1, "FUEL");
Console.WriteLine(cost);
}
public static void solve()
{
var input = InputLoader.loadAsStringArray("12");
var moons = load(input);
var stepX = getStepsToRepeat(moons, 0);
var stepY = getStepsToRepeat(moons, 1);
var stepZ = getStepsToRepeat(moons, 2);
Console.WriteLine(lcm(lcm(stepX, stepY), stepZ));
}
public static void solve()
{
var input = InputLoader.loadAsStringArray("01");
var sum = 0;
foreach (var line in input)
{
var mass = Int32.Parse(line);
sum += getRequiredFuel(mass);
}
Console.WriteLine(sum);
}
public static void solve()
{
var input = InputLoader.loadAsStringArray("06");
var planets = new Dictionary <string, Planet>();
foreach (var line in input)
{
var planetIds = line.Split(")");
Planet parent;
if (planets.ContainsKey(planetIds[0]))
{
parent = planets[planetIds[0]];
}
else
{
planets.Add(planetIds[0], parent = new Planet());
}
Planet child;
if (planets.ContainsKey(planetIds[1]))
{
child = planets[planetIds[1]];
}
else
{
planets.Add(planetIds[1], child = new Planet());
}
child.orbitsAround = parent;
}
var sum = 0;
foreach (var planet in planets.Values)
{
sum += planet.getTotalOrbitCount();
}
Console.WriteLine(sum);
}
public static void solve()
{
var input = InputLoader.loadAsStringArray("10");
List <Asteroid> asteroids = load(input);
for (int i = 0; i < asteroids.Count; i++)
{
for (int j = 0; j < asteroids.Count; j++)
{
if (i == j)
{
continue;
}
var slope = getSlope(asteroids[i], asteroids[j]);
if (!asteroids[i].directions.ContainsKey(slope))
{
asteroids[i].directions[slope] = new List <Asteroid>();
}
asteroids[i].directions[slope].Add(asteroids[j]);
}
foreach (var asteroidsInDirection in asteroids[i].directions.Values)
{
asteroidsInDirection.Sort((Asteroid a, Asteroid b) =>
{
var distance1 = getDistance(asteroids[i], a);
var distance2 = getDistance(asteroids[i], b);
return(distance1.CompareTo(distance2));
});
}
}
Asteroid monitoringStation = getBestMonitoringStation(asteroids);
// Console.WriteLine(monitoringStation.x + ","+ monitoringStation.y);
var order = new List <Tuple <int, int> >(monitoringStation.directions.Keys);
order.Sort((Tuple <int, int> a, Tuple <int, int> b) =>
{
var angle1 = getAngle(0, 0, a.Item1, a.Item2);
var angle2 = getAngle(0, 0, b.Item1, b.Item2);
return(angle1.CompareTo(angle2));
});
var vaporiseCount = 0;
while (vaporiseCount < 200)
{
foreach (var tuple in order)
{
var asteroidsInDirection = monitoringStation.directions[tuple];
if (asteroidsInDirection.Count > 0)
{
vaporiseCount++;
if (vaporiseCount == 200)
{
Console.WriteLine(asteroidsInDirection[0].x * 100 + asteroidsInDirection[0].y);
}
asteroidsInDirection.RemoveAt(0);
}
}
}
}
