Day 4: Camp Cleanup

#!/usr/bin/env pypy3

import sys

def main():
    pairs = ([set(range(a, b + 1)) for a, b in c] for c in
             (([*map(int, d.split('-'))] for d in line.strip().split(','))
              for line in sys.stdin))
    overlaps = (a.issubset(b) or b.issubset(a) for a, b in pairs)
    print(sum(overlaps))

if __name__ == '__main__':
    main()

#!/usr/bin/env pypy3

import sys

def main():
    pairs = ([set(range(a, b + 1)) for a, b in c] for c in
             (([*map(int, d.split('-'))] for d in line.strip().split(','))
              for line in sys.stdin))
    overlaps = (a & b != set() for a, b in pairs)
    print(sum(overlaps))

if __name__ == '__main__':
    main()

import Foundation

var totalFullSubRanges: Int = 0
var totalAnySubRanges: Int = 0

while let line = readLine() {
    let sectionRanges = line.components(separatedBy: ",").map { $0.components(separatedBy: "-").map { Int($0) ?? -1 } }
    let rangeOne = Set(Array(sectionRanges[0][0]...sectionRanges[0][1]))
    let rangeTwo = Set(Array(sectionRanges[1][0]...sectionRanges[1][1]))
    if rangeOne.isSubset(of: rangeTwo) || rangeTwo.isSubset(of: rangeOne) {
        totalFullSubRanges += 1
    }
    
    if !rangeOne.intersection(rangeTwo).isEmpty {
        totalAnySubRanges += 1
    }
}

print(totalFullSubRanges)
print(totalAnySubRanges)

(ls
 > fe(X.split(",") | fe(X.split("-") | fe(int) | tuple)
      | permutations | fe(as_args(λ a, b: a[0] <= b[0] <= b[1] <= a[1])) | any)
 | sum
)

from itertools import permutations
from pipetools import X
from pipetools import as_args
from pipetools import foreach
import sys
from pyp import pypprint
fe = foreach
lines = [x.rstrip('\n') for x in sys.stdin]
ls = lines
output = ls > fe(X.split(',') | fe(X.split('-') | fe(int) | tuple) | permutations | fe(as_args(lambda a, b: a[0] <= b[0] <= b[1] <= a[1])) | any) | sum
if output is not None:
    pypprint(output)

(ls
 > fe(X.split(",") | fe(X.split("-") | fe(int) | tuple)
      | permutations | fe(as_args(λ a, b: a[0] <= b[0] <= a[1])) | any)
 | sum
)

from itertools import permutations
from pipetools import X
from pipetools import as_args
from pipetools import foreach
import sys
from pyp import pypprint
fe = foreach
lines = [x.rstrip('\n') for x in sys.stdin]
ls = lines
output = ls > fe(X.split(',') | fe(X.split('-') | fe(int) | tuple) | permutations | fe(as_args(lambda a, b: a[0] <= b[0] <= a[1])) | any) | sum
if output is not None:
    pypprint(output)

#!/usr/bin/env bash

file=day4.dat
part=2

if [[ ${part} -eq 1 ]]; then
# /////////////////////////////////////////////////////////////////////////////
#part 1 0.55s // 463
sed 's/-/ /g' $file > $file.tmp
sum=0
while IFS=, read -r range1 range2 || [[ -n ${range1} ]]; do
    ranges=($(echo $range1 $range2))
    if [[ ${ranges[2]} -le ${ranges[0]} && ${ranges[3]} -ge ${ranges[1]} ]]; then
        ((sum = sum + 1))
        continue #mandatory to make sure we don't double count somehow
    fi

    if [[ ${ranges[0]} -le ${ranges[2]} && ${ranges[1]} -ge ${ranges[3]}  ]]; then
        ((sum = sum + 1))
        continue
    fi
done < $file.tmp

echo Part 1: $sum
# /////////////////////////////////////////////////////////////////////////////
fi

if [[ ${part} -eq 2 ]]; then
# /////////////////////////////////////////////////////////////////////////////
#part 2  0.54s // 919
sed 's/-/ /g' $file > $file.tmp
sum=0
while IFS=, read -r range1 range2 || [[ -n ${range1} ]]; do
    ranges=($(echo $range1 $range2))
    if [[ ${ranges[2]} -le ${ranges[0]} && ${ranges[0]} -le ${ranges[3]} ]]; then
        # echo overlap
        # echo ${ranges[@]}
        ((sum=sum+1))
        continue
    fi


    if [[ ${ranges[0]} -le ${ranges[2]} && ${ranges[2]} -le ${ranges[1]} ]]; then
        # echo overlap
        # echo ${ranges[@]}
        ((sum=sum+1))
        continue
    fi


done < $file.tmp

echo Part 2: $sum
# /////////////////////////////////////////////////////////////////////////////
fi

rm $file.tmp

(define (part-01 input)
  (for/sum ([elves (in-list input)]
            #:when (contained? (assignments elves)))
    1))

(define (assignments elves)
  (map string->number (regexp-match* #px"\\d+" elves)))

(define (contained? elves)
  (match-define (list mina maxa minb maxb) elves)
  (or (and (<= mina minb) (>= maxa maxb))
      (and (<= minb mina) (>= maxb maxa))))

(define (part-02 input)
  (for/sum ([elves (in-list input)]
            #:when (overlap? (assignments elves)))
    1))

(define (overlap? elves)
  (match-define (list mina maxa minb maxb) elves)
  (or (and (>= maxa minb) (>= maxb mina))
      (and (>= maxb mina) (>= maxa minb))))

#!/usr/bin/awk -f
BEGIN { FS = "[,-]" }
{ sum += (($1 >= $3 && $2 <= $4) || ($3 >= $1 && $4 <= $2)) }
END { print(sum) }

#!/usr/bin/awk -f
BEGIN { FS = "[,-]" }
{ sum += ($1 <= $4 && $3 <= $2) }
END { print(sum) }

import re


def cleanup(full: bool = True) -> int:
    overlap: int = 0

    for line in open("input.txt"):
        a, b, c, d = map(int, re.findall(r"\d+", line))
        first = set(range(a, b + 1))
        second = set(range(c, d + 1))

        if first.issubset(second) or second.issubset(first) if full else first.intersection(second):
            overlap += 1

    return overlap


print(cleanup())  # Part One: 498
print(cleanup(False))  # Part Two: 859

-        if full and (first.issubset(second) or second.issubset(first)) or not full and first.intersection(second):
+        if first.issubset(second) or second.issubset(first) if full else first.intersection(second):

defmodule AdventOfCode.Solution.Year2022.Day04 do
  def part1(input) do
    input
    |> String.split("\n", trim: true)
    |> Enum.map(&parse_ints/1)
    |> Enum.count(&superset_subset?/1)
  end

  def part2(input) do
    input
    |> String.split("\n", trim: true)
    |> Enum.map(&parse_ints/1)
    |> Enum.count(&overlap?/1)
  end

  defp parse_ints(line) do
    ~r/^(\d+)-(\d+),(\d+)-(\d+)$/
    |> Regex.run(line, capture: :all_but_first)
    |> Enum.map(&String.to_integer/1)
  end

  defp superset_subset?([a, b, x, y]) do
    (a <= x and b >= y) or (a >= x and b <= y)
  end

  defp overlap?([a, b, x, y]) do
    not Range.disjoint?(a..b, x..y)
  end
end

def part1(lines):
    print(f"Part 1!")
    numTimes = 0
    for line in lines:
        first, second = line.split(',')
        firstA = list(range(int(first.split('-')[0]), int(first.split('-')[1])+1))
        secondA = list(range(int(second.split('-')[0]), int(second.split('-')[1])+1))
        if set(firstA).issubset(set(secondA)) or set(secondA).issubset(set(firstA)):
            numTimes += 1
    print(f"Result: {numTimes}")


def part2(lines):
    print(f"Part 2!")
    numTimes = 0
    for line in lines:
        first, second = line.split(',')
        fA = list(range(int(first.split('-')[0]), int(first.split('-')[1])+1))
        sA = list(range(int(second.split('-')[0]), int(second.split('-')[1])+1))
        if any(i in fA for i in sA):
            numTimes += 1
    print(f"Result: {numTimes}")


def openFile():
    return open("input.txt", "r").readlines()


def main():
    f = openFile()
    part1(f)
    part2(f)


if __name__ == '__main__':
    main()

=ARRAYFORMULA(
  IF(C2=FALSE,"Part 1",
   QUERY(
    SPLIT(A2:A,"-,"),
    "select Count(Col1)
     where 
      Col1 is not null and
       (Col1 <= Col3 and Col2 >= Col4) or
       (Col3 <= Col1 and Col4 >= Col2)
     label Count(Col1) 'Part 1'")))

=ARRAYFORMULA(
  QUERY(
   SPLIT(A2:A,"-,"),
   "select Count(Col1)
    where Col1 is not null and
     (Col1 <= Col4 and
      Col3 <= Col2)
    label Count(Col1) 'Part 2'"))

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

extern crate regex;
use regex::Regex;

struct Team {
    elf1: RangeInclusive<usize>,
    elf2: RangeInclusive<usize>,
}
impl Team {
    pub fn has_overlaps1(&self) -> bool {
        (self.elf1.contains(&self.elf2.start()) && self.elf1.contains(&self.elf2.end())) ||
        (self.elf2.contains(&self.elf1.start()) && self.elf2.contains(&self.elf1.end()))
    }
    pub fn has_overlaps2(&self) -> bool {
        self.elf1.contains(&self.elf2.start()) || self.elf1.contains(&self.elf2.end()) ||
        self.elf2.contains(&self.elf1.start()) || self.elf2.contains(&self.elf1.end())
    }
}
impl From<&String> for Team {
    fn from(s: &String) -> Self {
        let re = Regex::new(r"(\d+)\-(\d+),(\d+)\-(\d+)").unwrap();
        let matches = re.captures(s).unwrap();
        Self {
            elf1: RangeInclusive::new(matches[1].parse().unwrap(),matches[2].parse().unwrap()),
            elf2: RangeInclusive::new(matches[3].parse().unwrap(),matches[4].parse().unwrap()),
        }
    }
}

fn solve(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,
    };

    // Part 1
    let part1 = input
        .iter()
        .map(Team::from)
        .filter(|x| x.has_overlaps1())
        .count();
    println!("Part 1: {:?}", part1); // 450

    // Part 2
    let part2 = input
        .iter()
        .map(Team::from)
        .filter(|x| x.has_overlaps2())
        .count();
    println!("Part 2: {:?}", part2); // 837

    Ok(())
}

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

import std/[sets, sequtils, strutils, sugar]

proc assignmentToSet(assignment: string): HashSet[int] =
  # This is janky as hell... I'm so sorry, nim.
  let assignmentSet = collect:
    let intEnds = collect:
      for a in assignment.split('-'):
        parseInt(a)
    (intEnds[0]..intEnds[1]).toSeq().toHashSet()
  result = assignmentSet[0]

proc day04*() =
  var 
    numProperSubsets = 0 
    numAnySubsets = 0

  for line in lines("inputs/day04.in"):
    let pairAssignments = line.split(',')
    let assignment1 = assignmentToSet(pairAssignments[0])
    let assignment2 = assignmentToSet(pairAssignments[1])

    let intersection = assignment1 * assignment2

    # Part 1
    if intersection == assignment1 or intersection == assignment2:
      numProperSubsets += 1

    # Part 2
    if intersection.len > 0:
      numAnySubsets += 1

  echo "Part 1: " & $numProperSubsets
  echo "Part 2: " & $numAnySubsets

mod part1;
mod part2;
mod utilities;

fn main() {
    let _input = include_str!("./input.txt");
    let _structured_input = utilities::parse(_input);

    println!("Part One");
    println!("Result: {}", part1::part1(&_structured_input));

    println!("Part Two");
    println!("Result: {}", part2::part2(&_structured_input));
}

use once_cell::sync::Lazy;
use regex::Regex;
#[derive(Debug, PartialEq, Eq)]
pub struct Range {
    start: u16,
    end: u16,
}

impl Range {
    pub fn new(start: u16, end: u16) -> Self {
        Self {
            start: start.min(end),
            end: end.max(start),
        }
    }

    pub fn calc_size(&self) -> u16 {
        self.start.abs_diff(self.end)
    }

    pub fn any_overlap(&self, other: &Self) -> bool {
        self.start <= other.end && self.end >= other.start
    }

    pub fn calc_overlap(&self, other: &Self) -> Range {
        let overlap_start = self.start.min(other.start);
        let overlap_end = self.end.max(other.end);
        Range::new(overlap_start, overlap_end)
    }

    pub fn complete_overlap(&self, other: &Self) -> bool {
        self.calc_overlap(other) == *self || self.calc_overlap(other) == *other
    }

    pub fn start(&self) -> u16 {
        self.start
    }

    pub fn end(&self) -> u16 {
        self.end
    }
}

static PARSE_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^(\d+)-(\d+),(\d+)-(\d+)").unwrap());

pub fn parse(input: &str) -> Vec<(Range, Range)> {
    input
        .lines()
        .map(|line| {
            let cap = PARSE_REGEX.captures(line).unwrap();
            (
                Range::new(
                    cap.get(1).unwrap().as_str().parse().unwrap(),
                    cap.get(2).unwrap().as_str().parse().unwrap(),
                ),
                Range::new(
                    cap.get(3).unwrap().as_str().parse().unwrap(),
                    cap.get(4).unwrap().as_str().parse().unwrap(),
                ),
            )
        })
        .collect()
}

use crate::utilities::*;

pub fn part1(input: &[(Range, Range)]) -> usize {
    input
        .iter()
        .filter(|tuple| tuple.0.complete_overlap(&tuple.1))
        .count()
}

use crate::utilities::*;

pub fn part2(input: &[(Range, Range)]) -> usize {
    input
        .iter()
        .filter(|tuple| tuple.0.any_overlap(&tuple.1))
        .count()
}

def create_assignments(pair: str) -> Tuple[Tuple[int, int], Tuple[int, int]]:
    first, second = pair.split(",")
    first_low = int(first.split("-")[0])
    first_high = int(first.split("-")[1])
    second_low = int(second.split("-")[0])
    second_high = int(second.split("-")[1])
    return ((first_low, first_high), (second_low, second_high))


def are_completely_overlapping(
    assignments: Tuple[Tuple[int, int], Tuple[int, int]]
) -> bool:
    return (
        assignments[0][0] <= assignments[1][0]
        and assignments[0][1] >= assignments[1][1]
    ) or (
        assignments[1][0] <= assignments[0][0]
        and assignments[1][1] >= assignments[0][1]
    )   


def are_overlapping(assignments: Tuple[Tuple[int, int], Tuple[int, int]]) -> bool:
    return (
        assignments[0][1] >= assignments[1][0]
        and assignments[0][0] <= assignments[1][1]
    )   


def main(filepath: str) -> Tuple[int, int]:
    pairs = load_file.load_cleaned_lines(filepath)
    assignments = [create_assignments(pair) for pair in pairs]
    return (
        sum((are_completely_overlapping(assignment) for assignment in assignments)),
        sum((are_overlapping(assignment) for assignment in assignments)),
    ) 

(defn parse-line [line]
  (let [[[g1-start g1-end] [g2-start g2-end]]
        (->> line
             (re-matches #"(\d+)-(\d+),(\d+)-(\d+)")
             (rest)
             (map parse-long)
             (partition 2))
        group1 (set (range g1-start (inc g1-end)))
        group2 (set (range g2-start (inc g2-end)))]
    [group1, group2]))

(defn subset-or-superset [set1 set2]
  (or (clojure.set/subset? set1 set2)
      (clojure.set/subset? set2 set1)))

(defn overlaps? [set1 set2]
  (not-empty (clojure.set/intersection set1 set2)))

(defn part-1 [input]
  (let [set-pairs (map parse-line input)]
    (->> set-pairs
         (map #(apply subset-or-superset %))
         (filter true?)
         (count))))

(defn part-2 [input]
  (let [set-pairs (map parse-line input)]
    (->> set-pairs
         (map #(apply overlaps? %))
         (filter #(not (nil? %)))
         (count))))

type InputData = [[number, number], [number, number]][];

function formatInput(input: string): InputData {
  return input.split('\n').map(e => e.split(',').map(f => f.split('-').map(g => Number(g)))) as InputData;
}

export function run(input: string): string[] {
  const data = formatInput(input);

  const countFullContainments = (pairs: InputData): number => {
    let count = 0;
    for (const pair of pairs) {
      if (
        (pair[0][0] <= pair[1][0] && pair[0][1] >= pair[1][1]) ||
        (pair[1][0] <= pair[0][0] && pair[1][1] >= pair[0][1])
      ) {
        count++;
      }
    }
    return count;
  };

  const countOverlaps = (pairs: InputData): number => {
    let nonOverlapCount = 0;
    for (const pair of pairs) {
      if (pair[0][1] < pair[1][0] || pair[0][0] > pair[1][1]) {
        nonOverlapCount++;
      }
    }
    return pairs.length - nonOverlapCount;
  };

  return [`${countFullContainments(data)}`, `${countOverlaps(data)}`];
}

import { readFileSync } from "fs";

const input = readFileSync("./input.txt", "utf-8").toString();
const groups = input.split("\n");

// Put numbers into an array
const expandNumbers = (start, end) => {
  let numbers = [];
  for (let index = Number(start); index <= Number(end); index++) {
    numbers.push(index);
  }
  return numbers;
};

// Check if either number contains the other completely
const containsAll = (left, right) => {
  return (
    left.every((number) => right.includes(number)) ||
    right.every((number) => left.includes(number))
  );
};

// Check if any of the numbers overlap
const containsSome = (left, right) => {
  return (
    left.some((number) => right.includes(number)) ||
    right.some((number) => left.includes(number))
  );
};

let part1 = 0;
let part2 = 0;

groups.forEach((group) => {
  const [first, second] = group.split(",");

  const [firstStart, firstEnd] = first.split("-");
  const [secondStart, secondEnd] = second.split("-");

  const firstExpanded = expandNumbers(firstStart, firstEnd);
  const secondExpanded = expandNumbers(secondStart, secondEnd);

  if (containsAll(firstExpanded, secondExpanded)) part1++;
  if (containsSome(firstExpanded, secondExpanded)) part2++;
});

console.log(part1);
console.log(part2);

require "active_support/all"

sum = File
      .read("input.txt")
      .split(/-|,|\s/)
      .map(&:to_i)
      .each_slice(4)
      
p1 = sum.count{ |a, b, c, d| (a..b).cover?(c..d) || (c..d).cover?(a..b) }
p2 = sum.count{ |a, b, c, d| (a..b).overlaps?(c..d) }

p p1 # Part 1
p p2 # Part 2

import * as fs from 'node:fs/promises';

function parseNumbers(input: string): number[][] {
	const pair: string[] = input.split(",");
	
	let pair_array: number[][] = [];
	for (const elf of pair) {
		pair_array.push(elf.split("-").map((item: string) => parseInt(item)));
	};

	return pair_array;
};

async function main(): Promise<void> {
	const assignments: string[] = (await fs.readFile("input/day4", "utf-8")).split("\n");

	const pairs: number[][][] = assignments.map(
					(pair: string): number[][] => parseNumbers(pair));

	let fully_contained: number = 0;
	let overlap: number = 0;

	for (const pair of pairs) {
		const elf_1_start = pair[0][0];
		const elf_1_end = pair[0][1];
		const elf_2_start = pair[1][0];
		const elf_2_end = pair[1][1];

		// Part 1
		if (   (elf_1_start <= elf_2_start && elf_1_end >= elf_2_end)
			|| (elf_2_start <= elf_1_start && elf_2_end >= elf_1_end)) {
			fully_contained++;
		};
		
		// Part 2
		if (   (elf_1_start <= elf_2_start && elf_1_end >= elf_2_start)
			|| (elf_2_start <= elf_1_start && elf_2_end >= elf_1_start)) {
			overlap++;
		};
	}

	// Output
	console.log("Fully Contained Range: ",fully_contained);
	console.log("Overlapping Range: ",overlap);
};

main();

use std::error::Error;
use std::fs::File;
use std::io::Read;

fn main() -> Result<(), Box<dyn Error>> {
	let mut file = File::open("input_4.txt")?;
	let mut contents = String::new();
	file.read_to_string(&mut contents)?;
	let number_containing = contents.lines().fold(0, |acc, line| {
		let mut pieces = line.splitn(2, ',').map(Range::from_str);
		let first = pieces.next().unwrap();
		let second = pieces.next().unwrap();
		if Range::contains(&first, &second) {
			acc + 1
		} else {
			acc
		}
	});
	println!("{number_containing}");
	Ok(())
}

struct Range {
	start: u32,
	end: u32,
}

impl Range {
	// Creates a new Range from a string of the form "<start>-<end>"
	fn from_str(s: &str) -> Range {
		let mut pieces = s.splitn(2, '-');
		let start = pieces.next().unwrap().parse::<u32>().unwrap();
		let end = pieces.next().unwrap().parse::<u32>().unwrap();
		Range {
			start,
			end
		}
	}

	// Returns true if x contains y or y contains x
	fn contains(x: &Range, y: &Range) -> bool {
		(x.start <= y.start && x.end >= y.end) || (y.start <= x.start && y.end >= x.end)
	}
}

use std::error::Error;
use std::fs::File;
use std::io::Read;

fn main() -> Result<(), Box<dyn Error>> {
	let mut file = File::open("input_4.txt")?;
	let mut contents = String::new();
	file.read_to_string(&mut contents)?;
	let number_containing = contents.lines().fold(0, |acc, line| {
		let mut pieces = line.splitn(2, ',').map(Range::from_str);
		let first = pieces.next().unwrap();
		let second = pieces.next().unwrap();
		if Range::overlaps(&first, &second) {
			acc + 1
		} else {
			acc
		}
	});
	println!("{number_containing}");
	Ok(())
}

struct Range {
	start: u32,
	end: u32,
}

impl Range {
	// Creates a new Range from a string of the form "<start>-<end>"
	fn from_str(s: &str) -> Range {
		let mut pieces = s.splitn(2, '-');
		let start = pieces.next().unwrap().parse::<u32>().unwrap();
		let end = pieces.next().unwrap().parse::<u32>().unwrap();
		Range {
			start,
			end
		}
	}

	// Returns true if x contains y or y contains x
	#[allow(dead_code)]
	fn contains(x: &Range, y: &Range) -> bool {
		(x.start <= y.start && x.end >= y.end) || (y.start <= x.start && y.end >= x.end)
	}

	// Returns true if x and y overlap
	fn overlaps(x:&Range, y: &Range) -> bool {
		(x.start >= y.start && x.end <= y.end)
		|| (x.end >= y.start && x.end <= y.end)
		|| (y.start >= x.start && y.end <= x.end)
		|| (y.end >= x.start && y.end <= x.end)
	}
}