public IEnumerable <Result> GetResults(IInputRepository inputRepository)
{
IEnumerable <int> input = inputRepository.GetDay01Input();
yield return(new Result(input.Select(nr => (int)Math.Round((decimal)(nr / 3)) - 2).Sum()));
yield return(new Result(input.Select(nr => getFuelRequiredForWeightRecursing(nr, 0)).Sum()));
}
public AddNewMessageHandler(IMessageRepository messageRepository, IProjectRepository projectRepository,
IInputRepository inputRepository, IAuthorRepository authorRepository)
{
_messageRepository = messageRepository;
_projectRepository = projectRepository;
_inputRepository = inputRepository;
_authorRepository = authorRepository;
}
private ICalculator CreateArithmeticController(IInputRepository inputRepositoryObjectStub, IPrintRepository printRepositoryObjectStub)
{
ISeparationEquation separationEquation = new ArithmeticSeparationEquation();
ICalculationEquation calculationEquation = new ArithmeticCalculationEquation();
ICalculatorRepository calculatorRepository = new CalculatorRepository(separationEquation, calculationEquation);
CalculatorController calculator = new CalculatorController(inputRepositoryObjectStub, printRepositoryObjectStub, calculatorRepository);
return(calculator);
}
public NewInputIntegrationEventHandler(
ILogger <NewInputIntegrationEventHandler> logger,
IRabbitMQEventBus eventBus,
IInputRepository inputRepository,
IDiffLogic logic
)
{
_logger = logger;
_eventBus = eventBus;
_inputRepository = inputRepository;
_logic = logic;
}
public DiffController(
ILogger <DiffController> logger,
IDiffRepository diffRepository,
IInputRepository inputRepository,
IMapper mapper,
IRabbitMQEventBus eventBus
)
{
_logger = logger;
_diffRepository = diffRepository;
_inputRepository = inputRepository;
_mapper = mapper;
_eventBus = eventBus;
}
public IEnumerable <Result> GetResults(IInputRepository inputRepository)
{
int[] integers = inputRepository.GetDay02Input().ToArray();
// These changes are made in the inputfile
// integers[1] = 12;
// integers[2] = 2;
bool isStopped = false;
for (int i = 0; !isStopped; i += 4)
{
int param1 = integers[integers[i + 1]];
int param2 = integers[integers[i + 2]];
int register = integers[i + 3];
if (integers[i] == 1)
{
integers[register] = param1 + param2;
}
else if (integers[i] == 2)
{
integers[register] = param1 * param2;
}
else if (integers[i] == 99)
{
isStopped = true;
}
else
{
throw new ArgumentException();
}
}
yield return(new Result(integers[0]));
}
public InputController(InputHandler handler, IInputRepository repository)
{
_handler = handler;
_repository = repository;
}
public InputHandler(ICustomerRepository customerRepository, IStatementRepository statementRepository, IInputRepository inputRepository)
{
_customerRepository = customerRepository;
_statementRepository = statementRepository;
_inputRepository = inputRepository;
}
public InputsController(IInputRepository inputRepository)
{
_inputRepository = inputRepository;
}
public CalculatorController(IInputRepository inputRepository, IPrintRepository printRepository, ICalculatorRepository calculatorRepository)
{
this.inputRepository = inputRepository;
this.printRepository = printRepository;
this.calculatorRepository = calculatorRepository;
}
public IEnumerable <Result> GetResults(IInputRepository inputRepository)
{
List <List <Line> > paths = new List <List <Line> >();
List <Point> intersections = new List <Point>();
IEnumerable <IEnumerable <Move> > LineMoveInstructions = inputRepository.GetDay03Input();
foreach (IEnumerable <Move> moveInstuctions in LineMoveInstructions)
{
List <Line> currentPath = new List <Line>(moveInstuctions.Count());
Point currentPosition = new Point(0, 0);
foreach (Move move in moveInstuctions)
{
Point newPosition = move.Direction switch
{
Direction.up => new Point(currentPosition.X, currentPosition.Y + move.Steps),
Direction.down => new Point(currentPosition.X, currentPosition.Y - move.Steps),
Direction.left => new Point(currentPosition.X - move.Steps, currentPosition.Y),
Direction.right => new Point(currentPosition.X + move.Steps, currentPosition.Y),
_ => throw new Exception(),
};
Line newline = new Line(move.Direction, currentPosition.X, newPosition.X, currentPosition.Y, newPosition.Y);
currentPath.Add(newline);
foreach (IEnumerable <Line> path in paths)
{
foreach (Line line in path.Where(l => l.Orientation != newline.Orientation))
{
if (newline.Orientation == Orientation.horizontal)
{
if (TryGetIntersections(newline, line, out Point intersection))
{
intersections.Add(intersection);
}
}
else
{
if (TryGetIntersections(line, newline, out Point intersection))
{
intersections.Add(intersection);
}
}
}
}
currentPosition = newPosition;
}
paths.Add(currentPath);
}
int smallesManhattenDistance = int.MaxValue;
foreach (Point crossing in intersections)
{
int manhattanDistance = Math.Abs(crossing.X) + Math.Abs(crossing.Y);
if (manhattanDistance < smallesManhattenDistance)
{
smallesManhattenDistance = manhattanDistance;
}
}
yield return(new Result(smallesManhattenDistance));
}
