Advent of Code day 6

r←⊃1⌷⊢⎕FIO[49] 'day6raw.txt'
{1-⍨⍵+⍵⍳⍨↑¨⍴¨⍵∪/r}¨4 14

Deduplicated and modestly cleaned up version again. Used a set comprehension when actually solving it because I didn't know how the set() constructor builtin handled iterables. Strangely easy for a Day 6; guess we're gonna get reamed tomorrow.

k = 14
file = open("input.txt")
c=file.read(k-1)
i = k-1
while True:
    c+= file.read(1)
    i+=1
    if(len(set(c[-k:]))) == k: break;
print(i)

No part1/2 because all i had to do is change one variable. They must be being generous before the big ones

ez

MESSAGE_LENGTH = 14

index = 0
while len(set([*message[index:index+MESSAGE_LENGTH]])) != MESSAGE_LENGTH: index+=1
print(index+MESSAGE_LENGTH)

trans lives matter

Change 14 to 4 for part one

from collections import deque


with open('./input6.txt') as infile:
    text =infile.read().strip()


q = deque(maxlen=14)


for i, char in enumerate(text,1):
    q.append(char)
    if i < 14: continue
    if len(set(q)) == 14:
        print(i)
        break

nothing special

finally awake for it and r-slurred because i forgot that strings are iterables

My brute force solution

#include <iostream>

#define PREAMBLE_WINDOW_SIZE 4
#define MESSAGE_WINDOW_SIZE 14

inline bool contains_duplicates(const std::string& window)
{
  // O(n²) meh
  for(size_t i = 0; i < window.length(); i++)
    for(size_t j = 0; j < window.length(); j++)
      if(i != j and window[i] == window[j])
        return 1;
  return 0;
}

int main()
{
  std::string line;
  std::getline(std::cin, line);
  size_t i = 0;

  for(; i < line.length() - PREAMBLE_WINDOW_SIZE; i++)
  {
    if(not contains_duplicates(line.substr(i, PREAMBLE_WINDOW_SIZE)))
    {
      // PART A
      //std::cout << (i + PREAMBLE_WINDOW_SIZE) << std::endl;
      // return 0;
      break;
    }
  }

  for(; i < line.length() - MESSAGE_WINDOW_SIZE; i++)
    if(not contains_duplicates(line.substr(i, MESSAGE_WINDOW_SIZE)))
    {
      // PART B
      std::cout << (i + MESSAGE_WINDOW_SIZE) << std::endl;
      return 0;
    }

  return -1;
}

Discuss

I'm getting 2019 Intcode flashbacks, where AoC had us build up a signal processor over about 10 days. This was too easy, we haven't seen the last of it.

I'm too embarrassed to post my entire answer, but I parsed each part of the puzzle input one character at a time, appending it to a string of characters, and validating each character in the string was unique or not.

I assumed that the first N characters (N being equal to the message token length, so 4 for part A and 14 for part B), were not going to have uniques (imagine if the very first four numbers were all unique and the answer was just 4 lmao) so I read in N number of characters all at once, then from there, validated that string to see if there were any dupes, and then would push a new character to the end and pop off the front, and then validate the new string, repeat until you get N unique characters.

My validation algorithm is bare-bones stupid, literally just a for-loop nested inside another for-loop, checking each character one-by-one. This would be monstrously inefficient if the input or message-length was huge but hey, the point is to do it fast right?

PLEASE HELP :(

#include <stdio.h>

int auth(char *buffer, int index, const int seq){
	int result = 1;
	for(int i=1;i<=seq;i++){
		result = result && (buffer[index] != buffer[index - i]);
	}
	return result;
}

int main(void){
	FILE *f = fopen("input.txt","r");
	char buffer[8192];
	fgets(buffer,8192,f);
	
	int i;
	const int num = 14;
	for(i=num;i<8192;i++){
		int result = 1;
		
		for(int k=0;k<num;k++){
			result = result && auth(buffer,i-k,num-k);
			if(result == 0)
				break;
		}
		if(result == 1)
			break;
		
	}
	fclose(f);
	printf("%d\n",i);
	return 0;
}

Idk what's wrong with my code. It gave the correct answer for 4 consecutive characters but for 14 it just goes through the entire string without finding a match. I ended up running the solutions for 13 consecutive characters, 12 consecutive chars, etc and noticed that the answers were always incremented:

3: 1099

4:1100

5:1101

6:1107

7:1108

8:1154

9:1155

10:1321

11:1322

12:2419

13:2420

So I just guessed 2421 for 14 and it was right... It's weird because I tried the test inputs and got the correct answer for them all except for mjqjpqmgbljsphdztnvjfqwrcgsmlb. Apparently the answer is supposed to be 19 but that makes no sense to me because the 19th character is j and there is also a j for the 10th character. Maybe I am fundamentally misunderstanding the problem. Either way I give up

input="string here"
seen=[]
for i in range(len(input)):
    ch=input[i]
    seen.append(ch)
    if (seen.index(ch)!=len(seen)-1):
        seen=seen[seen.index(ch)+1:]
    if(len(seen)==14): #4 for part 1
        print(i+1)

i = "" + fs.readFileSync("input")

q = l => a => [...Array(a.length)].map((_,i) => [...new Set(a.slice(i-l+1,i+1))].length == l).indexOf(true) + 1

part 1: q(4)(input)

part 2: q(14)(input)

today was weirdly easy. also, JS needs a better stdlib, the above is vanilla JS but incredibly ugly. the JS committee adds a few functions every year, not enough

I wish I stayed up for this one, took me about 5 minutes lol.

foo = ""
with open('day6_input.txt', 'r') as inp:
    foo = inp.read()
a = 4 # a = 14 for part 2
index = a
while len([*foo[index-a:index]]) > len(set([*foo[index-a:index]])):
    index += 1
print(index)

great filter when

A = char(readlines("input.txt","EmptyLineRule","skip"));
N = [4,14];

I = zeros(1,length(N));
Cond = false(1,length(N));
i = 1;
while all(Cond) && (i+1<=length(A))
    for j = 1:length(N)
        if (Cond(j)) && (length(unique(A(i:i+N(j)-1))) == N(j))
            I(j) = i+N(j)-1;
            Cond(j) = true;
        end
    end
    i = i+1;
end

fprintf("Part 1 : %d\n",I(1))
fprintf("Part 2 : %d\n",I(2))

I'm not super familiar with what programming language you're using but "set" is a data structure with unique keys, right? and if you stick four characters in a set and any are dupes, the size of the container will be less than 4 (or 14)? Honestly I had that idea too at first but didn't know off the top of my head how to do that in C++ and I figured a dumbass manually-check-each-character algorithm would take my brain less time to understand. I like your answer a lot.

Very easy today. Not going to optimize. I'm not going to do it.

with open('testinput', 'r') as f:

    for line in f:

        markerFound = False

        count = 0

        line = line.strip()

        curFound = ''

        for ch in line:

            curFound += ch

            if count >= 13 and not markerFound:

                good = True

                for c in curFound:

                    if curFound.count(c) > 1:

                        good=False

                if not good:

                    curFound = curFound[1:]

                if good: 

                    markerFound = True

                    break

            count += 1

        print('Line Count:', count + 1)

guaranteed O(n) solution, if only javascript was a real language and had proper hashmaps with size tracking

const l = 14; // change for code length
const h: any = [];
let d = 0;
console.log(fs.readFileSync(process.argv[2], 'utf-8')
  .split('').map(ch => ch.charCodeAt(0)).reduce((p, c, i, s,) => p
     ((h[c] ??= 0)  1) && ++h[c] && (h[c] === 2 ? ++d : 1) && (i >= l-1) && !d && i+1
    || (i >= l-1) && (h[s[i-(l-1)]]--) && (h[s[i-(l-1)]] === 1 ? d-- : 1) && 0
    || 0
  , 0));

c++

spent some time to find a O(1) for adding and checking if string is unique and then just gave up and ended up on O(n), with n being the length of the substring

bool isUnique(const std::string& substring) {
	std::array<bool, 26> chars{false};

	for (std::size_t i{0 }; i < substring.size(); ++i) {
		if (chars[substring[i] - 'a']) return false;
		chars[substring[i] - 'a'] = true;
	}
	return true;
}


int solution(const std::string& buf, int word_size) {
	std::string substring;
	std::size_t idx{ 0 };

	for (std::size_t i{ 0 }; i < buf.size(); ++i) {
		if (substring.size() < word_size) substring += buf[i];
		if (substring.size() == word_size && isUnique(substring)) {
			idx = i;
			break;
		}
		else {
			substring.erase(0, 1);
		}
		substring += buf[i];
	}
	return idx;
}

int main() {
	std::ifstream file("input.txt");

	std::string buf;
	std::getline(file, buf);
	auto a = std::chrono::high_resolution_clock::now();
	int p1 = solution(buf, 4);
	auto b = std::chrono::high_resolution_clock::now();
	int p2 = solution(buf, 14);
	auto c = std::chrono::high_resolution_clock::now();


	auto ab = std::chrono::duration_cast<std::chrono::microseconds>(b - a);

	auto bc = std::chrono::duration_cast<std::chrono::microseconds>(c - b);

	std::cout << "Part One: " << p1 << " Time: " << ab << '\n'
		<< "Part Two: " << p2 << " Time: " << bc << '\n';
}

this was sort of easy

using static System.Linq.Enumerable;

namespace AOC2022.Puzzles;

public class Day6 : IPuzzle
{
	private readonly int _totalLength;
	private readonly string _actualInput;

	public Day6(IReadOnlyList<string> linesFromFile)
	{
		_actualInput = linesFromFile[0];
		_totalLength = _actualInput.Length;
	}

	public void SolveFirstPuzzle()
	{
		const int sopLength = 4;
		var result = Range(sopLength, _totalLength)
			.First(x => 
				_actualInput.Substring(x - sopLength, sopLength).ToHashSet().Count == sopLength);
		Console.WriteLine(result);
	}

	public void SolveSecondPuzzle()
	{
		const int somLength = 14;
		var result = Range(somLength, _totalLength)
			.First(x => 
				_actualInput.Substring(x - somLength, somLength).ToHashSet().Count == somLength);
		Console.WriteLine(result);
	}
}

can improve more but I got work today :( thx to rider for making it almost one line lmao

ez

package six

import (
	"bufio"
	"bytes"
	"os"
)

const packet_size int = 4
const message_size int = 14

func One() int {
	var deliver int
	var buffer []byte

	fp, _ := os.Open("six.txt")
	defer fp.Close()
	rd := bufio.NewReader(fp)

	for i := 0; ; i++ {
		ch, _ := rd.ReadByte()
		buffer = append(buffer, ch)

		if len(buffer) > packet_size {
			for _, x := range buffer[i-packet_size : i] {
				sep := string(x)
				deliver += bytes.Count(buffer[i-packet_size:i], []byte(sep))
			}

			if deliver == packet_size {
				return i
			} else {
				deliver = 0
			}
		}
	}
}

func Two() int {
	var deliver int
	var buffer []byte

	fp, _ := os.Open("six.txt")
	defer fp.Close()
	rd := bufio.NewReader(fp)

	for i := 0; ; i++ {
		ch, _ := rd.ReadByte()
		buffer = append(buffer, ch)

		if len(buffer) > message_size {
			for _, x := range buffer[i-message_size : i] {
				sep := string(x)
				deliver += bytes.Count(buffer[i-message_size:i], []byte(sep))
			}

			if deliver == message_size {
				return i
			} else {
				deliver = 0
			}
		}
	}
}