🌟 Advent of Code (AoC) 2021 🌟

internal class Puzzle1 : IPuzzle
{
    public int PuzzleNumber => 1;
        
    private readonly List<int> _depths = File.ReadAllLines("Inputs/Puzzle1.txt")
        .Select(int.Parse)
        .ToList();

    public int One() => GetMeasurementCounts(_depths);

    public int Two()
    {
        const int windowSize = 3;

        var windowSums = _depths
            .Where((_, idx) => idx <= (_depths.Count - windowSize))
            .Select((_, idx) =>  _depths.GetRange(idx, windowSize).Sum())
            .ToList();

        return GetMeasurementCounts(windowSums);
    }

    private static int GetMeasurementCounts(IReadOnlyCollection<int> depths)
    {
        return depths
            .Zip(depths.Skip(1))
            .Aggregate(0, (c, t) => t.Second > t.First ? c + 1 : c);
    }
}

int solve_part1(vector<int> data)
{

    adjacent_difference(data.begin(), data.end(), data.begin());
    int count = count_if(data.begin()+1, data.end(), [](int i){ return i>0; });

    return count;
    
}

int solve_part2(vector<int> data)
{
    vector<int> sums(data.size()-2);

    for (int i = 0, n = sums.size(); i < n; i++)
    {
        sums[i] = accumulate(data.begin()+i,data.begin()+(i+3),0);
    }
    
    int count = solve_part1(sums);
    
    return count;
}

template<typename Iterator>
int compare(Iterator start, Iterator end, int i){
    int count = 0;
    while(start+i != end){
        if(*start < *(start+i))
            count++;
        start++;
    }
    return count;
}

int main(){
    std::vector<int> data = readInput("input.txt");
    std::cout << compare(data.begin(), data.end(),1) << std::endl;
    std::cout << compare(data.begin(), data.end(),3) << std::endl;
}

# Advent Of Code day 01

depth_num = []
prev_number = 0
count_inc = 0

with open('input.txt') as f:
    lines = f.read().splitlines()

    for i in lines:
    	depth_num.append(int(i))

    for i in depth_num:
    	if prev_number < i:
            count_inc= count_inc + 1
    	prev_number = i

print(count_inc - 1) # we dont want it to count the first number of the dive.

using System;

namespace adventofcode01
{
    class Program
    {
        static void Main(string[] args)
        {
            int prev_num = 0;
            int count_inc = -1;

            foreach (string line in System.IO.File.ReadLines("PATH/TO/FILE"))
            {
                int line_to_int = int.Parse(line);

                if (line_to_int > prev_num)
                {
                    Console.WriteLine("Not bigger");
                    count_inc++;
                }

                prev_num = line_to_int;
               
            }

            Console.WriteLine(count_inc.ToString());
            Console.ReadLine();
        }
    }
}

def fileReader():
    input = []
    with open('inputDay1.txt') as file:
        for depth in file:
            input.append(int(depth))
        file.close()
    return input

def day1_part1(input):
    increased = 0
    prev = input[0]
    for depth in input:
        if (depth > prev):
            increased += 1           
        prev = depth
    return increased;
    
def day1_part2(input):
    previousBlock =  input[0] + input[1] + input[2] 
    increase = 0
    for index in range(1, len(input) - 2):
        currentBlock =  input[index] + input[index + 1] + input[index + 2]        
        if(currentBlock > previousBlock):
            increase +=1
        previousBlock = currentBlock
    return increase

print('Day One part 1:', day1_part1(fileReader()))
print('Day One part 2:', day1_part2(fileReader()))

fn main() {
    let input = std::fs::read_to_string("input.txt");
    let res: Vec<_> = input
        .unwrap()
        .lines()
        .filter_map(|s| s.parse::<_>().ok())
        .collect();

    calc(&res); // 1342
    calc(&res.windows(3).map(|s| s.iter().sum()).collect::<Vec<_>>()); // 1378
}

fn calc(data: &[i32]) {
    let acc = data.iter().fold((-1, 0), |mut acc, &v| {
        acc.0 += (v > acc.1) as i32;
        (acc.0, v)
    });
    println!("Svar: {}", acc.0);
}

List<string> lines = File.ReadAllLines("./input.txt").ToList();
List<int> numbers = new List<int>();

foreach (var line in lines)
{
    numbers.Add(int.Parse(line));
}

int increamentPartA = 0;
int increamentPartB = 0;

for (int i = 1; i < lines.Count; i++)
{
    if (numbers[i-1] < numbers[i]) 
    {
        increamentPartA++;
    }

    if (i +2 < lines.Count)
    {
        int compareA = numbers[i - 1] + numbers[i] + numbers[i + 1];
        int compareB = numbers[i] + numbers[i + 1] + numbers[i + 2];

        if (compareA < compareB)
        {
            increamentPartB++;
        }
    }    
}

Console.WriteLine("Part A: " + increamentPartA.ToString());
Console.WriteLine("Part B: " + increamentPartB.ToString());

use std::fs;

pub fn run() {
    let data = fs::read_to_string("dec_01.txt").expect("unable to read file");
    let numbers: Vec<u32> = data.lines().map(|line| line.parse().unwrap()).collect();

    println!("Part 1: {}", part1(&numbers));
    println!("Part 2: {}", part2(&numbers));

}

fn part1(numbers: &Vec<u32>) -> u32{
    let mut count = 0;
    for i in 1..numbers.len(){
        if numbers[i] > numbers[i-1]{
            count += 1;
        }
    }
    count
}

fn part2(numbers: &Vec<u32>) -> u32{
    let mut sum = u32::MAX;
    let mut count = 0;
    for n in 0..numbers.len() - 2 {
        if (numbers[n] + numbers[n + 1] + numbers[n + 2]) > sum {
            count += 1;
        }
        sum = numbers[n] + numbers[n + 1] + numbers[n + 2];
    }
    count
}

dag1←⍎¨⊃⎕NGET'aoc2021\dag1.txt'1
 aoc21_1←{+/⍵<1↓⍵,0}
aoc21_1 dag1

aoc21_2←{+/(3+/⍵)<1↓(3+/⍵),0}
aoc21_2 dag1

fun partOne() {
    val count = File("C:\\Users\\Lol\\Downloads\\input.txt")
        .readLines()
        .map { string -> string.toInt() }
        .zipWithNext { a, b -> b > a }
        .count { it }
    println(count)
}

fun partTwo() {
    val count = File("C:\\Users\\Lol\\Downloads\\input.txt")
        .readLines()
        .map { string -> string.toInt() }
        .windowed(3) { (a, b, c) -> a + b + c }
        .zipWithNext { a, b -> b > a }
        .count { it }
    println(count)
}

(import std)

(define main
  (do io/bind
      (<- inp (io/map unwrap! (read-file "inputs/day1.txt")))
      (let1 depths (map (<o unwrap! parse-nat) (lines inp)))
      (display "Part 1:")
      (display (show-nat (count-increases depths)))
      (display "Part 2:")
      (display (show-nat (count-increases (map (<o sum array/iter)
                                               (windows (cast 3) depths)))))))

(define (count-increases ns)
  (count (filter (fun ([a b]) (> b a))
                 (zip ns (skip (cast 1) ns)))))

;; Sliding windows over an iterator, each of width `n`
(define: (windows n)
    (forall (a) (Fun Nat (Iter a) (Iter (Array a))))
  (unfoldr (fun (xs)
             (let1 window (array/collect (take (cast n) xs))
               (if (< (array/length window) n)  ; At the end
                   None
                 (Some [window (skip (cast 1) xs)]))))))

static void Main(string[] args)
        {
            var input = File.ReadAllLines($"Day{DateTime.Now.Day}.txt").Select(int.Parse).ToList();

            int One() => Day_1_Part_1(input);
            int Two() => Day_1_Part_2(input);

            Console.WriteLine($"Part One: {One()}\nPart Two: {Two()}");
            Console.ReadLine();
        }

        public static int Day_1_Part_1(List<int> input)
        {
            int count = 0;
            for (int i = 1; i < input.Count(); i++)
            {
                if (input[i] > input[i - 1])
                    count++;
            }
            return count;
        }

        public static int Day_1_Part_2(List<int> input)
        {
            int count = 0;
            int a = 0;
            int b = 0;

            for (int i = 0; i < input.Count(); i++)
            {
                if (i + 2 < input.Count())
                    a = input[i] + input[i + 1] + input[i + 2];
                if (i + 3 < input.Count())
                    b = input[i + 1] + input[i + 2] + input[i + 3];
                if (b > a)
                    count++;
            }
            return count;
        }