def PartA():
global posx
global posy
print("Part A")
InitGrid()
posx = 0
posy = 0
computer = IntComputer(inputdata, OnOutputA, "PartA")
computer.run([])
while True:
if computer.finished:
break
alignment = 0
for x in range(gridsizex):
for y in range(gridsizey):
if grid[y][x] == WALL:
if TryGet(x + 1,
y) == WALL and TryGet(x - 1, y) == WALL and TryGet(
x, y - 1) == WALL and TryGet(x, y + 1) == WALL:
alignment += x * y
print("Answer:", alignment)
def PartB():
print("Part B")
computer = IntComputer(inputdata)
computer.run([2])
print("Answer:")
print(computer.outputs)
def PartA():
print("Part A")
InitGrid()
game = IntComputer(inputdata, OnOutput, "Game")
game.run([])
blockCount = 0
for row in grid:
for col in row:
if col == BLOCK:
blockCount += 1
print("Answer:", blockCount)
def tryPhaseSeq1(phaseSeq):
value = 0
for i in range(5):
amp = IC.IntComputer(intlist,phaseSeq[i])
amp.addInput(value)
value = amp.operate()
return value
def findOxygen(max_length, explo):
repair_robot = IC.IntComputer(intlist)
status = 0
position = (21, 21)
plan[21][21] = "R"
trajet = [(21, 21)]
while status != 2 or explo:
try:
next_position, dep = getMove(position, trajet)
except:
break
repair_robot.addInput(dep)
status = repair_robot.operate()
coord[next_position] = status
if status > 0:
if plan[position[1]][position[0]] != "O":
plan[position[1]][position[0]] = "."
position = next_position
if len(trajet) > 1 and position == trajet[-2]:
del trajet[-1]
else:
trajet.append(position)
plan[position[1]][position[0]] = "R" if status == 1 else "O"
plan[21][21] = "S"
else:
plan[next_position[1]][next_position[0]] = "#"
if explo and status == 2:
safe.append(position)
print("Partie 1 :\t", len(trajet) - 1)
def PartA():
global inputdata
print("Part A")
test1 = "109,1,204,-1,1001,100,1,100,1008,100,16,101,1006,101,0,99"
test2 = "1102,34915192,34915192,7,4,7,99,0"
test3 = "104,1125899906842624,99"
# inputdata = [int(x) for x in test1.split(",")]
# inputdata = [int(x) for x in test2.split(",")]
# inputdata = [int(x) for x in test3.split(",")]
computer = IntComputer(inputdata)
computer.run([1])
print("Answer:")
print(computer.outputs)
def tryPhaseSeq2(phaseSeq):
amps = [IC.IntComputer(intlist,phase) for phase in phaseSeq]
value = 0
for i in itertools.cycle(range(5)):
amps[i].addInput(value)
value = amps[i].operate()
if amps[4].isOver():
return value
def run_amplifiers(sequence, input_value):
inputs = parse_data()
outputA, codeA = IntComputer.interpreter(inputs, [0, sequence[0]])
outputB, codeB = IntComputer.interpreter(inputs, [outputA, sequence[1]])
outputC, codeC = IntComputer.interpreter(inputs, [outputB, sequence[2]])
outputD, codeD = IntComputer.interpreter(inputs, [outputC, sequence[3]])
outputE, codeE = IntComputer.interpreter(inputs, [outputD, sequence[4]])
print(outputE, codeE)
while True:
outputA, codeA = IntComputer.interpreter(inputs, [outputE, outputE])
if codeA == 99:
outputA = outputE
outputB, codeB = IntComputer.interpreter(inputs, [outputA, outputA])
if codeB == 99:
outputB = outputB
outputC, codeC = IntComputer.interpreter(inputs, [outputB, outputB])
if codeC == 99:
outputC = outputB
outputD, codeD = IntComputer.interpreter(inputs, [outputC, outputC])
if outputD == 99:
outputD = outputC
outputE, codeE = IntComputer.interpreter(inputs, [outputD, outputD])
if codeE == 99:
return outputE
#if codeA == 99:
outputA = outputE
# if outputD == None:
# outputD = outputC
# if outputC == None:
# outputC = outputB
# if outputB == None:
# outputB = outputA
# if outputA == None:
# outputA = outputE
# print(outputE)
if outputA == None and outputB == None and outputC == None and outputD == None:
print('Halted')
return outputE
break
def run_amplifiers(sequence,input_value):
inputsA = parse_data()
inputsB = parse_data()
inputsC = parse_data()
inputsD = parse_data()
inputsE = parse_data()
iA = 0
iiiA = 0
iB = 0
iiiB = 0
iC = 0
iiiC = 0
iD = 0
iiiD = 0
iE = 0
iiiE = 0
initial_conditionsA = [sequence[0],0]
initial_conditionsB = [sequence[1]]
initial_conditionsC = [sequence[2]]
initial_conditionsD = [sequence[3]]
initial_conditionsE = [sequence[4]]
outputEs = []
while True:
outputA,inputsA,iA,iiiA = IntComputer.interpreter(inputsA,initial_conditionsA,iA,iiiA)
initial_conditionsB.append(outputA)
outputB,inputsB,iB,iiiB = IntComputer.interpreter(inputsB,initial_conditionsB,iB,iiiB)
initial_conditionsC.append(outputB)
outputC,inputsC,iC,iiiC = IntComputer.interpreter(inputsC,initial_conditionsC,iC,iiiC)
initial_conditionsD.append(outputC)
outputD,inputsD,iD,iiiD = IntComputer.interpreter(inputsD,initial_conditionsD,iD,iiiD)
initial_conditionsE.append(outputD)
outputE,inputsE,iE,iiiE = IntComputer.interpreter(inputsE,initial_conditionsE,iE,iiiE)
initial_conditionsA.append(outputE)
outputEs.append(outputE)
if iE == None:
return outputEs[-2]
def BuildMap():
global posx
global posy
global direction
posx = int(gridsizex / 2)
posy = int(gridsizey / 2)
direction = NORTH
InitGrid()
grid[posy][posx] = UNKNOWN
game = IntComputer(inputdata, OnOutput, "Robot")
game.run([])
while True:
direction = DetermineDirection()
# if direction == NORTH:
# print("NORTH")
# elif direction == SOUTH:
# print("SOUTH")
# elif direction == EAST:
# print("EAST")
# elif direction == WEST:
# print("WEST")
if direction == None:
break
game.run([direction])
if game.finished:
break
print("Map Created")
def PartA():
global gridsizex
global gridsizey
gridsizex = 50
gridsizex = 50
print("Part A")
InitGrid()
computer = IntComputer(inputdata, None, "Compu")
for x in range(gridsizex):
for y in range(gridsizey):
computer.reset()
computer.run([x, y])
grid[y][x] = computer.lastoutput
count = 0
for x in range(gridsizex):
for y in range(gridsizey):
if grid[y][x] == 1:
count += 1
PrintGrid(0, 0)
print("Answer:", count)
def getCase(x, y):
rajout = False
try:
etat = plan[y][x]
if etat not in ".#":
rajout = True
else:
etat = 0 if etat == '.' else 1
except:
rajout = True
if rajout:
if y == len(plan):
plan.append(list(" " * len(plan[y - 1])))
if x == len(plan[y]):
plan[y].append(" ")
drone = IC.IntComputer(intlist, x, y)
etat = drone.operate()
plan[y][x] = "#" if etat == 1 else "."
return etat
def amplifiers2(sequence,input_value):
output_values = []
i = 0
j = 0
while True:
for i in range(5):
inputs = parse_data()
sequence_value = sequence[i]
if j == 0:
input_values = (input_value,sequence_value)
if j != 0:
input_values = (input_value,input_value)
output_value = IntComputer.interpreter(inputs,input_values)
print(output_value)
if output_value == 'Halt':
return output_values[-1]
break
else:
output_values.append(output_value)
input_value = output_value
i = 0
j += 1
def PartB():
print("Part B")
InitGrid()
inputdata[0] = 2
game = IntComputer(inputdata, OnOutput, "Game")
while True:
game.run([])
if game.finished:
break
joy = 0
if ballx < paddlex:
joy = -1
elif ballx > paddlex:
joy = 1
game.run([joy])
print("Answer:", score)
def PartB():
size = 1000
answer = 0
print("Part B")
computer = IntComputer(inputdata, None, "Compu")
for y, x in itertools.product(range(size), range(size)):
computer.reset()
computer.run([x, y])
if computer.lastoutput == 1:
if TryPartB(x, y):
answer = x * 10000 + y
break
# poging 1: 7800985 is too high
# poging 2: 7720975 Correct
print("Answer:", answer)
def PartA():
print("Part A")
computer = IntComputer(inputdata, OnOutput, "CPU")
computer.run([])
while True:
if computer.finished:
break
if lastcommand == "Command?":
cmd = input("Command:")
computer.run(AsciiToArray(cmd))
# FOOD RATION heavy 0
# MOUSE light 1
# ORNAMENT light 0
# CANDY CANE heavy 1
# SEMICONDUCTOR heavy 1
# MUG light 0
# COIN light 1
# MUTEX light 0
answer = 100667393
print("Answer:", answer)
def PartB():
global inputdata
global ampA
global ampB
global ampC
global ampD
global ampE
print("Part B")
test1 = "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"
# test1 results = 139629729
test2 = "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"
# test2 results = 18216
# inputdata = [int(x) for x in test1.split(",")]
# inputdata = [int(x) for x in test2.split(",")]
largest = 0
settings = [5, 6, 7, 8, 9]
for subsettuple in itertools.permutations(settings):
subset = [x for x in subsettuple]
# print("Settings: ", end = "")
# print(subset)
trust = 0
ampA = IntComputer(inputdata, name = "ampA")
ampB = IntComputer(inputdata, name = "ampB")
ampC = IntComputer(inputdata, name = "ampC")
ampD = IntComputer(inputdata, name = "ampD")
ampE = IntComputer(inputdata, name = "ampE")
ampA.run(subset[0:1] + [trust])
trust = ampA.lastoutput
ampB.run(subset[1:2] + [trust])
trust = ampB.lastoutput
ampC.run(subset[2:3] + [trust])
trust = ampC.lastoutput
ampD.run(subset[3:4] + [trust])
trust = ampD.lastoutput
ampE.run(subset[4:5] + [trust])
trust = ampE.lastoutput
while True:
ampA.run([trust])
trust = ampA.lastoutput
ampB.run([trust])
trust = ampB.lastoutput
ampC.run([trust])
trust = ampC.lastoutput
ampD.run([trust])
trust = ampD.lastoutput
ampE.run([trust])
trust = ampE.lastoutput
if ampE.finished:
break;
if trust > largest:
largest = trust
print("Answer:", largest)
def PartB():
global posx
global posy
print("Part B")
# First build the grid (Same as in Part A)
InitGrid()
posx = 0
posy = 0
computer = IntComputer(inputdata, OnOutputA, "PartA")
computer.run([])
while True:
if computer.finished:
break
path = BuildPath()
# PrintGrid(0, 0)
print("Path: ")
print(len(path))
print(path)
solution = MakeSentences(path)
if solution == None:
print("No solution found :(")
return
print(solution)
# Now Part B
inputdata[0] = 2
computer = IntComputer(inputdata, OnOutputB, "PartB")
program = solution[0].rstrip(",")
functiona = solution[1].rstrip(",")
functionb = solution[2].rstrip(",")
functionc = solution[3].rstrip(",")
program = [ord(letter) for letter in program]
program.append(NEWLINE)
functiona = [ord(letter) for letter in functiona]
functiona.append(NEWLINE)
functionb = [ord(letter) for letter in functionb]
functionb.append(NEWLINE)
functionc = [ord(letter) for letter in functionc]
functionc.append(NEWLINE)
computer.run(program)
computer.run(functiona)
computer.run(functionb)
computer.run(functionc)
computer.run([ord("n"), NEWLINE])
while True:
computer.run([])
if computer.finished:
break
print("Answer:", computer.lastoutput)
import IntComputer as IC
# Lecture fichier d'entrée
donnees = open("aoc9.txt", 'r')
intlist = list(map(int, donnees.read().split(",")))
donnees.close()
part1 = IC.IntComputer(intlist, 1)
print(part1.operate())
part2 = IC.IntComputer(intlist, 2)
print(part2.operate())
for testB, ster in iB:
iC = deeper(ster, "C")
for testC, sfinal in iC:
if len(sfinal) == 0:
return testA + "\n", testB + "\n", testC + "\n", s.replace(
testA, "A").replace(testB, "B").replace(testC,
"C") + "\n"
# Lecture fichier d'entrée
donnees = open("aoc17.txt", 'r')
Intlist = list(map(int, donnees.read().split(",")))
donnees.close()
del donnees
Robot = IC.ASCIIComputer(Intlist)
Robot.operate()
Plan_str = "".join(c for c in lireTerrain())
plan = [ligne for ligne in Plan_str.split("\n") if len(ligne) > 0]
Alignment = sum(x * y for x, y in getIntersections())
print("Partie 1 :\t\t", Alignment)
T1 = time.perf_counter()
print("Temps partie 1 :\t", T1 - T0)
FACING = "URDL"
COORD = {'U': (0, -1), 'R': (1, 0), 'D': (0, 1), 'L': (-1, 0)}
RCOORD = {COORD[key]: key for key in COORD.keys()}
Robot2 = IC.ASCIIComputer(Intlist)
Robot2[0] = 2
def RunRobot(startColor):
global deltaix
minx = 100000
maxx = 0
miny = 100000
maxy = 0
deltaix = 0
InitGrid()
posx = startx
posy = starty
grid[posy][posx] = startColor
computer = IntComputer(inputdata)
color = grid[posy][posx]
if color == -1:
color = BLACK
computer.run([color])
while True:
if computer.finished:
break
o1 = computer.outputs[-2]
o2 = computer.outputs[-1]
# print(o1)
# print(o2)
# input("Press...")
if o1 == BLACK:
grid[posy][posx] = BLACK
elif o1 == WHITE:
grid[posy][posx] = WHITE
if o2 == LEFT:
deltaix = (deltaix + 1) % 4
elif o2 == RIGHT:
deltaix = (deltaix - 1) % 4
dx = deltas[deltaix][0]
dy = deltas[deltaix][1]
posx += dx
posy += dy
if posx < minx:
minx = posx
if posy < miny:
miny = posy
if posx > maxx:
maxx = posx
if posy > maxy:
maxy = posy
print("POS: %d,%d" % (posx, posy), end="\r")
color = grid[posy][posx]
if color == -1:
color = BLACK
computer.run([color])
import IntComputer as IC
# Lecture fichier d'entrée
donnees = open("aoc2.txt", 'r')
intlist = list(map(int, donnees.read().split(",")))
donnees.close()
# Part 1
intlist[1:3] = 12, 2
part1 = IC.IntComputer(intlist, 0)
print(part1.operate())
# Part 2
stop = False
for noun in range(len(intlist)):
if not stop:
for verb in range(len(intlist)):
intlist[1:3] = noun, verb
part2 = IC.IntComputer(intlist, 0)
try:
if part2.operate() == 19690720:
print(100 * noun + verb)
stop = True
except:
pass
def part_one():
rawinput = parse_data()
filled_indices = create_blank_list(rawinput)
integers = IntComputer.interpreter(filled_indices)
"R": lambda y: y
}
def changePanel(move, direction, panel):
direction = dirs[dirs.index(direction) -
1] if move == 0 else dirs[(dirs.index(direction) + 1) % 4]
panel = dx[direction](panel[0]), dy[direction](panel[1])
return panel, direction
currentPanel = 0, 0
direction = "U"
panels = {currentPanel: 1}
robot = IC.IntComputer(intlist)
while not robot.isOver():
robot.addInput(panels.setdefault(currentPanel, 0))
robot.operate()
panels[currentPanel] = robot.getOutput()
currentPanel, direction = changePanel(robot.getOutput(), direction,
currentPanel)
print(len(panels))
xmin, xmax = min(panel[0] for panel in list(panels.keys())), max(
panel[0] for panel in list(panels.keys()))
ymin, ymax = min(panel[1] for panel in list(panels.keys())), max(
panel[1] for panel in list(panels.keys()))
def PartA():
global outputstring
print("Part A")
outputstring = ""
computer = IntComputer(inputdata, OnOutputA, "JumpComputer")
computer.run([])
computer.run(AsciiToArray("NOT A J"))
computer.run(AsciiToArray("NOT J J"))
computer.run(AsciiToArray("AND B T"))
computer.run(AsciiToArray("AND C J"))
computer.run(AsciiToArray("NOT J J"))
computer.run(AsciiToArray("AND D J"))
computer.run(AsciiToArray("WALK"))
while True:
if computer.finished:
break
print("Answer:", computer.lastoutput)
def PartB():
global outputstring
print("Part B")
outputstring = ""
computer = IntComputer(inputdata, OnOutputA, "JumpComputer")
computer.run([])
computer.run(AsciiToArray("NOT C J"))
computer.run(AsciiToArray("AND H J"))
computer.run(AsciiToArray("NOT B T"))
computer.run(AsciiToArray("OR T J"))
computer.run(AsciiToArray("NOT A T"))
computer.run(AsciiToArray("OR T J"))
computer.run(AsciiToArray("AND D J"))
computer.run(AsciiToArray("RUN"))
while True:
if computer.finished:
break
print("Answer:", computer.lastoutput)
def TryPartB(ox, oy):
size = 99
print(f"Trying Offset {ox}, {oy}")
computer = IntComputer(inputdata, None, "Compu")
computer.run([ox, oy])
if computer.lastoutput == 0:
print("Fail at corner TL")
return False
computer.reset()
computer.run([ox + size, oy])
if computer.lastoutput == 0:
print("Fail at corner TR")
return False
computer.reset()
computer.run([ox, oy + size])
if computer.lastoutput == 0:
print("Fail at corner BL")
return False
computer.reset()
computer.run([ox + size, oy + size])
if computer.lastoutput == 0:
print("Fail at corner BR")
return False
return True
if getCase(i, j) == 0:
return False
return True
T0 = time.perf_counter()
# Lecture fichier d'entrée
donnees = open("aoc19.txt", 'r')
intlist = list(map(int, donnees.read().split(",")))
donnees.close()
total = 0
plan = [[''] * 50 for _ in range(50)]
for x, y in product(range(50), repeat=2):
drone = IC.IntComputer(intlist, x, y)
etat = drone.operate()
total += etat
plan[y][x] = '#' if etat == 1 else '.'
afficher()
print("Partie 1 :\t\t", total)
T1 = time.perf_counter()
print("Temps partie 1 :\t", T1 - T0)
stop = False
next_start = 30
for y in count(50):
if stop:
break
debut_rayon = False
for x in count(next_start):
