Primera practica

ago-dic-2024/Max Vazquez/Examen2.py

@@ -0,0 +1,34 @@
+def quicksort(arr, left, right, key):
+    if left < right:
+        pivot_index = partition(arr, left, right, key)
+        quicksort(arr, left, pivot_index - 1, key)
+        quicksort(arr, pivot_index + 1, right, key)
+
+def partition(arr, left, right, key):
+    pivot = key(arr[right])
+    i = left - 1
+    for j in range(left, right):
+        if key(arr[j]) <= pivot:
+            i += 1
+            arr[i], arr[j] = arr[j], arr[i]
+    arr[i + 1], arr[right] = arr[right], arr[i + 1]
+    return i + 1
+
+def ordenar_plumones(n, plumones):
+    arcoiris = ["Rojo", "Anaranjado", "Amarillo", "Verde", "Indigo", "Violeta", "Azul"]
+    color_index = {color: i for i, color in enumerate(arcoiris)}
+
+    plumones_tuplas = [
+        (color.split('-')[0], int(color.split('-')[1]))
+        for color in plumones
+    ]
+
+    quicksort(plumones_tuplas, 0, n - 1, key=lambda x: (color_index[x[0]], x[1]))
+
+    return [f"{color}-{nivel}" for color, nivel in plumones_tuplas]
+
+# Ejemplo de uso:
+n = 5
+plumones = ["Anaranjado-34", "Indigo-3", "Rojo-43", "Indigo-0", "Anaranjado-44"]
+resultado = ordenar_plumones(n, plumones)
+print("\n".join(resultado))

ago-dic-2024/Max Vazquez/Examen2_1.py

@@ -0,0 +1,18 @@
+def counting_sort(n, numeros):
+    max_num = max(numeros)  
+    count = [0] * (max_num + 1)  
+
+    for numero in numeros:
+        count[numero] += 1  
+
+    sorted_list = []
+    for i in range(len(count)):
+        sorted_list.extend([i] * count[i])  
+
+    return sorted_list
+
+# Ejemplo de uso:
+n = 6
+numeros = [7, 5, 15, 3, 6, 1]
+resultado = counting_sort(n, numeros)
+print(" ".join(map(str, resultado)))

ago-dic-2024/Max Vazquez/Pokemon.py

@@ -0,0 +1,23 @@
+def selection_sort_desc(arr):
+    # Recorremos la lista para ordenar de mayor a menor
+    n = len(arr)
+    for i in range(n):
+        # Suponemos que el máximo está en la posición actual
+        max_idx = i
+        # Buscamos el valor más grande en el resto de la lista
+        for j in range(i + 1, n):
+            if arr[j] > arr[max_idx]:
+                max_idx = j
+        # Intercambiamos el valor más grande encontrado con el valor actual
+        arr[i], arr[max_idx] = arr[max_idx], arr[i]
+    return arr
+
+# Lectura de entrada
+n = int(input())  # Número de Pokémons
+cp_list = list(map(int, input().split()))  # Lista de CPs
+
+# Ordenamos la lista usando selection sort en orden descendente
+sorted_cp = selection_sort_desc(cp_list)
+
+# Imprimimos la lista ordenada
+print(" ".join(map(str, sorted_cp)))

ago-dic-2024/Max Vazquez/Practica_1.py

@@ -0,0 +1,11 @@
+# Solicitar la entrada del usuario
+entrada = input("Introduce dos enteros separados por un espacio: ")
+
+# Dividir la entrada en dos partes y convertirlas a enteros
+num1, num2 = map(int, entrada.split())
+
+# Calcular la suma
+suma = num1 + num2
+
+# Imprimir el resultado
+print("Resultado:", suma)

ago-dic-2024/Max Vazquez/Practica_2.py

@@ -0,0 +1,38 @@
+def insertion_sort(arr):
+    # Implementamos el algoritmo Insertion Sort
+    for i in range(1, len(arr)):
+        key = arr[i]
+        j = i - 1
+        # Mover los elementos de arr[0...i-1] que son mayores que key
+        # a una posición adelante de su posición actual
+        while j >= 0 and arr[j] > key:
+            arr[j + 1] = arr[j]
+            j -= 1
+        arr[j + 1] = key
+
+def max_problems_solved(n, m, problem_times):
+    # Ordenamos los tiempos de los problemas usando Insertion Sort
+    insertion_sort(problem_times)
+
+    total_time = 0
+    problems_solved = 0
+
+    # Iteramos sobre la lista de tiempos ordenada
+    for time in problem_times:
+        if total_time + time <= m:
+            total_time += time
+            problems_solved += 1
+        else:
+            break
+
+    return problems_solved
+
+# Leer los valores de entrada
+n, m = map(int, input().split())
+problem_times = list(map(int, input().split()))
+
+# Obtener el número máximo de problemas que David puede resolver
+result = max_problems_solved(n, m, problem_times)
+
+# Imprimir el resultado
+print(result)

ago-dic-2024/Max Vazquez/Primer_Parcial.py

@@ -0,0 +1,20 @@
+# Función para implementar el algoritmo Bubble Sort
+def bubble_sort(arr):
+    n = len(arr)
+    # Iterar sobre cada elemento de la lista
+    for i in range(n):
+        # Últimos i elementos ya están en su lugar
+        for j in range(0, n-i-1):
+            # Intercambiar si el elemento actual es mayor que el siguiente
+            if arr[j] > arr[j+1]:
+                arr[j], arr[j+1] = arr[j+1], arr[j]
+
+# Paso 1: Leer la entrada STDIN
+n = int(input())  # Leemos el número de medicamentos (aunque no es necesario usar 'n')
+medicinas = input().split()  # Leemos los nombres de las medicinas y las dividimos en una lista
+
+# Paso 2: Ordenar la lista usando Bubble Sort
+bubble_sort(medicinas)
+
+# Paso 3: Imprimir la lista ordenada STDOUT
+print(" ".join(medicinas))

ago-dic-2024/Max Vazquez/Primer_Parcial_2.py

@@ -0,0 +1,16 @@
+# Ejercicio numero 2
+# Leer el número de medicamentos
+n = int(input())
+
+# Leer la lista de medicamentos y sus cantidades
+data = input().split()
+
+# Crear una lista de tuplas (medicina, cantidad)
+medicinas = [(data[i], int(data[i+1])) for i in range(0, 2*n, 2)]
+
+# Ordenar la lista de mayor a menor según la cantidad de pastillas
+medicinas_ordenadas = sorted(medicinas, key=lambda x: x[1], reverse=True)
+
+# Imprimir solo los nombres de las medicinas en el orden correcto
+resultado = [medicina[0] for medicina in medicinas_ordenadas]
+print(' '.join(resultado))

ago-dic-2024/Max Vazquez/Programa_2.py

@@ -0,0 +1,17 @@
+def ordenar_por_insercion(lista): 
+    for i in range(1, len(lista)):       
+        valor_actual = lista[i]
+        j = i - 1          
+        while j >= 0:
+            if lista[j] > valor_actual:               
+                lista[j + 1] = lista[j]
+                j -= 1
+            elif lista[j] <= valor_actual:                
+                break
+            else:   
+                pass
+        lista[j + 1] = valor_actual
+    return lista
+numeros = [99, 38, 78, 25, 82, 101]
+ordenados = ordenar_por_insercion(numeros)
+print("Lista ordenada:", ordenados)