CAPITULO 4

Unidad 22
Q1.
El documento HTML consta de muchas etiquetas, como se muestra a continuación. Escriba
un programa que coincida con las etiquetas de documentos HTML.

TIP
En Python, el método find() se usa para ubicar la posición inicial de la subcadena.
Encuentre '<' y '>' para distinguir las etiquetas de documentos HTML.
Si la etiqueta distinguida incluye '/', entonces es una etiqueta abierta y, si no, es una
etiqueta cerrada. Verifique la coincidencia de la etiqueta HTML de una manera similar al
uso de una pila para hacer coincidir los paréntesis.
text= input('Ingrese la cadena del documento HTML: ')

Ingrese la cadena del documento HTML: <p>Mi gato es

<strong>muy</strong> gruñon.</p>

#SOLUCIÓN 1.
start=text.find('<')
while start != -1:
end= text.find('>',start +1)
tag=text[start:end+1]
print(tag,end=' ')
start=text.find('<',end+1)

<p> <strong> </strong> </p>

#SOLUCIÓN 2.
import re

def encontrar_etiquetas(html):
patron = re.compile("<.*?>")

etiquetas = patron.findall(html)

return etiquetas
html = text
encontrar_etiquetas(html)

['<p>', '<strong>', '</strong>', '</p>']

Unidad 23
Q1.
Consulte la definición de clase de la siguiente manera para completar y probar la clase
Deque.
Una cola es un tipo de datos abstracto donde solo es posible agregar en un lado y solo es
posible eliminar en el otro lado.
Por el contrario, la cola de doble terminación (Deque) es la estructura de datos en la que es
posible agregar y eliminar en ambos lados.

class Deque:
def __init__(self):
self.queue =[]

def is_empty(self):
return True if len(self.queue)==0 else False

def add_first(self,item):
return self.queue.insert(0,item)

def remove_first(self):
return None if self.is_empty() else self.queue.pop(0)

def add_last(self,item):
return self.queue.append(item)

def remove_last(self):
return None if self.is_empty() else self.queue.pop()
lista=Deque()
lista.add_first(1)
print("Adición al inicio")
print(lista.queue)
lista.add_first(2)
print(lista.queue)
lista.add_first(3)
print(lista.queue)
lista.add_first(4)
print(lista.queue)
print(" ")

print("Eliminar al inicio")
lista.remove_first()
print(lista.queue)
lista.remove_first()
print(lista.queue)
print(" ")

print("Adición al final")
lista.add_last(3)
print(lista.queue)
lista.add_last(4)
print(lista.queue)
print(" ")

print("Remover al final")
lista.remove_last()
print(lista.queue)
lista.remove_last()
print(lista.queue)

Adición al inicio
[1]
[2, 1]
[3, 2, 1]
[4, 3, 2, 1]

Eliminar al inicio
[3, 2, 1]
[2, 1]

Adición al final
[2, 1, 3]
[2, 1, 3, 4]

Remover al final
[2, 1, 3]
[2, 1]

Unidad 24
Q1.
Escriba un programa para contar cuántas veces se usó una palabra específica en la oración
ingresada por el usuario.
En la oración ingresada por el usuario, una palabra se distingue por la presencia de
espacios.
• Use la función input().split() para crear la lista S que tiene cada cadena como su
elemento.
• Use la función input() para recibir la palabra que el usuario buscará y guárdela en x.
• La función word_count() recibe S y x como parámetros y proporciona un retorno
contando cuántas x están presentes en la S.

def word_count(lista,letra):
contador=0
for i in lista:
if i==letra:
contador+=1
return contador

s=list(input('Ingrese una oración: ').split())

x=input('Ingrese la letra a buscar: ')
count=word_count(s,x)
print(f'En la lista S, {x} aparece {count} veces.')

Ingrese una oración: the quick brown fox jumps over the lazy dog
Ingrese la letra a buscar: the
En la lista S, the aparece 2 veces.

Unidad 25
Q1.
Si se proporciona una lista ordenada de números y un número entero aleatorio x,
implemente la función que devuelve la ubicación del índice donde se insertará x. Sin
embargo, S debe ser una lista ordenada incluso después de insertar x.
nums=[10,20,40,50,60,80]
x=int(input('Ingrese un número para ser insertado: '))

def insertar (lista,x):

mini = 0
supe = len(lista)
while mini<supe:
mitad=(mini+supe)//2
if lista[mitad]==x:
return mitad
 elif lista[mitad]<x:
mini=mitad+1
elif lista[mitad]>x:
supe=mitad
return mitad

pos=insertar(nums,x)
print(f'x={x} dese ser insertado en la posición {pos}.')
nums.insert(pos,x)
print(nums)

Ingrese un número para ser insertado: 28

x=28 dese ser insertado en la posición 2.
[10, 20, 28, 40, 50, 60, 80]

#repaso
from random import randint

myArray = [12, 15,17,20,30,45,68,90]

numeroGenerado = randint(myArray[0], myArray[-1])
print(myArray)
def buscarNumero(nums, x):
# nums: Lista Ordenada de numeros enteros donde vamos a realizar
la búsqueda
# x: Número que vamos a buscar en la lista nums

low,high = 0, len(nums)
while low<high:
mid = (high+low)//2
if nums[mid] == x:
return mid
elif nums[mid] > x:
high = mid - 1
else:
low = mid + 1
return -1
print('El número generado es:'+ str(numeroGenerado))
print(buscarNumero(myArray,numeroGenerado))

[12, 15, 17, 20, 30, 45, 68, 90]

El número generado es:21
-1

Unidad 26
Q1.
Cree un convertidor que convierta números arábigos en números romanos utilizando la
tabla hash que se proporciona a continuación.
def arabic_to_roman(number):
roman_dict = {1000:'M', 900:'CM', 500:'D', 400:'CD',
100:'C', 90:'XC', 50:'L', 40:'XL',
10:'X', 9:'IX', 5:'V', 4:'IV', 1:'I'}
romano_ans = ''
for value, numero in sorted(roman_dict.items(), reverse=True):
while number >= value:
romano_ans += numero
number -= value
return romano_ans

numero=int(input("Ingrese un numero arabigo para convertirlo en número

romano:"))

print(numero,":",arabic_to_roman(numero))

Ingrese un numero arabigo para convertirlo en número romano:150

150 : CL

CAPITULO 5
Unidad 27
Q1.
¿Cuántas operaciones de intercambio se han ejecutado en el proceso de ordenamiento de
burbujas siguiente?
def burbuja(S):
n = len(S)
contador=0
for i in range(n):
contador+=1
for j in range(n - 1):
if S[j] > S[j + 1]:
S[j], S[j + 1] = S[j + 1], S[j]
return print("Operaciones de comparación:",contador)

lista=[5,4,3,7,9,6,10,8]
burbuja(lista)
print(lista)

Operaciones de comparación: 8
[3, 4, 5, 6, 7, 8, 9, 10]

Q2.
¿Cuántas operaciones de comparación se han ejecutado en el proceso de ordenamiento por
inserción que se muestra a continuación?
def clasificación_por_inserción2(S):
n = len(S)
for i in range(1, n): #i= 1,2,3,4,5
x = S[i]
j = i - 1 #s[j=0,1,2,3,4 este es el indice
contador=0
while j >= 0 and S[j] > x: #
contador+=1
S[j + 1] = S[j]
j -= 1
S[j + 1] = x
contador+=1
return print ("Operaciones de comparación:",contador)
S = [50, 30, 40, 10, 20]
clasificación_por_inserción2(S)
print(S)

Operaciones de comparación: 4
[10, 20, 30, 40, 50]

Q3.
El uso de un algoritmo de clasificación permite determinar fácilmente si se trata de un
anagrama o no.
• Cree una función que evalúe los anagramas utilizando la función sorted()
incorporada de Python.
• Modificar la función selection_sort2() para crear una función que determine los
anagramas.
• Modificar la función insertion_sort2() para crear una función que determine el
anagrama.
def organizar(palabra):
organizada_palabra=sorted(palabra)
return (organizada_palabra)

def is_anagram (palabra1,word1):

if organizar(palabra1)==organizar(word1):
return True
else:
return False

print(is_anagram("listen","silent"))
print(is_anagram("anagram","nagaram"))
print(is_anagram("listen","silence"))
print(is_anagram("anagram","anagrams"))

True
True
False
False
def burbuja(S):
n = len(S)
for i in range(n):
for j in range(n -1):
if S[j] > S[j +1]:
S[j], S[j + 1] = S[j + 1], S[j] #🔵

def is_anagram (palabra1,word1):

pal=list(palabra1)
wor=list(word1)
if burbuja(pal)==burbuja(wor):
return True
else:
return False

print(is_anagram("listen","silent"))
print(is_anagram("anagram","nagaram"))
print(is_anagram("listen","silence"))
print(is_anagram("anagram","anagrams"))

a=list("silent")
b=list("anagrams")
print(burbuja(a))
print(burbuja(b))

True
True
True
True
None
None

Unidad 28
Q1.
Dadas N listas ordenadas como entrada, escribe un programa que las fusione en una lista
ordenada.
def divide_venceras(lista):

if len(lista)>1:
mitad=len(lista)//2
primera_mitad=lista[:mitad]
segunda_mitad=lista[mitad:]

divide_venceras(primera_mitad)
 divide_venceras(segunda_mitad)
i=0
j=0
k=0

while i<len(primera_mitad) and j<len(segunda_mitad):

if primera_mitad[i]<segunda_mitad[j]:
lista[k]=primera_mitad[i]
i+=1
else:
lista[k]=segunda_mitad[j]
j+=1
k+=1

while i<len(primera_mitad):
lista[k]=primera_mitad[i]
i+=1
k+=1

while j<len(segunda_mitad):
lista[k]=segunda_mitad[j]
j+=1
k+=1
return(lista)

def convertidor(s):
manzana = [elemento[0] for elemento in s]
s=manzana
return(s)

def fusion_multiple(n):
t=divide_venceras(n)
l=convertidor(t)
return(l)

N = int(input("Ingrese la cantidad de números que quiere tener en la

lista: "))
lista_de_numeros = []
for i in range(N):
numeros = list(map(int, input("Ingrese los números que quiere
organizar: ").split()))
print(numeros)
lista_de_numeros.append(numeros)

ordenada = fusion_multiple(lista_de_numeros)
print("Fusionada dentro : ", ordenada)

Ingrese la cantidad de números que quiere tener en la lista: 5

Ingrese los números que quiere organizar: 9
[9]
Ingrese los números que quiere organizar: 7
[7]
Ingrese los números que quiere organizar: 6
[6]
Ingrese los números que quiere organizar: 1
[1]
Ingrese los números que quiere organizar: 5
[5]
Fusionada dentro : [1, 5, 6, 7, 9]

Unidad 29
Q1.
Escriba un algoritmo que encuentre el Kº elemento mayor, dados N elementos
desordenados. Después de resolver el problema con los dos métodos anteriores, analiza
qué algoritmo es más eficiente.
def ordenamiento_rapido1(S, bajo, alto):
if bajo < alto:
print(S)
punto_pivote = particion1(S, bajo, alto)
ordenamiento_rapido1(S, bajo, punto_pivote - 1)
ordenamiento_rapido1(S, punto_pivote + 1, alto)

def particion1(S, low, high):

pivote = S[low]
izquierda, derecha = low + 1, high
while izquierda < derecha:
print(S)
while izquierda <= derecha and S[izquierda] <= pivote:
izquierda += 1
while izquierda <= derecha and S[derecha] >= pivote:
derecha -= 1
if izquierda < derecha:
S[izquierda], S[derecha] = S[derecha], S[izquierda]
punto_pivote = derecha
S[low], S[punto_pivote] = S[punto_pivote], S[low]
return punto_pivote

def Num_max(lista):
organizador=ordenamiento_rapido1(lista, 0, len(lista) - 1)
return(lista[-1])

S = [7,3,1,4,10,2,11,5,6,9,8]
print("El número mayor es",Num_max(S))
import time
print("El tiempo que demora el programa {0:0.3f}".format(time.time()))
[7, 3, 1, 4, 10, 2, 11, 5, 6, 9, 8]
[7, 3, 1, 4, 10, 2, 11, 5, 6, 9, 8]
[7, 3, 1, 4, 6, 2, 11, 5, 10, 9, 8]
[7, 3, 1, 4, 6, 2, 5, 11, 10, 9, 8]
[5, 3, 1, 4, 6, 2, 7, 11, 10, 9, 8]
[5, 3, 1, 4, 6, 2, 7, 11, 10, 9, 8]
[5, 3, 1, 4, 2, 6, 7, 11, 10, 9, 8]
[2, 3, 1, 4, 5, 6, 7, 11, 10, 9, 8]
[2, 3, 1, 4, 5, 6, 7, 11, 10, 9, 8]
[2, 1, 3, 4, 5, 6, 7, 11, 10, 9, 8]
[1, 2, 3, 4, 5, 6, 7, 11, 10, 9, 8]
[1, 2, 4, 3, 5, 6, 7, 11, 10, 9, 8]
[1, 2, 4, 3, 5, 6, 7, 11, 10, 9, 8]
[1, 2, 4, 3, 5, 6, 7, 8, 10, 9, 11]
[1, 2, 4, 3, 5, 6, 7, 8, 10, 9, 11]
[1, 2, 4, 3, 5, 6, 7, 8, 10, 9, 11]
El número mayor es 11
El tiempo que demora el programa 1680898878.877

def ordenamiento_rapido2(S, low, high):

if low < high:
punto_pivote = particion2(S, low, high)
ordenamiento_rapido2(S, low, punto_pivote - 1)
ordenamiento_rapido2(S, punto_pivote + 1, high)

from random import randint

def particion2(S, low, high):
rand = randint(low, high)
S[low], S[rand] = S[rand], S[low]
pivote, izquierda, derecha = S[low], low, high
print(S, izquierda, derecha, "Pivote = ", pivote)
while izquierda <derecha:
while izquierda < high and S[izquierda] <= pivote:
izquierda += 1
while derecha > low and pivote <= S[derecha]:
derecha -= 1
if izquierda < derecha:
S[izquierda], S[derecha] = S[derecha], S[izquierda]
S[low], S[derecha] = S[derecha], S[low]
return derecha
S = [7,3,1,4,10,2,11,5,6,9,8]

def Num_max2(lista):
organizador=ordenamiento_rapido2(lista, 0, len(lista) - 1)
return(lista[-1])

S = [7,3,1,4,10,2,11,5,6,9,8]
print("El número mayor es",Num_max2(S))
import time
print("El tiempo que demora el programa :
{0:0.3f}".format(time.time()))

[4, 3, 1, 7, 10, 2, 11, 5, 6, 9, 8] 0 10 Pivote = 4

[2, 3, 1, 4, 10, 7, 11, 5, 6, 9, 8] 0 2 Pivote = 2
[1, 2, 3, 4, 10, 7, 11, 5, 6, 9, 8] 4 10 Pivote = 10
[1, 2, 3, 4, 7, 9, 8, 5, 6, 10, 11] 4 8 Pivote = 7
[1, 2, 3, 4, 6, 5, 7, 8, 9, 10, 11] 4 5 Pivote = 6
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] 7 8 Pivote = 8
El número mayor es 11
El tiempo que demora el programa : 1680898889.650

#Según el tiempo entre el primer progrma y el segundo, el primero lo

resuleve en menor tiempo
#sin embargo si se vuelve a cargar a veces los valores son diferenetes
y el primero es más lento que el segundo
#Por lo tanto no se puede decir cual es más rapido.

CAPITULO 6
Unidad 30
Q1.
En el problema del intercambio de monedas, supongamos que hay una moneda de 400
wones.
Si es así, escriba el resultado de cómo el algoritmo coin_change() determinará el cambio de
la moneda de 800 wones.

Respuesta

Monedas:[500, 400, 100, 50, 10]

Posición: 500-0 400-1 100-2 50-3 10-4
cambio=[ ] mas_grande=0 valor a cambiar=800

1.
valor a cambiar < monedas(mas_grande), 800 < 500=False
cambio=[monedas(mas_grande),500] valor a cambiar-cambio= 800-500 = 300

2.
valor a cambiar < monedas(mas_grande), 300 < 500=True mas_grande+=1 mas_grande=1

3.
valor a cambiar < monedas(mas_grande), 300 < 400=True mas_grande+=1 mas_grande=2
4.
valor a cambiar < monedas(mas_grande), 300 < 100=False
cambio=[monedas(mas_grande),500,monedas(mas_grande),100]...[ 500+100] valor a
cambiar-cambio= 300-100 = 200

5.
valor a cambiar < monedas(mas_grande), 200 < 100=False
cambio=[monedas(mas_grande),500,monedas(mas_grande),100,monedas(mas_grande),10
0]...[ 500+100+100] valor a cambiar-cambio= 200-100 = 100

6.
valor a cambiar < monedas(mas_grande), 100 < 100=False
cambio=[monedas(mas_grande),500,monedas(mas_grande),100,monedas(mas_grande),10
0,monedas(mas_grande),100]...[ 500+100+100+100] valor a cambiar-cambio= 100-100 = 0

7.
Valor a cambiar=0 return cambio cambio=[500+100+100+100]
def coin_change(coins, amount):
changes = []
largest = 0
while(amount > 0):
if amount < coins[largest]:
largest +=1
else:
changes.append(coins[largest])
amount -=coins[largest]
return changes

coins = [500,400, 100, 50, 10]

amount = int(input('Ingrese la cantidad:'))
changes = coin_change(coins, amount)
print('Ingrese la cantidad:', amount)
print(changes, len(changes))

Ingrese la cantidad:800
Ingrese la cantidad: 800
[500, 100, 100, 100] 4

Q2.
Suponga que el número de monedas en el problema de intercambio de monedas no es
infinito. Por ejemplo, si tiene las siguientes monedas en su billetera, ¿cómo debe distribuir
710 won como cambio?
def coin_change(coins, amount):
llavescoins = [500, 100, 50, 10]
 changes = []
largest = 0
while(amount > 0):
if amount < llavescoins[largest]:
largest +=1
elif coins[llavescoins[largest]]>0:
changes.append(llavescoins[largest])
amount -=llavescoins[largest]
coins[llavescoins[largest]]-=1
else:
largest +=1
return changes

monedas={500:1,100:1,50:3,10:2}
amount = int(input('Ingrese la cantidad del cambio que necesita:'))
changes = coin_change(monedas, amount)
print("Estas son las monedas que debe devolver:",changes,
len(changes))

Ingrese la cantidad del cambio que necesita:710

Estas son las monedas que debe devolver: [500, 100, 50, 50, 10] 5

Q2.
Dada la cantidad de monedas y la cantidad de cambio, encuentre la cantidad mínima de
monedas que puede devolver como cambio.
def coin_change(coins, amount):
llavescoins = [500, 100, 50, 10]
changes = []
largest = 0
while(amount > 0):
if amount < llavescoins[largest]:
largest +=1
elif coins[llavescoins[largest]]>0:
changes.append(llavescoins[largest])
amount -=llavescoins[largest]
coins[llavescoins[largest]]-=1
else:
largest +=1
return changes

monedas={500:1,100:1,50:3,10:2}
amount = int(input('Ingrese la cantidad del cambio que necesita:'))
changes = coin_change(monedas, amount)
print("La cantidad minima de monedas que debe devolver es de
",len(changes),"monedas")

Ingrese la cantidad del cambio que necesita:710

La cantidad minima de monedas que debe devolver es de 5 monedas