Advent of Code 2022: no pato edition

Colgajo #121 Dic '22

NodeJS Día 3

Parte 1

const fs = require('fs').promises;

const getItemValue = (char) => {
  const utfCode = char.charCodeAt(0);
  if (utfCode < 97) {
    return utfCode - 38;
  }
  return utfCode - 96;
};

getCommonItem = (backpackHalves) => {
  const [backpackHalveA, backpackHalveB] = backpackHalves;
  for (const item of backpackHalveB) {
    if (backpackHalveA.has(item)) {
      return item;
    }
  }
}

const main = async () => {
  const result = (await fs.readFile('input.txt', 'utf8'))
  .split('\n')
  .map((backpack) => [
    new Set(backpack.slice(0, backpack.length / 2)),
    new Set(backpack.slice(backpack.length / 2)),
  ])
  .reduce((acc, backpackHalves) => acc + getItemValue(getCommonItem(backpackHalves)), 0);
  console.log(result);
  process.exit();
};

main();

Parte2

spoiler

const fs = require('fs').promises;

const getItemValue = (item) => {
  const utfCode = item.charCodeAt(0);
  if (utfCode < 97) {
    return utfCode - 38;
  }
  return utfCode - 96;
};

getCommonItem = ([firstBackpack, ...otherBackpacks]) => {
  for (const item of firstBackpack) {
    if (otherBackpacks.every((backpack) => backpack.has(item))) {
      return item;
    }
  }
}

const main = async () => {
  const backpacks = (await fs.readFile('input.txt', 'utf8'))
  .split('\n')
  .map((backpack) => new Set(backpack));

  let result = 0;
  for (let i = 0; i < backpacks.length; i += 3) {
    result += getItemValue(getCommonItem(backpacks.slice(i, i + 3)));
  }
  console.log(result);
  process.exit();
};

main();

Se agradece feedback

Naith #122 Dic '22 Penitente

Dia 3

#include <iostream>
#include <fstream>
#include <set>
#include <algorithm>

#define UPPERFACTOR 38
#define LOWERFACTOR 96
#define itemVal(x) (std::isupper(x) ? (int)x - UPPERFACTOR : (int) x - LOWERFACTOR)

int checkSack(const std::string sack){
    for(int i = 0; i < sack.size()/2; ++i)
            for(int j = sack.size()/2; j < sack.size(); ++j)
                if (sack[i] == sack[j])
                    return itemVal(sack[i]);

return 0;
}

void part1(std::ifstream& input){
    std::string sack;
    int value = 0;

while(std::getline(input, sack))
    value += checkSack(sack);

std::cout << "Value: " << value << std::endl;
}

void part2(std::ifstream& input){
    std::string elf1, elf2, elf3;
    int badgeValue = 0;

while(input >> elf1 >> elf2 >> elf3){
    std::set<char> elf1Set(elf1.begin(), elf1.end());
    std::set<char> elf2Set(elf2.begin(), elf2.end());
    std::set<char> elf3Set(elf3.begin(), elf3.end());

    std::set<char> badge, badge2;

    std::set_intersection(elf1Set.begin(), elf1Set.end(),
                          elf2Set.begin(), elf2Set.end(),
                          std::inserter(badge, badge.begin()));

    std::set_intersection(badge.begin(), badge.end(),
                          elf3Set.begin(), elf3Set.end(),
                          std::inserter(badge2, badge2.begin()));

    const char badgeChar = *(badge2.begin());
    badgeValue += itemVal(badgeChar);
}

std::cout << "Badge values: " << badgeValue << std::endl;
}

jilker #123 Dic '22

Creo que me he complicado mucho la vida hoy pero bueno...

Día 3-1

#include <fstream>
#include <iostream>
#include <set>

int main(int argc, char const* argv[]) {
    std::ifstream myfile("data.txt");
    if (!myfile) {
        std::cout << "Error loading path files" << std::endl;
        return 0;
    }
    std::string input;
    std::set<char> items_in_rusksack = {};
    int sum_item_values = 0;
    std::string first_compartment;
    std::string second_compartment;
    while (getline(myfile, input)) {
        first_compartment = input.substr(0, input.length() / 2);
        second_compartment = input.substr(input.length() / 2, input.length());
        items_in_rusksack.insert(first_compartment.begin(), first_compartment.end());
        for (char& item : second_compartment) {
            if (items_in_rusksack.find(item) != items_in_rusksack.end()) {
                // ASCII CODE RULES!
                // A = 65     a = 97
                // a = (1 to 26) A = (27 to 52)
                sum_item_values += (int(item) > 96) ? int(item) - 96 : int(item) - 38;
                break;
            }
        }
        items_in_rusksack.clear();
    }
    std::cout << sum_item_values << std::endl;
}

Día 3-2

#include <fstream>
#include <iostream>
#include <set>

// ASCII CODE RULES!
// A = 65     a = 97
// a = (1 to 26) A = (27 to 52)
inline int priority_value(char _val) { return (int(_val) > 96) ? int(_val) - 96 : int(_val) - 38; }

int main(int argc, char const* argv[]) {
    std::ifstream myfile("data.txt");
    if (!myfile) {
        std::cout << "Error loading path files" << std::endl;
        return 0;
    }
    std::string input;
    std::set<char> first_elf = {};
    std::set<char> repeated_items = {};
    int sum_item_values = 0;
    int number_elf = 0;
    while (getline(myfile, input)) {
        switch (number_elf) {
            case 0:
                first_elf.insert(input.begin(), input.end());
                number_elf++;
                break;
            case 1:
                for (char& item : input) {
                    if (first_elf.find(item) != first_elf.end()) {
                        repeated_items.insert(item);
                    }
                }
                number_elf++;
                break;
            case 2:
                for (char& item : input) {
                    if (repeated_items.find(item) != repeated_items.end()) {
                        sum_item_values += priority_value(item);
                        break;
                    }
                }
                first_elf.clear();
                repeated_items.clear();
                number_elf = 0;
                break;
            default:
                break;
        }
    }
    std::cout << sum_item_values << std::endl;
}

PiradoIV #124 Dic '22 Brongster

Tercer día haciendo el parias xD

7

Soumynon #125 Dic '22

Día 3 . NodeJS. Parte 1 y 2.

const fs = require("fs");
const path = require("path");

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".split(
    ""
);

const getInput = (type) => {
    const input = fs
        .readFileSync(path.resolve(__dirname, "input.txt"), "utf8")
        .split("\n");
    return type === "half" ? input : splitArray(input);
};

const splitArray = ([a, b, c, ...rest]) =>
    rest.length ? [
        [a, b, c], ...splitArray(rest)
    ] : [
        [a, b, c]
    ];

const getCommonPoints = (common) =>
    common.reduce((acc, current) => {
        const index = letters.findIndex((letter) => letter === current);
        return acc + index !== -1 ? index + 1 : 0;
    }, 0);

const getCommonBadges = (type, current) => {
    const halfDepartments = () => {
        const compartments = current.split("");
        const first = compartments.splice(0, current.length / 2);
        const second = compartments;

    return first.reduce((acc, current) => {
        if (second.includes(current)) {
            acc.push(current);
        }
        return acc;
    }, []);
};
const threeElvesDeparments = () => {
    const [first, second, third] = current;

    return first.split("").reduce((acc, current) => {
        if (
            second.split("").includes(current) &&
            third.split("").includes(current)
        ) {
            acc.push(current);
        }
        return acc;
    }, []);
};
const commonBadges = {
    half: () => halfDepartments(),
    three: () => threeElvesDeparments(),
};
return commonBadges[type]();
};

const getResult = (type) =>
    getInput(type).reduce((acc, current) => {
        return acc + getCommonPoints(getCommonBadges(type, current));
    }, 0);

console.log(getResult("half"), getResult("three"));

W0rd #126 Dic '22

Day 3, parte 1, Go

spoiler

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
)

const A_ASCII = 65
const a_ASCII = 97

func main() {
	f, err := os.Open("data.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	scanner := bufio.NewScanner(f)

var priority int
for scanner.Scan() {
	priority += getPriority(scanner.Text())
}

fmt.Printf("Priority %d\n", priority)

if err := scanner.Err(); err != nil {
	log.Fatal(err)
}
}

func getPriority(line string) int {
	lineR := []rune(line)
	len := len(lineR)
	middle := len / 2
	for i := 0; i < middle; i++ {
		c := lineR[i]
		if isIn(c, lineR[middle:len]) {
			return getPoints(c)
		}
	}
	return 0
}

func isIn(find rune, list []rune) bool {
	for _, value := range list {
		if value == find {
			return true
		}
	}
	return false
}

func getPoints(character rune) int {
	if character < a_ASCII && character >= A_ASCII {
		return int(character) - (A_ASCII - 27)
	}
	if character > a_ASCII {
		return int(character) - (a_ASCII - 1)
	}
	return 0
}

Pizzelio #127 Dic '22

Soy yo o este año ha empezado muy amable el aoc?

1 respuesta

B

[Borrado] #128 Dic '22

Dia 4, me dan una excusa pa poner una bitmask y me siento jaquer

spoiler

import re
import sys
import numpy as np
from functools import reduce

print(
  reduce(np.add,
    (
      np.array([a, a | b], dtype=np.uint32)
      for l1, r1, l2, r2 in map(lambda x: [int(y) for y in re.match(r'(\d+)-(\d+),(\d+)-(\d+)', x).groups()], sys.stdin)
      for (a, b) in
      [(int(l1 <= l2 <= r2 <= r1 or l2 <= l1 <= r1 <= r2), int(l1 <= l2 <= r1 <= r2 or l2 <= l1 <= r2 <= r2))]
    )
  )
)

PiradoIV #129 Dic '22 Brongster

#127 Normalmente los fines de semana los suele poner más fáciles, para poder recuperar los horrores de la semana.

Si el día es % 5, suele ser un horror y además suele venir relacionado con días anteriores xD

El de hoy es facilito en Xojo

Var lines() As String = input.Split(EndOfLine)
Var counter As Integer

For Each line As String In lines
  Var parts() As String = line.Split(",")
  Var elfA As New CleanupAssignment(parts(0).NthField("-", 1).Val, parts(0).NthField("-", 2).Val)
  Var elfB As New CleanupAssignment(parts(1).NthField("-", 1).Val, parts(1).NthField("-", 2).Val)
  If elfA = elfB Then counter = counter + 1
Next

System.DebugLog(counter.ToString)

2

Hipnos #130 Dic '22 Dungeon Master

Día 4 en python noob:

Parte 1:

spoiler

Parte 2:

spoiler

gonya707 #131 Dic '22 Moderador

Soy consciente de que hoy era muy fácil el reto pero haciéndolo en móvil menudo pifostio he montado, y eso que trabajar con bitwise es mi rollo

3

JonaN #132 Dic '22 Juntabrackets

Seguimos haciendo recursiones ilegibles para meter todo en una linea.

D4 python

import re

print(sum([((k[0]>=k[2])&(k[1]<=k[3]))|((k[2]>=k[0])&(k[3]<=k[1])) for k in [[int(i) for i in t] for t in [re.findall('[0-9]+', c) for c in [l.strip() for l in open('./Input04.txt').readlines()]]]]))

print(sum([not((k[1]<k[2])|(k[3]<k[0])) for k in [[int(i) for i in t] for t in [re.findall('[0-9]+', c) for c in [l.strip() for l in open('./Input04.txt').readlines()]]]]))

wolfie6949 #133 Dic '22

Dia 4 en Node:

spoiler

La parte 1 sería eliminando los overlaps de la comprobación

const fs = require("fs");

const ranges = fs
  .readFileSync("input.txt", "utf8")
  .split("\n")
  .filter((x) => x !== "")
  .map((x) => x.split(","))
  .map((x) => x.map((y) => y.split("-").map((z) => parseInt(z, 10))));

let count = 0;

const contains = (a, b) => a[0] <= b[0] && a[1] >= b[1];
const overlaps = (a, b) => a[0] <= b[1] && a[1] >= b[0];

for (let i = 0; i < ranges.length; i++) {
  const elementA = ranges[i][0];
  const elementB = ranges[i][1];

  if (
    contains(elementA, elementB) ||
    contains(elementB, elementA) ||
    overlaps(elementA, elementB) ||
    overlaps(elementB, elementA)
  ) {
    count++;
  }
}

console.log(count);

Colgajo #134 Dic '22

Día 4 NodeJS

Parte 1

spoiler

const { open } = require('fs').promises;

const hasSubset = ([[ startA, endA ], [ startB, endB ]]) => (
  startA >= startB && endA <= endB || startB >= startA && endB <= endA
);

const main = async () => {
  const file = await open('input.txt');
  let overlappedAssignments = 0;
  for await (const line of file.readLines()) {
    const ranges = line.split(',')
      .map(
        (assignment) => (
          assignment.split('-').map((value) => Number.parseInt(value))
        )
      );
    if (hasSubset(ranges)) {
      overlappedAssignments++;
    }
  }
  console.log(overlappedAssignments);
  process.exit();
};

main();

Parte 2

spoiler

const { open } = require('fs').promises;

const hasIntersection = ([[ startA, endA ], [ startB, endB ]]) => (
  (
    startA >= startB && startA <= endB
    || endA >= startB && endA <= endB
  )
  ||
  (
    startB >= startA && startB <= endA
    || endB >= startA && endB <= endA
  )
);

const main = async () => {
  const file = await open('input.txt');
  let overlappedAssignments = 0;
  for await (const line of file.readLines()) {
    const ranges = line.split(',')
      .map(
        (assignment) => (
          assignment.split('-').map((value) => Number.parseInt(value))
        )
      );
    if (hasIntersection(ranges)) {
      overlappedAssignments++;
    }
  }
  console.log(overlappedAssignments);
  process.exit();
};

main();

Naith #135 Dic '22 Penitente

Bastante facil hoy

Day 4 cpp

#include <iostream>
#include <fstream>

inline bool contain(std::pair<int, int> a, std::pair<int, int> b) {
    return a.first >= b.first && a.second <= b.second;
}

inline bool overlap(std::pair<int, int> a, std::pair<int, int> b){
    return a.first >= b.first && a.first <= b.second;
}

inline std::pair<int, int> getElfJobs(std::string& elf) {
   int delimPos = elf.find("-");
   return std::pair<int, int>(std::stoi(elf.substr(0, delimPos)),
                              std::stoi(elf.substr(delimPos+1, elf.size())));
}

std::pair<std::pair<int,int>, std::pair<int,int>> parseJob(std::string& pairJob ) {
    int delimPos = pairJob.find(",");
    std::string elf1Jobs = pairJob.substr(0, delimPos);
    std::string elf2Jobs = pairJob.substr(delimPos+1, pairJob.size());

return std::pair<std::pair<int,int>, std::pair<int,int>>(getElfJobs(elf1Jobs),
                                                         getElfJobs(elf2Jobs));
}

int main(int argc, char *argv[]) {
    std::ifstream input(argv[1]);

std::string pairJob;
int contPairs = 0;
int overPairs = 0;

while(std::getline(input, pairJob)){
    auto [elf1, elf2] = parseJob(pairJob);

    if (contain(elf1, elf2) || contain(elf2, elf1))
        contPairs += 1;

    if (overlap(elf1, elf2) || overlap(elf2, elf1))
        overPairs += 1;
}

std::cout << "Fully contained: " << contPairs << std::endl;
std::cout << "Overlapped jobs: " << overPairs << std::endl;

input.close();
return 0;
}

1

nobody1 #136 Dic '22

Si, hoy el más fácil.

Día 4 c++

spoiler

int main()
{
    string input, e1, e2;
    int a1, a2, b1, b2;
    int score = 0;   

while (cin >> input){ 

    e1 = input.substr(0, input.find(","));
    e2 = input.substr(input.find(",") + 1);
    a1 = stoi(e1.substr(0, e1.find("-")));
    a2 = stoi(e1.substr(e1.find("-") + 1));
    b1 = stoi(e2.substr(0, e2.find("-")));
    b2 = stoi(e2.substr(e2.find("-") + 1));

    if ((a1 <= b1 && a2 >= b2) || (a1 >= b1 && a2 <= b2)) score+=1;
}
cout << score << endl;
}

spoiler

int main()
{
    string input, e1, e2;
    int a1, a2, b1, b2;
    int score = 0;   

while (cin >> input){ 
    e1 = input.substr(0, input.find(","));
    e2 = input.substr(input.find(",") + 1);

    a1 = stoi(e1.substr(0, e1.find("-")));
    a2 = stoi(e1.substr(e1.find("-") + 1));

    b1 = stoi(e2.substr(0, e2.find("-")));
    b2 = stoi(e2.substr(e2.find("-") + 1));

    if (!(a2 < b1 || a1 > b2)) score+=1;
}
cout << score << endl;
}

1

PiradoIV #137 Dic '22 Brongster

La calma que precede a la tempestad xDD

3

Soumynon #138 Dic '22

Día 4. NodeJS. Parte 1 y 2.

Me ha jodido al principio el caso de 54-55, que si lo comparaba con 4-5, me daba falso positivo. Un Set y a correr.

const fs = require("fs");
const path = require("path");

const getSections = (elf) => {
  const [start, end] = elf.split("-");
  let sections = [];
  for (let i = Number(start); i <= Number(end); i++) {
    sections.push(i);
  }
  return sections;
};

const getResult = (overlap) =>
  fs
    .readFileSync(path.resolve(__dirname, "input.txt"), "utf8")
    .split("\n")
    .reduce((acc, current) => {
      const [firstElf, secondElf] = current.split(",");
      const firstSections = getSections(firstElf);
      const secondSections = getSections(secondElf);
      const maxLength =
        firstSections.length > secondSections.length
          ? firstSections.length
          : secondSections.length;

  const set = new Set(firstSections.concat(secondSections));
  const included = overlap
    ? set.size !== firstSections.length + secondSections.length
    : maxLength === set.size;

  return acc + (included ? 1 : 0);
}, 0);

console.log(getResult(false), getResult(true));

Slowbro #139 Dic '22

Pura manquedad en rust (sobrecomplicando, honestamente sin querer, pero diré que es para aprender)

Dia 1

extern crate file_reader;

use std::env;

fn get_max_calories(calories: &[String]) -> (u32, Vec<u32>) {
    let mut max_cal_reg  = Vec::new();
    let num_calories = calories
        .iter()
        .fold(0, |acc, s| {
            match s.is_empty() {
                true  => { max_cal_reg.push(acc); 0 }
                false => { acc + s.parse::<u32>().unwrap() }
            }} );
    max_cal_reg.sort_by(|u, v| v.cmp(u));
    (num_calories, max_cal_reg)
}


fn main() {
    // Get input file as argument
    let args: Vec<String> = env::args().collect();
    

// Read file
let path = file_reader::sanitize(&args);
let inputs: Vec<String> = file_reader::read_file(&path);

// Get calories
let (last_calories,  max_calories) = get_max_calories(&inputs);

println!("Max calories [1]: {:?}", &max_calories[0]);
println!("Max calories [3]: {:?}. Sum: {:?}", 
            &max_calories[0..3], &max_calories[0..3].iter().sum::<u32>());

}

Dia 2

extern crate file_reader;

use std::env;

fn policy_2col_move(tactic: &str) -> u32 {
    match tactic {
        "A X" => { 1 + 3 }
        "A Y" => { 2 + 6 }
        "A Z" => { 3 + 0 }
        "B X" => { 1 + 0 }
        "B Y" => { 2 + 3 }
        "B Z" => { 3 + 6 }
        "C X" => { 1 + 6 }
        "C Y" => { 2 + 0 }
        "C Z" => { 3 + 3 }
        _ => { panic!("Unparsable tactic!: {:?}", tactic); }
    }
}

fn policy_2col_result(tactic: &str) -> u32 {
    match tactic {
        "A X" => { 3 + 0 }
        "A Y" => { 1 + 3 }
        "A Z" => { 2 + 6 }
        "B X" => { 1 + 0 }
        "B Y" => { 2 + 3 }
        "B Z" => { 3 + 6 }
        "C X" => { 2 + 0 }
        "C Y" => { 3 + 3 }
        "C Z" => { 1 + 6 }
        _ => { panic!("Unparsable tactic!: {:?}", tactic); }
    }
}

fn follow_strategy(strategy: &[String], policy_id: &str) -> u32 {
    let policy = match policy_id {
        "move"   => { policy_2col_move }
        "result" => { policy_2col_result }
        _ => { panic!("Unparsable policy!: {:?}", policy_id); }
    };

let global_score =
    strategy.iter()
            .fold(0, |acc, s| {
                acc + policy(s)
            });
global_score
}

fn main() {
    // Get input file as argument
    let args: Vec<String> = env::args().collect();
    

// Read file
let path = file_reader::sanitize(&args);
let inputs: Vec<String> = file_reader::read_file(&path);

// Follow given strategy
let global_score = follow_strategy(&inputs, "move");
println!("Global score with move: {:?}", &global_score);

let global_score = follow_strategy(&inputs, "result");
println!("Global score with result: {:?}", &global_score);


}

Dia 3

extern crate file_reader;

use std::env;
use std::collections::HashSet;

const LOWERCASE_MAP : u8 = 'a' as u8 - 1;
const UPPERCASE_MAP : u8 = 'A' as u8 - 1;
const OFFSET : u8 = 26;

fn char2n_map(c: &char) -> u8 {
    match *c {
        'a'..='z' => { *c as u8 - LOWERCASE_MAP }
        'A'..='Z' => { *c as u8 - UPPERCASE_MAP + OFFSET }
        _ => panic!("fault_finder>> non expected character: {:?}", *c)
    }
}

fn iter_intersection(sets: &[HashSet<char>]) -> HashSet<char> {
    let mut result = sets[0].clone();

for set in &sets[1..] {
    result = result.intersection(set).cloned().collect();
}
result
}

fn priority_finder(pload: &Vec<HashSet<char>>) -> u8 {

let isect: HashSet<char> = iter_intersection(&pload);

let mut isec_num: Vec<u8> = isect
    .iter()
    .map(|c| { char2n_map(c) })
    .collect();
isec_num.pop().unwrap()
}

fn priority_sum_perline(rucksacks: &[String]) -> u32 {
    let priority: u32 = rucksacks
        .iter()
        .fold(0u32, |acc, s| {
            let hhalf:  HashSet<char> = 
                s.chars().take(s.len() / 2).collect();
            let lhalf:  HashSet<char> = 
                s.chars().skip(s.len() / 2).collect();
            let payload = vec![hhalf, lhalf];
            acc + priority_finder(&payload) as u32
        });
    priority
}

fn priority_sum_nlines(rucksacks: &[String], n: u32) -> u32 {
    let mut idx = 0u32;
    let mut payload: Vec<HashSet<char>> = Vec::new();

let priority: u32 = rucksacks
    .iter()
    .fold( 0u32,| acc, s | {
        let mut delta = 0u32;
        match idx % n {
            x if x == n - 1  => { 
                let set: HashSet<char> = s.chars().collect();
                payload.push(set);
                delta = priority_finder(&payload) as u32;
                payload.clear();
            }
            _ => { 
                let set: HashSet<char> = s.chars().collect();
                payload.push(set);
            }
        } 
        idx += 1;
        acc + delta
    });
priority
}

fn main() {
    // Get input file as argument
    let args: Vec<String> = env::args().collect();
    

// Read file
let path = file_reader::sanitize(&args);
let inputs: Vec<String> = file_reader::read_file(&path);

// Part 1
println!("Priority each line: {:?}", priority_sum_perline(&inputs));

// Part 2
println!("Priority with the 3 lines rule: {:?}", priority_sum_nlines(&inputs, 3));

}

Dia 4

extern crate file_reader;

use std::env;
use std::collections::HashSet;


fn extract_ranges(section: &str) -> Vec<HashSet<u32>> {
    let mut assignments:  Vec<HashSet<u32>> = Vec::new();
    

for range in section.split(',') {
    let extremes : Vec<&str> = range.split('-').collect();
    let start: u32 = extremes[0].parse().unwrap();
    let end: u32 = extremes[1].parse().unwrap();
    let assignment: HashSet<u32> = (start..=end).collect();
    assignments.push(assignment);
}
assignments
}

fn check_containment(sets : &[HashSet<u32>]) -> bool {
    sets[0].is_subset(&sets[1]) || sets[1].is_subset(&sets[0])
}

fn check_overlapping(sets : &[HashSet<u32>]) -> bool {
    let isect: HashSet<_> = sets[0].intersection(&sets[1]).collect();
    !isect.is_empty() 
}

fn get_redundant_assignments(assignments: &[String], policy_id: &str) -> u32 {

let policy = match policy_id {
    "containment"   => { check_containment }
    "overlapping" => { check_overlapping }
    _ => { panic!("Unparsable policy!: {:?}", policy_id); }
};

let sections = assignments
    .iter()
    .fold(0u32, |acc, section| {
        let assignments = extract_ranges(&section);
        match policy(&assignments) {
            true => { acc + 1 }
            false => { acc }
        }
    });
sections
}

fn main() {
    // Get input file as argument
    let args: Vec<String> = env::args().collect();
    

// Read file
let path = file_reader::sanitize(&args);
let inputs: Vec<String> = file_reader::read_file(&path);

// Part 1
println!("Containment: {:?}", get_redundant_assignments(&inputs, "containment"));
// Part 2
println!("Overlapping: {:?}", get_redundant_assignments(&inputs, "overlapping"));

}

ilyabakhlin #140 Dic '22

Día 4 - Parte 1 (TypeScript)

spoiler

import { FileHandle, open } from "fs/promises";
import { join } from "path";
import { Interface } from "readline";

const fileName: string = "input.txt";
const filePath: string = join(__dirname, fileName);

const ranges = {
    s1: 0,
    e1: 0,
    s2: 0,
    e2: 0
};

let overlaps: number = 0;

open(filePath).then((file: FileHandle): Interface => file.readLines()).then((output: Interface): void => {
    output.on("line", (content: string): void => {
        let count: number = 0;
        content.split(",").map((value: string): number[] => {
            return value.split("-").map((range: string): number => Number(range));
        }).forEach((segment: number[]): void => {
            if (count++ % 2) {
                ranges.s2 = segment[0];
                ranges.e2 = segment[1];
            } else {
                ranges.s1 = segment[0];
                ranges.e1 = segment[1];
            }
        });
        if ((ranges.s1 <= ranges.s2 && ranges.e1 >= ranges.e2) || (ranges.s2 <= ranges.s1 && ranges.e2 >= ranges.e1)) {
            overlaps++;
        }
    });
    output.on("close", (): void => {
        global.console.log(overlaps);
    });
});

Día 4 - Parte 2 (TypeScript)

spoiler

import { FileHandle, open } from "fs/promises";
import { join } from "path";
import { Interface } from "readline";

const fileName: string = "input.txt";
const filePath: string = join(__dirname, fileName);

const ranges = {
    s1: 0,
    e1: 0,
    s2: 0,
    e2: 0
};

let overlaps: number = 0;

open(filePath).then((file: FileHandle): Interface => file.readLines()).then((output: Interface): void => {
    output.on("line", (content: string): void => {
        let count: number = 0;
        content.split(",").map((value: string): number[] => {
            return value.split("-").map((range: string): number => Number(range));
        }).forEach((segment: number[]): void => {
            if (count++ % 2) {
                ranges.s2 = segment[0];
                ranges.e2 = segment[1];
            } else {
                ranges.s1 = segment[0];
                ranges.e1 = segment[1];
            }
        });
        if (ranges.s1 <= ranges.e2 && ranges.e1 >= ranges.s2) {
            overlaps++;
        }
    });
    output.on("close", (): void => {
        global.console.log(overlaps);
    });
});

B

[Borrado] #141 Dic '22

Con un input no hecho por un sadico el problema de hoy dia 5 tendria 2 lineas lol

spoiler

import sys
import re


line = input()
num_stacks = (len(line) + 1) // 4
stacks = []


for _ in range(num_stacks):
  stacks.append([])


while any(x == '[' for x in line):
  for i in range(num_stacks):
    if line[4 * i + 1] != ' ':
      stacks[i].append(line[4 * i + 1])
  line = input()


stacks = list(map(lambda x: list(reversed(x)), stacks))

_, line = input(), input()

while line:
  k, s, d = map(int, re.match(r'move (\d+) from (\d+) to (\d+)', line).groups())
  # part 1
  for _ in range(k):
    stacks[d - 1].append(stacks[s - 1].pop())
  # part 2
  stacks[d - 1][-k:] = list(reversed(stacks[d - 1][-k:]))
  try:
    line = input()
  except:
    line = None

print(''.join(stack[-1] for stack in stacks))

Flashk #142 Dic '22

El puzzle en si era fácil, pero vaya tela para parsear la entrada...

4 1 respuesta

gonya707 #143 Dic '22 Moderador

#142 Tal cual xD. Y he hecho sin querer la parte 2 antes de la 1 por estar poco avispado y no darme cuenta de que logicamente las cajas quedan al reves, asi que lo he resulto eso en... 5 segundos

4

Colgajo #144 Dic '22

Día 5 NodeJS

Parte 1

spoiler

const fs = require('fs').promises;

const cleanRawSupplyStacks = (rawSupplyStacks) => {
  rawSupplyStacks.pop();
  return rawSupplyStacks.reduce((acc, line) => {
    const splittedLine = line.match(/.{1,4}/g);
    for (let i = splittedLine.length - 1; i >= 0; i--) {
      acc[i] = acc[i] || [];
      const crate = splittedLine[i][1];
      if (crate !== ' ') {
        acc[i].push(splittedLine[i][1]);
      }
    }
    return acc;
  }, []);
} ;

const main = async () => {
  const input = await fs.readFile('input.txt', 'utf-8');
  const [rawSupplyStacks, procedures] = input.split('\n\n')
    .map((value) => value.split('\n'));

  const supplyStacks = cleanRawSupplyStacks(rawSupplyStacks);
  for (const procedure of procedures) {
    const [quantity, from, to] = procedure.match(/\d+/g);
    const movedBoxes = supplyStacks[from - 1].splice(0, quantity);
    supplyStacks[to - 1].unshift(...movedBoxes.reverse());
  }

  console.log(supplyStacks.reduce((acc, supplyStack) => acc + supplyStack.shift(), ''));
};

main();

Parte 2

spoiler

const fs = require('fs').promises;

const cleanRawSupplyStacks = (rawSupplyStacks) => {
  rawSupplyStacks.pop();
  return rawSupplyStacks.reduce((acc, line) => {
    const splittedLine = line.match(/.{1,4}/g);
    for (let i = splittedLine.length - 1; i >= 0; i--) {
      acc[i] = acc[i] || [];
      const crate = splittedLine[i][1];
      if (crate !== ' ') {
        acc[i].push(splittedLine[i][1]);
      }
    }
    return acc;
  }, []);
} ;

const main = async () => {
  const input = await fs.readFile('input.txt', 'utf-8');
  const [rawSupplyStacks, procedures] = input.split('\n\n')
    .map((value) => value.split('\n'));

  const supplyStacks = cleanRawSupplyStacks(rawSupplyStacks);
  for (const procedure of procedures) {
    const [quantity, from, to] = procedure.match(/\d+/g);
    const movedBoxes = supplyStacks[from - 1].splice(0, quantity);
    supplyStacks[to - 1].unshift(...movedBoxes);
  }

  console.log(supplyStacks.reduce((acc, supplyStack) => acc + supplyStack.shift(), ''));
};

main();

Eckooo #145 Dic '22

python day 3

temp = open("input.txt", 'r').read().splitlines()

repeated_items = []

for x in temp:
    z = x[int(len(x)/2):]
    p = x[:int(len(x)/2)]
    for y in p:
        if y in z:
            repeated_items.append(y)
            break

count = []

for x in repeated_items:
    if x.islower():
        count.append(ord(x) - 96)
    else:
        count.append(ord(x) - 38)

chunked_list = []

for i in range(0, len(temp), 3):
    chunked_list.append(temp[i:i+3])

groups = []

for x in chunked_list:
    for y in x:
        for z in y:
            if z in x[1] and z in x[2]:
                if z.islower():
                    groups.append(ord(z) - 96)
                else:
                    groups.append(ord(z) - 38)
                break
        break

part1 = sum(count)
part2 = sum(groups)

python day 4

temp = open("input.txt", 'r').read().splitlines()

groups = []
strlist =  []
intlist = []

for x in temp:
    groups.append(x.split(','))
for x in groups:
    strlist.append(x[0].split('-'))
    strlist.append(x[1].split('-'))
for x in strlist:
    intlist.append(int(x[0]))
    intlist.append(int(x[1]))

count_part1 = 0
count_part2 = 0

for x in range(0, len(intlist)-3, 4):
    if intlist[x] <= intlist[x+2] and intlist[x+1] >= intlist[x+3]:
        count_part1 += 1
    elif intlist[x] >= intlist[x+2] and intlist[x+1] <= intlist[x+3]:
        count_part1 += 1
    elif intlist[x] < intlist[x+2] and intlist[x+1] < intlist[x+2]:
        count_part2 += 1
    elif intlist[x+2] < intlist[x] and intlist[x+3] < intlist[x]:
        count_part2 += 1

part1 = count_part1
part2 = 1000 - count_part2

No creo que pueda sacar el 5, gg.

thenanox #146 Dic '22 Virconita

catching up del finde, 3 dias del tiron

Naith #147 Dic '22 Penitente

Dia 5

#include <iostream>
#include <fstream>
#include <deque>
#include <sstream>
#include <vector>
#include <string>

std::vector<std::deque<char>> parseInput(std::ifstream& input){
    std::vector<std::deque<char>> ship;
    std::string line;

getline(input,line);
ship.resize(line.length() / 4 + 1);

// Get initial config.
while(line[1] != '1') {
    for(int i = 1, j = 0; i < line.length(); i = i + 4, ++j){
        if(line[i] == ' ')
            continue;
        ship[j].push_front(line[i]);
    }
    getline(input,line);
}

// Read empty line.
getline(input,line);

return ship;
}


void part1Logic(std::vector<std::deque<char>>& ship, int amount, int src, int dst){
     for(int i = 0; i < amount; ++i){
            ship[dst - 1].push_back(ship[src-1].back());
            ship[src-1].pop_back();
    }
}

void part2Logic(std::vector<std::deque<char>>& ship, int amount, int src, int dst){
    std::vector<char> substack;
        for(auto it = ship[src-1].end()-amount; it != ship[src-1].end(); ++it){
           substack.push_back(*it);
        }

    for(auto& x: substack){
        ship[dst-1].push_back(x);
        ship[src-1].pop_back();
    }
}

int main(int argc, char *argv[]) {
    std::ifstream input(argv[1]);

std::vector<std::deque<char>> ship1 = parseInput(input);
std::vector<std::deque<char>> ship2 = ship1;
std::string line, stub;
int amount, src, dst;

while(std::getline(input, line)){
    std::stringstream ss(line);
    ss >> stub >> amount >> stub >> src >> stub >> dst;
    part1Logic(ship1, amount, src, dst);
    part2Logic(ship2, amount, src, dst);
}

std::string tops1 = "";
std::string tops2 = "";

for(auto it1 = ship1.begin(), it2 = ship2.begin(); it1 != ship1.end(); ++it1, ++it2){
    tops1 += std::string(1, it1->back());
    tops2 += std::string(1, it2->back());
}

std::cout << "Tops Crane 9000: " << tops1 << std::endl;
std::cout << "Tops Crane 9001: " << tops2 << std::endl;

input.close();
return 0;
}

2 1 respuesta

B

[Borrado] #148 Dic '22

#147 Qué gusto ver C++, trabajas con él?

1 respuesta

Naith #149 Dic '22 Penitente

#148 No, pero empiezo a trabajar en C++ en enero asi que lo estoy usando para practicar.

JonaN #150 Dic '22 Juntabrackets

Python day 5

def apply1order (dictionary,order,reverse):
    cut=dictionary[order[1]][-order[0]:]
    if reverse:
        cut.reverse()
    dictionary[order[2]] =  dictionary[order[2]] +  cut
    dictionary[order[1]] =  dictionary[order[1]][:len(dictionary[order[1]])-order[0]]
    return dictionary

import re
input = [l.replace('    ','A ').strip() for l in open('./Input05.txt').readlines()]

br=input.index('')
boxes=input[:br-1]
orders=input[br+1:]
colnumber=int(re.findall('[0-9]+', input[br-1])[-1])
orderlist = [[int(i) for i in t] for t in [re.findall('[0-9]+', c) for c in orders]]

boxdict = dict.fromkeys(range(1,colnumber+1), [])

for e in boxes:
    elem=re.findall('[A-Z]+',e)
    for i in range(len(elem)):
        if elem[i]!='A':
            boxdict[i+1] = [elem[i]] + boxdict[i+1]

part1=boxdict.copy()
part2=boxdict.copy()

for order in orderlist:
    part1 = apply1order(part1,order,1)
    part2 = apply1order(part2,order,0)

res1=''
res2=''
for value in part1.values():
    res1+=value[-1][0]
for value in part2.values():
    res2+=value[-1][0]   
    

print(res1)
print(res2)

Usuarios habituales

Tags