Problemas del Capítulo 3: Estructura de Datos Arrays

3.2 Arrays Unidimensionales (vectores)

Aplicaciones:

Problema 1.- Diseñar un programa que permita leer nota y sexo de n alumnos(n definido por el usuario)
y luego generar un reporte que permita conocer la cantidad de alumnos aprobados de sexo masculino.

print("Sistemas de notas vs Sexo")

print("---------------------------------")
print("M: Masculino F: Femenino")

cantidad_alumnos = int(input("Ingrese numero de alumnos: "))

cadena_alumnos=[]
for i in range(cantidad_alumnos):
print(f"Alumno{i+1}")
nota=int(input("Ingrese nota: "))
sexo= input("Ingrese sexo(M/F): ")
alumno=[nota,sexo]
cadena_alumnos.append(alumno)

for reporte in cadena_alumnos:

print(f'Nota : {nota} Sexo: {sexo}')

j=0
for reporte_masculino_aprobados in cadena_alumnos:
if nota>10 or sexo=='M':
j+=1

print("Total de Aprobados Masculino: ", j)

Problema 2.- Diseñar un programa que permita leer notas de n alumnos(n definido por el usuario) y
luego generar un reporte que permita conocer el promedio de prácticas.

print("Sistema de promedio de practicas ")

print("-----------------------------------------")
cantidad_alumnos= int(input("Ingrese la cantidad de alumnos: "))

acumulador_notas=0
contador=0
for i in range(cantidad_alumnos):
print(f"Alumno{i+1}")
nota=int(input("Ingrese nota: "))
contador+=1
acumulador_notas += nota

promedio_notas = acumulador_notas/contador

print("Promedio de practicas de los alumnos : ",promedio_notas)

Problema 3.- Diseñar un programa que permita leer números enteros y almacenarlo en un vector de
longitud n, luego generar un reporte de los elementos ordenados en forma ascendente.

longitud = int(input("Ingrese la longitud del vector: "))

print("------------------------------")
print("Ingrese los numeros: ")
cadena_vector=[]
for i in range(longitud):
vector=int(input(f'Numero {i+1} :'))
cadena_vector.append(vector)

cadena_vector.sort()
print(cadena_vector)

Problema 4.-Diseñar un programa que permita leer números enteros y almacenarlo en un vector A de
longitud n, luego:
 Generar un reporte de los elementos ordenados en forma ascendente.
 Almacenar en un vector B los elementos pares del vector A y en un vector C los elementos
impares del vector A. Asimismo, mostrar el mayor elemento del vector B y el menor elemento
del vector C.
 En un vector M, almacenar el máximo y el mínimo, según parte b) y luego solicitar al usuario que
ingrese el número de elementos a insertar en este vector. Generar un reporte para conocer los
elementos respectivos.

longitud = int(input("Ingrese la longitud del vector: "))

print("------------------------------")
print("Ingrese los numeros: ")
cadena_vector=[]
for i in range(longitud):
vector=int(input(f'Numero {i+1} :'))
cadena_vector.append(vector)
cadena_vector.sort()

lista = cadena_vector
print("------------------")
print("Reporte de los numeros: ")
m=0
for j in lista:
print(f'n{m+1} = {j}')
m+=1

print("_____________________________")
print("En el vector B => elementos pares de B")
print("En el vector C => elementos impares de A")
cadena_vector_b=[]
for element_b in lista:
if element_b % 2 == 0 :
cadena_vector_b.append(element_b)

print("Reporte de vector B")

r_b=0
for reporte_b in cadena_vector_b:
print(f'n{r_b} = {reporte_b}')
r_b+=1

max_b = max(cadena_vector_b)
print("El maximo valor del vector B es: ",max_b)

print("------------------------------")
cadena_vector_c=[]
for element_c in lista:
if element_c %2 != 0:
cadena_vector_c.append(element_c)

print("Reporte de vector C")

r_c=0
for reporte_c in cadena_vector_c:
print(f'n{r_c}= {reporte_c}')
r_c+=1

min_c = min(cadena_vector_c)
print("El maximo valor del vector C es : ", min_c)
print("-----------------------------")
print("Vector M => vector con los maximos y minimos")

vector_M = [max_b,min_c]

print(f'max = {max_b} , min = {min_c}')

Problema 5.- Diseñar un programa que permita leer números enteros y almacenarlo en un vector A de
longitud n, luego:
a).-Generar un reporte del total de elementos eliminados
b).- Generara un reporte de los elementos del vector sin repetirse.

longitud = int(input("Ingrese la longitud del vector: "))

print("------------------------------")
print("Ingrese los numeros: ")
cadena_vector=[]
for i in range(longitud):
vector=int(input(f'Numero {i+1} :'))
cadena_vector.append(vector)
cadena_vector.sort()

lista = cadena_vector
print("------------------")
print("Reporte de los numeros: ")
m=0
for j in lista:
print(f'n{m+1} = {j}')
m+=1

print("---------------------------")
print("Reporte de Elementos sin repetirse")
nuevo_vector = set(lista)
k=0
for l in nuevo_vector:
print(f'n{k+1} = {l}')
k+=1

print("El numero de eliminados en la lista es : ", m-k)

Problema 6.- Diseñar un programa que permita mostrar el total de caracteres que se repiten en el
vector inicializado: b[20]={'a','b','a','a','b','a','c','d','d' ,'d','c'}

b=['a','b','a','a','b','a','c','d','d' ,'d','c']
n=0
for i in b:
print(f'letra {n+1} = {i}')
n+=1

b2= set(b)
print(b2)

l=0
p=0
r=0
s=0

for m in b:
if m == 'a':
l+=1
elif m == 'b':
p+=1
elif m == 'c':
r+=1
elif m == 'd':
s+=1
print("----------------------------------")
print("Cantidad de veces que se repite las letras: ")
print(" # de veces de 'a' es ",l)
print(" # de veces de 'b' es ",p)
print(" # de veces de 'c' es ",r)
print(" # de veces de 'd' es ",s)

Problema 7.- Diseñar un programa que permita ingresar caracteres (letras) desde teclado. Luego
mostrar: a).- El número de veces que se repite la letra “a”.
b).- El número de veces que se repite la palabra “uní”
c).- Elementos vector sin repetirse.

print("Ingreso de letras: ")

cant_letras = int(input("Cantidad de letras: "))
vector_letras=[]
for i in range(cant_letras):
letra=input(f'letra {i+1} : ')
vector_letras.append(letra)

print(vector_letras)
m=0
for j in vector_letras:
 if j == 'a':
m+=1
vector_uni=[]
r=0
k=0
g=0
for p in vector_letras:
if p == 'u':
r+=1
elif p == 'n':
k+=1
elif p == 'i':
g+=1

print(r)
print(k)
print(g)

if r < k:
if r < g :
cantidad_uni= r
if r > g :
cantidad_uni = g
if r == g :
cantidad_uni = r

if k < r :
if k < g :
cantidad_uni = k
if k > g :
cantidad_uni = g
if k == g:
cantidad_uni = k

print("Cantidad de letra 'a' :",m)

print("Cantidad de letras 'uni' es ", cantidad_uni)

print("Vector sin repetirse: ")

vector_letras_sin_repetirse = set(vector_letras)
a=0
for t in vector_letras_sin_repetirse:
 print(f'letra {a+1} = {t}')
a+=1

Problema 8.- Diseñar un programa que permita ingresar números enteros y almacenarlo en un vector de
longitud n(n definido por el usuario), luego mostrar: Reporte de elementos ingresados Opciones en un
menú para:
a).- Insertar elementos al inicio del vector.
b).- Insertar según posición especificada por usuario.
c).- Insertar al final, cuando los datos están ordenados.

longitud = int(input("Ingrese la longitud del vector: "))

print("------------------------------")

print("Ingrese los numeros: ")

cadena_vector=[]

for i in range(longitud):

vector=int(input(f'Numero {i+1} :'))

cadena_vector.append(vector)

print("Opciones para Insertar un elemento en vector: ")

print("<p> En una posicion")

print("<f> Al final de la lista")

print("<o> Si A esta ordenada")

print("........................")

opcion = input("Edite opcion: ")

if opcion == 'p':

element = int(input("Elemento: "))

posicion = int(input("Posicion: "))

cadena_vector.insert(posicion -1 , element)

print(cadena_vector)
if opcion == 'f':

element = int(input("Elemento: "))

cadena_vector.append(element)

print(cadena_vector)

if opcion == 'o':

orden_cadena = set(cadena_vector)

print(orden_cadena)

Problema 9.- Diseñar un programa que permita leer n alumnos(n ingresado por usuario ) y por cada
alumno ingrese su práctica, luego generar un reporte que permita mostrar el promedio de prácticas de
los n alumnos.

print("Sistema de promedio de practicas ")

print("-----------------------------------------")
cantidad_alumnos= int(input("Ingrese la cantidad de alumnos: "))

acumulador_notas=0
contador=0
for i in range(cantidad_alumnos):
print(f"Alumno{i+1}")
nota=int(input("Ingrese nota: "))
contador+=1
acumulador_notas += nota

promedio_notas = acumulador_notas/contador

print("Promedio de practicas de los alumnos : ",promedio_notas)

Problema 10.- Diseñar un programa que permita leer datos de tipo entero y almacenarlo en un vector,
luego generar un reporte sin elementos repetidos.

longitud = int(input("Ingrese la longitud del vector: "))

print("------------------------------")

print("Ingrese los numeros: ")

cadena_vector=[]

for i in range(longitud):

vector=int(input(f'Numero {i+1} :'))

cadena_vector.append(vector)

j=0

print("----------------------")

for report in cadena_vector:

print(f'Elemento{j+1} = {report}')

j+=1

print("-------------------------------")

print("Vector sin repetirse")

vector_sinrepetirse = set(cadena_vector)

p=0

for report_sin_repetirse in vector_sinrepetirse:

print(f'Elemento{p+1} = {report_sin_repetirse}')

p+=1

Problema 11.- Diseñar un programa que permita leer datos de tipo entero y almacenarlo en un vector,
luego generar un reporte que permita conocer:

a).- Número de elementos eliminados (cuando se repiten).

b).- Total de elementos que quedan en el vector, después de a).

c).- Reporte ordenado de los elementos del vector después de ejecutar a).

import collections

print("Reporte de Vectores repetidos")

print("--------------------------------------")

longitud = int(input("Ingrese la longitud del vector: "))

print("------------------------------")

print("Ingrese los numeros: ")

cadena_vector=[]

for i in range(longitud):

vector=int(input(f'Numero {i+1} :'))

cadena_vector.append(vector)

print("-------------------------------")

cadena_vector_new=[]

for m in cadena_vector:

cadena_vector_new.append(m)

print("El vector: ")

print(cadena_vector)

print("--------------------------")

print("Lista sin Repeticiones")

for j in range(len(cadena_vector)-1, -1, -1):

if cadena_vector[j] in cadena_vector[:j]:

del(cadena_vector[j])

print("La lista sin repeticiones es:", cadena_vector)

repiticion = collections.Counter(cadena_vector)

print(repiticion)

for clave,valor in repiticion.items():

print(f"Se repite {valor} veces el numero {clave}")

m=set(cadena_vector_new) & set(cadena_vector)

print("---------------------------------")

print("Los numeros repitidos son: ")

for l in m:

print(l)

print("-----------------------------------")

print("Elementos ordenados después de la eliminación")

print(set(cadena_vector))

Problema 12.- Diseñar un programa que permita leer datos de tipo entero y almacenarlo en un
vector a[ ], luego generar un reporte que permita conocer:

a).- Elementos del vector.

b).- Elementos de un vector b[ ], que contiene números pares e impares positivos
c).- Elementos de un vector b[ ], que contiene números pares e impares negativos
d).- El número positivo mayor.
e).- El número menor negativo.

print("--------------------------------------")

longitud = int(input("Ingrese la longitud del vector: "))

print("------------------------------")

print("Ingrese los numeros: ")

a=[]

for i in range(longitud):

vector=int(input(f'Numero {i+1} :'))

a.append(vector)

print("Vector a : ",a)
print("-------------------------------")

print("Elementos de un vector b[ ], que contiene números pares e impares positivos")

b=[]

for positivos in a:

if positivos>= 0 :

b.append(positivos)

print("Vector b : ",b)

print("--------------------------------")

print("Elementos de un vector c[ ], que contiene números pares e impares positivos")

c=[]

for negativos in a:

if negativos<= 0 :

c.append(negativos)

print("Vector c : ", c)

print("-----------------------")

maximo= max(b)

minimo= min(c)

print("El mayor numero: ", maximo)

print("El menor numero: ", minimo)

Problema 13.- Diseñar un programa que permita leer datos de tipo entero positivos y almacenarlo en un
vector a[100 ], luego generar un reporte que permita conocer el factorial de cada elemento del vector
a[100].
print("Reporte de factorial")
print("--------------------------------------")
longitud = int(input("Ingrese la longitud : "))
print("------------------------------")
print("Ingrese los numeros: ")
cadena_vector=[]
if longitud<100:
for i in range(longitud):
vector=int(input(f'Numero {i+1} :'))
cadena_vector.append(vector)
print(cadena_vector)

else:
print("El maximo numero de la cadena es 100")

print("El factorial de cada elemento: ")

for fact_element in cadena_vector:

if fact_element==0 or fact_element==1:
print(1)
else:
if fact_element>=2:
m=1
for i in range(1,fact_element+1):
m*=i
print("el factorial del numero ",fact_element," es ",m)

Problema 14.- Diseñar un programa que permita leer datos de tipo entero positivos y almacenarlo en un
vector a[ ], luego buscar los elementos múltiplo de 5 y no de 2 y almacenarlo en un vectorm[ ], mostrar
sus elementos, la suma de éstos, así como su promedio.

print("Reporte de multiplos de 5 y no de 2: ")

print("--------------------------------------")
longitud = int(input("Ingrese la longitud del vector: "))
print("------------------------------")
print("Ingrese los numeros: ")
cadena_vector=[]
for i in range(longitud):
vector=int(input(f'Numero {i+1} :'))
cadena_vector.append(vector)

#Reporte de multiplos de y no de 2
new_cadena_vector=[]
for j in cadena_vector:
if j%5 == 0 and j%2 != 0 :
new_cadena_vector.append(j)

print(new_cadena_vector)
r=0
suma=0
print("Los numeros multiplos de 5 y no de 2")
for m in new_cadena_vector:
print(f"n{r+1} = {m}")
r+=1
suma += m

print("La suma de los numeros es: ", suma)

print("El promedio es: " , suma/r)

Problema 15.- Diseñar un programa que permita leer n alumnos, definido por usuario, luego genere
reportes para conocer:
a) Promedio general
b) Promedio de desaprobados
c) Promedio de aprobados
d ) Total alumnos con nota 20

Problema 16.- Diseñar un programa que permita leer el grado de un polinomio Pn(x)

y luego calcular para un valor x0 en x, el valor de P(x0), en la primera derivada:

P'(x0) y en la segunda derivada: P''(x0).

El polinomio es de la forma : Pn (x) = P0 + P1x + P2x2 + P2x3 +....+ Pnxn

'''

n=int(input("Ingrese el grado del polinomio : "))

x=int(input("Ingrese el valor de Xo : "))

print("Ingrese el valor de los coeficientes : \n")

p=[]

px=0

dx=0

d2x=0

for i in range(n):

num=int(input("P[%i]="%(i)))

p.append(int(num))

if x==0:

px=p[0]

else:

for i in range(n):

px=px+ p[i]*(x**i)

if (n>0):

dx = dx + p[i]*i*(x**(i-1))

if(n>1):
 d2x =d2x + p[i]*i*(i-1)*(x**(i-2))

print("\nRESULTADOS : ")

print("\t\tEl valor de P(",x,") = ",px )

print("\t\tEl valor de P'(",x,") = ",dx )

print("\t\tEl valor de P''(",x,") = ",d2x )

Problema 17.- Diseñar un programa que permita leer un número entero

positivo y luego retornar su equivalente en letras.'''

Unidad=["cero","uno", "dos","tres","cuatro","cinco", "seis", "siete", "ocho", "nueve"]

Diez=["diez", "once", "doce", "trece", "catorce", "quince", "dieciseis", "diecisiete", "dieciocho",

"diecinueve"]

Decena=["cero","diez","veinte","treinta","cuarenta", "cincuenta",
"sesenta","setenta","ochenta","noventa"]

Centena=["cien", "ciento", "doscientos", "trescientos", "cuatrocientos","quinientos", "seiscientos",

"setecientos","ochocientos", "novecientos"]

Millar= "mil";

print("CONVERTIR NUMEROS A PALABRAS")

Num=int(input("Ingrese un número menor que 100000: "))

if (Num<100000):

print("El número en letras es: ")

if (Num==0):

print(Unidad[0])

while(Num>0):

Aux=Num

if (Num<=1000):
 # Num/=1000

if (Num>0):

c=int(Num%10)

b=int((Num%100-c)/10)

a=int((Num-10*b-c)/100)

if (a>0):

if (b==0 and c==0):

print(Centena[0]," ")

else :

print(Centena[a]," ") #si 100<Num<200

if (b>0):

if (b==1):

print(Diez[c]," ") #si 10<Num<20

else:

print(Decena[b]," ") #si 1<b<10

if (c>0): #imprime las unidades

if (b>1):

print("y ")

if (b!=1):

print(Unidad[c]," ")

Num=0

if (Aux>=1000):

print(Millar," ")

Num=Aux%1000

else:

print("\n\t\tLo siento, número fuera de rango")

Problema 18.- Usando estructuras de control, diseñar un programa que permita

leer n alumnos (n>0 y n<=100) por código y nota respectivamente, los códigos
están formados solo por tres dígitos y las notas solo son validas de 0..20, inclusive.

Luego genere los siguientes reportes para conocer:

a) Mayor nota

b) Código, posición y número de veces que se repite la mayor nota

c) Secuencia de códigos y secuencia de notas respectivas (de la mayor).

Análogamente identificar la menor nota y realice los procesos anteriormente solicitados para la menor
nota.

'''

num=int(input("Ingrese el numero de alumnos (n>0 y n<=100) : "))

cod=[]

nt=[]

mayor=0

menor=20

for i in range(num):

print("\n\t\t\tAlumno ",i+1)

codigo=int(input("\tIngrese código (3cifras): "))

while codigo<100 or codigo>999:

codigo=int(input("\tIngrese codigo en el rango de 100-999 : "))

cod.append(codigo)

nota=int(input("\tIngrese nota (0-20): "))

while nota<0 or nota>20:

nota=int(input("\tIngrese nota en el rango de 0-20 : "))

nt.append(nota)

if nota>mayor:

mayor=nota

if nota<menor :
 menor = nota

mtz=[]

for i in range(num):

mtz.append([0]*3)

mtz[i][0]=cod[i]

mtz[i][1]=nt[i]

mtz[i][2]= i

#print("la matriz es : ",mtz)

nmayor=0

nmenor=0

print(" ")

print("\n\t\tmayor nota = ",mayor)

print("\tcódigo \tPosición")

for i in range(num) :

if mayor == mtz[i][1]:

nmayor = nmayor + 1

print("\t",mtz[i][0],"\t",mtz[i][2] + 1 )

print("\ttotal : ",nmayor," Alumnos")

print("\n\t\tmenor nota = ",menor)

print("\tcódigo \tPosición")

for i in range(num) :

if menor == mtz[i][1]:

nmenor = nmenor + 1

print("\t",mtz[i][0],"\t",mtz[i][2] + 1)

print("\ttotal : ",nmenor," Alumnos")

Arrays Bidimensionales

Problema 10.- Diseñar un programa que permita ingresar el número de filas y columnas, luego ingresar
datos de tipo entero y mostrar:
a).- La matriz ordenada por filas
b).- La matriz ordenada por columnas
c).- La suma acumulada por filas y por columnas
d).- Mostrar el valor mínimo y máximo de cada fila

matriz=[]

filas=int(input("Numero de filas: "))

columnas=int(input("Numero de columnas: "))

for i in range(filas):

matriz.append([])

for j in range(columnas):

matriz[i].append(int(input("Ingrese el valor de la posicion [%d,%d]: "%(i+1,j+1))))

print(matriz)

for a in range(filas):

for b in range(columnas):

min=matriz[a][b]

k=b+1

for k in range (columnas):

if matriz[a][k] > min:

min=matriz[a][k]

matriz[a][k]=matriz[a][b]

matriz[a][b]=min

print("La matriz ordenada por filas:",matriz)

for b in range(columnas):
 for a in range(filas):

min=matriz[a][b]

k=a+1

for k in range (filas):

if matriz[k][b] > min:

min=matriz[k][b]

matriz[k][b]=matriz[a][b]

matriz[a][b]=min

print("La matriz ordenada por columnas:",matriz)

import numpy as np

array = np.array(matriz)

salida = np.sum(array, axis=1)

salida2 = np.sum(array, axis=0)

maximo=np.max(matriz)

minimo=np.min(matriz)

print("La suma de sus filas es: ",salida)

print("La suma de sus columnas es:",salida2)

print("El valor maximo es:",maximo)

print("El valor minimo es:",minimo)

Problema 11.- Diseñar un programa que permita ingresar el número de filas y columnas de una matriz,
tal que permita ingresar números enteros positivos. Luego calcular el factorial de cada elemento de la
matriz, este resultado se debe ir almacenando en un vector, finalmente mostrar los resultados .
matriz2=[]

filas=int(input("Numero de filas: "))

columnas=int(input("Numero de columnas: "))

for i in range(filas):

matriz2.append([])
 for j in range(columnas):

matriz2[i].append(int(input("Ingrese el valor de la posicion [%d,%d]: "%(i+1,j+1))))

print(matriz2)

c=1

for a in range(filas):

for b in range(columnas):

num=matriz2[a][b]

if num==1:

f=1

matriz2[a][b]=f

else:

if num>1:

f=1

for c in range(1,num+1):

f=f*c

matriz2[a][b]=f

print("El factorial es ",matriz2)

Problema 14.- Diseñar un programa que permita leer n alumnos (n  200) y por cada alumno, leer
código y ocho notas de prácticas calificadas, luego se pide:
a) Calcular el promedio de prácticas (PP) eliminando las dos notas más bajas
b) Mostrar el cuadro de méritos con los siguientes datos: código, las ocho notas de prácticas y el
promedio de prácticas (PP).

num=int(input("Ingrese el numero de alumnos (n>0 y n<=100) : "))

cod=[]
nt=[]
pro=[]
mayor=0
menor=20

for i in range(num):
 print("\n\t\t\tAlumno ",i+1)
codigo=int(input("\tIngrese código: "))
cod.append(codigo)

nt.append([0]*8)
suma=0

print("\tIngrese Notas")
for j in range(8):
nota=int(input("\t\tNota %i :"%(j+1)))
nt[i][j] = nota
suma= suma + nota
pro.append(suma / 8 )

print("\tCODIGO \t\t\tnotas \t\t\tPromedio")

for i in range(num):
print(i,".-\t",cod[i],"\t", nt[i],"\t",pro[i])