Taller Estructuras de Datos Lineales

Universidad Nacional de Colombia

2023-2S
Presentado por: Manuel Nicolás Castiblanco Avendaño

1. Para abordar el primer problema "Menor altura más cercana", se optó por
utilizar una estructura de datos lineal, en este caso una lista (array), la cual
fue definida mediante la creación de la clase ‘Lista’. Esta clase presenta
una serie de métodos funcionales append, pop, print, y get_item. Los dos
últimos métodos, print y get_item, son especialmente relevantes ya que
permiten imprimir los elementos de la lista separados por espacios, tal
como se requiere en el enunciado, y obtener un elemento específico de la
lista según su índice, respectivamente. La implementación se llevó a cabo
en el lenguaje de programación Python.
Código de la solución planteada
class Lista():
def __init__(self):
"""
Constructor de la clase Lista.
Inicializa una lista vacía llamada 'items'.
"""
self.items: list = []

def empty(self):
return len(self.items) == []

def append(self, item):

"""
Agrega un elemento a la lista 'items'.

Args:
item: El elemento que se va a agregar a la lista.

Si 'item' es un entero, se agrega a la lista.

Si 'item' es una lista, sus elementos se extienden en la lista.

Returns:
None
"""
if isinstance(item, int):
self.items.append(item)
 elif isinstance(item, list):
self.items.extend(item)

def pop(self):
"""
Elimina y devuelve el último elemento de la lista 'items'.

Returns:
El último elemento de la lista 'items', o None si la lista está
vacía.
"""
if not self.empty():
return self.items.pop()
return None

def print(self):
"""
Imprime los elementos de la lista 'items' como una cadena de texto.

Returns:
None
"""
print(" ".join(map(str, self.items)))

def get_item(self, value):

"""
Obtiene un elemento de la lista 'items' en la posición especificada.

Args:
value: La posición del elemento que se desea obtener.

Returns:
El elemento en la posición 'value' de la lista 'items'.
"""
return self.items[value]

def encontrar_menor_altura(n:int, entrada:list):

if 1 <= n <= 2*(10**5):
alturas = Lista()
resultado = Lista()
alturas.append(entrada)

for i in range(n):
j = i - 1
while j >= 0 and alturas.get_item(j) >= alturas.get_item(i):
 j = resultado.get_item(j) - 1
resultado.append(j + 1)

resultado.print()

n = int(input())
entrada = list(map(int, input().split()))
encontrar_menor_altura(n, entrada)

Función ‘encontrar_menor_altura’
Esta función nos ayudará a encontrar el índice del valor menor a la izquierda que
tiene cada número en una lista. Para lograr esto, primero haremos una verificación
del valor de n (1 ≤n ≤ 2 ∙105 ¿, luego crearemos un array que almacenará los valores
separados por comas de la entrada que ha ingresado el usuario, también
crearemos un array con el nombre de resultado, que nos irá guardando el índice
del valor menor más cercano a la izquierda de cada número.
Posteriormente, inicializaremos un ciclo for de 0 a n-1, para cada ciclo tendremos
una variable i y una variable j, que nos irán dando un valor de True o False
(dependiendo de si el elemento a la izquierda (posición j) del número que estamos
evaluando es menor o no), el valor de j irá disminuyendo hasta encontrar un valor
menor o igual al número que estamos evaluando, de lo contrario el ciclo While
también se romperá sí j alcanza un valor de -1 (indicando que ya se recorrieron
todos los elementos de la izquierda). Cuando el ciclo While termina, agregamos a
la lista resultados nuestra variable j + 1 (agregamos este número 1 ya que, los
índices de la lista alturas van desde 1 hasta n). Por último, cuando el ciclo for
termine su ejecución por completo, mostraremos en consola todos los valores de
los índices almacenados en la lista resultados, dando una solución a nuestro
problema.
Es importante resaltar que el UNcode estuvo presentando fallas para este
problema, dejando presentar un número máximo de intentos, en mi caso tres (de
los cuales obtuve como máxima calificación 38.46%). Sin embargo, me comuniqué
con la monitora del curso para notificar el fallo de la plataforma y me dio la
siguiente respuesta (para esta última implementación de código).