Taller 1 Murillo Karla

ESTUDIANTE:
KARLA DOMENICA MURILLO ZAMBRANO
DOCENTE:
MARTÍNEZ CEPEDA VERONICA ISABEL
CARRERA:
BIOTECNOLOGÍA
PARALELO: ´´B´´
ASIGNATURA:
INTRODUCCIÓN A LA INFORMACIÓN
PERIODO:202051
FECHA: 11/03/2021
P á g i n a 1 | 22
MURILLO ZAMBRANO KARLA DOMENICA
INTRODUCCIÓN A LA PROGRAMACIÓN
ÍNDICE
1. INTRODUCCIÓN 3
2. OBJETIVOS 3
2.1. OBJETIVO GENERAL 3
2.2. OBJETIVOS ESPECÍFICOS 3
3. RESUMEN UNIDAD I 4
4. RESUMEN UNIDAD II 5
5. MARCO TEÓRICO 7
5.1. Subprogramas: Funciones o Procedimientos 7
5.1.1. Definición de Subprograma 7
5.1.2. Declaración, implementación y llamada de Subprogramas 7
5.1.2.1. Declaración 7
5.1.2.2. Implementación 7
5.1.2.3. Llamada de Subprogramas 8
5.1.3. Argumentos y Parámetros 9
5.1.3.1. Argumentos 9
5.1.3.1. Parámetros 9
5.1.4. Ámbito de las variables 10
5.1.4.1. Variables locales 10
5.1.4.2. Variables globales 11
5.1.5. Funciones de librerías o módulos 11
5.1.6. Recursividad 12
5.1.7. Creación de librerías o módulos 14
Método 1: Utilizar librerías en el mismo directorio #include “libreria.h” 14
Método 2: Utilizar librerías en el directorio include del compilador #include
<libreria.h> 15
6. DESARROLLO 17
6. CONCLUSIONES 20
7. RECOMENDACIONES 20
8. REFERENCIAS 21
P á g i n a 2 | 22
1. INTRODUCCIÓN
En el siguiente informe trataremos temas antes vistos en la unidad 1 y 2, también

conoceremos nuevos temas a desarrollar en esta nueva unidad, las cuales son muy
importantes para nuestro mejor conocimiento ya que con el aprendizaje adecuado de
aquellos temas tendremos un mejor funcionamiento académico.
La programación es una herramienta fundamental en el mundo en el que vivimos,

convirtiéndose en una salida laboral importante. Además, su aprendizaje constituye
una oportunidad al mejorar el razonamiento lógico formal.
2. OBJETIVOS
2.1. OBJETIVO GENERAL
Que el estudiante desarrolle la habilidad de crear algoritmos y codificar programas que

solucionen problemas específicos aplicando buenas prácticas de programación con la
teoría aprendida en cada Unidad.
2.2. OBJETIVOS ESPECÍFICOS
1. Identificar un problema específico, plantear la solución con la elaboración de un

algoritmo.
2. Elaborar un algoritmo aplicando los lenguajes algorítmicos gráficos (Diagrama de

flujos) y no gráficos (Pseudocódigo), paso a paso con
el detalle necesario cumpliendo con las características (finito, preciso, definido, legible,
eficaz) y las 3 partes del algoritmo (entradas,
proceso y salidas).
3. Usar dos herramientas para codificar el algoritmo. (Pseint + Code Blocks)
4. Desarrollar algoritmos en lenguajes de programación que nos permitirán cumplir con

las fases de la resolución de problemas y aprender
a usar la sintaxis y semántica correcta dependiendo del lenguaje de programación.
5. Usar operadores, entrada/salida y estructuras de control.
P á g i n a 3 | 22
3. RESUMEN UNIDAD I
En la anterior unidad aprendimos todo lo referente a lo que es Introducción a la

Programación en Computadoras, los Paradigmas de Programación, Compilador e
Interprete, los Lenguajes de Programación, los IDE y Editores y los Conceptos de
Programas. También las deferentes Estrategias para solucionar problemas de
Programación, que son Algoritmos, Variables y Tipos de Datos.
La programación es un proceso donde se analizan los pormenores de un problema y

se presenta una solución que puede ser implementada en un área determinada de las
TIC’s para que funcionen en el momento y forma deseada.
Muchas veces se confunde la programación con el simple hecho de generar código, pero la
verdad es, que la programación informática abarca muchas más cosas de lo puede parecer.
Aprendimos como utilizar los programas de PSeint y code blocks para trabajar y utilizar
todos los temas tratados.
Definición de PSeint
El programa PSEINT es una abreviatura a pseudocódigo y está diseñado para que los
estudiantes de la carrera de programación faciliten sus aprendizajes en una forma fácil y
sencilla utilizando el lenguaje español, este programa también tiene un editor de texto.
PSEINT también tiene un auto corrector donde te indica el error obtenido señalando con su
subrayado rojo, el programa incluye también la comprobación de los algoritmos o
pseudocódigos escritos.
Definición de Code blocks
Se trata de un entorno desarrollado integrado (IDE) para programadores y desarrolladores,

trae consigo herramientas predefinidas para desarrollar aplicaciones Qt, plugin, aplicaciones
de consola entre otros.
Es un IDE libre, de código abierto, multiplataforma construido para satisfacer las

necesidades de los usuarios. Está diseñado para ser muy extensible y completamente
configurable a las necesidades que a los desarrolladores les puedan surgir.
P á g i n a 4 | 22
4. RESUMEN UNIDAD II
Entrada y Salida de datos
Para que un programa pueda ejecutar las tareas para las que fue creado es necesario que
se pueda comunicar con los usuarios para capturar la información y presentar los
resultados. También debe poder almacenar y recuperar información de dispositivos de
almacenamiento permanente para preservarla ya que el contenido de las variables se
pierde una vez que la ejecución del programa termina. El contenido de los dispositivos
de almacenamiento permanente se organiza en unidades llamadas archivos que los
programas abren para poder leer o escribir información. El mecanismo para interactuar
con un usuario se llama interfaz de usuario y puede ser gráfica o de texto.
Entradas y Salidas en Pseint
Para pedir al usuario que introduzca un valor por teclado, usaremos

la operación leer. Después de esta operación debe ir una variable donde se guarde lo
que el usuario introduzca. Por ejemplo:
Leer A
Si usa PSeInt, si usas la operación leer y ejecutas, te dejaras que escribas un valor.
Para mostrar por pantalla un valor, usaremos la operación escribir. Después de

esta operación si ponemos una variable, nos mostrara el valor que contenga la variable.
Escribir A
También se puede mostrar mensajes, simplemente después de la operación escribir

escribimos el texto que queremos mostrar entre comillas, esto ayuda mucho al usuario
para saber qué tipo dato debe introducir.
P á g i n a 5 | 22
Entradas y Salidas en code blocks
Salidas con cout
Los valores de variables se pueden enviar a la pantalla empleando cout. Es posible

enviar a la pantalla cualquier combinación de variables y cadenas. Por ejemplo:
cout << num_dulces << “dulces\n”;
Esta instrucción le dice a la computadora que despliegue dos cosas: el valor de la

variable num_dulces y la cadena “dulces\n”.
Entrada con cin
cin es el flujo de entrada estándar. Supondremos que la entrada estándar es el teclado.

Veamos un ejemplo:
cin >> num_pasteles;
En la sentencia anterior lo que hacemos es leer un dato introducido por teclado y

almacenarlo en una variable ‘num_pasteles’.
P á g i n a 6 | 22
5. MARCO TEÓRICO
5.1. Subprogramas: Funciones o Procedimientos

Existen dos tipos de subprogramas que son: funciones o procedimientos, 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.
5.1.1. Definición de Subprograma

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 “procedure” o una
función “function”.
5.1.2. Declaración, implementación y llamada de Subprogramas

5.1.2.1. Declaración
La declaración de un subprograma consta de una especificación formada por un
identificador (defining_designator) y una lista de parámetros opcional (formal_part).
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 halla en otro lugar:
procedure Intercambia(A,B: in out Integer);
function Media(A,B: Float) return Float;
5.1.2.2. Implementación
Es la última fase que se revisará en este módulo, y consiste en transformar cada uno de
los pasos realizados en el DFD o en pseudocódigo, a instrucciones en un lenguaje de
programación.
Para realizar esta fase, es necesario consultar en el manual del lenguaje de programación
correspondiente, para identificar la sintaxis de las instrucciones correspondientes.
P á g i n a 7 | 22
Dado que en el presente curso se utilizará el lenguaje de programación java, a

continuación, se presenta la sintaxis de las instrucciones básicas, que serán requeridas
para transformar el diseño del ejemplo que se ha venido desarrollando en un programa.
Considerando además que es posible implementar en modo consola, es decir Modo Texto,
o en modo Gráfico, los programas de este módulo se realizarán en Modo Consola por lo
cual es necesario utilizar una librería Scanner que permita el ingreso de datos desde
teclado, ésta debe ser incluida con la siguiente instrucción:
import java.util.Scanner;
Al mismo tiempo, es necesario declarar una variable de esta librería, la cual será utilizada
para el ingreso de datos, es decir en las instrucciones de Lectura, la instrucción es la
siguiente:
Scanner entrada = new Scanner (System.in);
5.1.2.3. Llamada de Subprogramas

las llamadas a subprogramas pueden ser consideradas como estructuras de control que
simplemente evitan el copiar un gran número de sentencias idénticas (o casi idénticas)
que ocurren más de una vez en un programa.
La llamada a un procedimiento constituye una sentencia, mientras que la llamada a una

función sólo puede hacerse como parte de una expresión:
Intercambia(X,Y);
Z := Media(L,M);
if Media(L,M) > 5.0 then ...
return Media(L,M);
P á g i n a 8 | 22
5.1.3. Argumentos y Parámetros

Un procedimiento que realiza tareas repetidas o compartidas utiliza información
diferente para cada llamada. Esta información se compone de variables, constantes y
expresiones que se pasan al procedimiento cuando se llama.
Para comunicar esta información al procedimiento, el procedimiento define un

parámetro y el código de llamada pasa un argumento a ese parámetro
5.1.3.1. Argumentos
Un argumento representa el valor que se pasa a un parámetro de procedimiento cuando
se llama al procedimiento. El código de llamada proporciona los argumentos cuando se
llama al procedimiento.
Cuando se llama a “Function” un “Sub” procedimiento o, se incluye una lista de

argumentos entre paréntesis inmediatamente después del nombre del procedimiento.
Cada argumento corresponde al parámetro en la misma posición en la lista.
La sintaxis habitual en la definición de un subprograma es:
SUB identificador [(lista_de_parámetros)]
bloque_de_código
END SUB
donde:
➔ identificador es el nombre del subprograma. Debe ser un identificador válido;

➔ lista_de_parámetros es una lista de variables, separadas por comas, que
conforman los datos que le pasamos al subprograma y,
➔ bloque_de_código es un conjunto de sentencias.
5.1.3.1. Parámetros
Un parámetro representa un valor que el procedimiento espera que pase al llamarlo. La
declaración del procedimiento define sus parámetros.
Al definir un “Function” procedimiento o “Sub”, se especifica una lista de parámetros

entre paréntesis inmediatamente después del nombre del procedimiento. Para cada
parámetro, se especifica un nombre, un tipo de datos y un mecanismo de paso (ByVal o
P á g i n a 9 | 22
ByRef). También puede indicar que un parámetro es opcional. Esto significa que el
código de llamada no tiene que pasar un valor para él.
El nombre de cada parámetro actúa como una variable local en el procedimiento. El

nombre del parámetro se utiliza de la misma manera que cualquier otra variable. La lista
de parámetros formales se delimita por paréntesis y se compone de una o varias
sublistas de parámetros de la misma clase y tipo separadas por punto y coma (";"). Cada
sublista está formada por una secuencia de nombres separados por comas (","), seguida
de dos puntos (":") a continuación de los cuales se pone la clase y tipo de los parámetros
de la secuencia:
procedure Muchos_Parámetros(A,B: in Integer; C: out Float; L, M: in out Integer);
Donde en función del sentido en el que se transfiere la información, los parámetros

pueden ser: de entrada (in), de salida (out) y, de entrada/salida (in out).
5.1.4. Ámbito de las variables

El ámbito de una variable (llamado "scope" en inglés) es la zona del programa en la que
se define la variable. JavaScript define dos ámbitos para las variables: global y local.
5.1.4.1. Variables locales

Una variable local es aquella que se puede utilizar solo en un subprograma, es decir que
se limita a trabajar en una sola parte de un programa como por ejemplo en el programa
DFD al momento que utilizamos el ciclo “Para” colocamos una variable “A” esta
variable se utilizará solamente en ciclo que “Para” por lo tanto es un claro ejemplo de
variable local.
El siguiente ejemplo ilustra el comportamiento del ámbito:
function creaMensaje() {
var mensaje = “Mensaje de prueba”;
creaMensaje();
alert(mensaje);
P á g i n a 10 | 22
5.1.4.2. Variables globales

Una variable global es aquella que se puede utilizar en todo el programa sin limitaciones
al contrario que la variable local ésta es indispensable en cualquier programa ya que es
con la que se va a trabajar por ejemplo en el programa DFD utilizamos la variable
global cuando colocamos una lectura.
El siguiente ejemplo ilustra el comportamiento del ámbito:
var mensaje = “Mensaje de prueba”;
function muestraMensaje() {
alert(mensaje);
5.1.5. Funciones de librerías o módulos

Un módulo es una librería como en cualquier otro lenguaje, estas como ya mencionado
contienen variables y/o funciones ya descritas que nos ayudan a programar,
simplificando las líneas de código que se puede utilizar para programar.
Según Meza (2019) algunas de las librerías de uso más común de C++ y que forman
parte de las librerías estándar de este lenguaje.
➔ fstream: Flujos hacia/desde ficheros. Permite la manipulación de archivos desde

el programar, tanto leer como escribir en ellos.
➔ iosfwd: Contiene declaraciones adelantadas de todas las plantillas de flujos y sus
typedefs estándar. Por ejemplo ostream.
➔ iostream: Parte del a STL que contiene los algoritmos estándar, es quizá la más
usada e importante (aunque no indispensable).
➔ La biblioteca list: Parte de la STL relativa a contenedores tipo list; listas
doblemente enlazadas
➔ math: Contiene los prototipos de las funciones y otras definiciones para el uso y
manipulación de funciones matemáticas.
➔ memory: Utilidades relativas a la gestión de memoria, incluyendo asignadores y
punteros inteligentes (auto_ptr).
P á g i n a 11 | 22
➔ "auto_ptr" es una clase que conforma la librería memory y permite un fácil

manejo de punteros y su destrucción automáticamente.
➔ Biblioteca new: Manejo de memoria dinámica
➔ numeric: Parte de la librería numérica de la STL relativa a operaciones
numéricas.
➔ ostream: Algoritmos estándar para los flujos de salida.
➔ queue: Parte de la STL relativa a contenedores tipo queue (colas de objetos).
➔ Librería stdio: Contiene los prototipos de las funciones, macros, y tipos para
manipular datos de entrada y salida.
➔ Librería stdlib: Contiene los prototipos de las funciones, macros, y tipos para
utilidades de uso general.
➔ string: Parte de la STL relativa a contenedores tipo string; una generalización de
las cadenas alfanuméricas para albergar cadenas de objetos. Muy útil para el
fácil uso de las cadenas de caracteres, pues elimina muchas de las dificultades
que generan los char
➔ typeinfo: Mecanismo de identificación de tipos en tiempo de ejecución
➔ vector: Parte de la STL relativa a los contenedores tipo vector; una
generalización de las matrices unidimensionales C/C++
➔ forward_list: Esta librería es útil para implementar con gran facilidad listas
enlazadas simples.
➔ list: Permite implementar listas doblemente enlazadas (listas enlazadas dobles)
fácilmente.
➔ iterator: Proporciona un conjunto de clases para iterar elementos.
➔ regex: Proporciona fácil acceso al uso de expresiones regulares para la
comparación de patrones.
➔ thread: Útil para trabajar programación multihilos y crear múltiples hilos en
nuestra aplicación.
➔ time: Útil para obtener marcas de tiempo durante la ejecución. Se usa con
frecuencia para conocer el tiempo exacto durante un programa.
5.1.6. Recursividad
Un subprograma se llama recursivo si al menos en parte, está definido por sí mismo.
Dicho de otra manera, si una función o un procedimiento hacen una llamada a esta
P á g i n a 12 | 22
propia función o procedimiento, se llaman recursivas. El ejemplo más sencillo es el

factorial: n!=n*(n-1)!
Existen dos tipos de recursividad:
● Simple o rápida: el subprograma se llama así, se expresa de la siguiente manera:
Procedimiento recursivo()
Inicio
/* instrucciones */
recursiva()
/* instrucciones */
Fin
● Cruzada o indirecta: dos subprogramas se llaman el uno al otro: el primero llama

al segundo, que llama al primero, etc; se expresa de la siguiente mantera:
Procedimiento recur1()
Inicio
/* instrucciones */
recur2()
/* instrucciones */
Fin
Procedimiento recur2()
Inicio
/* instrucciones */
recur1()
/* instrucciones */
Fin
P á g i n a 13 | 22
5.1.7. Creación de librerías o módulos

Las librerías son archivos o bloques de código con funciones especiales que podemos
incluir en nuestro código importando sus funcionalidades. Las librerías estándar, por
ejemplo, “stdlib.h” y “stdio.h”, que importan funciones y tipos de datos especiales,
comunicación con periféricos de entrada y salida como la pantalla y el teclado así como
el manejo de archivos.
Según Romo (2019) la creación de librerías pueden realizarse a través de dos métodos:
Método 1: Utilizar librerías en el mismo directorio #include “libreria.h”
Si se busca crear una librería para operaciones aritméticas e incluir esta librería para
probarla en otro archivo. Para esto se debe seguir los siguientes pasos:
1. Crear el archivo de cabeceras: Se crea un archivo con extensión “.h” en el

mismo directorio del código principal, este archivo debe tener todos los
prototipos de funciones y definiciones de tipos de datos de tu librería.
#ifndef _LIBRERIA
#define _LIBRERIA
float suma(float A,float B);
float resta(float A,float B);
float multiplicacion(float A,float B);
#include ″libreria.c″
#endif
2. Crear el archivo del código de la librería: El archivo del código de la librería,

contiene incluye el archivo de cabecera que se creó anteriormente y además
contiene el código de todas las funciones que fueron escritas en el archivo de
cabecera.
P á g i n a 14 | 22
#include ″libreria.h″
float suma(float A,float B){
return A+B;
float resta(float A,float B){
return A-B;
float multiplicacion(float A,float B){
return A*B;
3. Llamar a la librería: Cuando estén terminados ambos archivos, la librería está

lista para ser usada. Se crea el archivo test.c dentro del mismo directorio, se
incluye las librerías estándar y la nueva librería que se creó.
#include ″libreria.h″
void main(){
int A = 1;
int B = 2;
printf(″Resultado de %d+%d = %f\n″, A,B,suma(A,B));
printf(″Resultado de %d-%d = %f\n″, A,B,resta(A,B));
printf(″Resultado de %d*%d = %f\n″, A,B,multiplicacion(A,B));
return 0;
Método 2: Utilizar librerías en el directorio include del compilador #include

<libreria.h>
Éste segundo método consiste en guardar una copia de la librería que se creó antes,
directamente en la carpeta del compilador. Esto permitirá llamar a la librería desde
cualquier código como si fuese una librería estándar.
P á g i n a 15 | 22
1. Copiar la librería a la carpeta del compilador: Copiar los archivos

“libreria.h” y “libreria.c” a la carpeta include del compilador.
2. Llamar a la librería: Luego de copiar los archivos a la carpeta correspondiente,
se puede utilizar la librería como si fuese una librería estándar, sin necesidad de
tener los archivos dentro del directorio del código principal. Para llamar a la
librería se usa la instrucción #include <libreria.h>, se utiliza <> en vez de » »
por qué de esta manera el compilador buscará la librería en la carpeta inclulde y
no en el directorio del código principal.
#include <libreria.h>
void main(){
int A = 1;
int B = 2;
printf(″Resultado de %d+%d = %f\n″, A,B,suma(A,B));
printf(″Resultado de %d-%d = %f\n″, A,B,resta(A,B));
printf(″Resultado de %d*%d = %f\n″, A,B,multiplicacion(A,B));
return 0;
P á g i n a 16 | 22
6. DESARROLLO
Code Blocks
Código del programa.

#include <iostream> void menuInicial(){
#include "caratulaLibreria.h" cout << "------------------------------------------------------------------------------------" << endl;
#include "ventaLibreria.h" cout << "Ha accedido correctamente a nuestro sistema digital" << endl;
using namespace std; cout << "Contamos con productos desde: " << endl;
string ciudadMurilloKarla,usuarioInMurilloKarla,usuarioMurilloKarla; cout << " 1. Ropa" << endl;
int cMurilloKarla, codCardMurilloKarla, contrasenaInMurilloKarla, contrasenaMurilloKarla, cout << " 2. Comida" << endl;
menupagoIMurilloKarla; cout << " 3. Electrodomesticos" << endl;
int menuPrincMurilloKarla, numCardMurilloKarla, numcuotasMurilloKarla, productoMurilloKarla, repetirMurilloKarla; cout << " 4. Maquillaje" << endl;
float cuotaMurilloKarla ; cout << "Le informamos que si su compra excede los 100 dolares, no se le cobrará el valor del envio,
void inicioSesion(); caso contrario se cobra un envío $15" << endl;
void menuInicial(); do {
void menuInformativo (); cout << "Escriba el numero correspondiente al producto que necesita" << endl;
void pagoInmediato(); cin >> productoMurilloKarla;
void pagoPlazos(); switch (productoMurilloKarla) {
void confirmarCiudad(); case 1:
void repetirInformativo(); cout << "Ingrese el valor que pagara por la ropa" << endl;
int main() { cin >> precioMurilloKarla;
caratula(); venta ();
inicioSesion(); break;
menuInicial(); case 2:
menuInformativo (); cout << "Ingrese el valor que pagara por la comida" <<
return 0; endl;
} cin >> precioMurilloKarla;
venta ();
void inicioSesion(){ break;
usuarioMurilloKarla = "KarlaM"; case 3:
contrasenaMurilloKarla = 123; cout << "Ingrese el valor que pagara por los
cout << "BIENVENIDO A SU PLATAFORMA DE MERCADO LIBRE DE QUITO" << endl; electrodomésticos" << endl;
cout << "------------------------------------------------------------------------------------" << endl; cin >> precioMurilloKarla;
cout << "Inicio sesion" << endl; venta ();
do { break;
cout << "Ingrese su usuario" << endl; case 4:
cin >> usuarioInMurilloKarla; cout << "Ingrese el valor que pagara por el maquillaje" <<
cout << "Ingrese su contraseña" << endl; endl;
cin >> contrasenaInMurilloKarla; cin >> precioMurilloKarla;
if (usuarioInMurilloKarla==usuarioMurilloKarla) { venta ();
cout << "El usuario digitado es correcto" << endl; break;
if (contrasenaInMurilloKarla==contrasenaMurilloKarla) { default:
cout << "Y el contraseña digitada es cout << "El numero de producto que ingreso no forma
correcta" << endl; parte de nuestro inventario" << endl;
} else { }
cout << "Pero la contraseña digitada } while (!(productoMurilloKarla>=1 && productoMurilloKarla<=4));
es incorrecta" << endl;
cout << "Intentelo de nuevo" << }
endl; void menuInformativo (){
} cout << "------------------------------------------------------------------------------------------------------------------------- " << endl;
} else { cout << "Escriba 1 para ingresar al menu de formas de pago inmediato" << endl;
cout << "El usuario digitado es incorrecto" << endl; cout << "Escriba 2 para ingresar al menu de pago a plazos" << endl;
if (contrasenaInMurilloKarla==contrasenaMurilloKarla) { cout << "Escriba 3 para ingresar al menu de confirmacion de ciudad" << endl;
cout << "Pero la contraseña digitada cout << "Escriba 4 para salir del sistema" << endl;
es correcta" << endl; do {
cout << "Intentelo de nuevo" << cout << "Digite el numero del menu de su interes" << endl;
endl; cin >> menuPrincMurilloKarla;
} else { switch (menuPrincMurilloKarla) {
cout << "Y la contraseña digitada es case 1:
incorrecta" << endl; pagoInmediato();
cout << "Intentelo de nuevo" << repetirInformativo();
endl; break;
} case 2:
}
} while (!(usuarioInMurilloKarla==usuarioMurilloKarla &&
contrasenaInMurilloKarla==contrasenaMurilloKarla));
}
pagoPlazos();
repetirInformativo(); void pagoPlazos(){
break; cout << "Por favor ingrese el numero de cuotas con el que quisiera pagar la compra" << endl;
case 3: cin >> numcuotasMurilloKarla;
confirmarCiudad(); cuotaMurilloKarla =
repetirInformativo(); totalMurilloKarla/numcuotasMurilloKarla;
break; cout << "El valor que usted pagara cada mes durante " <<
case 4: numcuotasMurilloKarla << " meses es de $" << cuotaMurilloKarla << " mas 5 dolares cada mes" << endl;
cout << "Gracias por usar nuestro sistema" << endl; for
break; (cMurilloKarla=1;cMurilloKarla<=numcuotasMurilloKarla;cMurilloKarla++) {
default: cuotaMurilloKarla =
cout << "EL numero ingresado no forma parte de nuestras cuotaMurilloKarla+5;
opciones de menu" << endl; cout << "Su cuota en el mes " <<
cout << "Por favor intente escribiendo un numero correcto cMurilloKarla << " sera de $" << cuotaMurilloKarla << endl;
esta vez" << endl; }
cout << "------------------------------------------------------------ }
-----------------------------------------" << endl; void confirmarCiudad(){
} cout << "Ingrese su ciudad de residencia" << endl;
} while (!(menuPrincMurilloKarla>=1 && menuPrincMurilloKarla<=4)); cin >> ciudadMurilloKarla;
} if (ciudadMurilloKarla=="Quito") {
void pagoInmediato(){ cout << "Usted no recibira ningun
cout << "Puede elegir entre" << endl; sobre cargo por su ciudad de residencia, su total a pagar es de: $" << totalMurilloKarla << endl;
cout << "1. Tarjeta de credito" << endl; } else {
cout << "2. Efectivo" << endl; cout << "Usted recibira un sobre
cout << "3. Salir del sistema sin pagar" << endl; cargo del 10% por no ser de la ciudad de Quito" << endl;
do { cout << "El total a pagar sera de: $"
cout << "Digite el numero de la << totalMurilloKarla*0.10+totalMurilloKarla << endl;
opcion que le interesa" << endl; }
cin >> menupagoIMurilloKarla; }
switch (menupagoIMurilloKarla) { void repetirInformativo(){
case 1: do{
cout << "Para cout<< "Escriba 1 para regresar al menu informativo o escriba 2 para finalizar el sistema"<<endl;
realizar su pago mediante tarjeta de credito por favor" << endl; cin >> repetirMurilloKarla;
cout << switch (repetirMurilloKarla) {
"Ingrese su numero de tarjeta de credito" << endl; case 1:
cin >> menuInformativo();
numCardMurilloKarla; break;
cout << case 2:
"Ingrese el codigo de seguridad de su tarjeta" << endl; cout<< "Gracias por usar el sistema"<< endl;
cin >> break;
codCardMurilloKarla; default:
cout << "Se cout<< "El numero ingresado no es correcto"<< endl;
procedera a hacer el respectivo cobro por su compra" << endl; }
break; }while (!(repetirMurilloKarla>=1 && repetirMurilloKarla<=2));
case 2: }
cout << "Por
favor acerquese al banco mas cercano y deposite el valor de su compra en la cuenta: 4321231312" << endl;
break;
case 3:
cout << "Su
compra sera cancelada, gracias por usar nuestro sistema" << endl;
break;
default:
cout << "El
numero que ingreso no corresponde a una de las opciones disponibles, intentalo de nuevo" << endl;
}
} while (!(menupagoIMurilloKarla>=1 &&
menupagoIMurilloKarla<=3));
}
P á g i n a 17 | 22
Captura de pantalla del código
K, Murillo (2021)
P á g i n a 18 | 22
Captura de ejecución
K, Murillo (2021)
P á g i n a 19 | 22
7. CONCLUSIONES
Con este trabajo he aprendido que la programación ha mejorado mucho con los años, y
con ello, nuestras propias vidas. Creo que en el futuro la programación será más
necesaria que hoy en día.
8. RECOMENDACIONES
• Prestar atención a todas las indicaciones que la docente de en clases

• Practicar más los ejercicios de programación
• Conocer sobre todos los sistemas informáticos que se utilizan en el momento de
• programar una aplicación y como se debería hacer el procedimiento.
P á g i n a 20 | 22
9. REFERENCIAS
Dollard, K. (2015, 20 julio). Diferencias entre parámetros y argumentos - Visual Basic.
Microsoft Docs. https://docs.microsoft.com/es-es/dotnet/visual-basic/programming-
guide/language-features/procedures/differences-between-parameters-and-
arguments#:%7E:text=Un%20argumento%20representa%20el%20valor,cuando%20se
%20llama%20al%20procedimiento.&text=A%20diferencia%20de%20la%20definici%
C3%B3n,m%C3%A1s%20variables%2C%20constantes%20y%20literales.
Eguíluz, J. (2007). Introducción a JavaScript. Librosweb.
https://www.jesusda.com/docs/ebooks/introduccion_javascript.pdf
González, V. (2004). Subprogramas. Platea.
http://platea.pntic.mec.es/vgonzale/cyr_0204/ctrl_rob/flowol/subprog.htm
Guzmán, A. (2015). Subprogramas: Funciones y procedimientos.
http://webdelprofesor.ula.ve/ingenieria/eliana/prog/unidad6.pdf
Meza, J. (2019). Librerías o Bibliotecas. ProgramarYa.
https://www.programarya.com/Cursos/C++/Bibliotecas-o-
Librerias#:%7E:text=Junto%20con%20los%20compiladores%20de,%2C%20realizar%
20funciones%20matem%C3%A1ticas%2C%20etc.
Millán, A. (2000). Parámetros y argumentos de las funciones en C++. Zator.
https://www.zator.com/Cpp/E4_4_5.htm#:%7E:text=Cuando%20se%20realiza%20una
%20llamada,actuales%20para%20los%20valores%20pasados.
Lòpez, R. (2017). Ámbito: variables locales y globales [Diapositivas]. Slideshare.
https://es.slideshare.net/RommelLpez/grupo-12-mbito-variables-locales-y-globales
P á g i n a 21 | 22
Pineda, C. (2016). Implementación | Fundamentos de Programación. Fundamentos de
Programación.
http://www.utn.edu.ec/reduca/programacion/fundamentos/implementacin.html#:%7E:te
xt=Es%20la%20%C3%BAltima%20fase%20que,en%20un%20lenguaje%20de%20prog
ramaci%C3%B3n
Subprogramas. (2005). Gedlc.
http://www.gedlc.ulpgc.es/docencia/NGA/subprogramas.html
Rohaut, S. (2019). Algoritma tecnica fundamentales de programación. eni.
Romo, R. (2020, 2 septiembre). Como crear una Librería en C/C++. Ricardo Romo.
https://ricardoromo.co/2019/como-crear-una-libreria-en-c-c/
P á g i n a 22 | 22

Taller 1 Murillo Karla

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Taller 1 Murillo Karla

Cargado por

Copyright:

Formatos disponibles

ESTUDIANTE:

KARLA DOMENICA MURILLO ZAMBRANO

En el siguiente informe trataremos temas antes vistos en la unidad 1 y 2, también

La programación es una herramienta fundamental en el mundo en el que vivimos,

2.1. OBJETIVO GENERAL

Que el estudiante desarrolle la habilidad de crear algoritmos y codificar programas que

2.2. OBJETIVOS ESPECÍFICOS

1. Identificar un problema específico, plantear la solución con la elaboración de un

2. Elaborar un algoritmo aplicando los lenguajes algorítmicos gráficos (Diagrama de

3. Usar dos herramientas para codificar el algoritmo. (Pseint + Code Blocks)

4. Desarrollar algoritmos en lenguajes de programación que nos permitirán cumplir con

a usar la sintaxis y semántica correcta dependiendo del lenguaje de programación.

5. Usar operadores, entrada/salida y estructuras de control.

En la anterior unidad aprendimos todo lo referente a lo que es Introducción a la

La programación es un proceso donde se analizan los pormenores de un problema y

Definición de Code blocks

Se trata de un entorno desarrollado integrado (IDE) para programadores y desarrolladores,

Es un IDE libre, de código abierto, multiplataforma construido para satisfacer las

Entrada y Salida de datos

Entradas y Salidas en Pseint

Para pedir al usuario que introduzca un valor por teclado, usaremos

Para mostrar por pantalla un valor, usaremos la operación escribir. Después de

También se puede mostrar mensajes, simplemente después de la operación escribir

Entradas y Salidas en code blocks

Salidas con cout

Los valores de variables se pueden enviar a la pantalla empleando cout. Es posible

cout << num_dulces << “dulces\n”;

Esta instrucción le dice a la computadora que despliegue dos cosas: el valor de la

Entrada con cin

cin es el flujo de entrada estándar. Supondremos que la entrada estándar es el teclado.

cin >> num_pasteles;

En la sentencia anterior lo que hacemos es leer un dato introducido por teclado y

5.1. Subprogramas: Funciones o Procedimientos

5.1.1. Definición de Subprograma

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

La declaración de un subprograma es como su cabecera, pero terminada en ";" en vez de

procedure Intercambia(A,B: in out Integer);

function Media(A,B: Float) return Float;

Dado que en el presente curso se utilizará el lenguaje de programación java, a

Scanner entrada = new Scanner (System.in);

5.1.2.3. Llamada de Subprogramas

La llamada a un procedimiento constituye una sentencia, mientras que la llamada a una

if Media(L,M) > 5.0 then ...

5.1.3. Argumentos y Parámetros

Para comunicar esta información al procedimiento, el procedimiento define un

Cuando se llama a “Function” un “Sub” procedimiento o, se incluye una lista de

La sintaxis habitual en la definición de un subprograma es:

SUB identificador [(lista_de_parámetros)]

➔ identificador es el nombre del subprograma. Debe ser un identificador válido;

Al definir un “Function” procedimiento o “Sub”, se especifica una lista de parámetros

El nombre de cada parámetro actúa como una variable local en el procedimiento. El

procedure Muchos_Parámetros(A,B: in Integer; C: out Float; L, M: in out Integer);

Donde en función del sentido en el que se transfiere la información, los parámetros

5.1.4. Ámbito de las variables

5.1.4.1. Variables locales

El siguiente ejemplo ilustra el comportamiento del ámbito:

var mensaje = “Mensaje de prueba”;

5.1.4.2. Variables globales

El siguiente ejemplo ilustra el comportamiento del ámbito:

var mensaje = “Mensaje de prueba”;

5.1.5. Funciones de librerías o módulos

➔ fstream: Flujos hacia/desde ficheros. Permite la manipulación de archivos desde

➔ "auto_ptr" es una clase que conforma la librería memory y permite un fácil