public void XORBlocks()
{
KnotHash kh = new KnotHash();
var input = new int[] { 65, 27, 9, 1, 4, 3, 40, 50, 91, 7, 6, 0, 2, 5, 68, 22 };
Assert.Equal(64, kh.XORBlock(input));
}
public void CalculateHashRounds()
{
KnotHash kh = new KnotHash();
var result = kh.PerformHashRounds(new int[] { 3, 4, 1, 5 }, 1, 5);
Assert.Equal(12, result[0] * result[1]);
}
public bool Solve(int part = 0)
{
string input = File.ReadAllText("Day10/input.txt");
KnotHash knotHash = new KnotHash();
if (part == 2)
{
int[] lengths = (input + "\x11\x1f\x49\x2f\x17").Select(c => (int)c).ToArray();
for (int round = 0; round < 64; round++)
{
knotHash.HashRound(lengths);
}
Console.WriteLine(knotHash.GetDenseHash());
}
else
{
int[] lengths = input.Split(',').Select(s => int.Parse(s)).ToArray();
int result = knotHash.HashRound(lengths);
Console.WriteLine(result);
}
return(true);
}
public void GenerateInputSequences()
{
KnotHash kh = new KnotHash();
int[] expected = { 49, 44, 50, 44, 51, 17, 31, 73, 47, 23 };
Assert.Equal(expected, kh.GenerateInputSequence("1,2,3"));
}
public void KnotHash_MultiplyFirstTwoHashedValues_SmallList()
{
// act
var result = KnotHash.MultiplyFirstTwoHashedValues(5, "3,4,1,5");
// assert
Assert.AreEqual(12, result);
}
public void KnotHash_ComplexHash_EmptyString()
{
// act
var result = KnotHash.OutputHexString(256, string.Empty);
// assert
Assert.AreEqual("a2582a3a0e66e6e86e3812dcb672a272", result);
}
public void KnotHash_ComplexHash_Letters()
{
// act
var result = KnotHash.OutputHexString(256, "AoC 2017");
// assert
Assert.AreEqual("33efeb34ea91902bb2f59c9920caa6cd", result);
}
public void KnotHash_ComplexHash_NumbersPassOne()
{
// act
var result = KnotHash.OutputHexString(256, "1,2,3");
// assert
Assert.AreEqual("3efbe78a8d82f29979031a4aa0b16a9d", result);
}
public void KnotHash_ComplexHash_NumbersPassTwo()
{
// act
var result = KnotHash.OutputHexString(256, "1,2,4");
// assert
Assert.AreEqual("63960835bcdc130f0b66d7ff4f6a5a8e", result);
}
public void HashStrings()
{
KnotHash kh = new KnotHash();
Assert.Equal("a2582a3a0e66e6e86e3812dcb672a272", kh.GenerateHash("", 64));
Assert.Equal("33efeb34ea91902bb2f59c9920caa6cd", kh.GenerateHash("AoC 2017", 64));
Assert.Equal("3efbe78a8d82f29979031a4aa0b16a9d", kh.GenerateHash("1,2,3", 64));
Assert.Equal("63960835bcdc130f0b66d7ff4f6a5a8e", kh.GenerateHash("1,2,4", 64));
}
public void ShouldCalculateUsedSpace()
{
KnotHash kh = new KnotHash();
GridCreator g = new GridCreator(kh);
var grid = g.Generate("flqrgnkx");
Defragmentor f = new Defragmentor();
Assert.Equal(8108, f.GetUsedSpace(grid));
}
public void ShouldCountConnectedComponents()
{
KnotHash kh = new KnotHash();
GridCreator g = new GridCreator(kh);
var grid = g.Generate("flqrgnkx");
Defragmentor f = new Defragmentor();
Assert.Equal(1242, f.CountUsedGroups(grid));
}
public void TestToDenseHash()
{
List <int> sparseHash = new List <int>()
{
65, 27, 9, 1, 4, 3, 40, 50, 91, 7, 6, 0, 2, 5, 68, 22
};
var sut = new KnotHash();
var result = sut.ToDenseHash(sparseHash, 16);
Assert.Equal(64, result.First());
}
public void Setup()
{
ClassUnderTest = new KnotHash();
Values = new ImportantValues
{
CurrentPosition = 0,
SkipSize = 0,
MarkList = ClassUnderTest.GenerateList()
};
}
public void TestKnotHash_string()
{
var dayTen = new DayTen();
List <int> originalInput = dayTen.Input;
string stringInput = string.Join <int>(",", originalInput);
var knotHash = new KnotHash(stringInput);
Assert.Equal(32, knotHash.HexOutput.Length);
Assert.Equal("0c2f794b2eb555f7830766bf8fb65a16", knotHash.HexOutput);
}
public void TestToHexString()
{
List <int> denseHash = new List <int>()
{
64, 7, 255
};
var sut = new KnotHash();
var result = sut.ToHexString(denseHash);
Assert.Equal("4007ff", result);
}
public void TestToHexString_Real()
{
List <int> denseHash = new List <int>()
{
12, 47, 121, 75, 46, 181, 85, 247, 131, 7, 102, 191, 143, 182, 90, 22
};
var sut = new KnotHash();
var result = sut.ToHexString(denseHash);
Assert.Equal(32, result.Length);
Assert.Equal("0c2f794b2eb555f7830766bf8fb65a16", result);
}
public void GenerateGrids()
{
KnotHash kh = new KnotHash();
GridCreator g = new GridCreator(kh);
var grid = g.Generate("flqrgnkx");
Assert.Equal(128, grid.Length);
foreach (var row in grid)
{
Assert.Equal(128, row.Length);
}
}
public void TestToAscii()
{
List <int> list = new List <int>()
{
1, 2, 3
};
var sut = new KnotHash();
var result = sut.ToAsciiCode(list);
Assert.Equal(new List <int>()
{
49, 44, 50, 44, 51
}, result);
}
public void PartitionBlocks()
{
KnotHash kh = new KnotHash();
var input = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
var blocks = kh.PartitionList(input, 4);
Assert.Equal(3, blocks.Count);
var arrayBlocks = blocks.ToArray();
Assert.Equal(new int[] { 1, 2, 3, 4 }, arrayBlocks[0]);
Assert.Equal(new int[] { 5, 6, 7, 8 }, arrayBlocks[1]);
Assert.Equal(new int[] { 9, 10, 11, 12 }, arrayBlocks[2]);
}
public string GenerateAnswer(string input)
{
var totalCount = 0;
for (var i = 0; i < 128; i++)
{
var hash = KnotHash.Generate($"{input}-{i}");
var usedCount = hash
.Select(it => Convert.ToString(Convert.ToByte(it.ToString(), 16), 2))
.SelectMany(it => it)
.Count(it => it == '1');
totalCount += usedCount;
}
return(totalCount.ToString());
}
public void TestCalculateKnotHash()
{
List <int> inputs = new List <int>()
{
3, 4, 1, 5
};
var knotSize = 5;
List <int> elements = Enumerable.Range(0, knotSize).ToList();
KnotHashState previousState = new KnotHashState(elements, 0, 0);
var sut = new KnotHash();
var result = sut.CalculateKnotHash(previousState, inputs);
var mult = result.Elements[0] * result.Elements[1];
Assert.Equal(12, mult);
}
private void BuildMap()
{
// Create the hasher
KnotHash hasher = new KnotHash();
// Prepare the input
string key = Aoc.Framework.Input.GetString(this);
// Build the map of used cells
int[,] grid = new int[128, 128];
for (int i = 0; i < 128; ++i)
{
string row = key + "-" + i.ToString();
hasher.Compute(row, true);
byte[] hash = hasher.GetBytesHash();
for (int j = 0; j < 128; j++)
{
grid[i, j] = IsUsed(hash, j) ? 0 : -1;
}
}
// Count bits
_bits = 0;
for (int i = 0; i < 128; ++i)
{
for (int j = 0; j < 128; j++)
{
if (grid[i, j] >= 0)
{
_bits++;
}
}
}
// Build groups
_groupId = 1;
for (int i = 0; i < 128; i++)
{
for (int j = 0; j < 128; j++)
{
if (grid[i, j] == 0)
{
BuildGroup(grid, i, j, _groupId++);
}
}
}
}
public override string Solve(string input, int part)
{
KnotHash knotHash = new KnotHash(256);
switch (part)
{
case 1:
knotHash.InitializeWeak(input);
return("" + knotHash.hash[0] * knotHash.hash[1]);
case 2:
knotHash.InitializeStrong(input);
return(knotHash.ToHexString());
}
return(String.Format("Day 10 part {0} solver not found.", part));
}
public string Run(Aoc.Framework.Part part)
{
if (part == Aoc.Framework.Part.Part1)
{
byte[] input = Aoc.Framework.Input.GetIntVector(this, ",").Select(i => (byte)i).ToArray();
KnotHash hash = new KnotHash(256, 1);
hash.Compute(input, false);
return(hash.GetSimpleHash().ToString());
}
if (part == Aoc.Framework.Part.Part2)
{
KnotHash hash = new KnotHash(256, 64);
hash.Compute(Aoc.Framework.Input.GetString(this), true);
return(hash.GetDenseHash());
}
return("");
}
public string GenerateAnswer(string input)
{
var points = new Point[128, 128];
for (var i = 0; i < 128; i++)
{
var hash = KnotHash.Generate($"{input}-{i}");
var pointsForHash = hash
.Select(it => Convert.ToString(Convert.ToByte(it.ToString(), 16), 2))
.Select(it => it.PadLeft(4, '0'))
.SelectMany(it => it)
.Select(it => it == '1' ? new Point() : null)
.ToArray();
var test = hash.Select(it => Convert.ToString(Convert.ToByte(it.ToString(), 16), 2))
.Select(it => it.PadLeft(4, '0'))
.SelectMany(it => it);
var test2 = String.Join(string.Empty, test);
//var test2 = "a0c2017"
for (var j = 0; j < pointsForHash.Length; j++)
{
points[i, j] = pointsForHash[j];
}
}
var currentGroups = 0;
for (var i = 0; i < 128 * 128; i++)
{
var x = i / 128;
var y = i % 128;
if (points[x, y] != null && points[x, y].Group == null)
{
++currentGroups;
AssignPointToGroup(currentGroups, points, x, y);
}
}
return(currentGroups.ToString());
}
public void ReverseSubsequences()
{
KnotHash kh = new KnotHash();
int[] a = { 0, 1, 2, 3, 4 };
kh.ReverseSubsequence(a, 0, 3);
Assert.Equal(new int[] { 2, 1, 0, 3, 4 }, a);
int[] b = { 2, 1, 0, 3, 4 };
kh.ReverseSubsequence(b, 3, 4);
Assert.Equal(new int[] { 4, 3, 0, 1, 2 }, b);
int[] c = { 4, 3, 0, 1, 2 };
kh.ReverseSubsequence(c, 3, 1);
Assert.Equal(new int[] { 4, 3, 0, 1, 2 }, c);
int[] d = { 4, 3, 0, 1, 2 };
kh.ReverseSubsequence(d, 1, 5);
Assert.Equal(new int[] { 3, 4, 2, 1, 0 }, d);
}
private KnotHash Process(int[] hashLengths, int arrayLength, Action <KnotHash> action)
{
var array = new int[arrayLength];
for (int i = 0; i < arrayLength; i++)
{
array[i] = i;
}
var knotHash = new KnotHash()
{
Pos = 0,
Skip = 0,
Data = array,
HashLengths = hashLengths
};
action(knotHash);
return(knotHash);
}
public override string Solve(string input, int part)
{
List <KnotHash> knotHashes = new List <KnotHash>();
for (int i = 0; i < 128; i++)
{
KnotHash knotHash = new KnotHash(256);
knotHash.InitializeStrong(input + "-" + i);
knotHashes.Add(knotHash);
}
switch (part)
{
case 1: return("" + GetUsedSquares(knotHashes));
case 2: return("" + GetRegionCount(knotHashes));
}
return(String.Format("Day 14 part {0} solver not found.", part));
}
public void Run()
{
var numbers = new int[256];
for (var i = 0; i < numbers.Length; i++)
{
numbers[i] = i;
}
const string input = "129,154,49,198,200,133,97,254,41,6,2,1,255,0,191,108";
var lengths = input.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(i => Convert.ToInt32(i)).ToArray();
var knotHash = new KnotHash(new ListReverser());
var result = knotHash.Calculate(numbers, lengths);
Console.WriteLine($"Result: {result}");
var hex = knotHash.Calculate(input);
Console.WriteLine($"Knot hash: {hex}");
}
