public void Part2Exercise()
{
var input = File.ReadAllText("day14.txt");
var p2 = RecipeGraph.Part2(input);
p2.Should().Be(1993284);
}
public void SolutionModify()
{
var item1 = new Item("a");
var item2 = new Item("b");
Recipe r = new Recipe("");
r.AddIngredient(new ItemAmount(item1, 1));
r.AddResult(new ItemAmount(item2, 1));
r.CraftingCategory = "test";
Building b = new Building("");
b.AddCraftingCategory("test");
b.IngredientCount = 4;
b.ProductionSpeed = 1;
Library l = new Library();
l.AddItem(item1);
l.AddItem(item2);
l.AddRecipe(r);
l.AddBuilding(b);
l.Initialize();
var coarseGraph = RecipeGraph.FromLibrary(l, new Item[] { item1 }, new ItemAmount[] { new ItemAmount(item2, 0.01) }, (a) => 1);
var denseGraph = TrivialSolutionFactory.CreateFactory(coarseGraph);
var parameters = SolutionParameters.FromFactory(12, 12, denseGraph);
Assert.AreEqual(parameters, parameters.Modify(0));
}
public void Part1Example2()
{
var input =
"9 ORE => 2 A\n8 ORE => 3 B\n7 ORE => 5 C\n3 A, 4 B => 1 AB\n5 B, 7 C => 1 BC\n4 C, 1 A => 1 CA\n2 AB, 3 BC, 4 CA => 1 FUEL";
RecipeGraph.Part1(input).Should().Be(165);
}
public void Part1Exercise()
{
var input = File.ReadAllText("day14.txt");
var result = RecipeGraph.Part1(input);
result.Should().Be(720484);
}
public void Part1Example1()
{
var input =
"10 ORE => 10 A\n1 ORE => 1 B\n7 A, 1 B => 1 C\n7 A, 1 C => 1 D\n7 A, 1 D => 1 E\n7 A, 1 E => 1 FUEL\n";
RecipeGraph.Part1(input).Should().Be(31);
}
public static SolutionParameters FromFactory(int width, int height, RecipeGraph factory)
{
if (factory == null)
{
throw new ArgumentNullException("factory");
}
var result = new SolutionParameters(width, height);
result.SinkPositions = factory.OutputNodes.Concat(factory.WasteNodes).Select((s) => new KeyValuePair <SinkStep, Vector2>(s, Vector2.Zero)).ToImmutableDictionary();
result.SourcePositions = factory.InputNodes.Select((s) => new KeyValuePair <SourceStep, Vector2>(s, Vector2.Zero)).ToImmutableDictionary();
var buildings = factory.Transformations.Cast <ProductionStep>().ToImmutableList();
result.BuildingPositions = buildings.Select((b) => new KeyValuePair <ProductionStep, Tuple <Vector2, BuildingRotation> >(b, new Tuple <Vector2, BuildingRotation>(Vector2.Zero, BuildingRotation.North))).ToImmutableDictionary();
var buildingInputs = buildings.SelectMany((b) => b.Recipe.Ingredients.Select((i) => new Tuple <IStep, Item, bool>(b, i.Item, true)));
var buildingOutputs = buildings.SelectMany((b) => b.Recipe.Results.Select((i) => new Tuple <IStep, Item, bool>(b, i.Item, false)));
var sinkInputs = result.SinkPositions.Keys.Select((s) => new Tuple <IStep, Item, bool>(s, s.Item.Item, true));
var sourceOutputs = result.SourcePositions.Keys.Select((s) => new Tuple <IStep, Item, bool>(s, s.Item.Item, false));
result.Connections = buildingInputs.Concat(buildingOutputs).Concat(sinkInputs).Concat(sourceOutputs).ToImmutableList();
for (int i = 0; i < 4; i++)
{
result = result.Modify(1);
}
return(result);
}
private void UpdateResultView()
{
solveButton.Enabled = false;
var inputs = ParseDataView(ingredientsView);
var outputs = ParseDataView(outputView);
if (inputs == null || outputs == null)
{
return;
}
var costs = new Dictionary <Item, double>();
foreach (var item in inputs)
{
costs.Add(item.Item1, item.Item2);
}
var outputAmounts = outputs.Select((t) => new ItemAmount(t.Item1, t.Item2));
try
{
var graph = RecipeGraph.FromLibrary(_library, inputs.Select((t) => t.Item1), outputAmounts, (i) => costs[i]);
if (expandCheckbox.CheckState == CheckState.Checked)
{
graph = TrivialSolutionFactory.CreateFactory(graph);
}
resultView.Text = string.Join("\r\n", graph.Children.AsDot());
_recipe = graph;
solveButton.Enabled = true;
}
catch (Exception e)
{
resultView.Text = e.Message;
}
}
public SolutionGenerator(RecipeGraph factory)
{
Factory = factory;
Grader = new SolutionGrader();
}
public static RecipeGraph CreateFactory(RecipeGraph recipe)
{
if (recipe == null)
{
throw new ArgumentNullException("recipe");
}
var inputs = new List <SourceStep>();
var outputs = new List <SinkStep>();
var wastes = new List <SinkStep>();
var resources = new List <FlowStep>();
var transforms = new List <TransformStep>();
foreach (var resource in recipe.Resources)
{
resources.Add(new FlowStep(resource.Item)
{
Parent = resource
});
}
foreach (var input in recipe.InputNodes)
{
var r = new FlowStep(input.Item)
{
Parent = input
};
var s = new SourceStep(input.Item)
{
Parent = input
};
r.Previous.Add(s);
resources.Add(r);
inputs.Add(s);
}
foreach (var output in recipe.OutputNodes)
{
var r = new FlowStep(output.Item)
{
Parent = output
};
var o = new SinkStep(output.Item)
{
Parent = output
};
o.Previous.Add(r);
resources.Add(r);
outputs.Add(o);
}
foreach (var waste in recipe.WasteNodes)
{
var w = new SinkStep(waste.Item)
{
Parent = waste
};
wastes.Add(w);
w.Previous.Add(resources.Where((r) => r.Item.Item == waste.Item.Item).First());
}
foreach (var transform in recipe.Transformations)
{
var amount = transform.Amount;
var transformRecipe = transform.Recipe;
var building = FirstMatchingBuilding(transformRecipe.Buildings);
var modTime = building.MaxProductionFor(transformRecipe);
var nrOfFactories = Math.Ceiling(amount / modTime);
for (int i = 0; i < nrOfFactories; i++)
{
var p = new ProductionStep(transform.Recipe, transform.Amount / nrOfFactories, building)
{
Parent = transform
};
foreach (var input in transformRecipe.Ingredients)
{
p.Previous.Add(resources.Where((r) => r.Item.Item == input.Item).First());
}
foreach (var output in transformRecipe.Results)
{
resources.Where((r) => r.Item.Item == output.Item).First().Previous.Add(p);
}
transforms.Add(p);
}
}
return(new RecipeGraph(wastes, inputs, outputs, resources, transforms));
}
