Advent of Code 2022: no pato edition

nobody1 #211 Dic '22

c++ D8

vector<vector<int>> matrix;
int max_x, max_y;


int visible(int x, int y){   

//Border
if (x == 0 || y == 0 || x == max_x - 1 || y == max_y - 1) return 1;

vector<int> newVec(matrix[y].begin(), matrix[y].begin() + x);
vector<int> newVec2(matrix[y].begin() + x + 1, matrix[y].end());
   
//Horizontal
auto max_left = max_element(matrix[y].begin(), matrix[y].begin() + x);
auto max_right = max_element(matrix[y].begin() + x + 1, matrix[y].end());
if (matrix[y][x] > *max_left || matrix[y][x] > *max_right) return 1;

//Vertical
vector<int> vertical;
for (int i = 0; i < max_y; i++){
    vertical.push_back(matrix[i][x]);     
}
  
max_left = max_element(vertical.begin(), vertical.begin() + y );
max_right = max_element(vertical.begin() + y + 1, vertical.end());
if (matrix[y][x] > *max_left || matrix[y][x] > *max_right) return 1;

return 0;

}

int main() 
{   

    string line;
    int score = 0;    

while (cin >> line){
    vector<int> tmp;
    for (auto &c: line){
        int a = c - 48;
        tmp.push_back(a);            
    }
    max_x = tmp.size();
    matrix.push_back(tmp);
}

max_y = matrix.size();

for (size_t i = 0; i < matrix.size(); i++){
    for (size_t j = 0; j < matrix[i].size(); j++){
        score += visible(j, i);         
    }
}

cout << score << endl;
}

spoiler

vector<vector<int>> matrix;
int max_x, max_y;

int max_view(int x, int y){

int left = 0, right = 0, up = 0, down = 0;   

//Border
if (x == 0 || y == 0 || x == max_x - 1 || y == max_y - 1) return 0;

vector<int> v_left(matrix[y].begin(), matrix[y].begin() + x);  
vector<int> v_right(matrix[y].begin() + x + 1, matrix[y].end());   

for (auto it = v_left.rbegin(); it != v_left.rend(); ++it){
    left++;
    if (matrix[y][x] <= *it) break;
}  

for (auto it = v_right.begin(); it != v_right.end(); ++it){      
    right++;
    if (matrix[y][x] <= *it) break;
}

//Vertical
vector<int> vertical;
for (int i = 0; i < max_y; i++){
    vertical.push_back(matrix[i][x]);       
}

vector<int> v_up(vertical.begin(), vertical.begin() + y);  
vector<int> v_down(vertical.begin() + y + 1, vertical.end());

for (auto it = v_up.rbegin(); it != v_up.rend(); ++it){
    up++;
    if (matrix[y][x] <= *it) break;
}   

for (auto it = v_down.begin(); it != v_down.end(); ++it){
    down++;
    if (matrix[y][x] <= *it) break;
}

return left * right * up * down;

}

int main() 
{   

    string line;
    int score = 0;    

while (cin >> line){
    vector<int> tmp;
    for (auto &c: line){
        int a = c - 48;
        tmp.push_back(a);
    }
    max_x = tmp.size();
    matrix.push_back(tmp);
}

max_y = matrix.size();

for (size_t i = 0; i < matrix.size(); i++){
    for (size_t j = 0; j < matrix[i].size(); j++){
        score = max(max_view(j, i), score);
    }
}

cout << score << endl;
}

Flashk #212 Dic '22

#210 y que es lo que determina que la estructura sea "demasiado" avanzada para el problema? Eso es algo bastante subjetivo:

Yo veo que unos datos de entrada que parecen encajar de forma bastante evidente en un árbol, por lo que he orientado mi solución inmediatamente por ese camino.

Quizá tú lo visualizas mejor como una cadena concatenada, con un mapa o como una lata de atún en escabeche, y entonces esa solución te será más fácil y no veas la necesidad de un árbol.

Todo eso está muy bien, pero no quiere decir que ni tu opción ni la mía sean más o menos mejores/incorrectas/sobrepensadas.

Por ver, he visto a gente en Reddit que ha decidido que ni siquiera hace falta codificar un algoritmo, que basta con abrir un terminal, ejecutar un script que genere todos esos comandos y ver con que tamaño se quedan los directorios.

1 respuesta

B

[Borrado] #213 Dic '22

#212 Había pensado en ejecutar los comandos y llenarlo de ficheros de x bytes pero me dio canguelo con el input normal, no fuera que hubiera algún 2 ** 64 o algo jajaja

2

Colgajo #214 Dic '22

No estoy nada contento con mi código, pero bueno, lo subo igualmente.

Día 8 NodeJS

spoiler

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

const main = async () => {
  const rows = (await fs.readFile('input.txt', 'utf8'))
    .split('\n').map((row) => row.split('').map((column) => Number.parseInt(column)))

  const columns = rows.reduce((acc, row, j) => {
    for (let i = 0; i < row.length; i++) {
      acc[i] = acc[i] || [];
      acc[i][j] = row[i];
    }
    return acc;
  }, []);

  let visibleTrees = 0;
  let maxScenicValue = 0;
  for (let i = 0; i < rows.length; i++) {
    const row = rows[i];
    for (let j = 0; j < row.length; j++) {
      const column = columns[j];

  const left = row.slice(0, j);
  const right = row.slice(j + 1);
  const top = column.slice(0, i);
  const bottom = column.slice(i + 1);

  const currentTree = row[j];

  if (
    left.length === 0 || Math.max(...left) < currentTree
    || right.length === 0 || Math.max(...right) < currentTree
    || top.length === 0 || Math.max(...top) < currentTree
    || bottom.length === 0 || Math.max(...bottom) < currentTree
  ) {
    visibleTrees++;
    const scenicValues = [];

    const blockingTreeLeftDistance = left.findLastIndex((tree) => tree >= currentTree);
    if (blockingTreeLeftDistance === -1) {
      scenicValues.push(left.length);
    } else {
      scenicValues.push(left.length - blockingTreeLeftDistance);
    }

    const blockingTreeRightDistance = right.findIndex((tree) => tree >= currentTree);
    if (blockingTreeRightDistance === -1) {
      scenicValues.push(right.length);
    } else {
      scenicValues.push(blockingTreeRightDistance + 1);
    }

    const blockingTreeTopDistance = top.findLastIndex((tree) => tree >= currentTree);
    if (blockingTreeTopDistance === -1) {
      scenicValues.push(top.length);
    } else {
      scenicValues.push(top.length - blockingTreeTopDistance);
    }

    const blockingTreeBottomDistance = bottom.findIndex((tree) => tree >= currentTree);
    if (blockingTreeBottomDistance === -1) {
      scenicValues.push(bottom.length);
    } else {
      scenicValues.push(blockingTreeBottomDistance + 1);
    }

    const scenicValue = scenicValues.reduce((acc, scenicValue) => acc * scenicValue);
    if (scenicValue > maxScenicValue) {
      maxScenicValue = scenicValue;
    }
  }
}
  }
  console.log(visibleTrees);
  console.log(maxScenicValue);
};

main();

Hipnos #215 Dic '22 Dungeon Master

Día 8 python noob:

1 y 2

La parte 2 me ha costado más de lo que quiero reconocer.

R

RsTTa #216 Dic '22

Dia 8 en Python
Parte 1

spoiler

Parte 2

spoiler

He estado por usar un arbol xD

thenanox #217 Dic '22 Virconita

#196 lo mismo que me paso a mi, al principio puse de clave solo el nombre de la carpeta y al haber colisiones, el full path y au

gonya707 #218 Dic '22 Moderador

Actualmente en la tesitura de que el test funciona pero con full datos no xD a debugear

Hipnos #219 Dic '22 Dungeon Master

Día 9 en Python noobísimo:

1

2

La parte 2 la he tenido que reescribir copiando trocitos de @RsTTa y @DarkRaptor, porque soy un inútil con python y me quedaban unos tochos infumables.

1 respuesta

JonaN #220 Dic '22 Juntabrackets

Voy a dejarlo en imagen, que es verdad que queda más legible.

D9, Python

gonya707 #221 Dic '22 Moderador

Uf, la he pasado putas para la segunda parte, he tenido que hacerme papelitos con numeros y moverlos en el escritorio para entender como se movian las cosas en diagonal

1 respuesta

R

RsTTa #222 Dic '22

Para la parte 2 me ha tocado dibujar la matriz por pantalla, que no había forma de ver el fallo

Colgajo #223 Dic '22

Me bajo hasta el domingo porque no voy a tocar PC este finde, eso si no me rajo antes. Ánimo cracks!

1

tirutu #224 Dic '22

#221

spoiler

2 respuestas

JonaN #225 Dic '22 Juntabrackets

#224

spoiler

2 respuestas

Hipnos #226 Dic '22 Dungeon Master

#225 Correcto, y me está costando la vida la parte 2 porque el algoritmo no es el mismo hehe

1 respuesta

gonya707 #227 Dic '22 Moderador

#224 #225 #226 efectivamente es lo que me paso a mi, mi algoritmo inicial solo sirve para 2 nodos, con mas hay 4 movimientos que no refleja, los diagonales, cuando la distancia entre head y tail es >=2 en ambas dimensiones

R

RsTTa #228 Dic '22

Día 9 en Python

spoiler

PiradoIV #229 Dic '22 Brongster

A partir de ahora siempre pasa más o menos lo mismo, si no lees entre lineas y no te preparas para la segunda parte... plaf xD

nobody1 #230 Dic '22

D9 C++, no negaré haber sudado un rato

spoiler

const int size = 1000;
const int ini = size/2;

int visited[size][size] = {0};
vector<pair<char,int>> movements;
int h_x = ini;
int h_y = ini;
int t_x = ini;
int t_y = ini;

void move_head(char dir){

switch (dir)
{
    case 'R':
        ++h_x;
        break;   
    
    case 'L':
        --h_x;
        break;   
    
    case 'U':
        ++h_y;
        break;   
    
    case 'D':
        --h_y;
        break;   
}
}

void move_tail(){

//left or right
if (h_y == t_y){
    if (h_x > t_x) 
        t_x++;
    else 
        t_x--;
} else if (h_x == t_x){ //up or down
    if (h_y > t_y) 
        t_y++;
    else 
        t_y--;
} else {
    //diagonally 
    if (h_x > t_x && h_y > t_y){ //up right
        t_x++;
        t_y++;
    } else if (h_x < t_x && h_y > t_y){ // up left
        t_x--;
        t_y++;
    } else if (h_x > t_x && h_y < t_y){ // down right
        t_x++;
        t_y--;
    } else { //down right
        t_x--;
        t_y--;
    }          
}

visited[t_y][t_x] = 1;
}

bool head_is_far(){   

    int x = abs(h_x - t_x);
    int y = abs(h_y - t_y);   

    if (x > 1 || y > 1 ) return true;
    return false;
}

int main() 
{
    int score = 0;
    char dir;
    int n;    

visited[ini][ini] = 1;

while (cin >> dir >> n ){
    movements.push_back(make_pair(dir, n));       
}

for(auto m:movements){
    for(int i=0; i < m.second; ++i){
        move_head(m.first);
        if (head_is_far()){
            move_tail();
        }
    }
}

for (int i = 0; i < size; i++){
    for (int j = 0; j < size; j++){
        score+=visited[i][j];
    }      
}    

cout << score << endl;
}

spoiler

struct point{    

    int x;
    int y; 
};

const int size = 1000;
const int ini = size/2;

int visited[size][size] = {0};
vector<pair<char,int>> movements;
vector<point> points; 


void move_head(char dir){

switch (dir)
{
    case 'R':
        ++(points[0].x);
        break;   
    
    case 'L':
        --(points[0].x);
        break;   
    
    case 'U':
        ++(points[0].y);
        break;   
    
    case 'D':
        --(points[0].y);
        break;   
} 
}

void move_point(int i){

int h_y = points[i-1].y;
int h_x = points[i-1].x;

int t_y = points[i].y;
int t_x = points[i].x;

//left or right
if (h_y == t_y){
    if (h_x > t_x) 
        t_x++;
    else 
        t_x--;
} else if (h_x == t_x){ //up or down
    if (h_y > t_y) 
        t_y++;
    else 
        t_y--;
} else {
    //diagonally 
    if (h_x > t_x && h_y > t_y){ //up right
        t_x++;
        t_y++;
    } else if (h_x < t_x && h_y > t_y){ // up left
        t_x--;
        t_y++;
    } else if (h_x > t_x && h_y < t_y){ // down right
        t_x++;
        t_y--;
    } else { //down right
        t_x--;
        t_y--;
    }          
}

points[i].y = t_y;
points[i].x = t_x;    

if (i == 9)
    visited[t_y][t_x] = 1;

}

bool next_is_far(int i){    

    int x = abs(points[i-1].x - points[i].x);
    int y = abs(points[i-1].y - points[i].y);        

    if (x > 1 || y > 1 ) return true;
    return false;
}



int main() 
{
    int score = 0;
    char dir;
    int n;

visited[ini][ini] = 1;

while (cin >> dir >> n ){
    movements.push_back(make_pair(dir, n));
}

//Init points
for (int i = 0; i < 10; i++){
    point p = {ini, ini};
    points.push_back(p);
}

for(auto m:movements){      
    for(int i=0; i < m.second; ++i){
        move_head(m.first);
        for (int i = 1; i < 10; i++){
            if (next_is_far(i)){
                move_point(i);
            }
        }
    }      
}

for (int i = 0; i < size; i++){
    for (int j = 0; j < size; j++){
        score+=visited[i][j];
    }      
}   

cout << score << endl;
}

Viendo vuestras soluciones deberían despedirme del trabajo yo creo.

1 respuesta

gonya707 #231 Dic '22 Moderador

#230 pf, tranquilo, yo lo estoy haciendo en python y creo que lo hemos hecho parecido, full low level

Naith #232 Dic '22 Penitente

Dia 9 C++

gonya707 #233 Dic '22 Moderador

Si que es verdad que el fin de semana se relaja un poco la cosa, ya estaba acojonado. El dia 10 facil y ademas interesante, creo que es el primer dia en el que no he hecho ninguna chapu para hacer las cosas

1

S

shaba #234 Dic '22

Me calente hoy.. hice unos pocos pero empeze de 0

D3 c++

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <limits>
#include <algorithm>
#include <numeric>
#include <functional>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <array>
#include <iostream>
#include <string>
#include <stack>

using namespace std;

int main()
{
    auto parse = []()
    {
        std::string s;
        if(!(std::cin >> s))
            throw std::exception();
        return s;
    };

auto parse3 = [&](){
    vector<string> group;
    group.emplace_back(parse());
    group.emplace_back(parse());
    group.emplace_back(parse());
    return group;
};

auto getVal = [](char c)
{
    if(islower(c))
        return c-'a'+1;
    return c-'A'+27;
};

int ans = 0;
auto solve1 =[&]()
{
    while(true)
    {
        auto rucksack = parse();
        unordered_map<char, int> counter;
        for(int i = 0; i < rucksack.size()/2; ++i)
            counter[rucksack[i]]++;
        for(int i = rucksack.size()/2; i < rucksack.size(); ++i)
            if((counter[rucksack[i]]))
            {
                ans += getVal(rucksack[i]);
                break;
            }
    }
};

auto solve2 =[&]()
{
    while(true)
    {
        auto group = parse3();
        unordered_map<char, int> counter;// 1<<0, 1<<1, 1<<2,
        for(int i = 0; i < group.size(); ++i)
            for(char c : group[i])
                counter[c]|= 1<<i;
        for(auto[key,val] : counter)
            if(val& 1<<0 && val & 1<<1 && val & 1<<2)
                ans+= getVal(key);
    }
};

try 
{
    solve2();
} catch(...)
{
    cout << ans << endl;
}

return 0;
}

D9 C++

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <limits>
#include <algorithm>
#include <numeric>
#include <functional>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <array>
#include <iostream>
#include <string>

using namespace std;

int main()
{
    auto parse = []() -> std::tuple<int, int, int>
    {
        char dir;
        if(!(std::cin >> dir))
            throw std::exception(); 
        int val;
        std::cin >> val;
        if(dir == 'U')
            return {1, 0, val};
        if(dir == 'D')
            return {-1, 0, val};
        if(dir == 'L')
            return {0, -1, val};
 
    return {0, 1, val};
};

set<pair<int,int>> visited;
visited.emplace(0,0);
const int L = 10;
auto solve = [&](){
    vector<pair<int,int>> snake(L, {0,0});
    while (true)
    {
        auto [dirx, diry, inc] = parse();
        auto& [snake_head_x,snake_head_y] = snake[L-1];
        while(inc--)
        {
            snake_head_x+=dirx;
            snake_head_y+=diry;
            for(int i = L-2; i >=0 ; --i)
            {
                auto& [head_x,head_y] = snake[i+1];
                auto& [tail_x,tail_y] = snake[i];
                int dx = (head_x-tail_x);
                int dy = (head_y-tail_y);
                if(abs(dx)>1 || abs(dy)>1)
                {
                    if(dx)
                        tail_x = tail_x+ dx/sqrt(dx*dx);
                    if(dy)
                        tail_y = tail_y+ dy/sqrt(dy*dy);
                    if(i == 0)
                        visited.emplace(tail_x, tail_y);
                }
            }
        }

    }
};

try{
    solve();
} 
catch(...)
{
    cout << visited.size() << endl;
}
return 0;
}

D10 1 c++

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <limits>
#include <algorithm>
#include <numeric>
#include <functional>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <array>
#include <iostream>
#include <string>

using namespace std;

int main()
{

auto parse = []() -> std::pair<int,int> // val, cycle_inc
{
    std::string inst;
    if(!(std::cin >> inst))
        throw std::exception();
    if(inst == "noop")
        return {0, 1}; 
    int val;
    std::cin >> val;
    return {val, 2};
};

int ans = 0;
auto solve = [&](){
    int cycle = 0;
    int X = 1;
    int pollcycle = 20;
    while (cycle < 241)
    {
        auto [val, inc] = parse();
        while(inc--)
        {
            cycle++;
            if(cycle == pollcycle)
            {
                ans += X*pollcycle;
                pollcycle +=40;
            }
        }
        X+= val;
    }
};

try{
    solve();
} 
catch(...)
{
 cout << ans << endl;   
}
return 0;
}

D10 2 c++

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <limits>
#include <algorithm>
#include <numeric>
#include <functional>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <array>
#include <iostream>
#include <string>

using namespace std;

int main()
{


auto parse = []() -> std::pair<int,int> // val, cycle_inc
{
    std::string inst;
    if(!(std::cin >> inst))
        throw std::exception();
    if(inst == "noop")
        return {0, 1}; 
    int val;
    std::cin >> val;
    return {val, 2};
};

auto solve = [&](){
    int cycle = 0;
    int X = 1;
    int pollcycle = 40;
    std::string row(40, '.');
    while (cycle < 241)
    {
        auto [val, inc] = parse();
        while(inc--)
        {
            if(abs(X-(cycle%40)) < 2)
                row[(cycle%40)] = '#';
            cycle++;
            if(cycle == pollcycle)
            {
                cout << row << endl;
                pollcycle +=40;
                row = std::string(40, '.');
            }
        }
        X+=val;
    }
};

try{
    solve();
} 
catch(...)
{
}
return 0;
}
}

1 respuesta

eZpit #235 Dic '22 Juntabrackets

El de hoy está gracioso.
A ver si son unas series y acabamos haciendo algo más complicado

Hipnos #236 Dic '22 Dungeon Master

Día 10 python terrible

PiradoIV #237 Dic '22 Brongster

Yo me he atascado hoy bastante, pero bueno, las estrellas cuentan igual xD

1

nobody1 #238 Dic '22

#234 Lo que te gustan las lambdas y los throw

D10

NSFW

B

[Borrado] #239 Dic '22

Me he descuidado un poco, dia 9

spoiler

import sys
import numpy as np
from itertools import product

char2dir = {
  k: np.array(v, dtype=np.int32) for k, v in
  {
    'R': [0, 1],
    'U': [1, 0],
    'D': [-1, 0],
    'L': [0, -1]
  }.items()
}


def _coord_prod():
  return product([-1, 0, 1], [-1, 0, 1])


def _adjacent(u, v):
  return tuple(u - v) in _coord_prod()


def _diagonals():
  return [v for v in _coord_prod() if np.prod(v) != 0]


def _suitable_diag(h, t, f):
  for diag in _diagonals():
    new_t = np.array(t + diag, dtype=np.int32)
    if f(h, new_t):
      return new_t
  return None


def _coalesce(gen):
  for arg in gen:
    if arg is not None:
      return arg
  return None


num_knots = int(sys.argv[1])

knots = [np.zeros(2, dtype=np.int32) for _ in range(num_knots)]
visited = set([(0, 0)])


for line in sys.stdin:
  mov, k = line.strip().split()
  for _ in range(int(k)):
    knots[0] = knots[0] + char2dir[mov]
    for i in range(1, num_knots):
      h, t = knots[i - 1], knots[i]
      if not _adjacent(h, t):
        dist = t - h
        if np.prod(dist) == 0:
          knots[i] = np.array(t - np.sign(dist), dtype=np.int32)
        else:
          knots[i] = _coalesce((_suitable_diag(h, t, lambda x, y: np.sum(np.abs(x - y)) == 1),  _suitable_diag(h, t, lambda x, y: _adjacent(x, y))))
      visited.add(tuple(knots[-1]))

print(len(visited))

eZpit #240 Dic '22 Juntabrackets

Uff que pereza de input

Usuarios habituales

Tags