Meta question: if there are going to be a decent number of people participating in this, should we have a daily thread so that each day's solutions/discussion can be separated out more easily? It will be a lot of posts, but if people aren't interested in them they can easily avoid them by either unsubscribing from ~comp or filtering out the "advent of code" tag.

Alternatively, we could even create a (temporary) sub-group just for these topics, making it even easier.

I won't do it just yet, but I can set up daily posts starting from Day 4 if people think it would be a good idea. I think it might be a good plan, especially if some people aren't keeping up with the schedule. Having it all in one topic is probably going to get overwhelming very quickly.

import math

with open('input','r') as f:
    data = f.read().splitlines()

Total = 0
for i in range(len(data)):
    Total = Total + (math.floor((int(data[i]) / 3)) - 2)

print(Total)

This was pretty simple. I'm sure it could be condensed down.

import math

def calculate(inamount):
    return math.floor((int(inamount) / 3)) - 2#divide by 3, round down, -2

with open('input','r') as f:
    data = f.read().splitlines()

Total = 0
for i in range(len(data)):
    FuelArray = []    
    FuelArray.append(calculate(data[i]))
    if calculate(data[i]) <= 0:
        Total = Total + calculate(data[i])
    else:
        while calculate(FuelArray[-1]) > 0:
            FuelArray.append(calculate(FuelArray[-1]))#-1 means last entry
        FuelArraySum = 0
        for i in range(len(FuelArray)):
            FuelArraySum = FuelArraySum + FuelArray[i]
        Total = Total + FuelArraySum
        
print(Total)

I'm not entirely sure I needed to use a function here. But it was easier for my brain to work around it that way. This one made me think a little with the whole calculating the weight of fuel needed for fuel.

data = [] #The input was given in something very similar to a python array so I just copy pasted it in here. To save space I haven't included it in the post.


ipointer = 0
ipointermax = (len(data) - 1) / 4#-1 because of 99 at the end.
#print(ipointermax)


for i in range(int(ipointermax)):#Probably could have just done a while loop that went until it found 99.
    #print('ipointer', ipointer)
    #print(data)
    val1 = data[data[ipointer + 1]]
    val2 = data[data[ipointer + 2]]
    #print('op', data[ipointer])
    #print('v1', val1)
    #print('v2', val2)
    if data[ipointer] == 1:
        data[data[ipointer + 3]] = val1 + val2
        #print(val1 + val2)
    elif data[ipointer] == 2:
        data[data[ipointer + 3]] = val1 * val2
        #print(val1 * val2)
    elif data[ipointer] == 99:
        print('STOP')
        print('Answer is', data[0])
        break
    else:
        print('Something has gone horribly and terribly wrong')
        break
    ipointer = ipointer + 4

I didn't include the actual input data in this post. I really liked this challenge.

One thing that tripped me up though. The challenge said:

To do this, before running the program, replace position 1 with the value 12 and replace position 2 with the value 2.

I didn't read the question properly, never changed that second value and spent a good 10 minutes manually checking that it was properly processing the intcode, before reading the question again and facepalming at my own negligence.

def calculate(noun,verb):
    data = [] #Again, not including my actual input data, it's long
    ipointer = 0
    ipointermax = (len(data) - 1) / 4#-1 because of 99 at the end.
    #print(ipointermax)
    data[1] = noun
    data[2] = verb

    for i in range(int(ipointermax)):
        #print('ipointer', ipointer)
        #print(data)
        val1 = data[data[ipointer + 1]]
        val2 = data[data[ipointer + 2]]
        #print('op', data[ipointer])
        #print('v1', val1)
        #print('v2', val2)
        if data[ipointer] == 1:
            data[data[ipointer + 3]] = val1 + val2
            #print(val1 + val2)
        elif data[ipointer] == 2:
            data[data[ipointer + 3]] = val1 * val2
            #print(val1 * val2)
        elif data[ipointer] == 99:
            #print('STOP')
            #print('Answer is', data[0])
            return data[0]
        else:
            print('Something has gone horribly and terribly wrong')
            break
        ipointer = ipointer + 4
        


verb = 0
noun = 0

for verb in range(100):
    for noun in range(100):
        if calculate(noun,verb) == 19690720:
            print('Answer is', 100 * noun + verb)

The first part is the same as part 1, but now it is part of a function that gets run over and over by a double for loop. I'm sure if you were mathematically talented you could probably use clever maths to solve this with a method that isn't brute force. But I'm not that smart.

#from tabulate import tabulate

with open('input','r') as f:
    data = f.read().splitlines()

for i in range(len(data)):#overdone to do it like this. But this way it isn't hardcoded to only dealing with two lines. Although the rest of the code is.. *shrug*
    data[i] = data[i].split(',')

print(data)

#make big array that has everything in it 20000x20000 should be big enough...
LinesArray = [['.' for i in range(20000)] for i in range(20000)]#Normally 2000

'''
Key:
5 = starting position
1 = part of line 1
2 = part of line 2
3 = intersection of both lines
blank = nothing here
'''
LinesArray[10000][10000] = 5#start point. Normally 1000

Position = [10000,10000]#y,x. Normally 1000,1000
PositionOriginal = Position#Store this for later...

#now to plot the lines
for i in range(len(data)):#Do once for each line. If len(data) is not 2, this will break.
    Position = [10000,10000]#y,x. Normally 1000,1000
    if i == 0:
        CurrentLine = 1
    elif i == 1:
        CurrentLine = 2
    else:
        print('More lines are not supported!!')
        break
    for j in range(len(data[i])):
        Direction = data[i][j][:1]
        Amount = data[i][j][1:]
        #print(Direction, Amount)
        #print(Position)
        if Direction == 'U':
            for k in range(int(Amount)):
                #print(k)
                if LinesArray[Position[0] - k - 1][Position[1]] == CurrentLine - 1 or LinesArray[Position[0] - k - 1][Position[1]] == 3:#neverhappens on first run. does on second
                    LinesArray[Position[0] - k - 1][Position[1]] = 3
                else:
                    LinesArray[Position[0] - k - 1][Position[1]] = CurrentLine
            Position[0] = Position[0] - k - 1
            #print(Position)
            #LinesArray[Position[0]][1] = 2
            #print(tabulate(LinesArray))
        elif Direction == 'D':
            for k in range(int(Amount)):
                #print(k)
                if LinesArray[Position[0] + k + 1][Position[1]] == CurrentLine - 1 or LinesArray[Position[0] + k + 1][Position[1]] == 3:
                    LinesArray[Position[0] + k + 1][Position[1]] = 3
                else:
                    LinesArray[Position[0] + k + 1][Position[1]] = CurrentLine
            Position[0] = Position[0] + k + 1
            #print(Position)
            #LinesArray[Position[0]][1] = 2
            #print(tabulate(LinesArray))
        elif Direction == 'L':
            for k in range(int(Amount)):
                #print(k)
                if LinesArray[Position[0]][Position[1] - k - 1] == CurrentLine - 1 or LinesArray[Position[0] - k - 1][Position[1]] == 3:
                    LinesArray[Position[0]][Position[1] - k - 1] = 3
                else:
                    LinesArray[Position[0]][Position[1] - k - 1] = CurrentLine
            Position[1] = Position[1] - k - 1
            #print(Position)
            #LinesArray[Position[0]][1] = 2
            #print(tabulate(LinesArray))
        elif Direction == 'R':
            for k in range(int(Amount)):
                #print(k)
                if LinesArray[Position[0]][Position[1] + k + 1] == CurrentLine -1 or LinesArray[Position[0]][Position[1] + k + 1] == 3:
                    LinesArray[Position[0]][Position[1] + k + 1] = 3
                else:
                    LinesArray[Position[0]][Position[1] + k + 1] = CurrentLine
            Position[1] = Position[1] + k + 1
            #print(Position)
            #LinesArray[Position[0]][1] = 2
            #print(tabulate(LinesArray))
        else:
            print('There is an issue')
            break

#print('---------------')
#Now do the manhattan distance thing to find the closest point...
ListOfIntersections = []
for i in range(len(LinesArray)):
    for j in range(len(LinesArray[i])):
        if LinesArray[i][j] == 3:#i is down from top, j is from left going right
            SubList = []
            SubList.append(i)
            SubList.append(j)
            ListOfIntersections.append(SubList)
            #print(ListOfIntersections)
            


#print(ListOfIntersections)

#Now find the one that is the closest...
ShortestDistance = -1
for i in range(len(ListOfIntersections)):
    XDistance = ListOfIntersections[i][1] - PositionOriginal[1]
    YDistance = ListOfIntersections[i][0] - PositionOriginal[0]
    if XDistance < 0:
        XDistance = XDistance * -1
    if YDistance < 0:
        YDistance = YDistance * -1
    ManhattanDistance = XDistance + YDistance
    #print('pos orig', PositionOriginal)
    #print(ListOfIntersections[i][1], PositionOriginal[1], XDistance)
    #print(ListOfIntersections[i][0], PositionOriginal[0], YDistance)
    #print(ManhattanDistance)
    if ManhattanDistance < ShortestDistance or ShortestDistance == -1:
        ShortestDistance = ManhattanDistance

print('Answer: ',ShortestDistance)

This is horrible. I used an absolutely massive two dimensional array to visualise the wires. When it runs it uses about 3.2GB's of ram and takes a minute or so to get the result.

I used tabulate to visualise the grid when it was small (10x10) for testing. I took this out for the final, massive array.

I kept on having to increase the size of the array, because the wires kept on going outside of it and causing errors. It worked at 20,000 by 20,000. (very big).

Also I kept on having weird issues where I would set an array to be equal to another array, and then if I changed the first array, the second one would also change. I fixed that by using some jank. For attempt 2 I learned when you say array = array2, they are both the same object, so you need to say array = array2[:] to make them separate.

So perhaps visualisation is not so great when dealing with very big things.

I thought that this was so bad that I should really give it another crack. But I think attempt 2 is arguably worse.

with open('input','r') as f:
    data = f.read().splitlines()

for i in range(len(data)):#overdone to do it like this. But this way it isn't hardcoded to only dealing with two lines. Although the rest of the code is.. *shrug*
    data[i] = data[i].split(',')

History = []#Always clear your history. Well... not this one.
StartPos = [0,0]#x,y (the middle of our 'cartesian plane' if we want to visualise)
CurrentPos = StartPos[:]#[:] so that it makes a new object
#print(CurrentPos)
#print(StartPos)
for i in range(len(data[0])):#first line
    print(len(data[0]), i)
    Direction = data[0][i][:1]
    Amount = int(data[0][i][1:])
    if Direction == 'U':
        for j in range(Amount):
            #print(CurrentPos)
            CurrentPos[1] = CurrentPos[1] + 1
            #if not CurrentPos in History:#this should save some time. Or perhaps its more checks so it takes longer??
            #    History.append(CurrentPos[:])
            History.append(CurrentPos[:])
    elif Direction == 'D':
        for j in range(Amount):
            #print(CurrentPos)
            CurrentPos[1] = CurrentPos[1] - 1
            #if not CurrentPos in History:#this should save some time. Or perhaps its more checks so it takes longer??
            #    History.append(CurrentPos[:])
            History.append(CurrentPos[:])
    elif Direction == 'L':
        for j in range(Amount):
            #print(CurrentPos)
            CurrentPos[0] = CurrentPos[0] - 1
            #if not CurrentPos in History:#this should save some time. Or perhaps its more checks so it takes longer??
            #    History.append(CurrentPos[:])
            History.append(CurrentPos[:])
    elif Direction == 'R':
        for j in range(Amount):
            #print(CurrentPos)
            CurrentPos[0] = CurrentPos[0] + 1
            #if not CurrentPos in History:#this should save some time. Or perhaps its more checks so it takes longer??
            #    History.append(CurrentPos[:])
            History.append(CurrentPos[:])
    else:
        print('Something has probably just caught fire...')
        break
#print(History)

CurrentPos = StartPos[:]
IntersectionList = []

for i in range(len(data[1])):#second line!
    print(len(data[1]), i)
    Direction = data[1][i][:1]
    Amount = int(data[1][i][1:])
    if Direction == 'U':
        for j in range(Amount):
            #print(CurrentPos)
            CurrentPos[1] = CurrentPos[1] + 1
            if CurrentPos in History:
                IntersectionList.append(CurrentPos[:])
    elif Direction == 'D':
        for j in range(Amount):
            #print(CurrentPos)
            CurrentPos[1] = CurrentPos[1] - 1
            if CurrentPos in History:
                IntersectionList.append(CurrentPos[:])
    elif Direction == 'L':
        for j in range(Amount):
            #print(CurrentPos)
            CurrentPos[0] = CurrentPos[0] - 1
            if CurrentPos in History:
                IntersectionList.append(CurrentPos[:])
    elif Direction == 'R':
        for j in range(Amount):
            #print(CurrentPos)
            CurrentPos[0] = CurrentPos[0] + 1
            if CurrentPos in History:
                IntersectionList.append(CurrentPos[:])
    else:
        print('Something has probably just caught fire... But in a different spot!')
        break

#print(IntersectionList)

#All the stuff down here is pretty similar to attempt 1
#Now find the one that is the closest...
ShortestDistance = -1
for i in range(len(IntersectionList)):
    XDistance = IntersectionList[i][0] - StartPos[0]
    YDistance = IntersectionList[i][1] - StartPos[1]
    if XDistance < 0:
        XDistance = XDistance * -1
    if YDistance < 0:
        YDistance = YDistance * -1
    ManhattanDistance = XDistance + YDistance
    #print('pos orig', StartPos)
    #print(IntersectionList[i][0], StartPos[0], XDistance)
    #print(IntersectionList[i][1], StartPos[1], YDistance)
    #print(ManhattanDistance)
    if ManhattanDistance < ShortestDistance or ShortestDistance == -1:
        ShortestDistance = ManhattanDistance

print('Answer: ',ShortestDistance)

So I thought, rather than make a massive array, why don't we just record every single place that the first line goes (a different, massive array), and then when figuring out the second line, check each place to see if it's in a spot that the first line has also been. If it is, then record those coordinates. Then do the same figuring out to find the closest one.

The good: This uses significantly less memory than the previous attempt (I didn't measure it but gotop didn't show any massive climbs like attempt 1 did)

The bad: This is very slow. Slower than slow. It took 8 minutes to get the correct answer. The guy who completed this challenge first did it in 2 minutes and 38 seconds. They could program this whole thing ~3x faster than I could run mine.

I tried reducing this time by checking if something has already been added to the "history" of the first line and then not adding it a second time (or perhaps more), reducing the size of the array and therefore hopefully making the comparisons quicker. But this made more checks have to be done, so it actually slowed it down. The modified code takes 11 minutes and 40 seconds to run. Ooops! I left that check code in but commented out.

I noticed that when it was being slow, it was getting slow in the "for j in range(Amount):" loops.

When the loops do an "if not CurrentPos in History:" check (for the first line, this is the thing I added to try speed it up that actually slowed it) they go slow. When they check is not present, the first part of the code completes very quickly.

Of course the "if CurrentPos in History:" checks are pretty necessary on the second line because how else would I check if the lines intersect. So this part is still slow.

Perhaps I could speed it up by just storing the end points of each line segment (eg 200,200 and 200,220 could be one segment) and then checking if the proposed spot falls within that range. I'm not sure if this will be faster though and I'm too tired at the moment to try it. Perhaps another time.

Please don't make me feel too bad about what I've just done.

use std::fs::File;
use std::path::Path;
use std::io::{BufRead, BufReader, Error, ErrorKind, Read};

const DIVISOR: usize = 3;
const SUBTRA: usize = 2;

fn main() -> Result<(), Error>{
	let path = Path::new("data/input.txt");
	let vec = read(File::open(path)?)?;

	let sum: usize = vec.iter()
						.map(|&x| div_and_subt(x, DIVISOR, SUBTRA))
						.sum();

	println!("{:?}", sum);

	Ok(())
}

fn div_and_subt(n: usize, x: usize, y: usize) -> usize {
	n/x - y
}

fn read<R: Read>(io: R) -> Result<Vec<usize>, Error> {
	let br = BufReader::new(io);
	br.lines()
		.map(|line| line.and_then(|v| v.parse().map_err(|e| Error::new(ErrorKind::InvalidData, e))))
		.collect()
}

inputf = open('day1input.txt', 'r')

def mod_fuel(mass):
    return (mass//3) - 2

def fuel_sum():
    sum = 0
    for line in inputf:
        sum += mod_fuel(int(line))
    return sum

print(fuel_sum());inputf.close()

pretty easy for the most part but didn't know how to open a file :(

inputf = open('day1input.txt', 'r')

def findfuel(mass):
    if mass <= 6:
        return 0
    fuel = (mass // 3) - 2
    fuel +=  findfuel(fuel)
    return fuel

def fuel_sum():
    sum = 0
    for line in inputf:
        sum += findfuel(int(line))
    return sum

print(fuel_sum());inputf.close()

took a little more thinking but got it down after another 10ish minutes :)

with open('input_p1only.txt', 'r') as inpfile:
    readfile = inpfile.read()

def convertolist(flist):
    stripped = flist.rstrip('\n')
    split = stripped.split(',')
    tape = [int(x)  for x in split]
    return tape

memory = convertolist(readfile)
pointer = 0
while True :    
    if memory[pointer] == 1 :
        memory[memory[pointer+3]] = memory[memory[pointer+1]] + memory[memory[pointer+2]]
        pointer+=4      
    elif memory[pointer] == 2:
        memory[memory[pointer+3]] = memory[memory[pointer+1]] * memory[memory[pointer+2]]
        pointer+=4
    elif memory[pointer] == 99:
        break
    else:
        print("FUCK")
        
print(memory)

It was fun having my program spit out a scrolling wall of "FUCK" when I implemented it wrong the first time 🙃

def convertolist(flist):
    stripped = flist.rstrip('\n')
    split = stripped.split(',')
    tape = [int(x)  for x in split]
    return tape

def IntCode(memory):
    pointer = 0
    while True :      
        if memory[pointer] == 1 :
            memory[memory[pointer+3]] = memory[memory[pointer+1]] + memory[memory[pointer+2]]
            pointer+=4
        elif memory[pointer] == 2:
            memory[memory[pointer+3]] = memory[memory[pointer+1]] * memory[memory[pointer+2]]
            pointer+=4
        elif memory[pointer] == 99:
            break
        else:
            print("FUCK")
    return memory[0]

def verbnounfinder():
    init_memory = convertolist(readfile)
    trymemory = init_memory[:]
    for x in range(100):
        trymemory[1] = x
        for y in range(100):
            trymemory[2] = y
            if IntCode(trymemory) == 19690720:
                print(trymemory[0:3])
                break
            trymemory = init_memory[:]
            trymemory[1] = x
        trymemory = init_memory[:]
        

with open('input_p1only.txt', 'r') as inpfile:
    readfile = inpfile.read()
verbnounfinder()

if anyone has any tips for making the verbnounfinder function any neater please tell me because it is a mess.

'use strict';

// Put everything in an async IIFE to use await
(async () => {
  const res = await fetch('./rocket.txt');
  const text = await res.text();
  const arr = text.split('\n');
  arr.pop();

  // PART 1
  const mass = arr.reduce((acc, number) => acc + Math.floor(number / 3) - 2, 0);
  console.log(mass);
  // PART 2
  const calcModule = fuel => {
    const numbers = [];
    const generateArr = num => {
      const result = Math.floor(num / 3) - 2;
      numbers.push(result);
      if (result > 0) generateArr(result);
    };
    generateArr(fuel);
    return numbers.filter(num => num > 0).reduce((acc, num) => acc + num, 0);
  };
  const solution = arr.map(calcModule).reduce((acc, num) => acc + num, 0);

  console.log(solution);
})();

v
0
   >3/2-v
v      +<
>&:|
   >$.@

v
0
    >>  3/2-v
v    : v< 
     ^ <|`0:<
        >$     >\:#v_v
               ^ +\<
v          +$        <
>0&:|
    >$$.@

This snippet of code might not work in all Befunge interpreters/compilers. I saw nothing in the spec that said I couldn't use the put instruction to store arbitrarily large numbers, but it doesn't work consistently. I actually created my own interpreter for this to run more smoothly (also so I could enter all the inputs as one array, rather than individually at each &).

v                                                             

1      >v
>: &:1+|>68*    + \0p 1+ v  <-- Encoder
^                        < 
       >$$$ 1v
           > >:0g 68*-    v
            
             v            <   <-- Opcode processing 

             > :1-#v_$ 1+:0g68*- 1+0 g68*-               v
             v     <v g10 +*86+p10\  -*86g 0+1 -*86g0:+1\<
                    > 1+0g68*- 1+0 p  01g 1+              v
             v                                      


             > :2-#v_$ 1+:0g68*- 1+0 g68*-               v
             v     <v g10 +*86*p10\  -*86g 0+1 -*86g0:+1\<
                    > 1+0g68*- 1+0 p  01g 1+              v
             v                                      

             >:25*9*9+-#v_$$0>1+:0g68*-:44*+#v_@
           + v          <    ^          ," ".<
           1 $
           ^ <                                            <

I just brute forced this section by manually trying a lot of different values.