private IDictionary <string, Guest> ParseGuests(IPuzzleInput input)
{
var guests = new Dictionary <string, Guest>();
foreach (var line in input.ReadLines())
{
var(name, _, direction, points, _, _, _, _, _, _, neighbor, rest) = line.Trim(' ', '.').Split(' ');
if (!guests.ContainsKey(name))
{
guests.Add(name, new Guest(new Dictionary <string, int>()));
}
var modifier = direction switch
{
"lose" => - 1,
_ => 1
};
if (!guests[name].Neighbors.ContainsKey(neighbor))
{
var number = int.Parse(points) * modifier;
guests[name].Neighbors.Add(neighbor, number);
}
}
return(guests);
}
}
protected ActivityMap(IPuzzleInput <bool[][]> input)
{
map = Enumerable.Range(0, input.Value.Length)
.SelectMany(j => Enumerable.Range(0, input.Value[j].Length)
.Select(i => new KeyValuePair <T, bool>(Construct(i, j), input.Value[j][i])))
.ToDictionary(pair => pair.Key, pair => pair.Value);
}
public WaypointNavigator(IPuzzleInput puzzleInput)
{
_puzzleInput = puzzleInput;
_heading = 0;
_currentPosition = Point.Empty;
_waypoint = new Point(10, 1);
}
private string Part1(IPuzzleInput <IEnumerable <char[][]> > input)
{
var answer = input.Value
.Select(group => group.SelectMany(chars => chars.Select(c => c)).Distinct().ToArray())
.Aggregate(0, (i, chars) => i + chars.Length);
return(answer.ToString());
}
private string Part2(IPuzzleInput <IEnumerable <char[][]> > input)
{
var answer = input.Value
.Select(group => group.SelectMany(person => person.Select(c => c))
.Distinct()
.Count(c => group.All(person => person.Contains(c))))
.Aggregate((i, i1) => i + i1);
return(answer.ToString());
}
private IList <int> ParseContainers(IPuzzleInput input)
{
List <int> containers = new();
foreach (var line in input.ReadLines())
{
containers.Add(int.Parse(line));
}
return(containers);
}
public InputChecker(IPuzzleInput puzzleInput, [Dependency(nameof(CycleRunner3D))] ICycleRunner cycleRunner3,
[Dependency(nameof(InputParser3D))] IInputParser inputParser3,
[Dependency(nameof(CycleRunner4D))] ICycleRunner cycleRunner4,
[Dependency(nameof(InputParser4D))] IInputParser inputParser4)
{
_puzzleInput = puzzleInput;
_cycleRunner3 = cycleRunner3;
_inputParser3 = inputParser3;
_cycleRunner4 = cycleRunner4;
_inputParser4 = inputParser4;
}
private IList <Reindeer> ParseReindeer(IPuzzleInput input)
{
var list = new List <Reindeer>();
foreach (var line in input.ReadLines())
{
var(name, _, _, speed, _, _, flySeconds, _, _, _, _, _, _, restSeconds, _) = line.Split(' ');
list.Add(new Reindeer(name, int.Parse(speed), int.Parse(flySeconds), int.Parse(restSeconds)));
}
return(list);
}
private string Part1(IPuzzleInput <IEnumerable <int> > input)
{
var memory = input.Value.ToList();
for (int idx = memory.Count; idx < 2020; idx++)
{
var turn = memory.LastIndexOf(memory[idx - 1], idx - 2, idx - 1);
memory.Add(idx - 1 - (turn == -1 ? idx - 1 : turn));
}
var answer = memory[2020 - 1];
return(answer.ToString());
}
public _24(IPuzzleInput input)
{
var packages = new List <ulong>();
foreach (var line in input.ReadLines())
{
if (ushort.TryParse(line, out var package))
{
packages.Add(package);
}
}
_packages = packages.OrderByDescending(p => p).ToArray();
}
private Character ParseEnemy(IPuzzleInput input)
{
Character enemy = new();
var type = enemy.GetType();
foreach (var line in input.ReadLines())
{
var(key, value, _) = line.Split(":");
var property = type.GetProperty(key.Replace(" ", ""));
if (property != null)
{
property.SetValue(enemy, int.Parse(value));
}
}
return(enemy);
}
private string Part1(IPuzzleInput <IEnumerable <int> > input)
{
var entries = input.Value.ToArray();
for (var i = 0; i < entries.Length; i++)
{
for (var j = i + 1; j < entries.Length; j++)
{
var sum = entries[i] + entries[j];
if (sum == 2020)
{
var answer = entries[i] * entries[j];
return(answer.ToString());
}
}
}
return(null);
}
private IList <Ingredient> ParseIngredients(IPuzzleInput input)
{
var list = new List <Ingredient>();
var separators = new[] { ' ', ',', ':' };
foreach (var line in input.ReadLines())
{
var(name, _, capacity, _, durability, _, flavor, _, texture, _, calories, _) = line.Split(separators, StringSplitOptions.RemoveEmptyEntries);
list.Add(new Ingredient(
name,
int.Parse(capacity),
int.Parse(durability),
int.Parse(flavor),
int.Parse(texture),
int.Parse(calories)
));
}
return(list);
}
private static IDictionary <string, Instruction> ParseInstructions(IPuzzleInput input)
{
var result = new Dictionary <string, Instruction>();
foreach (var line in input.ReadLines())
{
var(inputs, wire, _) = line.Split(" -> ");
var tokens = inputs.Split(" ");
string leftOperand = null;
string operatorStr = null;
string rightOperand = null;
switch (tokens.Length)
{
case 1:
(leftOperand, _) = tokens;
break;
case 2:
(operatorStr, rightOperand, _) = tokens;
break;
case 3:
(leftOperand, operatorStr, rightOperand, _) = tokens;
break;
}
Operator? @operator = null;
if (!string.IsNullOrWhiteSpace(operatorStr) && Enum.TryParse <Operator>(operatorStr, true, out var operatorEnum))
{
@operator = operatorEnum;
}
result.Add(wire, new Instruction(leftOperand, @operator, rightOperand));
}
return(result);
}
public InputChecker(IPuzzleInput puzzleInput, ITree <JoltNode> joltTree, ITree <PathNode> pathTree)
{
_puzzleInput = puzzleInput;
_joltTree = joltTree;
_pathTree = pathTree;
}
public void OnUpdateSelectable(IPuzzleInput _input)
{
throw new System.NotImplementedException();
}
public void OnUpdateSelectable(IPuzzleInput _input)
{
}
private string Part2(IPuzzleInput <IEnumerable <int> > input)
{
var start = input.Value.ToArray();
var memoized = start[..^ 1].Zip(Enumerable.Range(0, start.Length - 1))
public _12(IPuzzleInput input) => _input = input.ReadToEnd();
public _05(IPuzzleInput input) => _doorId = input.ReadToEnd();
public _21(IPuzzleInput input) => _enemy = ParseEnemy(input);
public _17(IPuzzleInput input) => _containers = ParseContainers(input);
public Map(IPuzzleInput puzzleInput)
{
_puzzleInput = puzzleInput;
}
public InputChecker(IPuzzleInput puzzleInput)
{
_puzzleInput = puzzleInput;
}
public _05(IPuzzleInput input) => _input = input;
public Navigator(IPuzzleInput puzzleInput)
{
_puzzleInput = puzzleInput;
_heading = 0;
_currentPosition = Point.Empty;
}
public _22(IPuzzleInput input) => _boss = new(input);
public _20(IPuzzleInput input) => _input = uint.Parse(input.ReadToEnd());
public PasswordProcessor(IPuzzleInput puzzleInput, IPasswordPolicyFactory passwordPolicyFactory)
{
_puzzleInput = puzzleInput;
_passwordPolicyFactory = passwordPolicyFactory;
}
public _18(IPuzzleInput input) => _input = input;
