string RunPart2(InputAnswer puzzleData)
{
TileGrid.Clear();
outputCache.Clear();
Score = 0;
var arcade = new IntCode(puzzleData.Code);
arcade.Output += ArcadeOutput;
var ballPosition = GetTilePositions(TileType.Ball);
var PaddlePosition = GetTilePositions(TileType.Paddle);
arcade.Poke(0, 2); // Put in 2 quarters
while (arcade.State != IntCodeState.Finished)
{
arcade.Run();
if (arcade.State == IntCodeState.NeedsInput)
{
var diff = ballPosition.First().X - PaddlePosition.First().X;
var inputValue = (diff == 0) ? 0 : diff / Math.Abs(diff);
arcade.AddInput(inputValue);
}
}
return(Helper.GetPuzzleResultText($"Final Score: {Score}", Score, puzzleData.ExpectedAnswer));
}
public InputAnswer ListenInput()
{
Debug.Log("UI Inpuit TODO");
inputAnswer = new InputAnswer();
inputAnswer.isPaused = false;
return(inputAnswer);
}
public void Update()
{
if (SimulationLoaded)
{
if (inPlaymode)
{
TimeingManager.PreformTimerManagerCycle();
inputAnswer = InputModulePlayMode.ListenToInput();
if (inputAnswer.isPaused)
{
inPlaymode = false;
}
else
{
SimulationInstance.Player.LaunchAction(inputAnswer);
SimulationInstance.PreformGameplay();
}
}
else
{
Time.timeScale = 0;
inputAnswer = InputModuleUIMode.ListenInput();
if (inputAnswer.isPaused == false)
{
Time.timeScale = 1;
inPlaymode = true;
}
else
{
UiInstance.PreformUIMode(inputAnswer);
}
}
}
}
public Level2()
{
Console.WriteLine("Level2");
Reset();
timebarSpace = 10.768F;
this.Add(new SpriteGameObject("spr_background"));
thePlayer = new Player(3, 3);
door = new Door(14, 0);
goal = new MainGoal(26, 3);
xaxis = new Xaxis(8, "Map/spr_horizontal_art_blue");
yaxis = new Yaxis(20, "Map/spr_vertical_art_blue");
Mouse.SetPosition(GameEnvironment.Screen.X / 2, GameEnvironment.Screen.Y / 2);
floors = new GameObjectList();
walls = new GameObjectList();
goals = new GameObjectList();
inputScreen = new InputScreen(GameEnvironment.Screen.X / 2 - 64 * 2, GameEnvironment.Screen.Y);
inputanswer = new InputAnswer(GameEnvironment.Screen.X / 2 - 64 * 2, GameEnvironment.Screen.Y);
timeGround = new SpriteGameObject("Map/time_ground");
guards = new GameObjectList();
lasers = new GameObjectList();
times = new GameObjectList();
score = new Score(12, 20, (int)time);
Axis_nums = new Axis_numbers(20, 8);
switchBoards = new GameObjectList();
this.Add(floors);
this.Add(switchBoards);
this.Add(lasers);
this.Add(walls);
this.Add(door);
this.Add(xaxis);
this.Add(yaxis);
this.Add(Axis_nums);
this.Add(goal);
this.Add(goals);
this.Add(guards);
this.Add(thePlayer);
this.Add(inputScreen);
this.Add(timeGround);
this.Add(times);
this.Add(score);
this.Add(inputanswer);
goals.Add(new ExtraGoal(11, 9));
guards.Add(new Guard(new Vector2(3, 13), new Vector2(25, 13)));
FloorSetup();
WallSetup();
TimeBarSetup();
SoundSetup();
lasers.Add(new Laser(new Vector2(11, 6), new Vector2(14, 10), Color.Red, xaxis.gridPos, yaxis.gridPos));
lasers.Add(new Laser(new Vector2(23, 10), new Vector2(28, 7), Color.Blue, xaxis.gridPos, yaxis.gridPos));
switchBoards.Add(new SwitchBoard(3, 7, Color.Blue));
switchBoards.Add(new SwitchBoard(22, 3, Color.Red));
}
public static Answer ToModel(InputAnswer inputAnswer)
{
return(new Answer()
{
RightAnswer = inputAnswer.RightAnswer,
Text = inputAnswer.Text
});
}
string RunPart2(InputAnswer puzzleData)
{
var phaseValues = new long[] { 5, 6, 7, 8, 9 };
var answer = 0L;
foreach (var phase in GetPhases(phaseValues, puzzleData.Phase))
{
var ampA = new IntCode(puzzleData.Code);
var ampB = new IntCode(puzzleData.Code);
var ampC = new IntCode(puzzleData.Code);
var ampD = new IntCode(puzzleData.Code);
var ampE = new IntCode(puzzleData.Code);
var outputValue = 0L;
ampA.Output += (s, e) => outputValue = e.OutputValue;
ampB.Output += (s, e) => outputValue = e.OutputValue;
ampC.Output += (s, e) => outputValue = e.OutputValue;
ampD.Output += (s, e) => outputValue = e.OutputValue;
ampE.Output += (s, e) => outputValue = e.OutputValue;
ampA.AddInput(phase[0]);
ampB.AddInput(phase[1]);
ampC.AddInput(phase[2]);
ampD.AddInput(phase[3]);
ampE.AddInput(phase[4]);
while (true)
{
ampA.AddInput(outputValue);
ampA.Run();
ampB.AddInput(outputValue);
ampB.Run();
ampC.AddInput(outputValue);
ampC.Run();
ampD.AddInput(outputValue);
ampD.Run();
ampE.AddInput(outputValue);
ampE.Run();
if (ampE.State == IntCodeState.Finished)
{
break;
}
}
if (outputValue > answer)
{
answer = outputValue;
}
}
return(Helper.GetPuzzleResultText($"Highest signal that can be sent to the thrusters: {answer}", answer, puzzleData.ExpectedAnswer));
}
InputAnswer GetPuzzleData(int part, string name)
{
var result = new InputAnswer(
InputHelper.LoadInputFile(DAY, name).ToList(),
InputHelper.LoadAnswerFile(DAY, part, name)?.FirstOrDefault()?.ToInt32()
);
return(result);
}
void Start()
{
inputAnswerScript = FindObjectOfType <InputAnswer>();
multiChoiceScript = FindObjectOfType <MultiChoice>();
inputAnswerScript.SetAnswer(answer); //feed into input field answer script
multiChoiceScript.SetAnswers(answers, answerIndex); //feed into multiple choice answer script
}
InputAnswer GetPuzzleData(int part, string name)
{
var result = new InputAnswer()
{
Input = InputHelper.LoadInputFile(DAY, name).ToList(),
ExpectedAnswer = InputHelper.LoadAnswerFile(DAY, part, name)?.FirstOrDefault()?.ToInt64()
};
return(result);
}
public InputModulePlayMode()
{
pathCapacity = 128;
path = new Vector3[pathCapacity];
for (int i = 0; i < path.Length; i++)
{
path[i] = new Vector3(0, 0, 0);
}
inputAnswer = new InputAnswer();
}
string RunPart1(InputAnswer puzzleData)
{
var phase = 0;
var signal = puzzleData.Input.Select(c => c.ToString().ToInt32()).ToList();
var maxDigits = signal.Count;
Debug("Input Signal: " + ListToString(signal));
Debug("");
var line = new StringBuilder();
while (phase < 100)
{
phase++;
var newSignal = new List <int>();
for (var i = 0; i < maxDigits; i++)
{
line.Clear();
var newSignalLine = signal.ToList();
var dupCount = i + 1;
var total = 0;
for (var j = 0; j < maxDigits; j++)
{
var val = GetPatternDigit(dupCount, j);
var tmp = $"{newSignalLine[j]}*{val}";
line.Append($"{tmp,-5}");
if (j + 1 < maxDigits)
{
line.Append(" + ");
}
newSignalLine[j] *= val;
total += newSignalLine[j];
}
total = Helper.GetDigitRight(Math.Abs(total), 1);
line.Append($" = {total}");
newSignal.Add(total);
Debug(line.ToString());
}
signal = newSignal;
Debug("");
Debug($"After {phase} Phase: {ListToString(signal)}");
Debug("");
}
var result = ListToString(signal.Take(8).ToList());
return(Helper.GetPuzzleResultText($"first 8 digits after {phase} phases : {result}", result, puzzleData.ExpectedAnswer));
}
string RunPart2(InputAnswer puzzleData)
{
var origin = new Point(0, 0);
var intersctions = FindIntersectionsWithDistance(puzzleData.Wire1, puzzleData.Wire2)
.Where(p => p.IntersectPoint != origin);
var minDist = intersctions.Select(p => p.Distance).Min();
return(Helper.GetPuzzleResultText($"The fewest combined steps is: {minDist}", minDist, puzzleData.ExpectedAnswer));
}
string RunPart2(InputAnswer puzzleData)
{
var meToCommonCOM = GetPathToUniversalCOM(puzzleData.UniqueBodies["YOU"].Orbits).ToList();
var destToCommonCOM = GetPathToUniversalCOM(puzzleData.UniqueBodies["SAN"].Orbits).ToList();
RemoveSharedCOMs(meToCommonCOM, destToCommonCOM);
var result = meToCommonCOM.Count + destToCommonCOM.Count;
return(Helper.GetPuzzleResultText($"The minimum # of orbit transfers required: {result}", result, puzzleData.ExpectedAnswer));
}
string RunPart1(InputAnswer puzzleData)
{
Log.Clear();
var reactions = BuildReactionChains(puzzleData.Input);
var orderedChems = SetTopologicalOrder(reactions);
var oreNeeded = CalcOreNeeded_Topological(FUEL, 1, reactions, orderedChems);
Log.AppendLine(Helper.GetPuzzleResultText($"Minimum amount of ORE needed for 1 Fuel: {oreNeeded}", oreNeeded, puzzleData.ExpectedAnswer));
return(Log.ToString().Trim());
}
string RunPart1(InputAnswer puzzleData)
{
var origin = new Point(0, 0);
var intersctions = FindIntersections(puzzleData.Wire1, puzzleData.Wire2)
.Where(p => p != origin);
var answer = intersctions.Select(p => CalcManhattenDistance(origin, p)).Min();
return(Helper.GetPuzzleResultText($"Closest distance: {answer}", answer, puzzleData.ExpectedAnswer));
}
string RunTestCase(InputAnswer puzzleData)
{
var outputBuffer = new List <long>();
var computer = new IntCode(puzzleData.Code);
computer.Output += (s, e) => outputBuffer.Add(e.OutputValue);
computer.Run();
var answer = string.Join(',', outputBuffer);
return(Helper.GetPuzzleResultText($"Output: {answer}", answer, puzzleData.ExpectedAnswer));
}
string RunBOOST(InputAnswer puzzleData, long initalInput)
{
var answer = default(string);
var computer = new IntCode(puzzleData.Code);
computer.Output += (s, e) => answer = e.OutputValue.ToString();
computer.AddInput(initalInput);
computer.Run();
return(Helper.GetPuzzleResultText($"BOOST key-code: {answer}", answer, puzzleData.ExpectedAnswer));
}
string RunPart2(InputAnswer puzzleData)
{
var originalState = puzzleData.Bodies.Select(b => b.GetCopy()).ToList();
var xCount = 0L;
var yCount = 0L;
var zCount = 0L;
CountSteps(puzzleData.Bodies, originalState, ref xCount, ref yCount, ref zCount);
var result = Helper.FindLeastCommonMultiple(
xCount,
Helper.FindLeastCommonMultiple(yCount, zCount));
return(Helper.GetPuzzleResultText($"Number of steps to return to original state: {result}", result, puzzleData.ExpectedAnswer));
}
string RunPart1(InputAnswer puzzleData)
{
TileGrid.Clear();
var arcade = new IntCode(puzzleData.Code);
arcade.Output += ArcadeOutput;
arcade.Run();
// var grid = DisplayHelper.DrawPointGrid2D(TileGrid, DrawGridTitle);
// Console.WriteLine(grid);
var result = TileGrid.Values.Where(v => v == TileType.Brick).Count();
return(Helper.GetPuzzleResultText($"Number of block tiles are on the screen: {result}", result, puzzleData.ExpectedAnswer));
}
string RunPart2(InputAnswer puzzleData)
{
var answer = 0L;
var computer = new IntCode(puzzleData.Code);
computer.Output += (s, e) => { answer = e.OutputValue; };
computer.Run();
if (computer.State == IntCodeState.NeedsInput)
{
computer.AddInput(5);
computer.Run();
}
return(Helper.GetPuzzleResultText($"The diagnostic Code is: {answer}", answer, puzzleData.ExpectedAnswer));
}
string RunPart1(InputAnswer puzzleData)
{
var phaseValues = new long[] { 0, 1, 2, 3, 4 };
var answer = 0L;
foreach (var phase in GetPhases(phaseValues, puzzleData.Phase))
{
var ampA = new IntCode(puzzleData.Code);
var ampB = new IntCode(puzzleData.Code);
var ampC = new IntCode(puzzleData.Code);
var ampD = new IntCode(puzzleData.Code);
var ampE = new IntCode(puzzleData.Code);
var outputValue = 0L;
ampA.Output += (s, e) => outputValue = e.OutputValue;
ampB.Output += (s, e) => outputValue = e.OutputValue;
ampC.Output += (s, e) => outputValue = e.OutputValue;
ampD.Output += (s, e) => outputValue = e.OutputValue;
ampE.Output += (s, e) => outputValue = e.OutputValue;
ampA.AddInput(phase[0], outputValue);
ampA.Run();
ampB.AddInput(phase[1], outputValue);
ampB.Run();
ampC.AddInput(phase[2], outputValue);
ampC.Run();
ampD.AddInput(phase[3], outputValue);
ampD.Run();
ampE.AddInput(phase[4], outputValue);
ampE.Run();
if (outputValue > answer)
{
answer = outputValue;
}
}
return(Helper.GetPuzzleResultText($"Highest signal that can be sent to the thrusters: {answer}", answer, puzzleData.ExpectedAnswer));
}
public void LaunchAction(InputAnswer _inputAnswer)
{
if (_inputAnswer.isSingleClicked)
{
float _clickDistanceToPlayerPosition = Vector2.Distance(_inputAnswer.singleClickPosition, transform.position);
if (_clickDistanceToPlayerPosition < 0.5f)
{
ForceObjectsManager.LaunchDefender(this);
}
else
{
ForceObjectsManager.LaunchExploder(_inputAnswer.singleClickPosition);
}
}
else if (_inputAnswer.isPathRecorded)
{
ForceObjectsManager.LaunchImploder(_inputAnswer.path);
}
}
string RunPart2(InputAnswer puzzleData)
{
Rules.Clear();
Rules.Add(Rule_IsSixDigits);
Rules.Add(Rule_OnlyTwoAdjacentDigitsAreTheSame);
Rules.Add(Rule_LeftToRightDigitValueNeverDecreases);
var numValidPasswords = 0;
for (var password = puzzleData.PasswordRangeMin; password <= puzzleData.PasswordRangeMax; password++)
{
if (IsPasswordValid(password))
{
numValidPasswords++;
}
}
return(Helper.GetPuzzleResultText($"Number of valid passwords: {numValidPasswords}", numValidPasswords, puzzleData.ExpectedAnswer));
}
string RunPart1(InputAnswer puzzleData, int numOfSteps)
{
// Console.WriteLine($"After {0} steps:");
// input.ForEach(ShowBodyInfo);
// Console.WriteLine();
for (var step = 1; step <= numOfSteps; step++)
{
puzzleData.Bodies.ForEach(b => ApplyGravity(b, puzzleData.Bodies));
puzzleData.Bodies.ForEach(ApplyVelocity);
// Console.WriteLine($"After {step} steps:");
// input.ForEach(ShowBodyInfo);
// Console.WriteLine();
}
var result = puzzleData.Bodies.Sum(b => b.TotalEnergy);
return(Helper.GetPuzzleResultText($"Total Energy: {result}", result, puzzleData.ExpectedAnswer));
}
string RunPart1(InputAnswer puzzleData, long inputValue, long?overrideExpectedAnswer = null)
{
if (overrideExpectedAnswer.HasValue)
{
puzzleData.ExpectedAnswer = overrideExpectedAnswer.Value;
}
var answer = 0L;
var computer = new IntCode(puzzleData.Code);
computer.Output += (s, e) => { answer = e.OutputValue; };
computer.Run();
if (computer.State == IntCodeState.NeedsInput)
{
computer.AddInput(inputValue);
computer.Run();
}
return(Helper.GetPuzzleResultText($"The diagnostic Code is: {answer}", answer, puzzleData.ExpectedAnswer));
}
string RunPart2(InputAnswer puzzleData)
{
Log.Clear();
var reactions = BuildReactionChains(puzzleData.Input);
var orderedChems = SetTopologicalOrder(reactions);
var fuelProduced = 1L;
var args = (reactions, orderedChems);
(var estimations, _) = EstimateFuelProduced(reactions, TRILLION_ORE, orderedChems);
(long result, long i) = Bisect(f, TRILLION_ORE, estimations, args);
long f(long x, IDictionary <string, ChemReaction> reactions, List <string> orderedChems)
{
var ore = CalcOreNeeded_Topological(FUEL, x, reactions, orderedChems.ToList());
return(ore);
}
fuelProduced = result;
Log.AppendLine(Helper.GetPuzzleResultText($"Maximum Fuel Produced: {fuelProduced}", fuelProduced, puzzleData.ExpectedAnswer));
return(Log.ToString().Trim());
}
public void PreformUIMode(InputAnswer _inputAnswer)
{
}
string RunPart2(InputAnswer puzzleData)
{
var answer = puzzleData.Input.Sum(CalcTotalFuel);
return(Helper.GetPuzzleResultText($"Total Fuel needed: {answer}", answer, puzzleData.ExpectedAnswer));
}
string RunPart2(InputAnswer puzzleData)
{
var answer = FindNounVerb(puzzleData.Code, 19690720);
return(Helper.GetPuzzleResultText($"Noun-Verb pair is : {answer}", answer, puzzleData.ExpectedAnswer));
}
string RunPart1(InputAnswer puzzleData)
{
var result = CountAllOrbits(puzzleData.UniqueBodies);
return(Helper.GetPuzzleResultText($"The total number of Direct and Indirect orbits: {result}", result, puzzleData.ExpectedAnswer));
}
