[C. Enrique B.]

.
(Del traductor de Google; apenas lo he repasado)

Día 8: Búsqueda de siete segmentos

Apenas llegas a la seguridad de la cueva cuando la ballena se estrella contra la boca de la cueva, colapsando. Los sensores indican otra salida a esta cueva a una profundidad mucho mayor, por lo que no tiene más remedio que seguir adelante.

A medida que su submarino avanza lentamente a través del sistema de cuevas, se da cuenta de que las pantallas de siete segmentos de cuatro dígitos de su submarino no funcionan correctamente; deben haber sido dañados durante la fuga. Te meterás en muchos problemas sin ellos, así que será mejor que averigües qué está mal.


--- --- Cada dígito de una pantalla de siete segmentos se representa activando o desactivando cualquiera de los siete segmentos denominados de la a a la g:

(ver gráfico en el documento original) https://adventofcode.com/2021/day/8

Entonces, para generar un 1, solo los segmentos cyf estarían activados; el resto estaría apagado. Para representar un 7, solo se activarían los segmentos a, c y f.


--- --- El problema es que las señales que controlan los segmentos se han mezclado en cada pantalla. El submarino todavía está tratando de mostrar números produciendo una salida en los cables de señal a hasta g, pero esos cables están conectados a segmentos al azar. Peor aún, las conexiones de cable / segmento se mezclan por separado para cada pantalla de cuatro dígitos. (Sin embargo, todos los dígitos dentro de una pantalla usan las mismas conexiones).

Por lo tanto, es posible que sepa que solo los cables de señal byg están encendidos, pero eso no significa que los segmentos byg estén encendidos: el único dígito que usa dos segmentos es 1, por lo que debe significar que los segmentos cyf están destinados para estar ON. Con solo esa información, todavía no puede saber qué cable (b / g) va a qué segmento (c / f). Para eso, necesitará recopilar más información.


--- --- Para cada pantalla, observa las señales cambiantes durante un tiempo, toma nota de los diez patrones de señal únicos que ve y luego escribe un solo valor de salida de cuatro dígitos (su entrada de rompecabezas). Usando los patrones de señal, debería poder determinar qué patrón corresponde a qué dígito.

Por ejemplo, esto es lo que puede ver en una sola entrada en sus notas:

acedgfb cdfbe gcdfa fbcad dab cefabd cdfgeb eafb cagedb ab |
cdfeb fcadb cdfeb cdbaf

(La entrada se ajusta aquí a dos líneas para que encaje; en sus notas, todo estará en una sola línea).


--- --- Cada entrada consta de diez patrones de señal únicos, un | delimitador y, finalmente, el valor de salida de cuatro dígitos. Dentro de una entrada, se utilizan las mismas conexiones de cable / segmento (pero no sabe cuáles son realmente las conexiones). Los patrones de señal únicos corresponden a las diez formas diferentes en que el submarino intenta representar un dígito utilizando las conexiones de cable / segmento actuales. Debido a que 7 es el único dígito que usa tres segmentos, dab en el ejemplo anterior significa que para representar un 7, las líneas de señal d, ayb están encendidas. Debido a que 4 es el único dígito que usa cuatro segmentos, eafb significa que para generar un 4, las líneas de señal e, a, f y b están encendidas.

Con esta información, debería poder determinar qué combinación de cables de señal corresponde a cada uno de los diez dígitos. Luego, puede decodificar el valor de salida de cuatro dígitos. Desafortunadamente, en el ejemplo anterior, todos los dígitos del valor de salida (cdfeb fcadb cdfeb cdbaf) usan cinco segmentos y son más difíciles de deducir.


--- --- Por ahora, céntrese en los dígitos fáciles (ver el gráfico original para observar las negritas, https://adventofcode.com/2021/day/8). Considere este ejemplo más grande:

be cfbegad cbdgef fgaecd cgeb fdcge agebfd fecdb fabcd edb |
fdgacbe cefdb cefbgd gcbe
edbfga begcd cbg gc gcadebf fbgde acbgfd abcde gfcbed gfec |
fcgedb cgb dgebacf gc
fgaebd cg bdaec gdafb agbcfd gdcbef bgcad gfac gcb cdgabef |
cg cg fdcagb cbg
fbegcd cbd adcefb dageb afcb bc aefdc ecdab fgdeca fcdbega |
efabcd cedba gadfec cb
aecbfdg fbg gf bafeg dbefa fcge gcbea fcaegb dgceab fcbdga |
gecf egdcabf bgf bfgea
fgeab ca afcebg bdacfeg cfaedg gcfdb baec bfadeg bafgc acf |
gebdcfa ecba ca fadegcb
dbcfg fgd bdegcaf fgec aegbdf ecdfab fbedc dacgb gdcebf gf |
cefg dcbef fcge gbcadfe
bdfegc cbegaf gecbf dfcage bdacg ed bedf ced adcbefg gebcd |
ed bcgafe cdgba cbgef
egadfb cdbfeg cegd fecab cgb gbdefca cg fgcdab egfdb bfceg |
gbdfcae bgc cg cgb
gcafb gcf dcaebfg ecagb gf abcdeg gaef cafbge fdbac fegbdc |
fgae cfgab fg bagce


--- --- Debido a que los dígitos 1, 4, 7 y 8 utilizan cada uno un número único de segmentos, debería poder saber qué combinaciones de señales corresponden a esos dígitos. Contando solo dígitos en los valores de salida (la parte después de | en cada línea), en el ejemplo anterior, hay 26 instancias de dígitos que usan un número único de segmentos (resaltados arriba: ver gráfico original para observar los resaltados en negrita, https://adventofcode.com/2021/day/8).

En los valores de salida, ¿cuántas veces aparecen los dígitos 1, 4, 7 u 8?


--- --- Para jugar, identifíquese a través de uno de estos servicios:

[GitHub] [Google] [Twitter] [Reddit]
.

---------------------
Moderación. Se han movido aquí los mensajes relativos al problema 8 del advent of code 2021. Aquí el hilo original.

[martiniano]

Vale. Era dándole al numerito correspondiente. Hoy es día 8, pues hay que darle al 8  . No sé por qué estas cosas cuando estoy delante de la pantalla me pasan desapercibidas.

Por otro lado, según parece todo apunta a que lo que habrá que hacer en la segunda parte será, a partir de una línea que contenga las codificaciones falsas de todos los dígitos del cero al nueve averiguar a qué segmento corresponde cada letra.

Es un problema interesante, desde luego. El mismo enunciado da la clave para hallar cuáles son las letras que aparecen en las codificaciones del 1, 4, 7 y 8.

Tenemos que:

La letra que aparezca en la codificación del 7 y no aparezca en la del 1 ya tiene asignada el segmento 'a'.

De las dos letras que aparezcan en la codificación del 4 que no aparezcan en la del 1 habrá una que aparezca en las codificaciones con seis letras (6, el 9 y el 0). A esa se le asigna el segmento b. A la otra el segmento d.

Como ya tenemos cuál es la letra del segmento a y la del d ya podemos averiguar cuál es la del segmento g buscando cuál es la otra letra que se repite en las codificaciones del 5, del 3 y del 2. Con eso sacas la letra asociada al segmento e.

Y así...

Un saludo.

[Richard R Richard]

Veamos, si analizamos cuales son los segmentos que se encienden en cada patron y llevamos la cuenta


los que no repiten cantidad de segmentos pueden servir de guia , 1,4,7,y 8 serían faciles e identificar


pero tambien podemos hacer una tabla y ver cuantas veces repite el segmento a ,b, c, d, e,f, o g

N	R	A	B	C	D	E	F	G
R		8	6	8	7	4	9	7
0	6	X	X	X		X	X	X
1	2			X			X
2	5	X		X	X	X		X
3	5	X		X	X		X	X
4	4		X	X	X		X
5	5	X	X		X		X	X
6	6	X	X		X	X	X	X
7	3	X		X			X
8	7	X	X	X	X	X	X	X
9	6	X	X	X	X		X	X

de la tabla se concluye que


F  aparece encendido en 9 diseños de los 10
E aparece encendido solo en 4 diseños por lo que tambien es identificable
B aparece encendido solo en 6 diseños
como en el 1  aparecen encendidos solo  C y F ,  C  será justo el que no aparece en los 9 diseños
A es el que aparece además de los identificados C y F cuando en pantalla halla 3 segmentos encendidos
Solo queda identificar D y G que encienden 7 veces los en los diseños , pero D es el único que estará encendido cuando haya 4 solos encendidos en un 4


Así que no importa cómo se cambien los cables, si se identifican los 10 diseños, los almacenas en matriz,  se podrá determinar cuáles eran los segmentos encendido, se hace un algoritmos que traduzcan las verdades lógicas anteriores,   y con ello saber de que numero se trata  , pues la tabla para decodificar de A-G a 0-9 ya la he presentado

[C. Enrique B.]

.
¡Lo logré, lo conseguí! ...

... ¡Justo ahora, cinco minutos antes del límite, he conseguido ...

...

... comprender el enunciadooo!!

[cerrar]

Ok, próximo objetivo: comprender el nuevo enunciado usando "sólo" una o dos horas (sale ya, a las 06:00 surOeste europeo).



____________________


https://adventofcode.com/2021/day/9

Day 9: Smoke Basin

These caves seem to be lava tubes. Parts are even still volcanically active; small hydrothermal vents release smoke into the caves that slowly settles like rain.

If you can model how the smoke flows through the caves, you might be able to avoid it and be that much safer. The submarine generates a heightmap of the floor of the nearby caves for you (your puzzle input).

--- --- Smoke flows to the lowest point of the area it's in. For example, consider the following heightmap:

2199943210
3987894921
9856789892
8767896789
9899965678

Each number corresponds to the height of a particular location, where 9 is the highest and 0 is the lowest a location can be.

--- --- Your first goal is to find the low points - the locations that are lower than any of its adjacent locations. Most locations have four adjacent locations (up, down, left, and right); locations on the edge or corner of the map have three or two adjacent locations, respectively. (Diagonal locations do not count as adjacent.)

In the above example, there are four low points, all highlighted (ver gráfico original para observar negritas, https://adventofcode.com/2021/day/9): two are in the first row (a 1 and a 0), one is in the third row (a 5), and one is in the bottom row (also a 5). All other locations on the heightmap have some lower adjacent location, and so are not low points.

The risk level of a low point is 1 plus its height. In the above example, the risk levels of the low points are 2, 1, 6, and 6. The sum of the risk levels of all low points in the heightmap is therefore 15.

--- --- Find all of the low points on your heightmap. What is the sum of the risk levels of all low points on your heightmap?

--- --- To play, please identify yourself via one of these services:

[GitHub] [Google] [Twitter] [Reddit]
.

[geómetracat]

Muy bien martiniano y Richard. 
Pero eso solo es la mitad del trabajo... ¡ahora hay que programarlo!

Dejo el código que hice yo (en Python):

Spoiler

Código: [Seleccionar]

with open("input8.txt") as f:
    inp = [x[:-1] for x in f.readlines()]
data = [(x.split('|')[0].split(), x.split('|')[1].split()) for x in inp]

# Part 1
fourdigits = [x[1] for x in data]
print(sum([len(x) in [2,3,4,7] for x in [x for y in fourdigits for x in y]]))

# Part 2

# Segments: a: upper, b: upper left, c: upper right, d: central, e: lower left, f: lower right, g: lower

num_to_char = {0:'abcefg',
              1:'cf',
              2:'acdeg',
              3:'acdfg',
              4:'bcdf',
              5:'abdfg',
              6:'abdefg',
              7:'acf',
              8:'abcdefg',
              9:'abcdfg'}

char_to_num = {y:x for x,y in num_to_char.items()}

def find_letters(inp):
    """Given a list of the digit segment (randomized) returns
    a dict with the correspondence with the original segments (dict[random]=original)"""
    # Convert every element of the list to a set
    inp = [set(x) for x in inp]
    corr = dict()
    # Step 1: Find the letter which is in 7 (length = 3) but not in 1 (length = 2)
    a = list([x for x in inp if len(x)==3][0] - [x for x in inp if len(x)==2][0])[0]
    corr['a'] = a
    # Step 2: Find b (appears 6 times), e (appears 4 times) and f (appears 9 times)
    for char in 'abcdefg':
        x = sum([char in x for x in inp])
        if x==6:
            corr['b'] = char
        elif x==4:
            corr['e'] = char
        elif x==9:
            corr['f'] = char
    # Step 3: Find c as the only char appearing in 1 (unique set of len 2) which is not f
    corr['c'] = list([x for x in inp if len(x)==2][0] - {corr['f']})[0]
    # Step 4: Find g as the only char appearing in 0 which is not abcef
    corr['g'] = list([x for x in inp if len(x)==6 and set([corr[x] for x in 'abcef']).issubset(x)][0]\
                - {corr[x] for x in 'abcef'})[0]
    # Step 5: Find d as the remaining letter
    corr['d'] = [x for x in 'abcdefg' if x not in corr.values()][0]
    return {y:x for x,y in corr.items()}

def word_to_num(inp, corr):
    """Given a list of 4 words returns the corresponding number.
    Corr: dictionary giving the correspondences with original segments"""
    digits = []
    for x in inp:
        x = char_to_num[''.join(sorted(list({corr[y] for y in x})))]
        digits.append(x)
    return sum([10**(3-i)*digits[i] for i in range(4)])

def solve(inp):
    """Returns the sum of all 4-digit numbers"""
    nums = []
    for x,y in inp:
        corr = find_letters(x)
        nums.append(word_to_num(y,corr))
    return sum(nums)
       
print(solve(data))


[cerrar]

Acabo de hacer el de hoy, que es quizás un problema más típico que el de ayer (encontrar mínimos locales y componentes conexas en una matriz). Si a alguien le interesa pongo también el programa.

[martiniano]

Hola.

Aquí dejo unas clases en Java para lo que dije del problema 8. Releyendo el enunciado me di cuenta de que probablemente lo que había que hacer no era identificar la letra errónea con el segmento correspondiente sinó directamente cuál era el dígito correspondiente a un código incorrecto. Lo cual es un poco diferente.

Utilizo la clase Palabra para manipular cadenas de caracteres con menos caracteres que un número dado, l clase Decoder para encontrar resolver el problema real, y un main para hacer pruebas.

Un saludo.