public object GetResult2()
{
int stepLength = 1;
ModNum direction = new ModNum(0, 4);
Coordinate current = new Coordinate(0, 0);
Dictionary <Coordinate, int> values = new Dictionary <Coordinate, int>();
Set(current, 1, values);
while (true)
{
for (int i = 0; i < 2; i++)
{
for (int n = 0; n < stepLength; n++)
{
current = Step(direction, current);
var value = values[current];
if (value > 277678)
{
return(value);
}
Set(current, value, values);
}
direction++;
}
stepLength++;
}
}
public MemoryBanks ReAllocate()
{
long highest = -1;
int topIndex = -1;
for (int n = 0; n < memory.Length; n++)
{
if (memory[n] > highest)
{
highest = memory[n];
topIndex = n;
}
}
long toAllocate = memory[topIndex];
var newBank = new MemoryBanks(this.memory);
newBank.memory[topIndex] = 0;
var index = new ModNum(topIndex + 1, memory.Length);
for (int n = 0; n < toAllocate; n++)
{
newBank.memory[index.number]++;
index++;
}
return(newBank);
}
public void DivisionShouldReturnModOfQuotient(long a, long b, int result)
{
var modNumA = new ModNum(a);
var modNumB = new ModNum(b);
Assert.Equal(modNumA / modNumB, result);
}
public void MultiplicationShouldReturnModOfProduct(int a, int b, int result)
{
var modNumA = new ModNum(a);
var modNumB = new ModNum(b);
Assert.Equal(modNumA * modNumB, result);
}
public void SubtractionShouldReturnModOfDiff(int a, int b, int result)
{
var modNumA = new ModNum(a);
var modNumB = new ModNum(b);
Assert.Equal(modNumA - modNumB, result);
}
public void AdditionShouldReturnModOfSum(int a, int b, int result)
{
var modNumA = new ModNum(a);
var modNumB = new ModNum(b);
Assert.Equal(modNumA + modNumB, result);
}
public static ModNum Pow(ModNum val, ulong count)
{
return(count == 0 ? new ModNum(1) :
count == 1 ? val :
count == 2 ? val * val :
count % 2 == 0 ?
Pow(Pow(val, count / 2), 2) :
Pow(Pow(val, count / 2), 2) * val);
}
public void EqualsShouldBeTruthy(int a, int b)
{
var modNumA = new ModNum(a);
var modNumB = new ModNum(b);
Assert.True(modNumA.Equals(modNumB));
Assert.True(modNumA == modNumB);
Assert.False(modNumA != modNumB);
}
private Coordinate Step(ModNum direction, Coordinate current)
{
switch (direction.number)
{
case 0: return(current.ShiftX(1));
case 1: return(current.ShiftY(-1));
case 2: return(current.ShiftX(-1));
case 3: return(current.ShiftY(1));
}
throw new InvalidOperationException("direction should be mod 4");
}
private static ModNum Inverse(ModNum val)
{
return(Pow(val, mod - 2));
}
public void PowShouldReturnModOfPower(int baseNum, int exponent, int result)
{
var modNum = new ModNum(baseNum);
Assert.Equal(ModNum.Pow(modNum, exponent), result);
}
public void XShouldReturnModOf1000000007(int x, int result)
{
var modNum = new ModNum(x);
Assert.Equal(modNum.X, result);
}
