INFORME LABORATORIO 1 – FUNCIONES, CICLOS Y

ARREGLOS
Nombre autores, Máxima formación académica
Resumen — En el presente informe se evidencia el Figura 2. Diagrama de flujo Estructura For
desarrollo del laboratorio No 2, el cual hace uso de ciclos,
arreglos y funciones para dar solución a problemáticas
básicas. Así mismo, se exponen las pruebas realizadas de
cada programa, análisis de resultados y conclusiones.

Palabras clave — Ciclos, bucles, arreglos, funciones,

programación

Abstract— This report shows the development of

laboratory No. 2, which makes use of cycles, arrangements
and functions to solve basic problems. Likewise, the tests
carried out for each program, analysis of results and
conclusions are exposed.

Keywords— Loops, arrangements, functions,

programming

MARCO TEORÍCO
Fuente: Fundamentos de Programación con el Lenguaje de
Programación C++, 2017.
A. Ciclos
Los ciclos son conocidos también como sentencias
de interacción o bucles que permiten repetir la
ejecución de un grupo de sentencias bajo ciertas B. Arreglos
condiciones. Estas estructuras de control funcionan
Los arreglos se encuentran dentro de los tipos
bajo una expresión lógica que decide si se continua o
compuestos de datos, que permiten la agregación de
detiene el bucle en cuestión [1]. Los diagramas de
elementos del mismo tipo [1]. Estos objetos tienen un
flujo que los describen se muestran a continuación:
límite de elementos cuando es definido[2].
Figura 1. Diagrama de flujo Estructura While.
Figura 3 Estructura de un Arreglo

A B C D E F

0 1 2 3 4 5
Fuente: Elaboración Propia

C. Funciones

Las funciones permiten la separación un programa

en módulos que permiten fraccionar el problema a
Fuente: Fundamentos de Programación con el Lenguaje de resolver en problemas más pequeños, con el fin de
Programación C++, 2017. facilitar la resolución. Las funciones se componen de
nombre, parámetros de entrada y retorno[3].
 DESARROLLO DEL CÓDIGO for i in am:
Am+=i
A. Programa 1. proAm=Am/len(am)
#print(proAm)
dic={}#Diccionario donde se guardan las respuestas
#Generar lista de promedios encontrados
cliente=input("ingrese su nombre o x para consultar promedio: ") promed=[('atencion: ', proAt), ('calidad: ', proCal), ('justicia:
print('calificar de 1 a 10 los siguientes aspectos (1 pesimo, 10 ',proJus),
excelente):') ('ambiente: ', proAm)]
while cliente!='x':
atencion=int(input('Atencion de parte de los empleados: ')) #ORdenamiento de la lista de mayor a menor
calidad=int(input('Calidad comida: ')) promed.sort(key=lambda x: x[1], reverse=True)
justicia=int(input('Justicia del precio (¿el precio que pago le #print(promed)
parece justo?): '))
ambiente=int(input('Ambiente (¿muebles comodos?,¿musca for i in promed:#Mostrar los promedios
adecuada?, etc. ): ')) print(i[0], i[1])
dic[cliente]=[atencion, calidad, justicia, ambiente]

cliente=input("Ingrese su nombre o x para consultar promedio: B. Programa 2.

")
print('calificar de 1 a 10 los siguientes aspectos (1 pesimo, 10 #Definición de los arreglos
excelente):') num=int(input('ingrese el tamaño del arreglo: '))
#print(dic) numeros=[]
pares=[]
print('promedio de aspectos segun clientes: ') impa=[]

#Declaración de arreglos vacíos for i in range(num):#Asignación de valores del arreglo

aten=[] numero=int(input(f"ingrese el valor de la posicion {i}: "))
cal=[] numeros.append(numero)
jus=[] print(numeros)
am=[]
for i in dic:#Se recorre el diccionario para separar las respuestas
aten.append(dic[i][0]) #Separación de posiciones pares e impares
cal.append(dic[i][1]) for i in range(len(numeros)):
jus.append(dic[i][2]) if i%2==0:
am.append(dic[i][3]) pares.append(numeros[i])
else:
#Inicialización de variables para promedio impa.append(numeros[i])
At=0
proAt=0
Cal=0 part=False#Variable para identificar si es partidario
proCal=0 for par in pares:#Recorrido de lista de posiciones pares
Jus=0 for imp in impa:#Recorrido de la lista de posiciones impares
proJus=0 if(par>imp):#Verificación de que el valor de la posición par es
Am=0 mayor a todas las impares
proAm=0 part=True
else:
#Cálculo del promedio por aspecto part=False
for i in aten:
At+=i #Muestra de resultado
proAt=At/len(aten) if part:
#print(proAt) print('el arreglo es partidario')
else:
for i in cal: print('el arreglo no es partidario')
Cal+=i
proCal=Cal/len(cal) C. Programa 3.
#print(proCal)
#Definición de funciones
for i in jus: def suma(a,b):
Jus+=i c=a+b
proJus=Jus/len(jus) print('la suma de los numeros ingresados es: ' + str(c))
#print(proJus) return
def resta(e,r): multiplicacion(y,u)
f=e-r elif operacion==4:
print('la resta de los numeros ingresados es: ' +str(f)) p=int(input('ingrese el primer numero: '))
return l=int(input('ingrese el segundo numero: '))
division(p,l)
def multiplicacion(y,u): elif operacion==5:
o=y*u ñ=int(input('ingrese el primer numero: '))
print('el producto de los numeros ingresados es: ' +str(o)) m=int(input('ingrese el segundo numero: '))
return o modulo(ñ,m)
elif operacion==6:
def division(p,l): k=int(input('ingrese el primer numero: '))
if l!=0: d=int(input('ingrese el segundo numero: '))
g=p/l potencia(k,d)
print('la division de los numeros ingresados es: ' +str(g)) elif operacion==7:
return ban=False
else: else:
print('la division entre cero es una indeterminacion') print('ingrese una opcion valida.')
return

D. Programa 4.
def modulo(ñ,m):
if m!=0: #definición de funciones
v=ñ%m def suma(arreg):
print('El modulo de la division de los numeros ingresados e=sum(arreg)
es: '+str(v)) print("La suma de los numero del arreglo es: ")
return return e
else:
print('la division entre cero es una indeterminacion') def vmax(arreg):
return maxi=max(arreg)
print("El valor maximo del arreglo es: ")
def potencia(k,d): return maxi
if k==0 and d==0:
print('la operacion que se quiere realizar es una def vmin(arreg):
indeterminacion.') mini=min(arreg)
return print("El valor minimo del arreglo es: ")
else: return mini
t=k**d
print('la potencia de los numero ingresados es: '+str(t)) def prom(arreg):
return 2 su=0
for i in arreg:
ban=True#Varaible que controla el bucle del menu su+=i
while ban==True: promedio=su/len(arreg)
operacion=int(input('''Ingrese el numero de la operacion que print("El promedio de los valores del arreglo es: ")
quiere realizar: return promedio
menu:
1.suma def cuadrado(arreg):
2.resta cuadrad=[]
3.multiplicacion for i in arreg:
4.division a=i**2
5.modulo cuadrad.append(a)
6.potencia print('los numeros del arreglo con su respectivo cuadrado son:
7.salir\n :''')) ')
if operacion==1: return cuadrad
a=int(input('ingrese el primer numero: '))
b=int(input('ingrese el segundo numero: ')) def modificar(arreg,pos,val):
suma(a,b) arreg.insert(pos,val)
elif operacion==2: print('El arreglo modificado es: ')
e=int(input('ingrese el primer numero: ')) return arreg
r=int(input('ingrese el segundo numero: '))
resta(e,r) def orden(arreg):
elif operacion==3: arreg.sort()
y=int(input('ingrese el primer numero: ')) print("valores del arreglo ordenado: ")
u=int(input('ingrese el segundo numero: ')) return arreg
 Figura 6. Prueba programa 3
def invert(arreg):
arreg.reverse()
print("valores del arreglo invertido: ")
return arreg

#Arreglo para probar funciones

arreg=[339,429,447,205,160,323,765,98,1,6]
print('Arreglo: ',arreg)
print(suma(arreg))
print(vmax(arreg))
print(vmin(arreg))
print(prom(arreg))
print(orden(arreg))
print(invert(arreg))
print(cuadrado(arreg))
pos=int(input('ingrese la posicion que quiere modificar: '))
val=int(input('ingrese el valor que quiere poner en el arreglo: '))
print(modificar(arreg, pos, val))

PRUEBAS DE CÓDIGO
A. Programa 1

Figura 4. Prueba programa 1

B. Programa 2

Figura 5. Prueba programa 2

C. Programa 3
 D. Programa 4 facilitan la suma y obtención de valores máximos y
mínimos de un arreglo, así como de bucles para
Figura 7. Prueba programa 4 encontrar el promedio de este.

CONCLUSIONES

El uso de estructuras de control como lo son los

bucles o ciclos, permiten realizar trabajos repetitivos
de manera controlada, lo cual es muy útil cuando una
sentencia necesita ser ejecutada varias veces o
cuando se hace necesario recorrer o rellenar un
arreglo.

Las funciones permiten fraccionar el problema en

problemas más pequeños y de resolución más
sencilla, para posteriormente unir sus resultados en el
programa general y con ello obtener una codificación
más limpia, funcional y que permita una corrección
de errores más rápida y eficiente.

El uso de arreglos para almacenar información de

un mismo tipo permite la administración de datos del
ANÁLISIS DE RESULTADOS programa de una manera más eficiente y ordenada, el
acceso a estos datos se hace a partir de subíndices de
posición de los elementos dentro del arreglo, los
Los resultados del programa 1 hacen referencia al cuales se encuentran de manera secuencial, lo cual
promedio obtenido para cada aspecto evaluado, en el hace fácil el acceso a los datos y su modificación.
caso de la prueba realizada, se obtienen los
promedios de los dos sujetos que han evaluado cada
aspecto. Así mismo, se presentan ordenamos de
mayor a menor los aspectos mencionados. Para esto, REFERENCIAS
se hizo uso de arreglos y bucles que permitieron [1] V. Benjumea and M. Roldán, “Fundamentos de
recorrer los arreglos y generar una suma general, Programación con el Lenguaje de Programación
para posteriormente dividir esa suma entre la C++,” 2017.
cantidad final de elementos dentro del arreglo de [2] G. Pérez, “Aprendiendo Java y Programación
cada aspecto. Orientada a Objetos.” pp. 1–6, 2008.
[3] L. Nyhoff, Programming in C++ for engineering
Los resultados del programa 2 muestran si un and science. New York, Estados Unidos: Taylor &
Francis Group LLC, 2012.
arreglo ingresado es partidario o no, para ello se hace
uso de un bucle inicial el cual permite almacenar los
datos del arreglo desde ingresos por consola del
usuario. Posteriormente se hace uso de bucles
anidados con el finde evaluar si el arreglo cumple
con las características de partidario o no.

Los resultados del programa 3 muestran la

iteración del usuario con el programa por medio de la
selección de una opción de menú, el cual permite
ingresar dos números para operarlos según
corresponda. Así mismo, se hace uso de un bucle
while para mantener el menú activo hasta que el
usuario desee terminar el programa.

Los resultados del programa 4 muestran el

procesamiento de diferentes operaciones con un
arreglo preestablecido. Se hizo uso de funciones que