Day 1: Sonar Sweep

List comprehensions, yay!

report    = [int(depth) for depth in sys.stdin]
increases = sum(1 for i in range(1, len(report)) if report[i] > report[i - 1])
print(increases)

This took me longer than it should have, but once I realized that if I could just form the windows separately, then I could re-use the method for counting the increases from Part A.

report    = [int(depth) for depth in sys.stdin]
windows   = [sum(report[i:i+3]) for i in range(0, len(report) - 2)]
increases = sum(1 for i in range(1, len(windows)) if windows[i] > windows[i - 1])
print(increases)

Just a text parser and a loop. Nothing particularly fancy

prev_val = None
count = 0

#data = test_data
data = real_data
data = data.split('\n')
data = [int(i) for i in data]

#print(data)

for val in data:
    if prev_val and prev_val < val:
        count = count + 1
    prev_val = val

print(count)

This one is slightly more tricky in that you need to combine the elements into a sliding window. This could definitely be done in place as you move through the list by keeping a running sum, but I just made a new list by adding every element to itself and the next 2 spots, then shortening the list back down to cut off the extra end pieces

#data = test_data
data = real_data
data = data.split('\n')
data = [int(i) for i in data]

sliding_window = list([0] * (len(data) + 2))

for index, val in enumerate(data):
    sliding_window[index] = sliding_window[index] + val
    sliding_window[index + 1] = sliding_window[index + 1] + val
    sliding_window[index + 2] = sliding_window[index + 2] + val
    
sliding_window = sliding_window[2:-2]

#print(sliding_window)

prev_val = None
count = 0

for val in sliding_window:
    if prev_val and prev_val < val:
        count = count + 1
    prev_val = val
    
print(count)

• The biggest challenge here is going to be getting your text parser up and running and converting your input into a form you can work with.

• Part 2 builds on part 1. See how you can reuse what you've already figured out. This is going to be a recurring theme for Advent of Code. Many problems build upon other problems

• There are multiple ways to do it, if you get stuck on one particular method, try something else

• With early Advent of Code problems you usually don't need to worry about making your code efficient. It's still good to think about because later problems will require you to use efficient methods or your code will never finish on time.

• Even if you're able to solve a problem right away, it's still good to think about other ways to approach it. They may help you out later

use itertools::Itertools;

fn main() {
    println!(
        "{}",
        include_str!("../input.txt")
            .lines()
            .map(|line: &str| line.parse::<usize>().unwrap())
            .tuple_windows::<(_, _)>()
            .filter(|(a, b)| b > a)
            .count()
    );
}

use itertools::Itertools;

fn main() {
    println!(
        "{}",
        include_str!("../input.txt")
            .lines()
            .map(|line: &str| line.parse::<usize>().unwrap())
            .tuple_windows::<(_, _, _, _)>()
            .filter(|(a, b, c, d)| (a + b + c) < (b + c + d))
            .count()
    );
}

=ARRAYFORMULA(
  SUM( 
   IF(ISBLANK(A3:A),,
    IF(A3:A<A2:A,,1))))

=ARRAYFORMULA(
  SUM(
   IFERROR(
    IF(ISBLANK(A2:A),,
     IF(A5:A<=A2:A,,1)))))

(for/sum ([x input]
          [y (drop input 1)]
          #:when (> y x))
  1)

I would normally use (rest input) to skip the first element of a list but I'm using drop instead to highlight the similarity to part 2.

(for/sum ([x input]
          [y (drop input 3)]
          #:when (> y x))
  1)

For part 2, there's no need to sum or maintain any sliding windows since for any 4 consecutive values [a b c d] you have two windows with a common pair of values [a B C] vs [B C d] so the window sum increases when d>a.

It turns out both parts can be solved by simply comparing the list of values that lag by 1 or 3 places.
Racket's for can iterate through lists either nested or in parallel so you can compare consecutive values (that lag by 1 place) by iterating through the same list and dropping the first element. You can compare values that lag by 3 places by iterating through the same list but dropping the first 3 values.
It works because the iteration stops when any list is empty.
I use this technique to compare consecutive items of a list regularly.

// I'm going to leave out getting the data from the input. I just put the data into an array called data.
const result = data.reduce((total, current, i, lines) => {
  if (lines[i + 1] > current) {
    total++;
  }
  return total;
}, 0);

const result = data.reduce((total, amount, index, array) => {
  let currentWindow = array.slice(index, index + 3).reduce((a, b) => a + b, 0);
  let nextWindow = array.slice(index + 1, index + 4).reduce((a, b) => a + b, 0);
  if (nextWindow > currentWindow) {
    total++;
  }
  return total;
}, 0);

use crate::lib::aoc;

pub fn run1() {
    let lines = aoc::get_lines("./inputs/day1.in");

    let mut times_increased_1 = 0;
    let mut times_increased_2 = 0;
    let mut last: u32 = u32::MAX;
    // last3.0 and last3.1 can be 0 since we will never reach an actual sum of u32::MAX
    let mut last3: (u32, u32, u32) = (0, 0, u32::MAX);
    let mut last3_sum: u32 = sum_triple(last3);

    for line in lines {
        let current = line.parse::<u32>().unwrap();
        let current3 = (last3.1, last3.2, current);
        let current3_sum = sum_triple(current3);

        if current > last {
            times_increased_1 += 1;
        }

        if current3_sum > last3_sum {
            times_increased_2 += 1;
        }

        last = current;
        last3 = current3;
        last3_sum = current3_sum;
    }

    // Output
    println!("~~~ Day 1 ~~~");
    println!("Part 1 - times increased: {}", times_increased_1);
    println!("Part 2 - times increased: {}", times_increased_2);
}

fn sum_triple(triple: (u32, u32, u32)) -> u32 {
    if triple.0 == u32::MAX || triple.1 == u32::MAX || triple.2 == u32::MAX {
        u32::MAX
    } else {
        triple.0 + triple.1 + triple.2
    }
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func main () {
	file, err := os.OpenFile("data-test.txt", os.O_RDONLY, 0644)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	count := 0
	prev := 2147483647
	s := bufio.NewScanner(file)
	for s.Scan() {
		tmp, _ := strconv.Atoi(s.Text())

		if tmp > prev {
			count += 1
		}

		prev = tmp
	}

	file.Close()
	fmt.Println(count)
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func GetIncrements (a *[]int) int {
	count := 0
	prev := 2147483647
	for _, n := range *a {
		if prev < n {
			count += 1
		}
		prev = n
	}
	return count
}

func ProcessWindows (data *[]int) []int {
	windows := []int{}
	buffer := [][]int{}

	for _, n := range *data {
		for i, b := range buffer {
			buffer[i] = append(b, n)
		}

		buffer = append(buffer, []int{n})

		if len(buffer[0]) == 3 {
			windows = append(windows, SumSlice(&buffer[0]))
			buffer = buffer[1:]
		}
	}

	return windows
}

func ReadData () []int {
	file, err := os.OpenFile("data.txt", os.O_RDONLY, 0644)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	res := []int{}
	s := bufio.NewScanner(file)
	for s.Scan() {
		n, _ := strconv.Atoi(s.Text())
		res = append(res, n)
	}

	file.Close()

	return res
}

func SumSlice (s *[]int) int {
	res := 0
	for _, n := range *s {
		res += n
	}
	return res
}

func main () {
	d := ReadData()
	w := ProcessWindows(&d)
	n := GetIncrements(&w)
	fmt.Println(n)
}

def compute_p1(input)
  input.lines.map(&:to_i).each_cons(2).reduce(0) do |sum, pair|
    pair.last > pair.first ? sum + 1 : sum
  end
end

def compute_p2(input)
  input
    .lines
    .map(&:to_i)
    .each_cons(3)
    .map(&:sum)
    .each_cons(2)
    .reduce(0) { |sum, pair| pair.last > pair.first ? sum + 1 : sum }
end

#!/usr/bin/env ruby

require 'benchmark'
require 'minitest'
require 'pry-byebug'

TEST_STR = "\
199
200
208
210
200
207
240
269
260
263
"

class Test < MiniTest::Test
  def test_p1
    assert_equal(7, compute_p1(TEST_STR))
  end

  def test_p2
    assert_equal(5, compute_p2(TEST_STR))
  end
end

def compute_p1(input)
  input.lines.map(&:to_i).each_cons(2).reduce(0) do |sum, pair|
    pair.last > pair.first ? sum + 1 : sum
  end
end

def compute_p2(input)
  input
    .lines
    .map(&:to_i)
    .each_cons(3)
    .map(&:sum)
    .each_cons(2)
    .reduce(0) { |sum, pair| pair.last > pair.first ? sum + 1 : sum }
end

if MiniTest.run
  puts 'Test case OK, running...'

  @input = File.read(ARGV[0] || 'input.txt')

  Benchmark.bm do |bm|
    bm.report('Part 1:') { @p1 = compute_p1(@input) }
    bm.report('Part 2:') { @p2 = compute_p2(@input) }
  end

  puts "\nResults:"
  puts 'Part 1: %i' % @p1
  puts 'Part 2: %i' % @p2

else
  puts 'Test case ERR'
end

part 1: +/2</\x

part 2: +/2</\3+/\x

>099*9*9*9*9*9*9*9*v                                                                                 
              >    >&: 01 p v                                                                               
                   v    _v#:<                                                                        
                   \     >$$.@
                   `                                                                                 
                   !
              ^g10<_1+v                                                                              
                  ^   <      

use std::env;
use std::io::{self, prelude::*, BufReader};
use std::fs::File;

fn main() {
    let args: Vec<String> = env::args().collect();
    let filename = &args[1];
    day01(&filename).unwrap();
}

fn day01(input: &str) -> io::Result<()> {
    let file = File::open(input).expect("Input file not found.");
    let reader = BufReader::new(file);

    // Input
    let input: Vec<String> = match reader.lines().collect() {
        Err(err) => panic!("Unknown error reading input: {}", err),
        Ok(result) => result,
    };
    let input: Vec<i64> = input
        .iter()
        .map(|x| x.parse::<i64>().unwrap())
        .collect();

    // Solutions
    println!("Part 1: {}", sonar(&input, 1)); // 1301
    println!("Part 2: {}", sonar(&input, 3)); // 1346

    Ok(())
}

fn sonar(input: &Vec<i64>, winsize: usize) -> usize {
    input
        .windows(winsize)
        .map(|x| x.iter().sum::<i64>())
        .collect::<Vec<_>>()
        .windows(2)
        .filter(|x| x[1] > x[0])
        .count()
}

const m = [/* given input values */]
console.log(m.reduce((a, c, i) => m[i-1] < c ? a + 1 : a, 0))

const m = [/* given input values */]
console.log(m.reduce((a, c, i) => m[i-1] + m[i-2] + m[i-3] < m[i] + m[i-1] + m[i-2] ? a + 1 : a, 0))

    use std::fs::File;
    use std::io::{BufReader, BufRead, Error};

    fn main() -> Result<(), Error> {
        let path = "input.txt";

        let input = File::open(path)?;
        let buffered = BufReader::new(input);

        let mut x = -1;
        let mut val = 0;

        for line in buffered.lines() {
            let line  = line.unwrap().parse::<i32>().unwrap();
            println!("line: {}, val:{}",line,val);
            if line > val{
                x += 1;
            }
            val = line;
        }
    println!("Final Result: {}",x);

    Ok(())
    }

I really wanted to just get the first line to initialize val before entering the loop but couldn't figure out how to do that.

import strutils, std/strformat

var input: seq[string] = strutils.split(readFile("input.txt"),  "\n")
var clean_input: seq[int] = @[]

for value in input[0 .. ^2]:
    clean_input.add(parseInt(strutils.strip(value)))


var previous: int = clean_input[0]
var increases: int = 0

for value in clean_input[1 .. ^1]:
    if value > previous:
        inc increases
    previous = value

echo &"The number of increases is {increases}"

var summed_increases: int = 0

for idx in 3 ..< clean_input.len:
    if clean_input[idx] > clean_input[idx - 3]:
        inc summed_increases

echo &"The number of summed increases is {summed_increases}"

#!/usr/bin/awk -f
{
	if (i != "" && $0 > i) n += 1
	i = $0
}

END { print n }

#!/usr/bin/awk -f
{ arr[NR] = $0 }

END {
	for (i = 3; i <= NR; ++i) {
		j = arr[i-2] + arr[i-1] + arr[i]
		if (k != "" && j > k) n += 1
		k = j
	}

	print n
}

My world is nothing.

Listen to your soul.
Listen to your heart.
While your heart isn't mysterious,
If your heart is greater than your soul,
Build my world up.
(guitar solo)
Put your heart into your soul!
Listen to your heart!
(bass solo)
Build my world up!

Whisper my world.

Our fire is smoldering...

Listen to the rhythm.
Listen to the wilfulness.
Listen to the guitar.
Listen to the wilderness.
(strong drums)
Burn the rhythm!
Burn the wilfulness!
Burn the guitar!
(guitar riff)
While the wilderness isn't mysterious,
Burn the wilderness!
Put the rhythm with the wilfulness with the guitar into the cities!
Put the wilfulness with the guitar with the wilderness into the forests!
If the cities are less than the forests,
Build our fire up!
(guitar solo)
Put the wilfulness into the rhythm.
Put the guitar into the wilfulness.
Put the wilderness into the guitar.
Listen to the wilderness!
(throw guitar at drummer)
Whisper our fire.

count = 0

with open("input.txt") as file:
    arr = [int(item) for item in file]

for i in range(1, len(arr)):
    if arr[i] > arr[i - 1]:
        count += 1

print("Part One: ", count)

count = 0
three = list()

for i in range(0, len(arr) - 2):
    three.append(sum(arr[i : i + 3]))

for i in range(1, len(three)):
    if three[i] > three[i - 1]:
        count += 1

print("Part Two: ", count)

const fs = require('fs');
const readline = require('readline');

let depthArr = [];

async function openFileForReading(file) {
	const fileStream = fs.createReadStream(file);

	const rl = readline.createInterface({
		input: fileStream,
		crlfDelay: Infinity
	});

	for await (const line of rl) {
		try {
			depthArr.push(parseInt(line));
		} catch(e) {
			console.error(e);
		}
	}
}

(async function mainExecution() {
	await openFileForReading('input.txt');
	let currentDepth = 0;
	let firstDepth = true;
	let numIncreases = 0;
	for (const depth of depthArr) {
		if (firstDepth != true) {
			diff = depth - currentDepth;
			if (diff > 0) {
				console.log("Depth increased from " + currentDepth + " to " + depth);
				numIncreases++;
			}
		}
		currentDepth = depth;
		firstDepth = false;
	}
	console.log("Answer found! " + numIncreases);
})();

const fs = require('fs');
const readline = require('readline');

let depthArr = [];

async function openFileForReading(file) {
	const fileStream = fs.createReadStream(file);

	const rl = readline.createInterface({
		input: fileStream,
		crlfDelay: Infinity
	});

	for await (const line of rl) {
		try {
			depthArr.push(parseInt(line));
		} catch(e) {
			console.error(e);
		}
	}
}

(async function mainExecution() {
	await openFileForReading('input.txt');
	let currentDepth = 0;
	let currentWindowIndex = 0;
	let firstDepth = true;
	let numIncreases = 0;
	for (let currentWindowIndex = 0; currentWindowIndex < depthArr.length-2; currentWindowIndex++) {
		if (firstDepth != true) {
			depthSum = depthArr[currentWindowIndex] + depthArr[currentWindowIndex+1] + depthArr[currentWindowIndex+2];
			diff = depthSum - currentDepth;
			if (diff > 0) {
				console.log("Depth increased from " + currentDepth + " to " + depthSum);
				numIncreases++;
			}
		}
		currentDepth = depthArr[currentWindowIndex] + depthArr[currentWindowIndex+1] + depthArr[currentWindowIndex+2];
		firstDepth = false;
	}
	console.log("Answer found! " + numIncreases);
})();