UNIVERSIDAD DE LAS FUERZAS ARMADAS-ESPE

SEDE SANTO DOMINGO DE LOS TSÁCHILAS

DEPARTAMENTO DE CIENCIAS DE LA COMPUTACIÓN - DCCO-SS

CARRERA DE INGENIERÍA EN TECNOLOGÍAS DE LA INFORMACIÓN

PERIODO : 202150 Mayo –

Septiembre 2021

ASIGNATURA : Fundamentos de Programación

GRUPO : 2

TEMA : Heladeria

INTEGRANTES : - Díaz Cristhofer, Torres Jennifer, Calapucha Carlos,

Toapanta Darwin

NIVEL-PARALELO - NRC: Primero B - 6326

DOCENTE : Ing. Verónica Martínez C., Mgs.

FECHA DE ENTREGA : 02 de Agosto de 2021.

 SANTO DOMINGO - ECUADOR

Contenido
1. Introducción...........................................................................................................3

2. Objetivos................................................................................................................3

Objetivo General:......................................................................................................3

Objetivos Específicos:...............................................................................................3

3. Desarrollo / Marco Teórico/ Práctica.....................................................................4

3.1. Marco Teórico:...................................................................................................4

3.1.1. RESUMEN UNIDAD 1.................................................................................4

3.2. Unidad 2.........................................................................................................8

3.2. Desarrollo: // cumplir con la estructura VER EN LA GUÍA EL EJEMPLO...22

4. Conclusiones.......................................................................................................26

5. Recomendaciones...............................................................................................26

6. Bibliografía/ Referencias.....................................................................................26

7. Anexos.................................................................................................................27

Anexo 1:.......................................................................................................................27

8. Legalización de documento.................................................................................28
1. Introducción

En este trabajo se dará a conocer sobre los temas de “Arreglos, algoritmos de

ordenamiento y de búsqueda”. Existen diferentes tipos de ordenamiento, los cuales
dependerán del tamaño del arreglo, el tipo de datos, incluso del tamaño de memoria
disponible. Por otro lado, tenemos a los métodos de Búsqueda, los cuales son
operaciones que tienen por objeto la localización de un elemento dentro de la
estructura de datos (arreglo). A menudo un programador estará trabajando con
grandes cantidades de datos almacenados en arreglos y pudiera resultar necesario
determinar si un arreglo contiene un valor que coincide con algún valor clave o
buscado.

2. Objetivos
Objetivo General:
Elaboración de un programa básico con FUNCIONES-SUBPROGRAMAS-
LIBRERIAS CON ARREGLOS Y ALGORITMOS DE
ORDENACIÓN Y BÚSQUEDA.
Objetivos Específicos:
● Elaborar el algoritmo según el tema asignado y aplicar todos los ítems
del silabo.
● Desarrollar el programa en Code Blocks.
● Explicar en el desarrollo el código, ejecución, diagrama y pruebas.
3. Desarrollo / Marco Teórico/ Práctica
3.1. Marco Teórico:
3.1.1. RESUMEN UNIDAD 1
Programa
Un programa informático o programa de computadora es una secuencia de
instrucciones, escritas para realizar una tarea específica en un computador.
Características de un programa
 Una interfaz amigable para el usuario.
 Fácil de usar para el usuario. Portabilidad de datos a nuevas
versiones. Depuración. Puesta en marcha. ...
 Fácil de usar para el usuario.
 Portabilidad de datos a nuevas versiones.
 Depuración.
 Puesta en marcha.
 Manual del usuario.
Algoritmo
Un algoritmo es una serie de instrucciones secuenciales ―es decir, que van
uno después del otro― que permiten ejecutar acciones o programas.
Lenguaje de programación
Un lenguaje de programación es un lenguaje formal (o artificial, es decir, un
lenguaje con reglas gramaticales bien definidas) que le proporciona a una
persona, en este caso el programador, la capacidad de escribir (o programar)
una serie de instrucciones o secuencias de órdenes en forma de algoritmos
con el fin de controlar el comportamiento físico o lógico de un sistema
informático, de manera que se puedan obtener diversas clases de datos o
ejecutar determinadas tareas. A todo este conjunto de órdenes escritas
mediante un lenguaje de programación se le denomina programa informático.
Tipos de datos

Numéricos

Enteros
Este tipo dato corresponde a aquellas variables que
exclusivamente pueden recibir VALORES SIN PARTE
DECIMAL. Generalmente se utilizan en las variables que
contienen cantidades de elementos que no pueden
fraccionarse, como el número de personas, el número de
edificios, entre otros.
Reales
Este tipo de dato, en cambio corresponde a aquellas variables
cuyos VALORES TIENEN PARTE DECIMAL, aunque al mismo
tiempo puede contener valores enteros. Así el lado de un
triángulo puede ser 3,5 (0,5 es la parte decimal), pero también
podría haber tomado un valor de 3,0 (0,0 es la parte decimal)
Texto

Caracteres

En este tipo de dato se encuentran todos los caracteres conocidos, una

letra, un número, un símbolo especial.

Cadenas

Constituyen conjuntos de caracteres, es decir la UNIÓN DE VARIOS

CARACTERES, que pueden ser palabras o frases. El valor de este tipo
de datos se encierra generalmente entre comillas (" ").

Lógicos

BOOLEAN

Los booleanos o tipos de datos lógicos, únicamente reciben dos

valores: true ó false. Se utilizan generalmente como banderas, para
identificar si se realizó o no un proceso. Más adelante se podrán aplicar
en ejemplos y comprender su funcionamiento. Lo importante por ahora
es conocer que únicamente pueden tomar DOS VALORES:
VERDADERO (true) o FALSO (false)
 Variables
Una variable es un espacio de memoria reservado para almacenar un
valor que corresponde a un tipo de dato soportado por el lenguaje de
programación. Una variable es representada y usada a través de una
etiqueta (un nombre) que le asigna un programador o que ya viene
predefinida.

Tipos de variables

● Para variables numéricas sin decimales se usa: int (Pseint Entero)

● Para variables numéricas con decimales se usa: float (Pseint Real)
● Para variables de un solo caracter se usa: char (Pseint Caracter)
● Para variables boolean se usa: bool (Pseint Logico)
Entradas y salidas de datos
ENTRADAS
Las entradas son todos aquellos insumos que se requieren para el
adecuado procesamiento de los datos y que se definirán como
variables, teniendo en cuenta el tipo de dato que puede representar.
SALIDAS
Son los valores o resultados que se generan después de una
operación o proceso, en el ejemplo anterior se puede ver que la salida,
se compone de dos partes, el mensaje final, que es la cadena: “el
cuadrado del número es:” y el valor de cuadrado que se visualiza para
el usuario.
Operadores matemáticos
Los operadores matemáticos o aritméticos son aquellos símbolos
especiales que se utilizan en el lenguaje de programación e indican al
compilador que debe realizarse una operación matemática o lógica
que puede ayudar a resolver desde problemas financieros hasta
problemas algebraicos.
Estructuras de control
Las estructuras de control, son instrucciones que permiten romper la
secuencialidad de la ejecución de un programa; esto significa que una
 estructura de control permite que se realicen unas instrucciones y
omitir otras, de acuerdo a la evaluación de una condición.
Condicionales
En programación, una sentencia condicional es una instrucción o
grupo de instrucciones que se pueden ejecutar o no en función del
valor de una condición.
3.2. Unidad 2
3.2.1. Subprogramas
Los subprogramas son rutinas, procedimientos o conjuntos de instrucciones
que realizan una labor específica. Los subprogramas o subrutinas nacieron
de la necesidad de no repetir innecesariamente un trabajo ya hecho. Pueden
invocarse desde el cuerpo del programa principal cuantas veces se desee.
Constituyen el núcleo de lo que se denomina programación estructurada, y
permiten la descomposición de un problema complejo en subproblemas más
sencillos abordables de forma independiente. Así, como recordaremos del
tema 1.2, la estructura general de un programa de Flowol se puede
representar como:

3.2.2. Definición de Subprogramas

Un subprograma es una unidad de programa o una operación cuya ejecución
se invoca mediante una llamada. Un subprograma puede ser un
procedimiento o una función. La diferencia entre un procedimiento y una
función es que el primero sólo indica la ejecución de una secuencia de
instrucciones, en función de unos parámetros, mientras que la segunda
representa un valor que se genera como resultado de su ejecución; es decir
la llamada a un procedimiento es una sentencia, mientras que la llamada a
una función es una expresión. Se pueden usar funciones para sobrecargar
los operadores del lenguaje, otorgándoles nuevos significados.

3.2.3. Declaración, implementación y llamada de Subprogramas

Declaración: La declaración de un subprograma es como su cabecera, pero
terminada en ";" en vez de con la palabra "is", para expresar que lo que se
está dando es una vista de un subprograma cuya definición se haya en otro
lugar.

Implementación: Los subprogramas se implementan por medio de lo que

conocemos como funciones o procedimientos. No son más que una lista de
sentencias que se escriben para resolver problemas, con algoritmos que
pueden operar de manera independiente.

// Subprograma

Llamada: Se realiza escribiendo el nombre del mismo, seguido de las

expresiones sobre las que queremos que trabaje. De esta forma se crea una
vía de comunicación entre la instrucción de llamada y el algoritmo llamado,
facilitando el intercambio de información entre ellos.” (Barber, n.d.)

// Llamada de Subprograma

3.2.4. Argumentos y Parámetros

“Son el medio a partir del cual podemos expandir el ámbito de variables
locales de funciones, hacia otras funciones y además quienes nos permiten
establecer comunicaciones entre funciones. Si nos vemos ante la necesidad
de visualizar o modificar el valor de una variable local en otra función que
llamaremos, debemos invocar a dicha función haciendo referencia de su
nombre, seguido de los parámetros o nombres de variables para las cuales,
// Parámetro

en teoría ampliaremos su ámbito.” (Parámetros y argumentos

(programación), n.d.)

// Argumento

3.2.5. Ámbitos de las variables

El ámbito, alcance o scope de una variable es la parte del programa donde la
variable es accesible.
Esta definición es también aplicable a constantes y objetos.
En C++ existen tres tipos de ámbitos:
- Global o de programa
- Local o de función.
- De bloque.
Según su ámbito las variables se clasifican en variables globales, variables
locales y variables de bloque.
Variables globales.
Son variables declaradas fuera de cualquier función, normalmente al
comienzo del programa.
Las variables globales son accesibles desde su declaración hasta el final del
programa por todas las funciones que lo forman.
Variables locales.
Las variables locales son las que se declaran dentro de una función. Son
accesibles desde el punto donde se declaran hasta el final del bloque donde
se han declarado. Los límites de los bloques están definidos por las llaves de
apertura y cierre { }. Normalmente el final del bloque coincide con el final de la
función. Si el bloque donde se ha declarado la variable local contiene a su
vez otros bloques, también son accesibles dentro de ellos.
Las variables locales se destruyen cuando se sale del bloque donde han sido
declaradas.
Los parámetros formales (los que aparecen en la cabecera de una función)
se consideran variables locales de la función.

3.2.6. Funciones de Librerías o Módulos.

Librerías: En C++, se conoce como librerías (o bibliotecas) a cierto tipo de
archivos que podemos importar o incluir en nuestro programa. Estos archivos
contienen las especificaciones de diferentes funcionalidades ya construidas y
utilizables que podremos agregar a nuestro programa, como por ejemplo leer
del teclado o mostrar algo por pantalla entre muchas otras más.
Las bibliotecas contienen el código objeto de muchos programas que
permiten hacer cosas comunes, como leer el teclado, escribir en la pantalla,
manejar números, realizar funciones matemáticas, etc.
Las bibliotecas están clasificadas por el tipo de trabajos que hacen, hay
bibliotecas de entrada y salida, matemáticas, de manejo de memoria, de
manejo de textos y como imaginarás existen muchísimas librerías disponibles
y todas con una función específica.

Módulos: En programación, un módulo es una porción de un programa de

ordenador. De las varias tareas que debe realizar un programa para cumplir
con su función u objetivos, un módulo realizará, comúnmente, una de dichas
tareas (o varias, en algún caso).
En general (no necesariamente relacionado con la programación), un módulo
recibe como entrada la salida que haya proporcionado otro módulo o los
datos de entrada al sistema (programa) si se trata del módulo principal de
este; y proporcionará una salida que, a su vez, podrá ser utilizada como
entrada de otro módulo o bien contribuirá directamente a la salida final del
sistema (programa), si se retorna al módulo principal.
Características de un módulo
Cada uno de los módulos de un programa idealmente debería cumplir las
siguientes características:
Tamaño relativamente pequeño. - Esto facilita aislar el impacto que pueda
tener la realización de un cambio en el programa, bien para corregir un error,
o bien por rediseño del algoritmo correspondiente.
Independencia modular. - Cuanto más independientes son los módulos
entre sí, más fácil y flexiblemente se trabajará con ellos. Esto implica que
para desarrollar un módulo no es necesario conocer detalles internos de otros
módulos. Como consecuencia de la independencia modular, un módulo
cumplirá:
Características de caja negra; es decir, abstracción (ver abstracción en
programación orientada a objetos).
Aislamiento de los detalles mediante encapsulamiento (ver encapsulamiento
en programación orientada a objetos).
La independencia modular mejora el rendimiento humano, pudiendo
realizarse programación en equipo y desarrollar módulos paralelamente.
También contribuye a la reutilización de software.

3.2.7. Recursividad
La recursividad es una técnica muy empleada en la programación informática
y consiste en que una función se llame a sí misma. El ejemplo clásico es la
función que calcula el factorial de un número. Un factorial consiste en
multiplicar un número natural por el número anterior, y este a su vez por el
anterior, y así sucesivamente hasta llegar al número 1. Por ejemplo, el
factorial de 8 sería el resultado de multiplicar 8 por 7, luego por 6 y así
sucesivamente hasta llegar a uno.
Una función recursiva que hiciera este cálculo multiplicaría el número que se
le pasa por el resultado de llamar a la función restando uno a ese número. En
nuestro ejemplo, multiplicar 8 por el factorial de 7. Cuando el número que se
le pasa es un 1, pues devuelve ese 1. Es la llamada "condición de salida", y
es esencial para impedir que la función se esté llamando a sí misma
eternamente.
3.2.8. Creación de Librerías o Módulos
 3.2.9. Arreglos
Definición Ventajas

Un arreglo es una estructura, es decir es un -El mismo es adecuado para llegar a

conjunto de variables que se citan y almacenar o leer bloque de datos
manejan con un mismo nombre, y que secuenciales que son muy grandes, como
permite además la utilización individual de aplicaciones con grandes bases de datos,
sus elementos. imágenes y vídeos entre otros.
Esto significa que un arreglo es una variable -Puedes recuperar la información.
que provee la opción de disponer de varios -Son de fácil trabajo.
datos o espacio para datos a los cuales se -Trabajas con direcciones.
puede acceder con un mismo nombre. -Partiendo de un archivo desordenado los
Un arreglo es en resumen un conjunto de arreglos llegarán a permitir generar los datos
datos finito y del mismo tipo. con cierto orden.

Características Ejemplo:
Dentro de las principales características que
pueden tener los tipos de arreglos o array
tenemos:
-Las variables son únicas y llegan a
representar cada elemento dentro del
arreglo, estos elementos se llegan a
diferenciar a través del índice.
-Los elementos del array serán guardados en
posición de forma continua dentro de la
memoria.
-En los elementos del array se puede accesar
de forma aleatoria y directa.
 3.2.10. Arreglos Unidimensionales
Definición Ventajas

Se les llama arreglos unidimensionales a - Ocupan menos recursos del ordenador.

aquellas estructuras de datos organizadas y - Menos problemas en cuanto a los datos
que se encuentran bien coordinadas, estas se válidos sean eliminados por error o a que
caracterizan por tener una cantidad pequeña existan datos no válidos en el arreglo.
de datos, los cuales tienen que ser del - El acceso a los arreglos es directo, nos
mismo tipo para que puedan ser procesados permiten hacer un conjunto de operaciones
en estos arreglos. Estas programaciones se para manipular los datos guardados en ellos,
usan mayormente en la creación de estas operaciones son: ordenar, buscar,
estructuras de listas en un orden natural y insertar, eliminar, modificar entre otras.
con elementos similares en su interior. - Son más seguros y claros.

Características Ejemplo:

Un arreglo unidimensional se caracteriza

por modelar listas de elementos iguales.
Arreglos se define como una colección
finita, homogénea y ordenada de elementos.
 3.2.11. Arreglos Bidimensionales
Definición Ventajas

Los arreglos bidimensionales son tablas de - Fácil acceso a los elementos.

valores. Cada elemento de un arreglo - Fácil extensión al caso multidimensional.
bidimensional está simultáneamente en una - Fácil acceso a renglones.
fila y en una columna. - Puede ser muy eficiente si se puede
En matemáticas, a los arreglos programar de manera adecuada.
bidimensionales se les llama matrices, y son
muy utilizados en problemas de Ingeniería.
En un arreglo bidimensional, cada elemento
tiene una posición que se identifica
mediante dos índices: el de su fila y el de su
columna.

Características Ejemplo:

- Un arreglo bidimensional tiene dos

dimensiones.
- Una matriz almacena elementos de un
mismo tipo.
- Son datos ordenados tipos estructurados,
homogéneos y de caso particular.
 3.2.12. Arreglos Multidimensionales
Definición Ventajas

Estos son arreglos que su estructura son de - No están limitados a dos índices.
dos o más dimensiones y se les llega a - Permite agrupar muchos datos usando un
conocer como arreglos multidimensionales. mismo identificador.
Cuando se habla de dimensiones en este tipo - Se utilizan cuando se necesita almacenar
de arreglo es porque en el mismo se múltiples valores del mismo tipo.
establecen diferentes números de índice que
los mismos y que deben de llevar en su
estructura para que estos puedan llevar a
cabo sus funciones dentro de la
programación.
Este número de índices que se llegan a
utilizar tienen que ser preestablecidos al
igual que los datos. Estos son
preestablecidos de igual forma que los
arreglos unidimensionales con la única
diferencia que este contará con una
estructura más robusta y con más funciones.

Características Ejemplo:

- Son una ampliación de las matrices de dos

dimensiones y utilizan subíndices
adicionales para la indexación.
- Se caracteriza por una combinación del
arreglo de una dimensión y de 2
dimensiones.

3.2.13. Pasos de Arreglos a Funciones

Para pasar un array a una función:
- En la función se debe declarar el parámetro como un array del tipo
adecuado. En los arrays unidimensionales no es necesario especificar el
tamaño por lo tanto aparecerán los corchetes vacíos.
- En la llamada a la función a la que se envía el array, el nombre del array
aparecerá solo, sin corchetes ni índices
Los arrays en C++ se pasan siempre a las funciones por referencia. El
nombre de un array realmente es un puntero que contiene la dirección de
memoria donde comienza el array, o lo que es lo mismo, la dirección de
memoria del primer elemento. Cuando se pasa un array a una función, la
función recibe la dirección de memoria donde se encuentra el primer
elemento del array. Por lo tanto, la función trabaja sobre el array original.

3.2.14. Algoritmos de Ordenación

En computación y matemáticas un algoritmo de ordenamiento es un algoritmo
que pone elementos de una lista o un vector en una secuencia dada por una
relación de orden, es decir, el resultado de salida ha de ser una permutación
—o reordenamiento— de la entrada que satisfaga la relación de orden dada.

Ordenamiento por selección

Consiste en encontrar el menor de todos los elementos del vector e
intercambiarlo con el que está en la primera posición. Luego el segundo más
pequeño, y así sucesivamente hasta ordenarlo todo.

Ordenamiento por intercambio

El método de intercambio se basa en comparar los elementos del arreglo e
intercambiarlos si su posición actual o inicial es contraria inversa a la
deseada.
Este es el método de ordenación más popular, que resulta ser al mismo
tiempo el más lento e ineficaz.

Ordenamiento por Burbuja

La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de
ordenamiento. Funciona revisando cada elemento de la lista que va a ser
ordenada con el siguiente, intercambiándolos de posición si están en el orden
equivocado.

3.2.15. Algoritmos de Búsqueda

Para encontrar un dato dentro de un arreglo, para ello existen diversos
algoritmos que varían en complejidad, eficiencia, tamaño del dominio de
búsqueda.

– Búsqueda Secuencial
• Consiste en ir comparando el elemento que se busca con cada elemento del
arreglo hasta cuándo se encuentra.
• Busquemos el elemento ‘u’
– Búsqueda Binaria
En el caso anterior de búsqueda se asume que los elementos están en cualquier
orden. En el peor de los casos deben hacerse n operaciones de comparación.
Una búsqueda más eficiente puede hacerse sobre un arreglo ordenado. Una de
éstas es la Búsqueda
Binaria.
La Búsqueda Binaria, compara si el valor buscado está en la mitad superior o
inferior. En la que esté, subdivido nuevamente, y así sucesivamente hasta
encontrar el valor.
3.2. Desarrollo: // cumplir con la estructura VER EN LA GUÍA EL EJEMPLO

Ejercicio en C++

3.3.1 Código en C++

//Copiar el código del programa desde la primera hasta la última línea. Usar tamaño de letra
< 8, sin espacios (interlineado simple, 0), para que entre en una sola hoja, caso contrario
crear una tabla y colocar el código en 2 columnas
#include<iostream> do{
#include<cmath> cout << "Ingrese cuantos helados desea llevar" << endl;
#include"caratula.h" cin >> n;
#include"MenuPrincipal.h" if(n<=0){
using namespace std; cout<<"No puede ingresar numeros negativos"<<endl;
#define ARREGLO_MAX 100 }
#define SIN_TIPO string }while(n<=0);

int main() { if (n>=0){

encabezado(); cout << "Ingrese el nombre del helado" << endl;
menuprincipal(); for (i=1;i<=n;i++) {
return 0; cin >> v[i-1];
} }
cout << "Ingrese el nombre del helado a buscar" << endl;
void registro() { cin >> num;
SIN_TIPO cedularuc; c = 0;
float cuenta1; for (i=1;i<=n;i++) {
float dato; if (num==v[i-1]) {
string dirdomicilio; cout << "El helado " << num << "se encuentra en la posicion" << i << endl;
float gasto; c = c+1;
int i; }
int id; }
int idcliente; if (c==0) {
int idregistro; cout << "El helado que desea buscar no se encuentra en el vector" << endl;
int j; }
float media; }
int menu; }
int menu2; void ordenamiento() {
string nombresapellidos; int a;
int p; int i;
float precios[ARREGLO_MAX]; int j;
float pro; int min;
string producto[3][3]; int n;
float producto1; string temp;
SIN_TIPO productos[ARREGLO_MAX]; string v[ARREGLO_MAX];
float suma; string vector[10];
SIN_TIPO telefono; float x;
float total; int z;
int x; // ----------------------------------------ordenamiento de burbuja ---------------------------------------------------
int x2; vector[0] = "1.mora";
int xi; vector[1] = "2.limon";
// variables vector[2] = "3.frambuesa";
cout << "Iniciar con el registro de datos para que sea nuestro cliente" << endl; vector[3] = "4.almendra";
cout << "Nombre : " << endl; vector[4] = "5.guanabana";
cin >> nombresapellidos; vector[5] = "0.manjar";
cout << "Direccion de domicilio:" << endl; vector[6] = "7.chocolate";
cin >> dirdomicilio; vector[8] = "8.vainilla";
cout << "Telefono: " << endl; vector[9] = "6.fresa";
cin >> telefono; vector[7] = "9.menta ";
cout << "Cedula:" << endl; cout << "--------------------------------------------------------------" << endl;
cin >> cedularuc; // Metodo de Burbuja
cout << " ---------------------------------------------------------------- " << endl; cout << " Metodo de Burbuja" << endl;
cout << "***Registro Satisfactorio, desde ahora eres nuestro/a CLIENTE *** " << nombresapellidos << endl; cout << "--------------------------------------------------------------" << endl;
cout << " ---------------------------------------------------------------- " << endl; cout << "orden ascendente:" << endl;
cout << " ---------------------------------------------------------------- " << endl; for (x=2;x<=10;x++) {
cout << ".............Sabores disponibles de nuestra TIENDA........... : " << endl; for (a=1;a<=9;a++) {
cout << " ---------------------------------------------------------------- " << endl; if (vector[a-1]>vector[a]) {
producto[0][0] = "coco"; temp = vector[a-1];
producto[1][0] = "chicle"; vector[a-1] = vector[a];
producto[2][0] = "naranjilla"; vector[a] = temp;
producto[0][1] = "maracuya"; }
producto[1][1] = "manjar"; }
producto[2][1] = "almendra"; }
producto[0][2] = "chocolate"; // Orden ascendente
producto[1][2] = "vainilla"; for (z=1;z<=10;z++) {
producto[2][2] = "fresa"; cout << vector[z-1] << endl;
for (i=1;i<=3;i++) { }
cout << "--------------------------------------------------------------" << endl; // -----------------------------ordenamiento de inserccion------------------------------------------
for (j=1;j<=3;j++) { interorden();
cout << producto[i-1][j-1] << endl; // ----------------------------------------------ordenamiento seleccion -------------------------------------------
} // ////........................................validar numero negativo
}
cout << "--------------------------------------------------------------" << endl; do{
cout << "--------------------------------------------------------------" << endl; cout << "Ingrese cuantos helados desea llevar " << endl;
cin >> n;
do{ if(n<=0){
cout << "Ingrese la cantidad de helados" << endl; cout<<"No puede ingresar numeros negativos"<<endl;
cin >> p; }
gasto = 0;
for (j=1;j<=p;j++) { }while(n<=0);
cout << "Ingrese el precio del " << j << " helado " << endl;
cin >> precios[j-1]; // ////................................validar numero................................
while((precios[j-1])<=0){ cout << "Ingrese el sabor del helado " << endl;
cout << "INCORRECT0 -- VUELVA A INGRESAR " << endl; for (i=1;i<=n;i++) {
cout << "Ingrese el precio del " << j << " helado " << endl; cin >> v[i-1];
cin >> precios[j-1]; }
} for (i=1;i<=n;i++) {
gasto = gasto+precios[j-1]; min = i;
} for (j=i+1;j<=n;j++) {
if(p<=0){ if (v[min-1]>v[j-1]) {
cout<<"No puede ingresar numeros negativos"<<endl; min = j;
} }
}while(p<=0); }
cout << "El costo a pagar es : " << gasto << endl; temp = v[min-1];
} v[min-1] = v[i-1];
v[i-1] = temp;
void busqueda() { }
float c; cout << "--------------------------------------------------------------" << endl;
bool encontro; cout << "helados ordenados alfabeticamente (a,b,c,d,e,f,j,..........)" << endl;
float final; cout << "--------------------------------------------------------------" << endl;
int i; for (i=1;i<=n;i++) {
int mitad; cout << v[i-1] << endl;
int n; }
SIN_TIPO num; }
string numer;
float puntero; void interorden() {
SIN_TIPO v[ARREGLO_MAX]; int a[ARREGLO_MAX];
string vec[4]; int clave;
// ------------------Busqueda Binaria-------------------------------- int i;
puntero = 1; int j;
final = 4; int n;
vec[0] = "acido"; float x1;
vec[1] = "dulce"; n = 10;
encontro = false; for (x1=1;x1<=10;x1++) {
cout << "------------------------------------------------------------------------" << endl; a[0] = 3;
cout << "1.acido----2.dulce" << endl; a[1] = 5;
cout << "------------------------------------------------------------------------" << endl; a[2] = 8;
cout << "Escriba el sabor del helado que quiere buscar" << endl; a[3] = 7;
cin >> numer; a[4] = 2;
while ((encontro==false && puntero<=final)) { a[5] = 4;
mitad = int((puntero+final)/2); a[6] = 10;
if (numer==vec[mitad-1]) { a[7] = 9;
encontro = true; a[8] = 1;
} else { a[9] = 6;
if (numer<vec[mitad-1]) { }
final = mitad-1; for (j=2;j<=n;j++) {
} else { clave = a[j-1];
puntero = mitad+1; i = j-1;
} while (i>0 && a[i-1]>clave) {
} a[i] = a[i-1];
} i = i-1;
if ((encontro==true)) { }
cout << "El helado se encuentra en la posicion " << mitad << endl; a[i] = clave;
} else { }
cout << "El sabor no se encuentra vuelva pronto" << endl; for (i=1;i<=n;i++) {
menuprincipal(); cout << a[i-1] << " ";
} }
cout << "------------------------------------------------------------------------" << endl; cout << " " << endl;
// -----------------------------busqueda secuencial------------------------------------ }
3.3.2. Captura de código:
3.2. Ejecución C++
Pruebas a mano

Opción 1: Opción 2:

Opción 3:
4. Conclusiones
Se debe redactar mínimo 3 conclusiones del tema desarrollado en base a los
resultados del laboratorio o investigación.
 Los métodos de Ordenación por Burbuja, Inserción, Mezcla son los más
sencillos de emplear para ordenar pocos datos, sin embargo, los métodos de
Burbuja y Mezcla son menos eficientes con arreglos grandes.
 El uso de Subprogramas facilita la estructuración del programa en partes más
pequeñas del mismo, y se puede reutilizar a un subprograma las veces que sea
necesario.
 Para que el método de Búsqueda Binaria funcione, se necesita que el array este
ordenado de forma ascendente.

5. Recomendaciones

 Al llamar a un subprograma, ubicarlo en el lugar correspondiente, para evitar

problemas se sintaxis.
 Practicar los distintos métodos de ordenamiento y búsqueda para evitar errores
en la ejecución del programa.
6. Bibliografía/ Referencias
● 3.6 ProgramaciÃ3n estructurada: subprogramas. (s. f.). Platea pntic.
Recuperado 28 de julio de 2021, de
http://platea.pntic.mec.es/vgonzale/cyr_0708/archivos/_15/Tema_3.6.htm
● Ambito de una variable en C++. (s. f.). Programacion C++. Recuperado 28 de
julio de 2021, de http://ejercicioscpp.blogspot.com/2013/07/ambito-alcance-
de-una-variable-en-c.html
● colaboradores de Wikipedia. (2020, 24 octubre). Módulo (informática).
Wikipedia, la enciclopedia libre. https://es.wikipedia.org/wiki/M
%C3%B3dulo_(inform%C3%A1tica)
● Crismar25, F. A. E. J. B. (2021, 21 abril). Vectores bidimensional
Características Ventajas y Desventajas Ejemplo. issuu.
https://issuu.com/crismar25/docs/unidad_5_arrays_en_java-
crismar_crespo/s/12124115
 ● González, J. D. M. (2020, 29 noviembre). Librerías o Bibliotecas.
Programarya. https://www.programarya.com/Cursos/C++/Bibliotecas-o-
Librerias
● Herrera, D. R. (2009, 29 julio). ¿Qué es la recursividad? ¿Qué es la
recursividad? ¿Qué es la recursividad?. . . Libertad Digital.
https://www.libertaddigital.com/internet/que-es-la-recursividad-que-es-la-
recursividad-que-es-la-recursividad-1276366373/
● Métodos de busqueda. (s. f.). 2011–2012 Ecodig. Todos los derechos
reservados. Recuperado 28 de julio de 2021, de
https://paginadec.webcindario.com/old/busqueda-metodos.html
● Pineda, C. I. C. N. I. E. (s. f.). Definiciones | Arreglos. UTN. Recuperado 28
de julio de 2021, de
http://www.utn.edu.ec/reduca/programacion/arreglos/definiciones1.html
● Subprogramas. (s. f.). gedlc. Recuperado 28 de julio de 2021, de
http://www.gedlc.ulpgc.es/docencia/NGA/Ada2005/ada/general/subprogramas
.html
● subprogramas. (s. f.). gledlc. Recuperado 28 de julio de 2021, de
http://www.gedlc.ulpgc.es/docencia/NGA/subprogramas.html

7. Anexos

Anexo 1:
Carpeta de Code Blocks con el nombre AvGrupo2
8. Legalización de documento
Nombres y Apellidos:
- Díaz Cristhofer - 2300104136

- Torres Jennifer
- Calapucha Carlos
- Toapanta Darwin