int GetCount(BagRule bagRule)
{
if (canHold.ContainsKey(bagRule.Name))
{
return(canHold[bagRule.Name]);
}
if (bagRule.Contains.Count == 0)
{
canHold[bagRule.Name] = 0;
return(0);
}
else
{
var cnt = 0;
foreach (var contains in bagRule.Contains)
{
if (contains.Item1 == "shiny gold")
{
cnt += contains.Item2 * 1;
}
else
{
var targetBagRule = bagRules.FirstOrDefault(b => b.Name == contains.Item1);
cnt += contains.Item2 * GetCount(targetBagRule);
}
}
canHold[bagRule.Name] = cnt;
return(cnt);
}
}
public async Task <string> ExecuteAsync(string[] data)
{
var bagRules = new List <BagRule>();
foreach (var rules in data)
{
var ruleParts = rules.Split(_bagToRuleDelimiter, StringSplitOptions.RemoveEmptyEntries);
var bagRule = new BagRule(ruleParts[0]);
if ((ruleParts[1] != _emptyBagPhrase))
{
var containedBagsParts = ruleParts[1].Remove(ruleParts[1].Length - 1, 1).Split(_containedBagDelimiter, StringSplitOptions.RemoveEmptyEntries);
var containedBags = containedBagsParts
.Select(x => x.Replace(_bagsSuffix, string.Empty).Replace(_bagSuffix, string.Empty).Split(_bagRuleDelimiter, StringSplitOptions.RemoveEmptyEntries))
.Select(x => new BagContents(int.Parse(x[0]), string.Join(_bagRuleDelimiter, x.Skip(1))))
.ToList();
bagRule.AddContents(containedBags);
bagRules.Add(bagRule);
}
else
{
bagRules.Add(bagRule);
}
}
return(CountBags(bagRules).ToString());
}
private void GetBagsInside(BagRule bag, string input)
{
var splitOnComma = input.Split(',');
foreach (var bagLine in splitOnComma)
{
bag.BagsInside.Add(GetBagColorAndNumber(bagLine));
}
}
public void BagRuleTest1()
{
var bagRule = new BagRule("light red bags contain 1 bright white bag, 2 muted yellow bags.");
bagRule.ContainerBag.Should().Be("light-red");
bagRule.ContainedBags.Should().Equal(new List <Bag> {
new Bag(1, "bright-white"), new Bag(2, "muted-yellow")
});
}
public void BagRuleParsesInputCorrectly(int expectedCount, string expectedColour, string ruleAsString)
{
// Arrange / Act
var sut = new BagRule(ruleAsString);
// Assert
sut.RequiredCount.Should().Be(expectedCount);
sut.BagColour.Should().Be(expectedColour);
}
public void CountAnswers2(string ruleString)
{
BagRule g = ruleString.ParseLuggageRule();
g.BagColor.Should().Be("bright white");
g.MustContain.Should().HaveCount(1);
g.MustContain[0].Quantity.Should().Be(1);
g.MustContain[0].Color.Should().Be("shiny gold");
}
public void CountAnswers3(string ruleString)
{
BagRule g = ruleString.ParseLuggageRule();
g.BagColor.Should().Be("muted yellow");
g.MustContain.Should().HaveCount(2);
g.MustContain[0].Quantity.Should().Be(2);
g.MustContain[0].Color.Should().Be("shiny gold");
g.MustContain[1].Quantity.Should().Be(9);
g.MustContain[1].Color.Should().Be("faded blue");
}
private int GetNestedBagCount(BagRule bag)
{
int count = 0;
foreach (var subBag in bag.Contents)
{
count += subBag.Value * GetNestedBagCount(bagRules.Single(b => b.Description == subBag.Key)) + subBag.Value;
}
return(count);
}
public void CountAnswers1(string ruleString)
{
BagRule g = ruleString.ParseLuggageRule();
g.BagColor.Should().Be("light red");
g.MustContain.Should().HaveCount(2);
g.MustContain[0].Quantity.Should().Be(1);
g.MustContain[0].Color.Should().Be("bright white");
g.MustContain[1].Quantity.Should().Be(2);
g.MustContain[1].Color.Should().Be("muted yellow");
}
private long CountNumberOfBagsInBag(BagRule bag)
{
long numberOfBags = 0;
foreach (var bagInside in bag.BagsInside)
{
var bagsInside = bags.Where(x => x.Bag == bagInside.BagColor);
numberOfBags += bagInside.NumberOfBags + bagInside.NumberOfBags * CountNumberOfBags(bagsInside);
}
return(numberOfBags);
}
public void AddRule(BagRule rule)
{
Rules.Add(rule.BagName, rule);
foreach (BagWithCount bag in rule.ContainedBags)
{
if (!ContainedBy.ContainsKey(bag.BagName))
{
ContainedBy[bag.BagName] = new List <string>();
}
ContainedBy[bag.BagName].Add(rule.BagName);
}
}
public static BagDefinition Parse(string input)
{
var definition = new BagDefinition();
var inputs = input.Split(SPLIT_TERM);
definition.Colour = inputs[0].Trim();
var ruleDefinitions = inputs[1].Split(", ").Select(rd => rd.Trim());
definition.Rules.AddRange(ruleDefinitions.Select(rd => BagRule.Parse(rd)));
return(definition);
}
private static async Task <Dictionary <string, BagRule> > ReadAndParseRules(string filename)
{
var result = new Dictionary <string, BagRule>();
foreach (var item in await File.ReadAllLinesAsync(filename))
{
if (BagRule.TryParse(item, out var rule))
{
result[rule.BagType] = rule;
}
}
return(result);
}
public Int64 CountContainedBags(String bag)
{
Int64 count = 0;
BagRule rule = Rules[bag];
foreach (BagWithCount innerBag in rule.ContainedBags)
{
long thisCount = innerBag.Count;
count += thisCount;
count += thisCount * CountContainedBags(innerBag.BagName);
}
return(count);
}
private bool RecurseRules(BagRule rule)
{
if (rule.Contents.ContainsKey(ruleTarget))
{
return(true);
}
foreach (var containedBag in rule.Contents)
{
if (RecurseRules(bagRules.Single(r => r.Description == containedBag.Key)))
{
return(true);
}
}
return(false);
}
public UInt64 Process(String[] input)
{
UInt64 result = 0;
// input = new String[] {
//"light red bags contain 1 bright white bag, 2 muted yellow bags.",
//"dark orange bags contain 3 bright white bags, 4 muted yellow bags.",
//"bright white bags contain 1 shiny gold bag.",
//"muted yellow bags contain 2 shiny gold bags, 9 faded blue bags.",
//"shiny gold bags contain 1 dark olive bag, 2 vibrant plum bags.",
//"dark olive bags contain 3 faded blue bags, 4 dotted black bags.",
//"vibrant plum bags contain 5 faded blue bags, 6 dotted black bags.",
//"faded blue bags contain no other bags.",
//"dotted black bags contain no other bags.",
// };
// input = new string[] {
//"shiny gold bags contain 2 dark red bags.",
//"dark red bags contain 2 dark orange bags.",
//"dark orange bags contain 2 dark yellow bags.",
//"dark yellow bags contain 2 dark green bags.",
//"dark green bags contain 2 dark blue bags.",
//"dark blue bags contain 2 dark violet bags.",
//"dark violet bags contain no other bags.",
// };
BagRuleEngine rules = new BagRuleEngine();
foreach (String line in input)
{
BagRule rule = new BagRule(line);
rules.AddRule(rule);
}
String bag = "shiny gold";
// Part 1
//HashSet<String> containingBags = rules.Part1_FindContainingBags(bag);
//result = (UInt64)containingBags.Count;
// Part 2
result = (UInt64)rules.CountContainedBags(bag);
return(result);
}
public async Task <string> ExecuteAsync(string[] data)
{
var totalBagsNeeded = 0;
var bagRules = new List <BagRule>();
foreach (var rules in data)
{
var ruleParts = rules.Split(_bagToRuleDelimiter, StringSplitOptions.RemoveEmptyEntries);
var bagRule = new BagRule(ruleParts[0]);
if ((ruleParts[1] != _emptyBagPhrase))
{
var containedBagsParts = ruleParts[1].Remove(ruleParts[1].Length - 1, 1).Split(_containedBagDelimiter, StringSplitOptions.RemoveEmptyEntries);
var containedBags = containedBagsParts
.Select(x => x.Replace(_bagsSuffix, string.Empty).Replace(_bagSuffix, string.Empty).Split(_bagRuleDelimiter, StringSplitOptions.RemoveEmptyEntries))
.Select(x => new BagContents(int.Parse(x[0]), string.Join(_bagRuleDelimiter, x.Skip(1))))
.ToList();
bagRule.AddContents(containedBags);
bagRules.Add(bagRule);
}
else
{
bagRules.Add(bagRule);
}
}
var bagsToReview = new List <BagRule>
{
bagRules.FirstOrDefault(x => x.Bag == _targetBag)
};
var allValidBags = new HashSet <string>();
BagsThatCouldContainTargetBag(bagRules, new List <string> {
_targetBag
}, ref allValidBags);
totalBagsNeeded = allValidBags.Count;
return(totalBagsNeeded.ToString());
}
protected override void Initialize()
{
//content = GetExample();
content = ReadFile();
bags = new List <BagRule>();
foreach (var line in content)
{
var splitOnContain = line.Split(" contain ");
var bag = new BagRule(GetBagColorAndNumber(splitOnContain[0]).BagColor);
if (splitOnContain[1] != "no other bags.")
{
GetBagsInside(bag, splitOnContain[1]);
}
bags.Add(bag);
}
}
private int GetBagsInBag(string colour)
{
int bags = 1;
BagRule currentBagRule = new BagRule();
foreach (var bagRule in _bagRules)
{
if (bagRule.colour == colour)
{
currentBagRule = bagRule;
break;
}
}
foreach (var containsBag in currentBagRule.containsBags)
{
bags += containsBag.Value * GetBagsInBag(containsBag.Key);
}
return(bags);
}
private void ReadInput()
{
var input = File.ReadAllLines(Environment.CurrentDirectory + "/Input/Input7.txt");
foreach (string line in input)
{
var rule = new BagRule()
{
Contents = new Dictionary <string, int>(),
Description = line.Substring(0, line.IndexOf("contain") - 6)
};
string contents = line.Substring(line.IndexOf("contain") + 8);
while (true)
{
if (contents.Contains("no other bags"))
{
break;
}
if (contents.IndexOf(',') == -1)
{
// last - break after this
string match2 = contents.Substring(0, contents.Length - 1);
rule.Contents.Add(match2.Substring(2, match2.Length - 6).Trim(), Convert.ToInt32(match2.Substring(0, 1)));
break;
}
// I'm not crying, you're crying
string match = contents.Substring(0, contents.IndexOf(','));
rule.Contents.Add(match.Substring(2, match.Length - 6).Trim(), Convert.ToInt32(match.Substring(0, 1)));
contents = contents.Substring(contents.IndexOf(',') + 2);
}
bagRules.Add(rule);
}
}
public Day7()
{
var inputList = _inputFiles.SplitString(_inputFiles.ReadInputFileForDay(7, false));
foreach (var rule in inputList)
{
var ruleSplit = rule.Split(" ");
var newRule = new BagRule();
newRule.colour = ruleSplit[0] + " " + ruleSplit[1];
var rulePos = 4;
while (ruleSplit.Length > rulePos)
{
if (ruleSplit[rulePos] == "no")
{
break;
}
newRule.containsBags.Add(ruleSplit[rulePos + 1] + " " + ruleSplit[rulePos + 2], Int32.Parse(ruleSplit[rulePos]));
rulePos += 4;
}
_bagRules.Add(newRule);
}
}
public static BagRule Parse(string ruleString)
{
var rule = new BagRule();
if (ruleString.Equals("no other bags.", StringComparison.CurrentCultureIgnoreCase))
{
rule.NumberOfBags = 0;
return(rule);
}
var parts = ruleString.IndexOf(" ");
var number = Convert.ToInt32(ruleString.Substring(0, parts));
rule.BagColour = ruleString.Replace(".", string.Empty)
.Replace("bags", string.Empty)
.Replace("bag", string.Empty)
.Trim()
.Substring(parts + 1);
rule.NumberOfBags = number;
return(rule);
}
int HoldsBags(BagRule bagRule)
{
if (holdsBags.ContainsKey(bagRule.Name))
{
return(holdsBags[bagRule.Name]);
}
if (bagRule.Contains.Count == 0)
{
holdsBags[bagRule.Name] = 0;
return(0);
}
else
{
var cnt = 0;
foreach (var contains in bagRule.Contains)
{
var targetBagRule = bagRules.FirstOrDefault(b => b.Name == contains.Item1);
cnt += (contains.Item2 + contains.Item2 * HoldsBags(targetBagRule));
}
holdsBags[bagRule.Name] = cnt;
return(cnt);
}
}
public void Setup()
{
_bagRule = new BagRule(_input);
}
