Advent of Code 2022: no pato edition

shaba #241 Dic '22

Vaya coniazo de parsing.. pog.

edit: estoy en el tren haciendo todos los que me faltan... full cerdo coding.

#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 <sstream>
#include <string>
#include <optional>

using namespace std;

struct Func{
    char op;
    optional<int> a;
    optional<int> b;
    int divisible;
    int t_true;
    int t_false;
};

struct Monkey
{
    int id;
    unordered_multiset<int> items;
    Func f;
};

int main()
{
    auto parseList = [](){
        string raw;
        getline(cin, raw);
        stringstream ss(raw);
        unordered_multiset<int> items;
        string temp;
        int i;
        while(!ss.eof())
        {
            ss >> temp;
            if(stringstream(temp) >> i)
                items.emplace(i);
            temp = "";
        }

    return items;    
};

auto parseOperator = [](string s) -> optional<int>
{
    try
    {
        int num = stoi(s);
        return num;
    } catch(...)
    {
    }
    return {};
};

auto parseFunc = [&]()
{
    Func f;
    string raw;
    getline(cin, raw);
    string a(5,' ');
    string b(5,' ');
    string c(5,' ');
    sscanf(raw.c_str(), "  Operation: new = %s %s %s", &a[0], &b[0], &c[0]);
    f.a = parseOperator(a);
    f.op = b[0];
    f.b = parseOperator(c);
    getline(cin, raw);
    sscanf(raw.c_str(), "  Test: divisible by %d", &f.divisible);
    getline(cin, raw);
    sscanf(raw.c_str(),"    If true: throw to monkey %d", &f.t_true);
    getline(cin, raw);
    sscanf(raw.c_str(),"    If false: throw to monkey %d", &f.t_false);

    return f;
};

auto parseMonkey = [&]()
{
    Monkey m;
    string raw;
    getline(cin, raw);
    sscanf(raw.c_str(), "Monkey %i:", &m.id);
    m.items = parseList();
    m.f = parseFunc();
    return m;
};

auto parse = [&]()
{
    unordered_map<int, Monkey> ms;
    try{
        while(true)
        {
            auto m = parseMonkey();
            ms[m.id] = move(m);
            string r;
            if(!getline(cin, r)) // clear
                throw exception();
        }
    } catch(...)
    {}
    return ms;
};

auto evalOp = [](Func& f, int item) -> pair<int,int>{
    int a = [&](){
        switch(f.op)
        {
            case '*': return (f.a.value_or(item) * f.b.value_or(item))/3;
            case '/': return (f.a.value_or(item) / f.b.value_or(item))/3;
            case '+': return (f.a.value_or(item) + f.b.value_or(item))/3;
            case '-': return (f.a.value_or(item) - f.b.value_or(item))/3;
        }
        return -1;
    }();
    return {a, a% f.divisible == 0 ? f.t_true : f.t_false};
};

auto eval = [&](auto& m, int i){
    auto uglycopy = m[i].items;
    for(auto& item: uglycopy)
    {
        auto [worry,new_monkey] = evalOp(m[i].f, item);
        m[i].items.erase(item);
        m[new_monkey].items.emplace(worry);
    }
    return uglycopy.size();
};

auto solve = [&]()
{
    auto monkeys = parse();
    unordered_map<int, int> counter;
    for(int i = 0; i < 20; ++i)
    {
        for(int j = 0 ; j < monkeys.size(); ++j)
            counter[j] += eval(monkeys, j);
    }
    priority_queue<int, vector<int>, greater<int>> pq;
    for(auto&[k,v]: counter)
    {
        pq.push(v);
        if(pq.size()>2)
            pq.pop();
    }
    int a = pq.top(); pq.pop();
    int b = pq.top(); pq.pop();
    cout << a << endl;
    cout << b << endl;
    cout << a*b << endl;
};


solve();
return 0;
}

D4 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 <sstream>
#include <string>
#include <optional>
#include <stack>

using namespace std;




int main()
{
    //1 // 5 // 9
    auto parseStack = [&]() -> vector<char>
    {
        char a,b,c;
        string s;
        getline(cin, s);
        if(isdigit(s[1]))
            throw exception();
        int cols = (s.size()+1)/4;
        vector<char> ret;
        for(int i = 0;i < cols; ++i)
            ret.emplace_back(s[i*4 + 1]);
        return ret;
    };

auto parseOp = [&]() -> tuple<int,int,int>
{
    int quan, from, to;
    string raw;
    if(!(getline(cin, raw)))
        throw exception();
    sscanf(raw.c_str(), "move %d from %d to %d", &quan, &from, &to);
    return {quan, from-1, to-1};
};


auto solve = [&](int question)
{
    vector<deque<char>> stacks(100, deque<char>());
    try{
        while(true)
        {
            auto v = parseStack();
            for(int i = 0 ; i < v.size(); ++i)
            {
                if(v[i] != ' ')
                    stacks[i].push_front(v[i]);
            }
                
        }
    } catch(...)
    {}
    try{
        string s;
        getline(cin, s);
        while(true)
        {
            auto [quantity, from, to] = parseOp();
            if(question == 2)
            {
                stack<char> qu;
                while(quantity--)
                {
                    if(!stacks[from].empty())
                    {
                        qu.push(stacks[from].back());
                        stacks[from].pop_back();  
                    } 
                }
                while(!qu.empty())
                {
                    stacks[to].push_back(qu.top());
                    qu.pop();
                }
                    
            }
            else 
            {
                while(quantity--)
                {
                    if(!stacks[from].empty())
                    {
                    stacks[to].push_back(stacks[from].back());
                    stacks[from].pop_back();  
                    } 
                }
            }

            
        }
    } catch(...)
    {}

    for(int i = 0 ; i < stacks.size(); ++i)
        if(!stacks[i].empty())
            cout << stacks[i].back();
        else
            cout << " ";

};


solve(2);
return 0;
}

D5 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 <sstream>
#include <string>
#include <optional>
#include <stack>

using namespace std;




int main()
{
    //1 // 5 // 9
    auto parseStack = [&]() -> vector<char>
    {
        char a,b,c;
        string s;
        getline(cin, s);
        if(isdigit(s[1]))
            throw exception();
        int cols = (s.size()+1)/4;
        vector<char> ret;
        for(int i = 0;i < cols; ++i)
            ret.emplace_back(s[i*4 + 1]);
        return ret;
    };

auto parseOp = [&]() -> tuple<int,int,int>
{
    int quan, from, to;
    string raw;
    if(!(getline(cin, raw)))
        throw exception();
    sscanf(raw.c_str(), "move %d from %d to %d", &quan, &from, &to);
    return {quan, from-1, to-1};
};


auto solve = [&](int question)
{
    vector<deque<char>> stacks(100, deque<char>());
    try{
        while(true)
        {
            auto v = parseStack();
            for(int i = 0 ; i < v.size(); ++i)
            {
                if(v[i] != ' ')
                    stacks[i].push_front(v[i]);
            }
                
        }
    } catch(...)
    {}
    try{
        string s;
        getline(cin, s);
        while(true)
        {
            auto [quantity, from, to] = parseOp();
            if(question == 2)
            {
                stack<char> qu;
                while(quantity--)
                {
                    if(!stacks[from].empty())
                    {
                        qu.push(stacks[from].back());
                        stacks[from].pop_back();  
                    } 
                }
                while(!qu.empty())
                {
                    stacks[to].push_back(qu.top());
                    qu.pop();
                }
                    
            }
            else 
            {
                while(quantity--)
                {
                    if(!stacks[from].empty())
                    {
                    stacks[to].push_back(stacks[from].back());
                    stacks[from].pop_back();  
                    } 
                }
            }

            
        }
    } catch(...)
    {}

    for(int i = 0 ; i < stacks.size(); ++i)
        if(!stacks[i].empty())
            cout << stacks[i].back();
        else
            cout << " ";

};


solve(2);
return 0;
}

Raistlin_TM #242 Dic '22

pues se me está atascando la parte2 por rendimiento, a partir de la iteración 1000 se me dispara.

1 respuesta

gonya707 #243 Dic '22 Moderador

#242 yo igual, la clave para que los números no se disparen es eso de You'll need to find another way to keep your worry levels manageable. Pero le estoy damdo vueltas y no hay manera. Habia pensado en factorizarlos y reducir los múltiplos que no necesito pero fijo que haciendo eso la lio en alguma comprobación

edit: por si os sirve, a mi me ha dado la pista que necesitaba

spoiler

PiradoIV #244 Dic '22 Brongster

Spoiler

1

Raistlin_TM #245 Dic '22

.

sergioRG #246 Dic '22 Juntabrackets

Menos mal que me ha dado por abrir el input y ver que

spoiler

Dia 11

spoiler

import sys
import re
from collections import deque
from functools import reduce


class monkey(object):


  def __init__(self, idx, items, operation, test, true_idx, false_idx):
    self._idx = idx
    self._items = items
    self._operation = operation
    self._test = test
    self._true_idx = true_idx
    self._false_idx = false_idx
    self._cnt = 0


  def add_item(self, item):
    self._items.append(item)


  def inspect_item(self, all_prods):
    self._cnt += 1
    front = self.eval_operation(self._items.popleft()) % all_prods
    if front % self._test == 0:
      return self._true_idx, front
    return self._false_idx, front


  def has_items(self):
    return len(self._items) > 0


  def eval_operation(self, old):
    return eval(self._operation)


  def get_count(self):
    return self._cnt


  def get_test(self):
    return self._test


  @staticmethod
  def from_string(string):
    pattern = r'Monkey (.*):\n.*Starting items: (.*)\n.*Operation: new = (.*)\n.*Test: divisible by (.*)\n.*If true: throw to monkey (.*)\n.*If false: throw to monkey (.*)'
    idx, item_list, operation, test, true_idx, false_idx = re.match(pattern, string).groups()
    return monkey(int(idx), deque([int(x.strip()) for x in item_list.strip().split(', ')]), operation, int(test), int(true_idx), int(false_idx))

monkeys = [monkey.from_string(group) for group in sys.stdin.read().split('\n\n')]


all_prods = reduce(int.__mul__, [x.get_test() for  x in monkeys])


for _ in range(10000):
  for i in range(len(monkeys)):
    while monkeys[i].has_items():
      index, item = monkeys[i].inspect_item(all_prods)
      monkeys[index].add_item(item)

print(
  sorted(
    [x.get_count() for x in monkeys],
    key=lambda x: -x
  )
)

Por si a alguien le ayuda

spoiler

2 respuestas

R

RsTTa #247 Dic '22

#246

spoiler

1

Flashk #248 Dic '22

#246 gran explicación!

Yo me he dado de cabezazos en la parte 2 hoy.
Tenía la solución a punto de caramelo, pero me seguían saliendo números negativos (por overflow) en el resultado. Y yo "no puede ser, ¿es posible que el módulo no sea lo suficiente grande?". Y aún cambiando de Integer a Long me seguía cascando.

Al final resultó una tontería: me había dejado dos variables declaradas como Integer (un compareTo para ordenar el listado de monos y el contador de items) y eso era lo que me estaba jodiendo. De hecho, comparé lo que me devolvía cada mono a mano, y era correcto, pero al aplicar la última multiplicación petaba.

Me he sentido muy estúpido de no conseguir verlo hasta después de muchas horas mirando.

Day 11 - MonkeyMiddle

public class MonkeyMiddle {

private static final int INPUT_LINES_PER_MONKEY = 7;
private Monkey[] monkeys;

public MonkeyMiddle(List<String> inputs) {

	List<List<String>> monkeyInputs = Lists.partition(inputs, INPUT_LINES_PER_MONKEY);
	monkeys = new Monkey[monkeyInputs.size()];

	int i = 0;
	int lcm = 1;
	for(List<String> monkeyInput : monkeyInputs) {
		monkeys[i] = new Monkey(monkeyInput);
		lcm *= monkeys[i].getDivisor();
		i++;
	}
	
	i = 0;
	for(i = 0; i < monkeys.length; i++) {
		monkeys[i].setLcm(lcm);
	}
}

public long solve(int rounds, boolean useRelief) {
	
	for(int i = 0; i < rounds; i++) {
		for(int monkeyIndex = 0; monkeyIndex < monkeys.length; monkeyIndex++) {
			Monkey currentMonkeyTurn = monkeys[monkeyIndex];
			while(currentMonkeyTurn.hasItems()) {
				Pair<Integer,Long> result = currentMonkeyTurn.throwItem(useRelief);
				monkeys[result.getFirst()].getItems().add(result.getSecond());
			}[spoiler=NSFW][/spoiler]
		}
		
		
	}
	AtomicLong monkeyBusinessCount = new AtomicLong(1);
	Arrays.stream(monkeys)
			.sorted(Comparator.reverseOrder()).limit(2)
			.map(monkey -> monkey.getCountedItems())
			.forEach(countedItems -> monkeyBusinessCount.set(monkeyBusinessCount.get()*countedItems));
	
	return monkeyBusinessCount.get();
}

Y la clase Monkey, donde realmente están las cosas interesantes, he quitado todas las funciones de inicialización para que ocupe menos y se vea la parte que importa del algoritmo:

Day 11 - Monkey

@Getter
public class Monkey implements Comparable<Monkey> {

    ...
private static final char MULTIPLY = '*';
private static final int BASIC_RELIEF = 3;

private Queue<Long> items = new LinkedList<>();

private char operation;
private boolean selfOperand;
private long operand;

private int divisor;
private int trueMonkey;
private int falseMonkey;

private long countedItems;

@Setter
private long lcm;

public Monkey(List<String> inputs) {		
	
	initializeItems(inputs.get(1));
	initializeOperation(inputs.get(2));
	initializeTest(inputs);

}

public boolean hasItems() {
	return !this.items.isEmpty();
}

public Pair<Integer,Long> throwItem(boolean useRelief) {
	
	// Inspect item
	long worryLevel = items.poll();
	countedItems++;
	
	// Calculate worry level
	if(selfOperand) {
		operand = worryLevel;
	}
	
	if(operation == MULTIPLY) {
		worryLevel *= operand;
	} else {
		worryLevel += operand;
	}

	// Apply relief
	if(useRelief) {
		worryLevel = worryLevel / BASIC_RELIEF;
	} else {
		worryLevel = worryLevel % lcm;
	}
	
	// Test
	long test = worryLevel % divisor;
	
	if(test == 0) {
		return new Pair<Integer,Long>(trueMonkey, worryLevel);
	} else {
		return new Pair<Integer,Long>(falseMonkey, worryLevel);
	}

}

@Override
public int compareTo(Monkey another) {
	return Long.compare(this.countedItems, another.countedItems);
}

}

eZpit #249 Dic '22 Juntabrackets

NSFW

nobody1 #250 Dic '22

unsigned long int

nope

R

RsTTa #251 Dic '22

Dia 11 en Python

spoiler

1

gonya707 #252 Dic '22 Moderador

Uf, toca pathfinding, algo de lo que no tengo ni zorra, me parece que el alcance de mis habilidades me dejan en este dia tirado

Sphere #253 Dic '22 Judas

Varios días pegándome en mis ratos libres con el día 10 y resulta que no me había dado cuenta de que addx consume 2 ciclos por sí solo, y yo tomándolo como que se ejecuta durante 2 ciclos en paralelo con la siguiente orden que venga a continuación

1 respuesta

sergioRG #254 Dic '22 Juntabrackets

#253 A mi me lio un poco lo de contar los valores añadidos según ciclo

thenanox #255 Dic '22

acabo de volver, recomenzando por el 8

he acabado la parte 1 sin mayor lio, y la segunda de conseguir el arbol con mayor score "scenic" por algun motivo no consigo que tire, se me queda un valor bajo

por confirmar, entiendo que se trata de devolver el arbol con mayor score de toda la matriz no? (multiplicacion de la distancia a la que ve a los cuatro lados)

thenanox #256 Dic '22

#255 ok just found. no multiplicaba en el caso de que llegara al borde con el score acumulado

Day 8 part 1

NSFW

Day 8 part 2

NSFW

sergioRG #257 Dic '22 Juntabrackets

Dia 12

spoiler

import sys
from collections import deque
from itertools import product


part = int(sys.argv[1])


def _find_vertex(m, x):
  return next((
    (i, j) for (i, j) in product(range(len(m)), range(len(m[0])))
    if m[i][j] == x
  ))


def _valid_step(m, s, t):
  si, sj = s
  ti, tj = t
  return ord(m[ti][tj]) - ord(m[si][sj]) < 2


m = [[y for y in x.strip()] for x in sys.stdin.readlines()]

S, E = _find_vertex(m, 'S'), _find_vertex(m, 'E')

m[S[0]][S[1]] = 'a'
m[E[0]][E[1]] = 'z'


q, vis, dis = deque([S]), set(), {S: 0}

if part == 2:
  for (i, j) in [(mi, mj) for (mi, mj) in product(range(len(m)), range(len(m[0]))) if m[mi][mj] == 'a']:
    q.append((i, j))
    dis[(i, j)] = 0

while q:
  cur = q.popleft()
  if cur not in vis:
    vis.add(cur)
    for (di, dj) in [x for x in product([-1, 0, 1], repeat=2) if any(z == 0 for z in x)]:
      nxt = (cur[0] + di, cur[1] + dj)
      if 0 <= nxt[0] < len(m) and 0 <= nxt[1] < len(m[0]) and _valid_step(m, cur, nxt):
        dis[nxt] = min(dis.get(nxt, abs(hash('mediavida'))), dis[cur] + 1)
        q.append(nxt)

print(dis[E])

gonya707 #258 Dic '22 Moderador

Hay algo mas terrorifico que te funcione el codigo para el input real y no para el test? Ahora toca la parte 2 y estoy acojonado

1 respuesta

R

RsTTa #259 Dic '22

Dia 13 en python, podria haber juntado ambas partes, pero bueno lo he dejado asi

spoiler

Del dia 12 no encuentro el codigo completo, lo tengo que tener por otro pc xD

1 respuesta

gonya707 #260 Dic '22 Moderador

#259 En la segunda parte has pasado de ordenar los paquetes y solo mirar los numeros a ver donde empiezan el 2 y el 6 no? No se que le pasaba a mi codigo que haciendolo asi no habia manera, la posicion del 2 me quedaba siempre mal, creo que debe de ser algo de los paquetes vacios o que empezaban por 0 pero ni idea

1 respuesta

R

RsTTa #261 Dic '22

#260

spoiler

sergioRG #262 Dic '22 Juntabrackets

Dia 13

spoiler

import sys
from functools import cmp_to_key, reduce


def _to_list(x):
  if isinstance(x, int):
    return [x]
  return x


def _both(lst, typ):
  return all(isinstance(x, typ) for x in lst)


def _less_than(a, b):
  na, nb = map(len, [a, b])
  for i in range(min(na, nb)):
    xa, xb = a[i], b[i]
    if _both([xa, xb], int):
      if xa != xb:
        return -1 if xa < xb else 1
    else:
      xa, xb = map(_to_list, [xa, xb])
      rec = _less_than(xa, xb)
      if rec != 0:
        return rec
  return -1 if na < nb else 1 if na > nb else 0


lists = [
  [eval(x), eval(y)]
  for (x, y) in [couple.split('\n') for couple in sys.stdin.read().split('\n\n')[:-1]]
]

print(
  sum(
    i + 1 for (i, (a, b)) in enumerate(lists) if _less_than(a, b) != 1
  )
)

divider_packets = [ [[2]], [[6]] ]

all_packets = sorted(
  reduce(lambda x, t: x.append(t[0]) or x.append(t[1]) or x, lists) + divider_packets,
  key=cmp_to_key(_less_than)
)

print(
  reduce(
    int.__mul__,
    [i + 1 for i, p in enumerate(all_packets) if any(sgn == p for sgn in divider_packets)]
  )
)

Tengo mucha curiosidad por saber como esta implementado el cmp_to_key por dentro

Flashk #263 Dic '22

El de hoy ha sido bastante curioso.

day 13 - Comentarios

day 13 - Clase Packet

@Getter
public class Packet implements Comparable<Packet> {

private static final int OK = 1;
private static final int UNDETERMINED = 0;
private static final int NOT_OK = -1;

private JsonNode root;
private String packetCode;

@Setter
private int packetIndex;

public Packet(String input) {
	root = buildTree(input);
	packetCode = input;
}

private int compare(JsonNode left, JsonNode right) {
	
	if(left.isNumber() && right.isNumber()) {

		if(left.intValue() < right.intValue()) {
			return OK;
		}

		if(left.intValue() > right.intValue()) {
			return NOT_OK;
		}

		return UNDETERMINED;
		
	}

	if (left.isArray() && right.isArray()) {
		return compareArray(left.elements(), right.elements());
	} else if(left.isNumber() && right.isArray()) {
		
		ObjectMapper mapper = new ObjectMapper();
		ArrayNode array = mapper.createArrayNode();
		array.add(left.intValue());
	
		return compare(array, right);
		
	} else {

		ObjectMapper mapper = new ObjectMapper();
		ArrayNode array = mapper.createArrayNode();
		array.add(right.intValue());
		
		return compare(left, array);
	}
	
}


private int compareArray(Iterator<JsonNode> leftElements, Iterator<JsonNode> rightElements) {

	while(leftElements.hasNext()) {
		
		JsonNode nextLeft = leftElements.next();
		
		if(!rightElements.hasNext()) {
			return NOT_OK;
		}
		
		JsonNode nextRight = rightElements.next();
		int lastComparison = compare(nextLeft, nextRight);
		
		if(lastComparison != UNDETERMINED) {
			return lastComparison;
		}
	}
	
	if(!rightElements.hasNext()) {
		return UNDETERMINED;
	} else {
		return OK;
	}

}

private JsonNode buildTree(String input) {
	
	try {
		ObjectMapper objectMapper = new ObjectMapper();
		return objectMapper.readTree(input);
	} catch (JsonProcessingException e) {
		e.printStackTrace();
	} catch (IOException e) {
		e.printStackTrace();
	}
	
	return null;
}

@Override
public int compareTo(Packet other) {
	return compare(root, other.root);
}


@Override
public String toString() {
	return "Packet [packetCode=" + packetCode + "]";
}

}

day 13 - Clase DistressSignal

public class DistressSignal {

private List<Packet> packets;

public DistressSignal(List<String> inputs) {
	packets = inputs.stream().filter(StringUtils::isNotBlank).map(Packet::new).collect(Collectors.toList());
}

public long solveA() {
	
	long result = 0;
	int packetIndex = 0;

	for(int i = 0; i < packets.size(); i++) {
		packetIndex++;
		Packet a = packets.get(i);
		Packet b = packets.get(i+1);
		i++;
		if(a.compareTo(b) > 0) {
			result += packetIndex;
		}
	}
	
	return result;
}

public long solveB() {
	
	// Add divider packets - Keep a pointer of them to use them later
	Packet dividerPacket1 = new Packet("[[2]]");
	Packet dividerPacket2 = new Packet("[[6]]");
	
	packets.add(dividerPacket1);
	packets.add(dividerPacket2);
	
	// Sort packages using comparator from part 1 and update indexes
	AtomicInteger packetIndex = new AtomicInteger(1);
	packets.stream()
			.sorted(Comparator.reverseOrder())
			.forEach(packet -> packet.setPacketIndex(packetIndex.getAndIncrement()));

	return dividerPacket1.getPacketIndex() * dividerPacket2.getPacketIndex();

}

}

Sphere #264 Dic '22 Judas

#258 Más terrorífico es que te funcione el código para el test pero no para el input. Menuda pesadilla para entender qué cojones está fallando.

1 respuesta

PiradoIV #265 Dic '22 Brongster

El de hoy ha sido algo tedioso, pero fácil.

Aquí va el video del de ayer, resolviendo en tiempo real la ruta:

nobody1 #266 Dic '22

El de hoy D13 con c++ a pelo ha superado mi paciencia
edit: Me he tenido que pasar a python, todo ok jose luis.
Al rico json

PiradoIV #267 Dic '22 Brongster

Spoiler Día 13

2 respuestas

R

RsTTa #268 Dic '22

spoiler

2

gonya707 #269 Dic '22 Moderador

#264 Eso es el pan ~~nuestro~~ mio de cada dia

#267

spoiler

yo pregunte al chatgpt como parsearlo y me recomendo

    left = ast.literal_eval(lines[i])
    right = ast.literal_eval(lines[i + 1])

muy practico

Por cierto en los ratos tontos por las tardes estoy haciendo el AoC del año pasado y en el cuarto dia con el bingo ha alcanzado la dificultad del de los monos del otro dia, que era el 11, muy hardcore esto

1

Flashk #270 Dic '22

#267

Day13

1

Usuarios habituales

Tags