Zulema

ago-dic-2024/Zulema/Ordenando.py

@@ -0,0 +1,45 @@
+def partition(arr, low, high, color_priority):
+    # Elegimos el último elemento como pivote
+    pivot = arr[high]
+    pivot_color = color_priority[pivot[0]]
+    pivot_level = pivot[1]
+    i = low -1 
+
+    for j in range(low, high):
+        current_color = color_priority[arr[j][0]]
+        current_level = arr[j][1]
+
+        # Comparar primero por color, luego por nivel
+        if (current_color < pivot_color) or (current_color == pivot_color and current_level <= pivot_level):
+            i += 1
+            arr[i], arr[j] = arr[j], arr[i]
+
+    arr[i + 1], arr[high] = arr[high], arr[i + 1]
+    return i + 1
+
+def quick_sort(arr, low, high, color_priority):
+    if low < high:
+        pi = partition(arr, low, high, color_priority)
+        quick_sort(arr, low, pi - 1, color_priority)
+        quick_sort(arr, pi + 1, high, color_priority)
+
+# Orden de los colores en el arco iris
+rainbow_colors = ["Rojo", "Anaranjado", "Amarillo", "Verde", "Indigo", "Violeta", "Azul"]
+color_priority = {color: index for index, color in enumerate(rainbow_colors)}
+
+# Lee entrada
+n = int(input())
+markers = []
+
+for _ in range(n):
+    s = input().strip()
+    color, level = s.split("-")
+    level = int(level)
+    markers.append((color, level))
+
+# Ordena los plumones usando Quick Sort
+quick_sort(markers, 0, n - 1, color_priority)
+
+# Imprimir la salida
+for color, level in markers:
+    print (f"{color}-{level}") 

ago-dic-2024/Zulema/OrdenandoCountingP2.py

@@ -0,0 +1,21 @@
+# leer la lista de entrada
+n = int(input().strip())
+numbers = list(map(int, input().strip().split()))
+
+# Encontrar el valor máximo en la lista para definir el tamaño del arreglo de conteo
+max_val = max(numbers)
+
+# Crear el arreglo de conteo
+conteo = [0] * (max_val + 1)
+
+# Llenar el arreglo de conteo
+for num in numbers:
+    conteo[num] += 1
+
+# Reconstruir la lista ordenada
+sorted_numbers = []
+for num in range(len(conteo)):
+    sorted_numbers.extend([num] * conteo[num])
+
+# Imprimir la lista ordenada
+print(" ".join(map(str, sorted_numbers)))

ago-dic-2024/Zulema/Practica2.py

@@ -0,0 +1,38 @@
+def insertion_sort(arr):
+    for i in range(1, len(arr)):
+        key = arr[i]
+        j = i - 1
+        while j >= 0 and key < arr[j]:
+            arr[j + 1] = arr[j]
+            j -= 1
+        arr[j + 1] = key
+
+def problemas_resueltos(n, m, tiempos):
+    insertion_sort(tiempos)
+
+    # Mostrar la lista ordenada
+    print("Lista ordenada:", tiempos)
+
+    contador = 0
+    tiempo_total = 0
+
+    for tiempo in tiempos:
+        if tiempo_total + tiempo <= m:
+            tiempo_total += tiempo
+            contador += 1
+        else:
+            break
+
+    return contador
+
+# Leer la entrada
+entrada = input("Ingresa el número de problemas y minutos disponible: ").strip().split()
+n = int(entrada[0])
+m = int(entrada[1])
+tiempos = list(map(int, input("Ingresa los tiempos para cada problema: ").strip().split()))
+
+# Obtener la cantidad de problemas que David puede resolver
+resultado = problemas_resueltos(n, m, tiempos)
+
+# Imprimir el resultado
+print("Problemas que puede resolver:", resultado)

ago-dic-2024/Zulema/Practica3.py

@@ -0,0 +1,29 @@
+def selection_sort_desc(arr):
+    n = len(arr)
+    # Recorrer todos los elementos de la lista
+    for i in range(n):
+        max_index = i  # Suponemos que el elemento más grande es el primero no ordenado
+
+        # Buscar el elemento más grande en la parte no ordenada
+        for j in range(i + 1, n):
+            if arr[j] > arr[max_index]:  # Para ordenar de mayor a menor
+                max_index = j
+
+        # Intercambiar el elemento más grande encontrado con el primero no ordenado
+        arr[i], arr[max_index] = arr[max_index], arr[i]
+
+# Leer la entrada
+n = int(input("Ingresa el número de Pokémons: ").strip())  # Número de Pokémons
+poderes = list(map(int, input("Ingresa los poderes de los Pokémons (separados por espacios): ").strip().split()))  # Lista de poderes
+
+# Mostrar entrada
+print("\nEntrada:")
+print(f"Número de Pokémons: {n}")
+print(f"Poderes: {' '.join(map(str, poderes))}")
+
+# Ordenar los poderes de mayor a menor
+selection_sort_desc(poderes)
+
+# Mostrar salida
+print("\nSalida:")
+print(" ".join(map(str, poderes)))

ago-dic-2024/Zulema/Practica4.py

@@ -0,0 +1,50 @@
+# Función de Merge Sort para ordenar las palabras
+def merge_sort(words):
+    if len(words) <= 1:
+        return words
+
+    # Dividir la lista en mitades
+    mid = len(words) // 2
+    left_half = merge_sort(words[:mid])
+    right_half = merge_sort(words[mid:])
+
+    # Mezclar las dos mitades ordenadas
+    return merge(left_half, right_half)
+
+# Función de mezcla para unir las dos mitades ordenadas
+def merge(left, right):
+    sorted_list = []
+    i = j = 0
+
+    # Comparar y mezclar
+    while i < len(left) and j < len(right):
+        if left[i] < right[j]:
+            sorted_list.append(left[i])
+            i += 1
+        else:
+            sorted_list.append(right[j])
+            j += 1
+
+    # Añadir los elementos restantes de cada mitad
+    sorted_list.extend(left[i:])
+    sorted_list.extend(right[j:])
+
+    return sorted_list
+
+# Lectura de entrada desde el estándar (STDIN)
+def main():
+    # Leer número de palabras (no se utiliza en el procesamiento)
+    n = int(input().strip())
+
+    # Leer la lista de palabras y dividirlas en una lista
+    words = input().strip().split()
+
+    # Ordenar la lista de palabras
+    sorted_words = merge_sort(words)
+
+    # Imprimir el resultado en formato requerido
+    print(" ".join(sorted_words))
+
+# Llamar a la función principal
+if __name__ == "__main__":
+    main()

ago-dic-2024/Zulema/Practica5.py

@@ -0,0 +1,55 @@
+# Implementación de Merge Sort para ordenar los libros por número de páginas
+def merge_sort(books):
+    if len(books) <= 1:
+        return books
+
+    # Dividir la lista en mitades
+    mid = len(books) // 2
+    left_half = merge_sort(books[:mid])
+    right_half = merge_sort(books[mid:])
+
+    # Mezclar las dos mitades ordenadas
+    return merge(left_half, right_half)
+
+# Función de mezcla para unir las dos mitades ordenadas
+def merge(left, right):
+    sorted_list = []
+    i = j = 0
+
+    # Comparar y mezclar según el número de páginas
+    while i < len(left) and j < len(right):
+        if left[i][1] < right[j][1]:  # Ordenar por el número de páginas
+            sorted_list.append(left[i])
+            i += 1
+        else:
+            sorted_list.append(right[j])
+            j += 1
+
+    # Añadir los elementos restantes de cada mitad
+    sorted_list.extend(left[i:])
+    sorted_list.extend(right[j:])
+
+    return sorted_list
+
+# Función principal para leer entrada y realizar el ordenamiento
+def main():
+    # Leer el número de libros
+    n = int(input().strip())
+
+    # Leer cada libro y su número de páginas
+    books = []
+    for _ in range(n):
+        line = input().strip().split()
+        book_name = line[0]
+        pages = int(line[1])
+        books.append((book_name, pages))
+
+    # Ordenar los libros usando Merge Sort
+    sorted_books = merge_sort(books)
+
+    # Imprimir el resultado solo con los nombres de los libros
+    print(" ".join(book[0] for book in sorted_books))
+
+# Llamar a la función principal
+if __name__ == "__main__":
+    main()

ago-dic-2024/Zulema/Practica6.py

@@ -0,0 +1,31 @@
+# Implementación de Quick Sort para ordenar los ids de los colores
+def quick_sort(arr):
+    if len(arr) <= 1:
+        return arr
+
+    # Seleccionar el pivote
+    pivot = arr[len(arr) // 2]
+    left = [x for x in arr if x < pivot]
+    middle = [x for x in arr if x == pivot]
+    right = [x for x in arr if x > pivot]
+
+    # Llamadas recursivas para ordenar las sublistas
+    return quick_sort(left) + middle + quick_sort(right)
+
+# Función principal para leer entrada y realizar el ordenamiento
+def main():
+    # Leer el número de colores (no se utiliza en el procesamiento)
+    n = int(input().strip())
+
+    # Leer los ids de los colores y convertirlos en una lista de enteros
+    color_ids = list(map(int, input().strip().split()))
+
+    # Ordenar los ids usando Quick Sort
+    sorted_colors = quick_sort(color_ids)
+
+    # Imprimir el resultado
+    print(" ".join(map(str, sorted_colors)))
+
+# Llamar a la función principal
+if __name__ == "__main__":
+    main()

ago-dic-2024/Zulema/ProfeEnfermo.py

@@ -0,0 +1,21 @@
+def insertion_sort(medicamentos):
+
+    for i in range(1, len(medicamentos)):
+        key = medicamentos[i]
+        j = i - 1
+
+        while j >= 0 and key < medicamentos[j]:
+            medicamentos[j + 1] = medicamentos[j]
+            j -= 1
+        medicamentos[j + 1] = key
+
+def main():
+    n = int(input(""))  
+    medicamentos = input("").split() 
+
+    insertion_sort(medicamentos)
+
+    print(" ".join(medicamentos))
+
+if __name__ == "__main__":
+    main()

ago-dic-2024/Zulema/Suma.py

@@ -0,0 +1,32 @@
+def main():
+    while True:
+        # Solicitar la entrada del usuario
+        entrada = input("Introduce dos números enteros separados por un espacio (o escribe 'salir' para terminar): ")
+
+        # Comprobar si el usuario quiere salir
+        if entrada.lower() == 'salir':
+            print("Programa terminado.")
+            break
+
+        # Dividir la entrada en partes
+        partes = entrada.split()
+
+        # Verificar que haya exactamente dos partes
+        if len(partes) == 2:
+            try:
+                # Convertir las partes a enteros
+                a = int(partes[0])
+                b = int(partes[1])
+
+                # Calcular la suma
+                suma = a + b
+
+                # Imprimir el resultado
+                print(f"La suma es: {suma}")
+            except ValueError:
+                print("Por favor, ingresa solo números enteros.")
+        else:
+            print("Entrada inválida. Asegúrate de ingresar exactamente dos números enteros.")
+
+if __name__ == "__main__":
+    main()

ago-dic-2024/Zulema/ordenar_medicinas.py

@@ -0,0 +1,31 @@
+def insertion_sort(medicinas):
+
+    for i in range(1, len(medicinas)):
+        key = medicinas[i]
+        j = i - 1
+
+        while j >= 0 and key[1] > medicinas[j][1]:
+            medicinas[j + 1] = medicinas[j]
+            j -= 1
+        medicinas[j + 1] = key
+
+
+if __name__ == "__main__":
+    n = int(input(""))
+    medicinas_data = input("").split()
+
+
+    medicinas = []
+    for i in range(n):
+        name = medicinas_data[2 * i]
+        count = int(medicinas_data[2 * i + 1])
+        medicinas.append((name, count))
+
+
+    insertion_sort(medicinas)
+
+
+    sorted_names = [med[0] for med in medicinas]
+
+
+    print(" ".join(sorted_names))