Add day07b

Author: ishanpranav

Makefile

@@ -53,8 +53,8 @@ day05b: src/day05b.c emulator parser
 day07a: src/day07a.c emulator parser
 $(CC) $(CFLAGS) $< -o $@.o emulator.o parser.o
 
-day07b: src/day07b.c
-$(CC) $(CFLAGS) $< -o $@.o
+day07b: src/day07b.c emulator parser
+$(CC) $(CFLAGS) $< -o $@.o emulator.o parser.o
 
 day08a: src/day08a.c
 $(CC) $(CFLAGS) $< -o $@.o

data/074.csv

@@ -0,0 +1 @@
+3, 26, 1001, 26, -4, 26, 3, 27, 1002, 27, 2, 27, 1, 27, 26, 27, 4, 27, 1001, 28, -1, 28, 1005, 28, 6, 99, 0, 0, 5

data/075.csv

@@ -0,0 +1 @@
+3, 52, 1001, 52, -5, 52, 3, 53, 1, 52, 56, 54, 1007, 54, 5, 55, 1005, 55, 26, 1001, 54, -5, 54, 1105, 1, 12, 1, 53, 54, 53, 1008, 54, 0, 55, 1001, 55, 1, 55, 2, 53, 55, 53, 4, 53, 1001, 56, -1, 56, 1005, 56, 6, 99, 0, 0, 0, 0, 10

lib/emulator.c

@@ -3,6 +3,7 @@
 // Licensed under the MIT license.
 
 #include <stdio.h>
+#include <string.h>
 #include "emulator.h"
 
 enum Opcode
@@ -33,23 +34,20 @@ static void emulator_on_output(Emulator instance, Word word)
 void emulator(Emulator instance, Word memory[])
 {
  instance->memory = memory;
+ instance->instruction = instance->memory;
  instance->input = emulator_on_input;
  instance->output = emulator_on_output;
- 
+
  queue(&instance->inputs, NULL, 0);
  queue(&instance->outputs, NULL, 0);
 }
 
-static void emulator_move(
- Emulator instance, 
- Word* instruction, 
- Word result, 
- int slot)
+static void emulator_move(Emulator instance, Word result, int slot)
 {
- instance->memory[instruction[slot]] = result;
+ instance->memory[instance->instruction[slot]] = result;
 }
 
-static Word emulator_load(Emulator instance, Word* instruction, int slot)
+static Word emulator_load(Emulator instance, int slot)
 {
  int denominator = 100;
 
@@ -58,121 +56,132 @@ static Word emulator_load(Emulator instance, Word* instruction, int slot)
  denominator *= 10;
  }
 
- Word value = instruction[slot];
+ Word value = instance->instruction[slot];
 
- if ((*instruction / denominator) % 10 == 0)
+ if ((*instance->instruction / denominator) % 10 == 0)
  {
  return instance->memory[value];
  }
 
  return value;
 }
 
-void emulator_execute(Emulator instance)
+bool emulator_execute(Emulator instance)
 {
- Word* instruction = instance->memory;
-
  for (;;)
  {
- Opcode opcode = *instruction % 100;
+ Opcode opcode = *instance->instruction % 100;
 
  switch (opcode)
  {
  case OPCODE_ADD:
  {
- Word a = emulator_load(instance, instruction, 1);
- Word b = emulator_load(instance, instruction, 2);
+ Word a = emulator_load(instance, 1);
+ Word b = emulator_load(instance, 2);
 
- emulator_move(instance, instruction, a + b, 3);
+ emulator_move(instance, a + b, 3);
 
- instruction += 4;
+ instance->instruction += 4;
  }
  break;
 
  case OPCODE_MULTIPLY:
  {
- Word a = emulator_load(instance, instruction, 1);
- Word b = emulator_load(instance, instruction, 2);
+ Word a = emulator_load(instance, 1);
+ Word b = emulator_load(instance, 2);
 
- emulator_move(instance, instruction, a * b, 3);
+ emulator_move(instance, a * b, 3);
 
- instruction += 4;
+ instance->instruction += 4;
  }
  break;
 
  case OPCODE_INPUT:
  {
  Word input;
 
- instance->input(instance, &input);
- emulator_move(instance, instruction, input, 1);
+ if (!instance->input(instance, &input))
+ {
+ return false;
+ }
+ 
+ emulator_move(instance, input, 1);
 
- instruction += 2;
+ instance->instruction += 2;
  }
  break;
 
  case OPCODE_OUTPUT:
  {
- Word output = emulator_load(instance, instruction, 1);
+ Word output = emulator_load(instance, 1);
 
  instance->output(instance, output);
- instruction += 2;
+ instance->instruction += 2;
  }
  break;
 
  case OPCODE_JUMP_IF_TRUE:
- if (emulator_load(instance, instruction, 1))
+ if (emulator_load(instance, 1))
  {
- Word label = emulator_load(instance, instruction, 2);
+ Word label = emulator_load(instance, 2);
 
- instruction = instance->memory + label;
+ instance->instruction = instance->memory + label;
 
  break;
  }
 
- instruction += 3;
+ instance->instruction += 3;
  break;
 
  case OPCODE_JUMP_IF_FALSE:
- if (!emulator_load(instance, instruction, 1))
+ if (!emulator_load(instance, 1))
  {
- Word label = emulator_load(instance, instruction, 2);
+ Word label = emulator_load(instance, 2);
 
- instruction = instance->memory + label;
+ instance->instruction = instance->memory + label;
 
  break;
  }
 
- instruction += 3;
+ instance->instruction += 3;
  break;
 
  case OPCODE_LESS_THAN:
  {
- Word a = emulator_load(instance, instruction, 1);
- Word b = emulator_load(instance, instruction, 2);
+ Word a = emulator_load(instance, 1);
+ Word b = emulator_load(instance, 2);
 
- emulator_move(instance, instruction, a < b, 3);
+ emulator_move(instance, a < b, 3);
 
- instruction += 4;
+ instance->instruction += 4;
  }
  break;
 
  case OPCODE_EQUALS:
  {
- Word a = emulator_load(instance, instruction, 1);
- Word b = emulator_load(instance, instruction, 2);
+ Word a = emulator_load(instance, 1);
+ Word b = emulator_load(instance, 2);
 
- emulator_move(instance, instruction, a == b, 3);
+ emulator_move(instance, a == b, 3);
 
- instruction += 4;
+ instance->instruction += 4;
  }
  break;
 
- case OPCODE_TERMINATE: return;
+ case OPCODE_TERMINATE: return true;
  }
  }
 }
 
+void emulator_reimage(Emulator instance, Word image[], int imageSize)
+{
+ instance->instruction = instance->memory;
+
+ memcpy(instance->memory, image, imageSize * sizeof(Word));
+ queue_clear(&instance->inputs);
+ queue_clear(&instance->outputs);
+}
+
 void queue(Queue instance, Word buffer[], int capacity)
 {
  instance->items = buffer;
@@ -225,3 +234,9 @@ bool queue_try_dequeue(Queue instance, Word* result)
 
  return true;
 }
+
+void queue_clear(Queue instance)
+{
+ instance->first = -1;
+ instance->last = -1;
+}

lib/emulator.h

@@ -16,6 +16,7 @@ struct Queue
 struct Emulator
 {
  long* memory;
+ long* instruction;
 
  bool (*input)(struct Emulator* instance, long* result);
  void (*output)(struct Emulator* instance, long value);
@@ -28,8 +29,10 @@ typedef struct Emulator* Emulator;
 typedef struct Queue* Queue;
 
 void emulator(Emulator instance, Word memory[]);
-void emulator_execute(Emulator instance);
+bool emulator_execute(Emulator instance);
+void emulator_reimage(Emulator instance, Word image[], int imageSize);
 
 void queue(Queue instance, Word buffer[], int capacity);
 void queue_enqueue(Queue instance, Word item);
 bool queue_try_dequeue(Queue instance, Word* result);
+void queue_clear(Queue instance);

lib/parser.c

@@ -7,15 +7,15 @@
 int parser_parse(FILE* stream, Word memory[])
 {
  Word word;
- int count = 0;
+ int size = 0;
 
  while (fscanf(stream, WORD_FORMAT ", ", &word) == 1)
  {
- memory[count] = word;
- count++;
+ memory[size] = word;
+ size++;
  }
 
- return count;
+ return size;
 }
 
 int parser_parse_file(ZString path, Word memory[])
@@ -27,12 +27,12 @@ int parser_parse_file(ZString path, Word memory[])
  return 0;
  }
 
- int count = parser_parse(stream, memory);
+ int size = parser_parse(stream, memory);
 
  if (fclose(stream) == EOF)
  {
  return 0;
  }
 
- return count;
+ return size;
 }

src/day02b.c

@@ -4,27 +4,27 @@
 
 // 1202 Program Alarm Part 2
 
-#include <string.h>
 #include <time.h>
 #include "../lib/emulator.h"
 #include "../lib/parser.h"
 #define MEMORY 256
 
-static Word scan(Word image[], int length)
+static Word scan(Word image[], int imageSize)
 {
+ Word memory[MEMORY];
+ struct Emulator processor;
+ 
+ emulator(&processor, memory);
+
  for (Word noun = 0; noun < 100; noun++)
  {
  for (Word verb = 0; verb < 100; verb++)
  {
- Word memory[MEMORY];
- struct Emulator processor;
-
- memcpy(memory, image, sizeof(Word) * length);
+ emulator_reimage(&processor, image, imageSize);
 
  memory[1] = noun;
  memory[2] = verb;
 
- emulator(&processor, memory);
  emulator_execute(&processor);
 
  if (memory[0] == 19690720)

src/day07a.c

@@ -12,7 +12,7 @@
 #include "../lib/parser.h"
 #define INPUTS 2
 #define MEMORY 4096
-#define OUTPUTS 100
+#define OUTPUTS 1
 
 struct PermutationIterator
 {
@@ -74,30 +74,30 @@ void permutation_next(PermutationIterator iter)
 int main()
 {
  Word max = 0;
- Word programMemory[MEMORY];
- Word sharedMemory[5][MEMORY];
+ Word image[MEMORY];
+ Word memory[5][MEMORY];
  Word inputs[5][INPUTS];
  Word outputs[5][OUTPUTS];
  struct PermutationIterator iter;
  struct Emulator amplifiers[5];
  int set[] = { 0, 1, 2, 3, 4 };
  clock_t start = clock();
- int length = parser_parse(stdin, programMemory);
+ int size = parser_parse(stdin, image);
 
- for (permutation_begin(set, 5, &iter); !iter.end; permutation_next(&iter))
+ for (int i = 0; i < 5; i++)
  {
- for (int i = 0; i < 5; i++)
- {
- memcpy(sharedMemory[i], programMemory, length * sizeof(Word));
- emulator(amplifiers + i, sharedMemory[i]);
- queue(&amplifiers[i].inputs, inputs[i], INPUTS);
- queue(&amplifiers[i].outputs, outputs[i], OUTPUTS);
- }
+ emulator(amplifiers + i, memory[i]);
+ queue(&amplifiers[i].inputs, inputs[i], INPUTS);
+ queue(&amplifiers[i].outputs, outputs[i], OUTPUTS);
+ }
 
+ for (permutation_begin(set, 5, &iter); !iter.end; permutation_next(&iter))
+ {
  Word output = 0;
 
  for (int i = 0; i < 5; i++)
  {
+ emulator_reimage(amplifiers + i, image, size);
  queue_enqueue(&amplifiers[i].inputs, set[i]);
  queue_enqueue(&amplifiers[i].inputs, output);
  emulator_execute(amplifiers + i);