00040_eMacro_Fundamentos_de_programacion_Visual_Basic.pdf

EDI TORIAL
MACRO" 1
ng. Ricardo Marcelo Villalobos
Fundamentos de programación
Más de 100 algoritmos codificados

Más de 100 algoritmos codificados
EDITORIAL
MACRO"
España - México - Colombia - Chile - E
cuador - Perú - Bolivia - Uruguay - Guatemala - Costa Rica

EDITORIAL
MACRO"
Fundamentos de programación Visual Basic
Autor: Ricardo Walter Marcelo Villalobos
© Derechos de autor registrados:
Empresa Editora Macro EIRL
© Derechos de edición, arte gráfico y diagramación reservados:
Empresa Editora Macro EIRL
Coordinadora de edición:
Cynthia Arestegui Baca
Diseño de portada:
Alejandro Marcas León
Corrección de estilo:
Milton A. Gonzales M .
Diagramación:
Katia Valverde Espinoza
Edición a cargo de:
© Empresa Editora Macro EIRL
Av. Paseo de la República N
: 5613, Miraflores, lima, Perú
t Teléfono: (511) 748 0560
i8! E-mail: proyecto@editorialmacro.com
® Página web: www.editorialmacro.com
Primera edición digital: julio 2016
Disponible en: macro.bibliotecasenlinea.com
ISBN N: 978-612-304-236-3
ISBN digital N
: 978-612-304-459-6
Prohibida la reproducción parcial o total, por cualquier medio o método, de este libro sin
previa autorización de la Empresa Editora Macro EIRL.

AUTOR
Ricardo Marcelo Villa lobos
Profesional de sistemas y contabilidad, con más de diez años de experiencia en TI, ha participado
como asesor y desarrollador en proyectos de software para diversas empresas privadas y públicas
del país, como Minera del Hill, Aruntani, Verkaufen, MINSA, IPD; y transnacionales como Magna
Rosseta Cerámica- MRC, en la cuales ha utilizando sus conocimientos de contabilidad y de ingeniería
de software para realizar el análisisy diseños de software con RUP, UML y patrones de arquitectura.
Asimismo, ha realizado diseños con lenguajes Java, .NET y PHP; también ha trabajado con base de
datos Oracle, SQL Server, MySQL y PostgreSQL.
Asimismo, ha participado como expositor en diferentes universidades e institutos (Universidad
Nacional de Ingeniería - CEPS-UN1
, Universidad Nacional de Trujillo, Universidad César Vallejo
de Trujillo, Universidad Nacional José Faustino Sánchez Carrión de Huacho, Instituto San Agustín,
Instituto José Pardo, Instituto Manuel Seoane Corrales, Instituto La Reyna Mercedaria). Ha escrito
libros, artículos y manuales de desarrollo de software (Visua/Basic Nivel 111 componentes, Oracle lOg,
manuales de VB.NET, ADO.NET, POO.NET, Access, Java POO, PHP Fundamentos, PHP POO).
En 2008 fue invitado por la Empresa Editora Macro para formar parte del staff de escritores, y
salen a la luz cuatro obras relacionadas a los primeros pasos de la ingeniería de software (libros de
fundamentos y mas de 100 Algoritmos con Visual Basic, Java, C++ y C#).
En la actualidad, difunde su experiencia como docente en la Universidad Nacional de Ingeniería
(UN I-FIIS- CEPS-UNI) y el Instituto San Ignacio (ISIL); asimismo, realiza capacitaciones para empresas,
como Telefónica del Perú, FAP, La Caja de Pensiones Militar Policial, ALPECO, Banco de Materiales,
entre otros.

Agradecimientos
Es difícil dejar de mencionar a las personas que día a día
fortalecen el conocimiento y la sabiduría de los demás. Me
faltarían líneas en este libro para mencionar a todos, pero
quiero agradecer, en primer lugar, a Dios y a mis padres.
También a personas muy especiales que, con su sabiduría y
experiencia, han ayudado y permitido plasmar muchas de
sus ideas en esta obra: Peggy Sánchez, Sergio Matsukawa,
Gustavo Coronel, Gino Henostroza, Julio Flores, Joel Carrasco,
Luis Zúñiga, Jesús Echevarria y todos mis alumnos y amigos
en general.

/
PROLOGO
Prólogo
Cómo no recordar las primeras clases de Algoritmo y la ilusión que todos tienen por aprender a
programar. Esta obra plasma los primeros pasos que cualquier estudiante de la carrera de Ingeniería
de Sistemas, software e informática debe conocer para empezar a analizar, diseñar y codificar
sus primeros algoritmos; y así pasar la barrera que todo programador debe dominar, que son las
estructuras de control de flujo tales como if, switch (C++, Java y C#), select case (vb), while y for.
Este libro contiene nueve capítulos con más de cien algoritmos resueltosy otros ochenta propuestos;
estoy seguro de que al concluir la lectura, el usuario formará parte del mundo de los desarrolladores
de software. En el primer capítulo se desarrollan los conceptos generales de arquitectura de la PC,
hardware, software, lenguajes de programación, metodología de algoritmos, diagramas de flujo,
pseudocódigo, variables, constantes, instrucciones, entre otros.
El segundo apartado contiene diez algoritmos básicos para entender y resolver en forma simple
los problemas de entrada, proceso (secuencial) y salida de los cálculos realizados. El tercer capítulo
presenta quince algoritmos con las estructuras más utilizadas en la solución de problemas, llamada
if. En el cuarto capítulo se explica la forma más fácil de solucionar problemas sin el uso de if anidados
y engorrosos. En el quinto capít ulo se enseña a entender y dominar la est ructura repetitiva, y a
aplicar los conceptos de contador, acumulador, bucles, entre otros.
Debido a que muchas veces es más fácil resolver procesos repetitivos usando la estructura for, en
el sexto apartado se encuentran quince problemas resueltos; aunque muchos de ellos pertenecen
al capít ulo anterior, esto servirá para analizar su simplicidad. En el sétimo apartado -tomando en
cuenta que uno de los temas más utilizados en el manejo de colecciones de datos tiene que ver
con los arreglos (arrays)- se explica el concepto y se resuelven problemas de arreglos, algoritmos
de búsqueda y ordenación de datos. En el capítulo octavo, se explican y resuelven problemas con
cadena de caracteres (texto). Finalmente, una de las mejores recomendaciones para resolver y
reutilizar procesos es el concepto de divide y vencerás, por ello en el capítulo nueve se enseña cómo
separar un problema en varias partes reutilizables.

00040_eMacro_Fundamentos_de_programacion_Visual_Basic.pdf

/
INDICE
índ ice
Capítulo 1
Fundamentos de programación ................................................... 13
1.1 Introducción .................................................................................................................. 13
1.2 Computadora ................................................................................................................ 14
1.3 Arquitectura de una com putadora ............................................................................... 14
1.4 Unidades de medida de almacenamiento .......... ...................................................... 15
1.5 Sistemas de numeración ............................................................................................... 16
1.6 Conversión binario a decimal ............................................................................. ........ 16
l.7 Conversión decimal a binario ....................................................................................... 16
1.8 Representación de texto en el sistema binario ............................................................ 17
1.9 Representación binaria de datos no numéricos ni de texto ........................................ 17
1.10 Los programas (software) ........................................................................................... 17
1.11 Lenguajes de programación ..................... .... ........................................................... 18
1.12 Traductores del lenguaje de programación ............................................................... 19
1.13 Ciclo de vida de un software ...................................................................................... 19
1.14 Algoritmo .................................................................................................................... 20
1.14.1 Características que deben de cumplir los algoritmos obligatoriamente ................ 20
1.14.2 Características aconsejables para los algoritmos ................................................ 21
1.14.3 Fases en la creación de algoritmos ......................................................................... 21
1.14.4 Herram ientas de un algoritmo ................................................................................ 21
1.14.5 Instrucciones ............................................................................................................ 23
1.15 Comentarios ................................................................................................................ 24
1.16 Palabras reservadas .................................... .... ......... .... ........................ .................. 24
1.17 Identificadores ............................................................................................................ 25
1.18 Variables ...................................................................................................................... 25
1.19 Constantes .................................................................................................................. 26
1.20 Tipo de datos simples (primitivos) ............................................................................. 26
1.21 Tipo de datos complejos (estructurados) .......... ......................................... .... ........ 28
1.22 Operadores y expresiones .......................................................................................... 29
1.23 Control de flujo ........................................................................................................... 31

Capítulo 2
Estructura secuencial ................................................................... 33
2.1 Estructura secuencial .................................................................................................... 33
Problema n.• 1 .................................................................................................................... 33
Problema n.0
2 ..................................................................................................................... 34
Problema n.0
3 ..................................................................................................................... 36
Problema n.0
4 ..................................................................................................................... 37
Problema n.0
5 ..................................................................................................................... 38
Problema n.0
6 ..................................................................................................................... 40
Problema n.0
7 ..................................................................................................................... 41
Problema n.0
8 ..................................................................................................................... 43
Problema n.0
9 ..................................................................................................................... 45
Problema n.0 10 .................................................................................................................. 46
2.2 Problemas propuestos .................................................................................................. 48
Capítulo 3
Estructura selectiva simple y doble .............................................. 49
3.11ntroducción .................................................................................................................. 49
3.2 Estructura selectiva simple ........................................................................................... 49
3.3 Estructura selectiva doble ............................................................................................ 50
3.4 Estructuras anidadas ..................................................................................................... 50
Problema n: 11 .................................................................................................................. 51
Problema n.• 12 .................................................................................................................. 53
Problema n.0
13 .................................................................................................................. 55
Problema n.0 14 .................................................................................................................. 57
Problema n.0
15 .................................................................................................................. 59
Problema n.0
16 .................................................................................................................. 61
Problema n.0
17 ...................................... ................... ........ ............................................. 63
Problema n.0
18 .................................................................................................................. 64
Problema n.0 19 ............. ................... .............. ......... ......... ......... ......... .... ...... ............ 67
Problema n.0
20 .................................................................................................................. 68
Problema n.0 21 .................................................................................................................. 71
Problema n.0
22 .................................................................................................................. 73
Problema n.0
23 .................................................................................................................. 76
Problema n.0 24 ... .......... .............. .... .............. ........ ......... .... .... .... .... .... ................... 78
Problema n.0
25 .................................................................................................................. 80
3.4 Problemas propuestos .................................................................................................. 83

Capítulo 4
Estructura selectiva múltiple ........................................................ 85
4.11ntroducción .................................................................................................................. 85
4.2 Estructura selectiva múltiple ........................................................................................ 85
4.2.1 Estructura selectiva múltiple usando rangos ............................................................ 86
Problema n.0
26 ............................................................ ... ............... .... .... ....................... 87
Problema n.0
27 .................................................................................................................. 89
Problema n.0
28 ............................................................ ................... .... .... ....................... 91
Problema n.0
29 .................................................................................................................. 93
Problema n.0
30 .................................................................................................................. 95
Problema n.0
31 .................................................................................................................. 97
Problema n.0
32 .................................................................................................................. 99
Problema n.0
33 ................................................................................ .... .... ..................... 101
Problema n.0
34 ................................................................................................................ 103
Problema n.0
35 ................................................................................................................ 105
Problema n.0
36 ................................................................................................................ 109
Problema n.0
37 ................................................................................................................ 111
Problema n.0
38 ............... ............................................ ................... .... .......................... 113
Problema n.0
39 ................................................................................................................ 115
Problema n.0
40 ................................................................................................................ 117
4.3 Problemas propuestos ................................................................................................ 123
Capítulo S
Estructura repetitiva «Mientras» ............................................... 125
5.11ntroducción ................................................................................................................ 125
5.2 Contador ..................................................................................................................... 125
5.3 Acumulador ................................................................................................................. 126
5.4 Salir del bucle ...................................... ................. .............. .... .... .......................... 126
5.5 Continuar al inicio del bucle ....................................................................................... 126
5.6 Estructura repetitiva «Mientras» .............................................................................. 127
5.7 Estructura repetitiva «Mientras» anidada .................................................................. 127
Problema n.0
41 ................................................................................................................ 128
Problema n.0
42 ................................................................................................................ 129
Problema n.0
43 ................................................................................................................ 131
Problema n.0
44 .............................. ................... .... .............. .... ......... .... ..................... 132
Problema n.0
45 ................................................................................................................ 134
Problema n.0
46 ................................................................................................................ 135
Problema n.0
47 ........................................ ....................................................................... 137

Problema n.0
48 ................................................................................................................ 138
Problema n.0
49 ................................................................................................................ 140
Problema n.0
50 ................................................................................................................ 142
Problema n.0
51 ................................................................................................................ 143
Problema n.0
52 .........•...................................................................................................... 145
Problema n.0
53 ................................................................................................................ 146
Problema n.0
54 ................................................................................................................ 148
Problema n.0
55 ................................................................................................................ 150
Capítulo 6
Estructura repetitiva <<Para>> ...................................................... 155
6.1 Introducción ................................................................................................................ 155
6.2 Estructu ra repetitiva «Para» ....................................................................................... 155
6.3 Estructu ra repetitiva «Para» anidada ......................................................................... 156
Problema n.0
56 ................................................................................................................ 156
Problema n.0
57 ........................ .... .... .............. ................... .............. ......................... 158
Problema n.0
58 ................................................................................................................ 159
Problema n.0
59 ................................................................................................................ 161
Problema n.0
60 ................................................................................................................ 162
Problema n.0
61 ................................................................................................................ 164
Problema n.0
62 ........................ .... .............. .... ................... .............. ........... ............. 165
Problema n.0
63 ................................................................................................................ 167
Problema n.0
64 ................................................................................................................ 170
Problema n.0
65 ................................................................................................................ 171
Problema n.0
66 ................................................................................................................ 173
Problema n.0
67 ................................................................................................................ 175
Problema n.0
68 ................................................................................................................ 176
Problema n.0
69 ................................................................................................................ 178
Problema n.0
70 ................................................................................................................ 180
Capítulo 7
Estructuras de datos. Arreglos (vectores y matrices) .................. 185
7.l lntroducción ................................................................................................................ 185
7.2 Arrays (arreglos) ......................................................................................................... 186
7.3 Operaciones con arrays .............................................................................................. 186
7.4 Creación de arrays ...................................................................................................... 187
7.5 Recorrido por los elementos del array ... ................................................................... 188
Problema n.0
71 ................................................................................................................ 189

Problema n.0
72 ................................................................................................................ 190
Problema n.0
73 ................................................................................................................ 192
Problema n.0
74 ................................................................................................................ 193
Problema n.0
75 ................................................................................................................ 195
Problema n.0
76 ..............•...................•......................... ................................................... 197
Problema n.0
77 ................................................................................................................ 199
Problema n.0
78 ................................................................................................................ 202
Problema n.0
79 ................................................................................................................ 203
Problema n.0
80 ................................................................................................................ 205
Problema n.0
81 ................................................................................................................ 207
Problema n.0
82 ................................................................................................................ 210
Problema n.0
83 ............... ...................................... .............. .... .... .... .... .... ................ 212
Problema n.0
84 ................................................................................................................ 214
Problema n.0
85 ................................................................................................................ 217
Capítulo 8
Cadenas de caracteres ............................................................... 223
8.11ntroducción ................................................................................................................ 223
8.2 Juego de caracteres .................................................................................................... 223
8.3 Carácter (char) ............................................................................................................ 224
8.4 Cadena de caracteres (string) ...... .......................... .................. ......... .... .... .... ...... 225
8.5 Operaciones con cadena ............................................................................................ 225
8.6 Concatenación ............................................................................................................ 225
8.7 Comparación ............................................................................................................... 226
8.8 Cálculo de longitud ..................................................................................................... 226
8.9 Extracción de cadenas (subcadenas) .... .... ......... .... ......................................... ... .. 227
8.10 Búsqueda de cadenas ............................................................................................... 228
8.11 Conversiones ............................................................................................................. 228
Problema n.0
86 ................................................................................................................ 230
Problema n.0
87 ................................................................................................................ 231
Problema n.0
88 ................................................................................................................ 232
Problema n.0
89 ................................................................................................................ 233
Problema n.0
90 ................................................................................................................ 235
Problema n.0
91 ................................................................................................................ 237
Problema n.0
92 ................................................................................................................ 238
Problema n.0
93 ................................................................................................................ 240
Problema n.0
94 ................................................................................................................ 241
Problema n.0
95 ..................................•...................•..... ................................................... 244
8.12 Problemas propuestos .............................................................................................. 247

Capítulo 9
SubAigoritmos (procedimientos y funciones) ............................. 249
9.11ntroducción ................................................................................................................ 249
9.2 Procedimientos ........................................................................................................... 250
9.3 Funciones .................................................................................................................... 250
9.4 Paso de parámetros ................. .......... ................... ........................ .... .................... 251
9.5 Parámetros por valor (entrada) .................................................................................. 251
9.6 Parámetros por referencia (salida) ............................................. ......... ..................... 252
Problema n.0
96 ................................................................................................................ 253
Problema n.0
97 ................................................................................................................ 255
Problema n.0
98 ............................................................ ................... ............................... 257
Problema n.0
99 ................................................................................................................ 259
Problema n.0
100 ............................................................................. .... .... ..................... 261
Problema n.0
101 .............................................................................................................. 263
Problema n.0
102 .............................................................................................................. 266
Problema n.0
103 .............................................................................................................. 269
Problema n.0
104 .............................................................................................................. 272
Problema n.0
105 .......................................................... ................... .... .......................... 275

1.11ntroducción
En los primeros ciclos de toda carrera profesional relacionada a la ingeniería de sistemas, los estudiantes
requieren entender, aprender y dominar los fundamentos de programación para resolver problemas que
permitirán automatizar procesos usando la computadora.
Saber programar es la base de toda su carrera y, para conseguir este objetivo, he plasmado mi experiencia
de docencia de mas de diez años en el campo de la Ingeniería de Sistemas. Sé que este libro le ayudará a
resolver todas sus dudas y dominar las principales estructuras de programación.
Este libro contiene más de 100 algoritmos resueltos y codificados en el lenguaje Visual Basic, que en la
actualidad es uno de los lenguajes de programación propuesto por Microsoft para la tecnología .NET
A continuación, se describen los conceptos generales de los fundamentos de programación.

Algoritmos con Visual Basic
1.2 Computadora
Es un aparato electrónico que recibe datos (entrada), los procesa (instrucciones denominado programa)
y devuelve información (salida), también conocido como ordenador o PC (Personal Computer). En la
actualidad existe una variedad de computadoras para diferentes propósitos.
Servidores Computadora personal Computadora portátil PDA
1.3 Arquitectura de una computadora
Las computadoras tienen dos componentes principales que son el hardware y el software, que trabajan
en coordinación para llevar a cabo sus objetivos.
Hardware: Hard (duro) - ware (componente), representa la parte física de la computadora.

Software: 5oft (blando) - ware (componente), representa la parte lógica de la computadora (los
programas); estos se encuentran almacenados en los componentes físicos de la computadora, tales como
memorias RAM, ROM, Discos Duros (Hard Disk), entre otros.
0:3
.....
M_........
Office
WindowsVISto
. .
Programas internos
tales como:
• BIOS
• CMOS
• SetUp

Capítulo 1: Fundamentos de programación
la siguiente figura muestra la arquitectura de la computadora y sus principales componentes en
coordinación.
Dispositivos de
entrada
(INPUT)
r
-
Proceso
CPU
(Central Processing Unit)
ALU
(Arithmetic Logic Unit)
t
cu
(Control Unit)
t
Memoria
interna
Memoria
externa
1.4 Unidades de medida de almacenamiento
Dispositivos de
salida J
(OUTPUT)
la memoria interna (RAM) y las memorias externas (disco duro) almacenan información. la información
que se guarda y entiende la PC está en formato binario (0- 1).
BIT (Binary DigiT): El bit representa la unidad mínima de información que almacena una computadora.
BYTE: Está compuesto por 8 bit (01110011), entonces existe 28 = 256 combinaciones diferentes (tabla de
código ASCII).
Por lo general, la información se representa por caracteres y cada carácter (número, letra, símbolo, etc.)
es un byte. Para medir la información se utilizan múltiplos de bytes.
Byte 1 B 8 bits
Kilobyte 1 KB 210
bytes 1024 bytes
Megabyte 1MB 220 bytes 1024 KB
Gigabyte 1GB 230
bytes 1024MB
Terabyte 1 TB 240
bytes 1024GB

1.5 Sistemas de numeración
Todos los sistemas de numeración tienen una base, que es el número total de símbolos que utiliza el
sistema. En el caso de la numeración decimal, la base es 10; en el sistema binario es 2.
El Teorema Fundamental de la Numeración permite saber el valor decimal que tiene cualquier número
en cualquier base. Dicho teorema utiliza la siguiente fórmula:
. . . + x3
• B3 + x ~ . B~ + x, .B' + x0
• B0 + x_,.s-• + x _~ . s-2 + ...
Donde:
• X1
: Es el símbolo que se encuent ra en la posición número i del número que se está convirtiendo.
Teniendo en cuenta que la posición de las unidades es la posición O(la posición -1 sería la del primer
decimal).
• 8 : Es la base del sistemas que se utiliza para representar al número.
Por ejemplo, si tenemos el número 153,6 utilizando el sistema octal (base ocho), el paso a decimal se
sería:
1 · 82
+ 5 · 81
+ 3 · 8° + 6 · 8"1
- 64 + 40 + 3 + 6 o 8 = 107 , 75
1.6 Conversión binario a decimal
El Teorema Fundamental de la Numeración se puede aplicar para saber el número decimal representado
por un número escrito en binario. Así, para el número binario 100110110111a conversión sería (los ceros
se han ignorado):
1 · 210
+ 1 · 27
+ 1 · 26
+ 1 · 2· + 1 · 23 + 1 · 2 1
+ 1 · 2° - 1243
1.7 Conversión decimal a binario
El método más utilizado consiste en ir haciendo divisiones sucesivas entre dos. Los restos son las cifras
binarias. Por ejemplo, para pasar el 39:
39 o 2 - 19 resto 1
19 o 2 - 9 resto 1
9 o 2 - 4 resto 1
4 . 2 - 2 resto o
2 o 2 - 1 resto o
1 . 2 - o resto 1
Ahora las cifras binarias se toman al revés. Con lo cual, el número 100111 es el equivalente en binario
de 39.

1.8 Representación de texto en el sistema binario
Puesto que una computadora no solo maneja números, habrán dígitos binarios que contengan información
no t raducible al sistema decimal. Todo depende de cómo se interprete esa traducción. Por ejemplo, en
el caso del texto, lo que se hace es codificar cada carácter en una serie de números binarios. El código
ASCII ha sido durante mucho tiempo el más utilizado; inicialmente era un código que utilizaba 7 bits para
representar texto, lo que significaba que era capaz de codificar 127 caracteres. Por ejemplo, el número 65
(1000001 en binario) se utiliza para la A mayúscula.
Poco después apareció un problema : este código bastaba para los caracteres del inglés, pero no para otras
lenguas. Entonces se añadió el octavo bit para representar otros 128 caracteres que son distintos, según
idiomas (Europa Occidental usa unos códigos que no utiliza Europa Oriental).
Eso provoca que un código como el 190 signifique cosas diferentes si cambiamos de país. Por ello, cuando
un ordenador necesita mostrar texto, tiene que saber qué juego de códigos debe de utilizar, lo cual supone
un tremendo problema.
Una ampliación de este método de codificación es el código UNICODE, que puede utilizar hasta 4 bytes
(32 bits), con lo que es capaz de codificar cualquier carácter en cualquier lengua del planeta, utilizando
el mismo conjunto de códigos. Poco a poco se ha ido extendiendo cada vez más, pero la preponderancia
histórica que ha tenido el código ASCII complica su popularidad.
1.9 Representación binaria de datos no numéricos ni de texto
En el caso de datos más complejos (imágenes, vídeo, audio) se necesita una codificación más compleja.
Además, en estos datos no hay estándares, por lo que hay decenas de formas de codificar. En el caso, por
ejemplo, de las imágenes, una forma básica de codificarlas en binario es la que graba cada píxel (cada
punto distinguible en la imagen) mediante tres bytes: el primero graba el nivel de rojo; el segundo, el nivel
de azul; y el tercero, el nivel de verde. Y así por cada píxel.
Por ejemplo, un punto en una imagen de color rojo puro:
[ 11111111 00000000 00000000
l
Naturalmente, en una imagen no solo se graban los píxeles sino el tamaño de la imagen, el modelo
de color, etc. De ahí que representar estos datos sea tan complejo para el ordenador (y tan complejo
entenderlo para nosotros).
1.10 Los programas (software)
Los programas o software son un conjunto de instrucciones ordenadas para ejecutarse de forma rápida
y precisa en una computadora. El software se divide en dos grupos: software de sistema operativo y
software de aplicaciones.
El proceso de escribir un programa se denomina programación, y el conjunto de instrucciones que se
utilizan para escribir un programa se llama lenguaje de programación.

1.11 Lenguajes de programación
Sirve para escribir programas y permite la comunicación usuario (programador) versus máquina (PC).
Existen tres tipos de lenguajes de programación:
• Lenguaje de máquina: Programación binaria, difícil de programar y dependiente de la máquina.
• Lenguaje de bajo nivel (ensamblador): Usa símbolos nemotécnicos, necesita ser traducido al lenguaje
de máquina y sigue siendo dependiente.
• Lenguaje de alto nivel: Cercano al lenguaje natural, tiempo de programación relativamente corto, es
independiente de la máquina. A continuación se muest ra un plano de la evolución de los lenguajes de
programación de alto nivel.
~----------------------------------~
Lisp
1958 Cobol
1960
Basic Simula
_+
Pl/1
1964 1964 1963
Pascal
1970
Sh
1971
SmaiiTalk
1971
1973
Modula
1975
Awk
1978
C++
1983
Perl
1984 1987
Python Oak
1991 1991
VBScript
1993
~
..walll
JavaScript
1995
PHP
1995
~

1.12 Traductores del lenguaje de programación
Son programas que traducen los códigos fuentes (programas escritos en un lenguaje de alto nivel) a
código máquina.
Los t raductores se dividen en:
• Intérpretes: Traducción y ejecución secuencial (línea por línea), ejecución lenta.
• Compiladores: Traduce el código fuente a programa objeto (ejecutable código máquina). Ejecución
rápida.
1.13 Ciclo de vida de un software
La construcción de un software, por más pequeño que sea, involucra las siguientes etapas:
• Requerimiento: Enunciado del problema a resolver.
• Análisis: ¿Qué? (Entender el problema - entrada- proceso - salida).
• Diseño: ¿Cómo? (Resolver el problema - algoritmo - diagrama de flujo - diseño de interfaz de usuario).
• Implementación: ¿Hacerlo? (Codificación 1Programar).
• Pruebas: ¿Funciona' (Verificar 1Comprobar).
• Despliegue: ¿Instalar? (Distribuir el programa).
( Requerimiento J
( Análisis
- [ Diseño
- [ Implementación )
( Pruebas
[ Despliegue )
• • .. 00900,¡¡¡ .. o
- -
--

1.14 Algoritmo
Método que describe la solución de un problema computacional mediante una serie de pasos precisos,
definidos y finitos.
• Preciso: Indicar el orden de realización en cada paso.
• Definido: Al epetir los pasos n veces se obtiene el mismo resultado.
• Finito: Tiene un número determinado de pasos.
La solución de un algoritmo debe describir tres partes:
• Entrada: Datos que se necesitan para poder ejecutarse.
• Proceso: Acciones y cálculos a realizar.
• Salida: Resultado esperado.
Entrada Proceso Salida
la palabra algoritmo procede del matemático árabe Mohamed lbn Al Kow Rizmi, quien escribió entre los
años 800 y 825 su obra Quitad Al Mugaba/a, donde recogió el sistema de numeración hindú y el concepto
del cero. Fibonacci, tradujo la obra al latín y la llamó Algoritmi Oicit.
El lenguaje algorítmico es aquel que implementa una solución teórica a un problema, indicando
las operaciones a realizar y el orden en el que deben efectuarse. Por ejemplo, en el caso de que nos
encontremos en casa con un foco malogrado de una lámpara, un posible algoritmo sería :
a. Comprobar si hay foco de repuesto.
b. En el caso de que haya, sustituir el foco anterior por el nuevo.
c. Si no hay foco de repuesto, bajar a comprar uno nuevo en la tienda y ponerlo en lugar del malogrado.
los algoritmos son la base de la programación de ordenadores, ya que los programas de ordenador se
pueden entender como algoritmos escritos en un código especial, entendible por un ordenador.
la desventaja del diseño de algoritmos radica en que no podemos escribir lo que deseemos; el lenguaje
ha utilizar no debe dejar posibilidad de duda, debe recoger todas las posibilidades.
1.14.1 Características que deben de cumplir los algoritmos obligatoriamente
• Un algoritmo debe resolver el problema para el que fue formulado. Lógicamente, no sirve un
algoritmo que no resuelve ese problema. En el caso de los programadores, a veces crean algoritmos
que resuelven problemas diferentes al planteado.
• Los algoritmos son independientes del lenguaje de programación. l os algoritmos se escriben para
poder ser utilizados en cualquier lenguaje de programación.
• Los algoritmos deben ser precisos. Los resultados de los cálculos deben ser exactos, de manera
rigurosa. No es válido un algoritmo que sólo aproxime la solución.
• Los algoritmos deben ser finitos. Deben de finalizar en algún momento. No es un algoritmo válido
aquel que produce situaciones en las que el algoritmo no termina.
• Los algoritmos deben poder repetirse. Deben perm itir su ejecución las veces que haga falta. No son
válidos los que tras ejecutarse una vez ya no pueden volver a hacerlo por la razón que sea.

1.14.2 Características aconsejables para los algoritmos
• Validez: Un algorit mo es válido si carece de errores. Un algoritmo puede resolver el problema para el
que se planteó y, sin embargo, no ser válido debido a que posee errores.
• Eficiencia: Un algoritmo es eficiente si obtiene la solución al problema en poco tiempo. No lo es si
tarda en obtener el resultado.
• Óptimo: Un algoritmo es óptimo si es el más eficiente posible y no contiene errores. La búsqueda
de este algorit mo es el objetivo prioritario del programador. No siempre podemos garantizar que el
algoritmo hallado sea el óptimo, a veces sí.
1.14.3 Fases en la creación de algoritmos
Hay tres fases en la elaboración de un algoritmo:
a. Análisis: En esta se determina cuál es exactamente el problema a resolver. Qué datos forman la
entrada del algoritmo y cuáles deberán obtenerse como salida.
b. Diseño: Elaboración del algoritmo.
c. Prueba: Comprobación del resultado. Se observa si el algoritmo obtiene la salida esperada para
todas las entradas.
1.14.4 Herramientas de un algoritmo
Para expresar la solución de un problema se pueden usar diferentes herramientas de programación, tales
como diagrama de flujo (flow chart), diagrama N-S(Nassi Schneiderman), pseudocódigo.
• Diagrama de flujo: Es una representación gráfica que utiliza símbolos normalizados por ANSI, y
expresa las sucesivas instrucciones que se deben seguir para resolver el problema. Estas instrucciones no
dependen de la sintaxis de ningún lenguaje de programación, sino que deben servir fácilmente para su
transformación (codificación) en un lenguaje de programación.
Inicio o fin
o o Conectores
/ / Entrada o salida
!l
Dirección (flujo)
Proceso Teclado
Decisión Impresora
Ll.~...l_ _ _......
l-'1 SubAigoritmo
Pantalla

r - " IMPAR"
Inicio
n Entero
r Cadena
Leer n
Escribir r
Fin
r - "PAR"
• Diagrama de Nassí Scheneíderman {N-S): Conocido también como el diagrama de Chapín, es como un
diagrama de flujo pero sin flechas y con cajas continuas.
F
n : Entero
r : Cadena
Leer n
n Mod 2=0
r ~ " IMPAR" r - ''PAR
11
Escribir r
V
• Pseudocódigo: Permite expresar las instrucciones en un lenguaje común (ingles, español, etc.) para
facilitar tanto la escritura como la lectura de la solución de un programa. No existen reglas para escribir
pseudocódigo.
...................................................................................................................................................................................................... ...
· Inicio
//Variables
n Entero
r : Cadena
//Entrada
Leer n
//Proceso
Si n Mod 2 = O Entonces
r - ''PAR"
SiNo
r - " IMPAR"
Fin Si
//Salida
Escribir r
Fin
.........................................................................................................................................................................................................

1.14.5 Instrucciones
Son las acciones que debe realizar un algorit mo para resolver un problema. Las instrucciones más comunes
son las siguientes:
A. Instrucción de inicio/ fin: Representa el inicio y fin de un algoritmo.
Diagrama de flujo Pseudocódigo
8 Inicio
Fin
B. Instrucción de asignación: Representa la asignación de un valor a una variable, se puede representar
usando una flecha o el símbolo de igualdad, el cual es usado por muchos de los lenguajes de programación.
N <-10 N <-10
N= 10 N= 10
C. Instrucción de lectura: Representa el ingreso de datos mediante un dispositivo de entrada, que muchas
veces es representado por un símbolo de teclado.
/ LeerN 7 Leer N
~
Leer N
D. Instrucción de escritura: Representa la salida de la información mediante un dispositivo de salida,
puede ser representado por el símbolo de entrada/salida, por símbolo de pantalla o impresora.
Diagrama de flujo
/ Escribir R 7
[Ese~
Escribir R
Pseudocódigo
Escribir R
Escribir R
Escribir R

E. Instrucción de bifurcación: Cambian el flujo del programa según el resultado de una expresión lógica
(condición).
Si <Exp. Log> Entonces
F V
<Instrucción>
Instrucc i on Instruccion SiNo
<Instrucción>
Fin Si
1.15 Comentarios
Permiten describir y explicar, además sirve como ayuda para recordar y entender las operaciones que
se van a ejecutar. Los comentarios no son instrucciones, por lo tanto al ser traducido el código fuente
a código binario (tiempo de compilación), los lenguajes de programación los ignoran. Dependiendo el
lenguaje de programación los comentarios se escriben usando cierta simbología, en este libro usaremos
el símbolo // en los pseudocódigos para colocar comentarios.
Ejemplo pseudocódigo
.
: //Variables
~ N : Ente ro .
........................................................................................' ........'............................................................................................................
Visual Basic
'Variables
~ Dim N As I nt eger
... .......................................................................................................' .................................................................................................. .
1.16 Palabras reservadas
Son palabras usadas por el lenguaje de programación que no deben ser utilizadas como identificadores de
variables, funciones, entre otros.
Algunas de las palabras reservadas de Visual Basic
Dim, I nt ege r , Long , Si ng le, Doub le, I f , For, Se l e ct , Me ...

1.19 Constantes
Representa un espacio de memoria RAM, el cual guarda un valor que servirá para algún proceso en
particular; dicho valor permanece fijo, es decir, no puede cambiarse en la ejecución del programa . las
constantes tienen, al igual que las variables, un identificador (nombre) y un tipo de dato.
............................................................................................................................................................................................................
· //Constantes
PI - 3 . 1 4159 : Rea l
//Error ya no puede modiñcarlo
PI - 3. 1 4
..............................................................................................................................................................................................................
Visual Basic
'Constantes
Const PI As I nteger = 3 . 14 1 59
'Error ya no puede modiñcarlo
PI = 3 . 1 4
... .......................................................................................................................................................................................................... '
1.20 Tipo de datos simples (primitivos)
Al declarar una variable, debemos indicar el tipo de dato que es permitido almacenar en dicha variable.
Cada lenguaj e de programación trabaja con una variedad de tipo de datos; por lo general, todos usan los
llamados «primitivos», que son los siguientes:
A. Entero: Representan los números enteros (no almacena decimales).
.· .......................................................................................................................................................................................................... ..'
//Crear la variable
//(identiñcador y tipo de dato)
N : Ente r o
//Asignar un valor
//(identiñcador, operador de asignación y valor)
N - 15
..............................................................................................................................................................................................................
En el lenguaje de Visual Basic el tipo entero se puede trabajar con short, int y long; la diferencia está en
que uno almacena rangos de números diferentes, llamados también <<entero corto» y <<entero largo».
Ejemplo Visual Basic
.· ............................................................................................................................................................................................................
'Entero corto
Dim N As I nteger
'Asignar un valor (error de desbordamiento)
·., ..:·ª·~·~.;.~P..~.~.~....~.~....~.;.~~.~-~.....<.~.~-~-g.g.),,,.."..'........................................'........."...........................'............................. ,:

........................................................................................................................................................................................................... ...
N = 45 000
'Entero largo
Dim N As Long
'Asignar un valor
N = 45 00099
... .......................................................................................................................................................................................................... .
B. Real: Representan los números reales (almacena decimales).
..........................................................................................................................................................................................................- ··.
//Crear la variable
//(identiñcador y tipo de dato)
N :Real
//Asignar un val or
//(identiñcador, operador de asignación y valor)
N~ 15.75
'•· ...........................................................................................................................................................................................................·
En el lenguaje de Visual Basic, el tipo real se puede trabajar con float o double, la diferencia está en la
cantidad de decimales que pueden almacenar, llamados también «precisión simple>> y <<precisión doble>>.
.·.......................................................................................................................................................................................................... ...
'Precisión simple
Dim N As Single
' Se redondea a 15.123457
N = 15 . 12345678
'Precisión doble
Dim N As Double
' Lo almacena sin redondear 15 . 12345678
N = 15 . 12345678
o
............................................................................................................................................................................................................
C. Carácter: Representa un carácter de cualquier tipo: texto, número, símbolo, etc. Elvalor se coloca entre
comillas simples.
............................................................................................................................................................................................................
· //Crear la variable
R : Caracter
//Asignar un valor
R - ' A'
R - ' 9 '
R - ' * '
.............................................................................................................................................................................................................·

........................................................................................................................................................................................................... ...
'Crear la variable
Dim R As String
'Asignar un valor
R - "A"
R - "9"
R - " * "
E. Lógico: Representan los valores <<verdadero>> o <<falso>>, conocidos también como boolean, no se colocan
comillas simple ni dobles.
.............................................................................................................................................................................................................
//Crear la variable
L : Logico
//Asignar un valor
L - VERDADERO
L - FALSO
..............................................................................................................................................................................................................
En Visual Basic se utiliza el tipo de dato llamado <<boolean>>, para almacenar valores lógicos.
'Crear la variable
Dim L As Boolean
'Asignar un valor
L = True
L = False
'•· .......................................................................................................................................................................................................... .
1.21 Tipo de datos complejos (estructurados)
Son aquellos que están constituidos por tipos de datos simples y definen una est ructura de datos, un
ejemplo claro es el tipo cadena, que esta compuesta por un conjunto de caracteres (tipo de dato caracter).
Existe una variedad de tipo de de datos complejos, el enfoque de este libro es Algoritmos y solo tocaremos
dos tipos de datos complejos que son cadena y arreglos, los libros que profundizan el tema se llaman
libros de Estructura de datos.
A. Cadena: Representa un conjunto de caracteres, internamente es un arreglo de caracteres; por lo
general, se representa con comillas dobles.
.......................................................................................................................................................................................................... ··.
//Crear la variable
R : Cadena
//Asignar un valor
R- " ricardomarcelo@hotmail . com"

1.22 Operadores y expresiones
Son los que permiten realizar los cálculos entre valores fijos y variables. Los operadores se clasifican en:
aritméticos, relacionales, lógicos y de cadena. Sobre estos expondremos a continuación.
A. Operadores aritméticos: Son aquellos operadores que permiten realizar las operaciones aritméticas,
de la misma forma como se utilizan en las matemáticas.
Operador Descripción
+ Suma
- Resta
* Multiplicación
1 División
División entera
1
Exponenciación
Mod Módulo (resto de una división)
Dependiendo el lenguaje de programación los operadores varían o no implementan uno u otro, en el caso
de Visual Basic implementa todos los mencionados en la tabla.
Expresiones aritméticas
8x3 Equivale a 8*3 =24
8
Equivale a
8/3 =2.666666
8-:-3o
83 =2
3
82 Equivale a 8"2 =64
,J9 Equivale a 9"(1/2) = 3
9~
Equivale a 9 Mod 4 = 1
(])2

B. Operadores relacionales: Llamados también operadores de comparación, y permiten evaluar si dos
valores guardan alguna relación entre sí.
= Igualdad
> Mayor que
>= Menor o igual que
< Menor que
<= Menor o Igual que
<> Diferente a
Dependiendo el lenguaje de programación, los operadores varían o no implementan uno u otro; en el caso
de Visual Basic implementa todos los mencionados en la tabla.
Expresiones lógicas (condiciones)
8=3
8>3
8 <= 3
8<> 8
Falso
Verdadero
Verdadero
Falso
C. Operadores lógicos: Son aquellos operadores que se utilizan en combinación con los operadores de
relación.
y Y lógico
o O lógico
No No lógico
«Y» lógico: Si p y q son valores lógicos, ambos deben ser verdaderos para que Y devuelva verdadero.
8>4
7 <> S
y
y
3=6
5>=4
Falso
Verdadero
«0» lógico: Si p y q son valores lógicos, uno de ellos debe ser verdadero para que O devuelva verdadero.

8>4
7 <> 5
o
y
3=6
5>=4
Verdadero
Verdadero
«No» lógico: Si pes un valor lógico, el operador No invierte su valor.
NO (8 > 4)
NO (7 <> 7)
Falso
Verdadero
D. Operadores de cadena: Son aquellos operadores que permiten realizar operaciones con cadenas; por
lo general, permiten unir en cadena, lo cual es llamado también «concatenar».
+ Unir cadenas
& Unir cadenas
Expresiones de cadena
"Ricardo" + JI"+ "Marcelo" Ricardo Marcelo
"ricardomarcelo" & "@" & "hotmail.com" ricardomarcelo@hotmail.com
1.23 Control de flujo
Todos los lenguajes de programación implementan estructuras para controlar la ejecución de un programa,
estas son:
• Estructura secuencial
• Est ructura selectiva simple y doble
• Est ructura selectiva múltiple
• Estructura repetitiva mientras
• Estructura repetitiva para
En los siguientes capítulos se explicarán cada una de las estructuras mencionadas.

Estructura secuencial
2.1 Estructura secuencial
Son aquellos algoritmos que ejecutan instrucciones en forma consecutiva, es decir, uno detrás de otro,
hasta finalizar el proceso.
Instrucción 1 Instrucción 1
l
Instrucción 2 Instrucción 2
!
Instrucción n Instrucción n
!
Enunciado: Dados dos números enteros, hallar la suma.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese dos números enteros;
luego, que el sistema realice el cálculo respectivo para hallar la suma. Para ello usará la siguiente expresión.
Expresión matemática
s=n1+n2
Expresión en el lenguaje de programación
s <- n1 + n2
Entrada
• Dos números (n1 y n2)
Diseño: Interfaz de usuario
Salida
• La suma de los números ingresados (s)
"' Problema 01 ~[Q)f8]
Número 1 j568
Número 2 j454
Suma j 1022
r-··-----""'1
• Calcull!r '
L.-················-·-·J

Diagrama de flujo
l Inicio )
¡
nl , n2 , S . Entero
.
!
/ Leer nl , n2/
¡
S - nl + n2
!
/Escribir s /
¡
Fin )
Codificación:
Algoritmo
Pseudocódigo
Inicio
//Variables
nl , n2 , s
//Entrada
Leer nl , n2
//Proceso
s - nl + n2
//Salida
Escribir s
Fin
Entero
.......................................................................................................................................................' ............................................' ..... ...
' Variables
Dim nl As Integer
Dim n2 As Integer
Dim s As Integer
' Entrada
nl = Val(Me . t xtnl . Text)
n2 - Val(Me . t xtn2 . Text )
' Proceso
s = nl + n2
' Salida
Me . t xts . Text = Str(s)
•,, ............................................................................................................................................" .............." .............................." ............
Enunciado: Hallar el cociente y el residuo (resto) de dos números enteros.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese dos números enteros;
luego, que el sistema realice el cálculo respectivo para hallar el cociente y residuo. Para esto use la siguiente
expresión:
c...-nl/n2
r+- nl Mod n2
Entrada
• Dos números (nl y n2)
Salida
• El cociente (e) • El Residuo (r)

Capítulo 2: Estructura secuencial
Diseño:
Interfaz de usuario
., Problema 02 ~(QJ[g)
Núrne~o 1
Núrneto 2
Cociente
Residuo
Diagrama de flujo
( Inicio )
~
nl , n2 , e , r o
Entero
o
~
/Leer nl , n2/
!
e - nl n2
r - nl Mod n2
!
/ Escribir e , r/
¡
( Fin )
Codificación:
1
11 IL ~·n
1
4
12
13
Algoritmo
Pseudocódigo
Inicio
//Variables
nl , n2 , e , r : Entero
//Entrada
Leer nl , n2
//Proceso
e - nl n2
r - nl Mod n2
//Salida
Escribir e , r
Fin
............................................................................................................................................................................................................
o ' Variables
Dim nl As Integer
Dim n2 As Integer
Di m e As Integer
Dim r As Integer
' Entrada
nl - Val(Me ot xtnl oText)
n2 = Val (Me ot xt n2 0Text)
' Proceso
e - nl n2
r = nl Mod n2
' Salida
Me ot xtc oText = Str(c)
M
e ot xtr oText = Str (r )
..............................................................................................................................................................................................................·

Problema n.o 3
Enunciado: Dado el valor de venta de un producto, hallar eiiGV (19 %) y el precio de venta.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el valor de venta del
producto; luego, que el sistema realice el cálculo respectivo para hallar el IGV y el precio de venta. Para
esto use la siguiente expresión:
igv <- vv * 0.19
pv +- vv + igv
Entrada
• Valor de venta (vv)
Diseño:
Salida
• EI IGV (igv)
• El precio de venta (pv)
Interfaz de usuario
"' Problema 03 ~(g]~
Val01 deVenta 1
100
IGV 119
Precio deVenta lns
!Calcular !
'··-·-···-·--·-·--······
Algoritmo
Diagrama de flujo
Inicio
!
vv , igv, pv . Real
.
!
1 Leer vv
1
!
i gv - vv * o.19
pv - vv + igv
!
/ Escribir igv , pv/
!
Fin
Pseudocódigo
Inicio
//Variables
vv , i g v , p v
//Entrada
Leer vv
//Proceso
Rea l
i gv- vv * 0 . 19
p v - vv + i gv
//Salida
Escribir igv, pv
Fin

Codificación:
' Variables
Dim vv As Single
Dim i gv As Single
Dim pv As Single
' En t rada
vv = Val(Me . txtvv . Text)
' Proceso
igv = vv * 0 . 19
pv = vv + i gv
' Salida
Me . t xt igv . Text = Str(igv)
Me . t xtpv . Text = Str (pv)
..............................................................................................................................................................................................................
. Problema n.o 4
Enunciado: Hallar la potencia de a", donde <<a» y<<n>> pertenecen a z• (números enteros positivos).
Análisis: Para la solución de este problema, se requiere que el usuario ingrese dos números enteros
positivos <<a» y <<n»; luego, que el sistema procese y obtenga la potencia <<p».
p = a" = a x a x a x .. . x a
n factores
p <-a An
Entrada
• Dos números enteros (a, n)
Diseño:
Salida
• La potencia (p)
Interfaz de usuario
"' Problema 04 [)[Q)(8]
Potencia 19765625

Diagrama de flujo
( Inicio
!
a , n . Entero corto
.
p . Entero largo
.
!
/ Leer a , n /
!
P •- a"n
!
/ Escribir
!
( Fin
Codificación:
~ ' Variables
¡ Di m a As Integer
[ Dim n As Integer
¡ Di m p As Long
¡ ' Entrada
P/
¡ a- Va l(Me . t xta . Tex t )
[ n = Val (Me . t x tn . Text )
¡ ' Proceso
¡ p=aAn
¡ ' Salida
[ Me . t x tp . Text = Str (p)
Algoritmo
Pseudocódigo
Ini cio
//Variables
a , n : Entero corto
p : Entero largo
//Entrada
Lee r a , n
//Salida
Escrib ir p
Fin
.............................................................................................................................................................................................................
Enunciado: Hallar la radicación de era ,donde «a» y «n>> pertenecen a z• (números enteros positivos).
positivos «a>> y «n»; luego, que el sistema procese y obtienga la radicación «r>>.
1
r = era = a~
r <- a A (1/n)
Entrada
• Dos números enteros (a, n)
Salida
• La radicación (r)

Diseño:
n ,
Codificación:
Interfaz de usuario
"' Problema 05 ~@Jl8J
a j9765625
n j10
Radicación 15
Diagrama de flujo
( Inicio )
l
r . Entero cor to
.
a . Entero largo
.
l
j Leer a , n j
l
r - a " (1/n )
l
/ Escribi r r /
l
( Fin )
Algoritmo
Pseudocódigo
Inicio
//Variables
n , r : Entero c o rto
a : Entero l argo
/ / Entrada
Leer a , n
/ / Proc e s o
r ~ a " ( 1/n)
/ /Sal ida
Escribir r
Fin
......................................................................' .......................'............................................................................................................ ...
' Variabl es
Dim n As Integer
Di m r As I nteger
Di m a As Long
' Ent r ada
a- Val (Me . t xta . Text )
n = Val (Me . txtn . Text )
' Proceso
r = a " (1/n )
' Salida
M
e . t xtr . Text = St r( r )
.............................................................................................................................................................................................................

Problema n.o 6
Enunciado: Dado un número de Sdígitos, devolver el número en orden inverso.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número <<n»; luego,
que el sistema procese y obtenga el número inverso <<ni», realizando 4 divisiones sucesivas ent re 10, para
acumular el residuo y el último cociente.
Entrada
12345 110
@1234~
@) 123 ~
® 12 1 10
@CD
Salida
• Un número entero (n) • El número inverso (ni)
Diseño:
Interfaz de usuario
,. Problema 06 ~[QJ(8]
lnve~so 154321
Diagrama de flujo
(rnicio
L
¡n, ni , r Entero largo ¡
!
j Leer n j
!
r - n mod 10
n - n 10
ni - r * 10
r - n mod 10
n - n 10
ni - (ni + r) * 10
r - n mod 10
n - n 10
ni - (ni + r) * 10
r - n mod 10
n - n 10
ni - (ni + r) * 10
ni - ni + n
/Escribir ni/
!
Fin
Algoritmo
Pseudocódigo
Inicio
//Variables
n, ni , r : Entero largo
/ / Entrada
Leer n
//Proceso
r - n mod 10
n - n 10
ni - r * 10
r - n mod 10
n - n 10
ni - (ni + r) * 10
r - n mod 10
n - n 10
ni - (ni + r) * 10
r - n mod 10
n - n 10
ni - (ni + r) * 1O
r - n mod 10
n - n 10
ni - (ni + r) * 1O
ni - ni + n
//Salida
Escribir ni
Fin

Codificación:
¡ ' Variables
¡ Dim n As Long
! Di m ni As Long
! Dim r As Long
! ' Entrada
¡ n = Val (Me . t xtn . Tex t )
! ' Proceso
! r = n mod 10
! n = n 10
: ni = r * 1 O
! r = n mod 10
! n = n 10
¡ ni = (ni + r) * 10
! r = n mod 10
¡ n = n 10
¡ ni = (ni + r) * 10
! r = n mod 10
! n = n 10
! ni - (ni + r) * 10
: ni - ni + n
! ' Salida
! Me . t x tni . Text = Str(ni)
Capít ulo 2: Estructura secuencial
... .......................................................................................................................................................................................................... .
Problema n.o7
Enunciado: Determinar la suma de los N primeros números enteros positivos (Z•); use la siguiente
fórmula:
S= N(N+1)
2
Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número entero positivo
«n»; luego, que el sistema procese y obtenga la suma de los primeros números enteros positivos hasta
«n ».
s- (n * (n + 1)) 12
Entrada
• Número entero (n)
S= N(N +1)
2
Salida
• Suma (s)

Diseño:
Interfaz de usuario
., Problema 07 r;]QJr8]
Número 1
5
Diagrama de flujo
( Inicio )
!
n, S . Entero corto
.
~
1 Leer n 1
~
S - (n * (n + 1)) 1 2
!
/ Escribir s j
~
( E"in )
Codificación:
Algoritmo
Pseudocódigo
Ini cio
//Vari ables
n , s : Entero corto
//Entrada
Leer n
/ / Proc eso
s - (n * (n + 1 )) 1 2
/ / Sal ida
Escribir s
Fin
.. .............................................................................................................................................................................................................
' Variables
Dim n As I nteger
Dim s As Integer
' Entrada
n = Val (Me . t xt n . Text )
' Proceso
s = (n * (n + 1)) 1 2
' Salida
•., ..........................................................................................................................................................................................................

Enunciado: Calcular el interés compuesto generado por un capital depositado durante cierta cantidad de
tiempo, a una tasa de interés determinada; aplique las siguientes fórmulas:
M = (1 + r%)'.C
1=M -e
Monto (M): Es la suma del capital más los intereses producidos en determinado tiempo.
Tasa de interés (r%): Es la ganancia que se obtiene por cada 100 unidades monetarias en cada periodo
de tiempo.
Capital (C): Es todo aquello que se va a ceder o imponer durante algún tiempo para generar una ganancia.
Interés (1): Parte de la utilidad que obtiene el capitalista al prestar su dinero.
Tiempo (t): Es el periodo de tiempo durante el cual se cede el capital.
Análisis: Para la solución de este problema se requiere que el usuario ingrese el capital «C» y la tasa de
interés «r>>; luego, que el sistema procese y obtenga el interés ganado y el monto producido.
m +-- ((1 + r /100) "t) * e
Entrada
• Capital (e)
• Tasa de interés (r)
• Tiempo (t)
Diseño:
M = (1 + r%)'.C
Salida
• Interés (i)
• Monto (m)
Interfaz de usuario
"' Problema 08 [)@[8]
Cop(al j100 1
C.t,atcuadl
Tasade interes jlO
Tiel!'4)0 lt2
lntetes 1213.8428
Mario 1313.8428

Diagrama de flujo
Q:nicio
)
~
e , r , t , i , m . Real
.
!
/ Leer e , r , t /
!
m - ( (l+r/100 ) At ) *e
i - m - e
~
/ Escribir
(
Codificación:
' Variables
Dim e As Single
Dim r As Single
Di m t As Single
Dim i As Single
Dim m As Single
' Entrada
!
Fin
i ,
)
e = Val (Me . txtc . Text )
r = Val (Me . t xt r . Text )
t - Val(Me . t xtt . Text )
' Proceso
m /
m - ( ( 1 + r 1 100) " t ) * e
i = m - e
' Salida
Me . t xt i . Text- Str(i)
Me . t xt m. Text- Str(m)
Algoritmo
Pseudocódigo
Inicio
//Variables
e , r , t , i , m : Rea l
//Entrada
Leer e , r , t
//Proceso
m- ((l +r/lOO)"t )*c
i <;- m - e
//Salida
Escribir ~ . m
Fin
.. ...........................................................................................................................................................................................................

Problema n. o9
Enunciado: Crear un programa para encontrar el área de un círculo, usan la siguiente fórmula:
A = n:.r2
Área (A): Es el área del círculo.
PI (n): Representa el valor constante pi (3.14159}.
Radio (r): Es el radio del círculo.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el radio del círculo; luego,
que el sistema procese y obtenga el área del círculo.
Expresión algebraica
A+-- 3.14159 * r A 2
Entrada
• Radio (r)
Diseño:
A= n:.r2
Salida
• Área (a)
Interfaz de usuario
"' Problema 09 ~[QJ(8]
Radio ls
Alea 178.53975
Diagrama de flujo
( Inicio )
~
PI - 3 . 14159 : Real
!
r , a . Rea l
.
~
/ Leer r
/
l
a - PI * r A 2
~
/ Escribir a
/
!
( Fi n J
Algoritmo
Pseudocódigo
Inicio
//Constantes
PI = 3 . 14 159 : Real
//Variables
r, a : Real
//Entrada
Leer r
//Proceso
a - PI * r A 2
//Salida
Escribir a
Fin

Codificación :
............................................................................................................................................................................................................
' Constante
Const PI As Single = 3 . 14159
' Variabl es
Di m a As Single
Di m r As Single
' Ent r ada
r = Va l(Me . t xt r . Te xt )
' Proceso
a = PI * r " 2
' Salida
M
e . t xta . Text = Str (a)
.. ...........................................................................................................................................................................................................
Enunciado: Crear un programa que permita convertir una cantidad de segundos en horas, minutos y
segundos.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese un tiempo expresado en
segundos; luego, que el sistema procese y obtenga el área del círculo.
Entrada
• Tiempo en segundos {t)
Diseño:
Salida
• Horas {h)
• M inutos {m)
• Segundos {s)
Interfaz de usuario
._ Problema 10 ~§(8]
Tiempo en Segundo$
lsssss
Hor.. Mirutos
r-:12:::-
7 - - 146
IC:ca~cu_~l
Seg.1dos
139

Diagrama de flujo
( Inicio )
l
HORA = 360 . Entero
.
MINUTO = 60 . Entero
.
l
t , h , m, S . Ent ero
.
l
/ Leer t
/
!
h - t HORA
t - t Mod HORA
m - t MINUTO
S - t Mod MINUTO
!
/ Escribir h , m, s/
l
( Fin )
Codificación:
Algoritmo
Pseudocódigo
Inicio
//Constantes
HORA = 360 : Entero
MINUTO = 60 : Entero
//Variables
t , h , m, s
//Entrada
Lee r t
//Proceso
h - t HORA
Entero
t - t Mod HORA
m - t MI NUTO
S - t Mod MINUTO
//Salida
Escribir h , m, s
Fin
.........................................................................................................................·····...........................·······................................·····......·.
' Constantes
Const HORA As Long = 3600
Const MINUTO As Long = 60
' Variables
Di m t As Long
Di m h As Long
Dim m As Long
Di m s As Long
' En t rada
t = Val (Me . t xtt . Text )
' Proceso
h - t HORA
t - t Mod HORA
m - t MINUTO
s = t Mod MINUTO
' Salida
Me . t xth . Text = Str (h )
M
e . t xtm . Text- Str (m)
Me . t xts . Text - Str(s)
... .............................................................................' ............................................................................................................................ ;

2.2 Problemas propuestos
Los siguientes problemas le servirán para medir su aprendizaje, es importante que los resuelva.
Propuesto n.o1
Enunciado: Dados dos números enteros (Z), a y b, hallar a+ by a- b.
Propuesto n.o2
Enunciado: Dados dos números enteros, determinar cuántos números enteros están incluidos en ellos.
Propuesto n.o3
Enunciado: Dada una cantidad de milímetros, expresarlo en la máxima cantidad de met ros, el resto en
decímetros, centímetros y milímetros.
Propuesto n.o4
Enunciado: Obtener el valor de <<C» y <<d» de acuerdo a la siguiente fórmula:
Propuesto n.o5
Enunciado: Dado 4 números enteros, obtener el porcentaje de cada uno en función a la suma de los 4
números ingresados.
Propuesto n.o6
Enunciado: Hallar el área y el perímetro de un cuadrado.
Propuesto n.o7
Enunciado: Dada una cantidad de horas, obtener su equivalente en minutos y segundos.
Propuesto n.o8
Enunciado: Convertir una cantidad de grados Fahrenheit a Celsius y Kelvin.
Propuesto n.o9
Enunciado: Hallar el área y el perímetro de un rectángulo.
Propuesto n.o1O
Enunciado: Convertir grados sexagesimales a centesimales.

Estructura selectiva simple y doble
3.11ntroducción
Muchas veces tenemos que decidir si realizar una u otra tarea, dependiendo de una condición; en la
programación existe una estructura que permite evaluar una condición (expresión lógica que devuelve
«verdadero» o <<falso») y determina qué instrucción o instrucciones se deben ejecutar si la condición es
verdadera o si la condición es falsa.
En este capítulo usted aprenderá a resolver problemas que permitan evaluar condiciones lógicas; esta es
una de las estructuras básicas y más utilizadas en todo lenguaje de programación, también se las conoce
como estructuras condicionales, alternativas y de decisiones.
3.2 Estructura selectiva simple
Evalúa una expresión lógica (condición), SI es verdadera ejecuta una determinada inst rucción o
instrucciones.
F
Exp . Log . Si <Exp. Log.> Entonces
V
<lnstruccion 1>
Instruccion 1 <lnstruccion n>
Instruccion n
Fin Si
:)
Sintaxis Visual Basic
.............................................................................................................................................................................................................
· lf <Exp. Log.> Then
End lf
<lnstruccion 1>
<lnstruccion n>
..........................................,...............................................................................................................................,................................. .

3.3 Estructura selectiva doble
Evalúa una expresión lógica (condición), si es verdadera ejecuta una o varias instrucciones; si es falsa,
ejecuta otro grupo de instrucciones.
Si <Exp. Log.> Entonces
F V
<lnstruccion 1>
Exp . Log .
<lnstruccion n>
SiNo
Instruccion 1 Instruccion 1 <lnstruccion 1>
Instruccion n Instruccion n <lnstruccion n>
Fin Si
. lf <Exp. Log.> Then
<lnstruccion 1>
<lnstruccion n>
Else
<lnstruccion 1>
<lnstruccion n>
End lf
•,, ···················.....................................................................................,.................................................................................................
3.4 Estructuras anidadas
Son aquellas estructuras que contienen una o más estructuras; es decir, está permitido colocar dentro de
una estructura, otra estructura.
F
Instruccion 1
Instruccion n
F
V
Instruccion 1
Instruccion n
F
V
Instruccion 1
Instruccion n

Capítulo 3: Estructura selectiva simple y doble
.............................................................................................................................................................................................................
.
<lnstruccion 1>
<lnstruccion n>
Fin Si
SiNo
<lnstruccion 1>
<lnstruccion n>
SiNo
<lnstruccion 1>
<lnstruccion n>
Fin Sí
Fin Sí
lf <Exp. Log.> Then
Else
lf <Exp. Log.> Then
<lnstruccion 1>
<lnstruccion n>
End lf
lf <Exp. Log.> Then
<lnstruccion 1>
<lnstruccion n>
Else
<lnstruccion 1>
<lnstruccion n>
End lf
End lf
... .......................................................................................................................................................................................................... ..
Problema n.o 11
Enunciado: Dados dos números enteros diferentes, devolver el número mayor.
diferentes; luego, que el sistema realice el proceso para devolver el número mayor.
Expresión
Si nl > n2 ::::> nl es mayor
Si n2 > nl ::::> n2 es mayor
Entrada
• Dos números (n l y n2)
Salida
• Número mayor (m)

Diseño:
Interfaz de usuario
,. Problcm11 11 [)[Q)(g)
Número 1
Número2
Mayor
Diagrama de flujo
Inicio
nl , n2 , m Entero
Leer nl , n2
m - nl
F
m - n2
Escribir m
Fin
la lecac.&ll
ls
la
Algoritmo
Pseudocódigo
Inicio
//Variables
nl , n2 , m
//Entrada
Leer nl , n2
//Proceso
Si nl > n2
m - nl
Fin Si
Si n2 > nl
m - n2
Fin Si
//Salida
Escribir m
Fin
En t ero
Entonces
Entonces

Codificación:
. ' Variabl es
Di m nl As Intege r
Dim n2 As Inte ger
Di m m As I nteger
' Entrada
nl- Va l( Me . t xtn l . Text )
n2 = Val (Me . t xtn2 . Text )
' Proceso
If nl > n2 Then
m = n l
End If
I f n2 > nl Then
m = n2
End If
' Salida
M
e . t xtm . Text = St r( m)
Problema n.o 12
Enunciado: Determinar si un número entero es positivo, negativo o neutro.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número entero; luego,
que el sistema verifique si es «positivo», «negativo» o «neutro>>.
Expresión
Si n > O~ POSITIVO
Sin< O~ NEGATIVO
Si n =O~ NEUTRO
Entrada
• Número (n)
Diseño:
Salida
• Resultado (r)
- POSITIVO
- NEGATIVO
- NEUTRO
Interfaz de usuario
- - - - - - - - - - - - - -
.. Problema 12 ~LQ)rEJ
Núme<o 1·5
Res.t.ado jNEGATIVO

F
F
F
Codificación:
Diagrama de flujo
n
r
Inicio
Entero
Cadena
Leer n
r - "POSITIVO"
r - " NEGATIVO"
r - " NEUTRO"
Escribir r
Fin
Algoritmo
Pseudocódigo
Inicio
//Variables
n Entero
r : Cadena
//Entrada
Leer n
//Proceso
Si n > O Entonces
r - " POSITIVO"
E'in Si
Si n < O Entonces
r - " NEGATIVO"
E'in Si
Si n = O Entonces
r - " NEUTRO"
E'in Si
//Salida
Escrib i r r
Fin
..........................................................................................................................................................................................................- ··.
' ' Variables
Dim n As Integer
Dim r As String
' Entrada
' Proceso
If n > O Then
r = " POSITIVO"
End If
If n < O Then
r = " NEGATIVO"
End I f
If n = O Then
r = " NEUTRO"
End If
' Salida
Me . t xtr . Tex t = r .
.............................................................................................................................................................................................................

Capítulo 3 : Estructura selectiva simple y doble
Problema n.o13
Enunciado: Dado un carácter, determinar si es una vocal.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese un carácter; luego, que el
sistema verifique si es una vocal.
Expresión
Si e ='a' v e ='A' :::::> VOCAL
Si e = 'e' v e = 'E' :::::> VOCAL
Si e = 'i' v e = '1' :::::> VOCAL
Si e = 'o' v e ='O' :::::> VOCAL
Si e= 'u' ve= 'U' :::::>VOCAL
Entrada
• Carácter (e)
Diseño:
Salida
• Resultado (r)
- ES VOCAL
- NO ES VOCAL
Interfaz de usuario
.. Problema 13 ~[QJ~
Ca.beler lu

Diagrama de flujo
{ Inicio )
~
e . Caracter
.
r . Cadena
.
~
1 Leer e
1
l_
F
e ' a ' O e ' A' >
V
r - "NO ES VOCAL"
F
e ' e ' o e , E , >
V
r - "ES VOCAL"
F
e 1 i , O e , I , >
Jv
r - "ES VOCAL"
F e-' o ' O e-' O' ::>
Jv
r - "ES VOCAL"
F
e ' u ' O c- ' U
¡v
r - "ES VOCAL"
/ Escribir r /
~
{ Fin )
Algoritmo
Pseudocódigo
Inicio
//Variables
e Caracter
r : Cadena
//Entrada
Leer e
//Proceso
r - " NO ES VOCAL"
Si c=' a ' O c=' A' Entonces
r - " ES VOCAL"
Fin Si
Si c=' e ' O c=' E' Entonces
r - " ES VOCAL"
Fin Si
Si c=' i ' o c=' I ' Entonces
r - " ES VOCAL"
Fin Si
Si c=' o ' O c=' O' Entonces
r - " ES VOCAL"
Fin Si
Si c=' U' O c=' U' Entonces
r - " ES VOCAL"
Fin Si
//Salida
Escribir r
Fin

Codificación:
. ' Variables
Di m e As St ring
Dim r As String
' Entrada
e = Me . txtc . Text
' Proceso
r = "NO ES VOCAL"
If e = " a " Or e = ''A" Then
r = " ES VOCAL"
End If
If e = " e " Or e = '' E" Then
r = " ES VOCAL"
End If
If e = " i " Or e = '' ! " Then
r = " ES VOCAL"
End If
If e = " o" Or e = ''O" Then
r = " ES VOCAL"
End If
If e = " u" Or e = ''U" Then
r = " ES VOCAL"
End If
' Salida
Me . t xtr . Tex t = r
... ...........................................................................................................................................................................................................
Problema n.o14
Enunciado: Determinar si un número es múltiplo de 3 y S.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número entero n;
luego, que el sistema analice y determine si el número es múltiplo de 3 y de S.
Expresión
Si n Mod 3 = O" n Mod S = O:::;>
SI ES MULTIPLO DE 3 y S
SiNo
NO ES MULTIPLO DE 3 y S
Entrada
• Número (n)
Salida
• Resultado (r)
- ES MULTIPLO
- NO ES MULTIPLO

Diseño:
Interfaz de usuario
, -. Problema 14 ~@1:8]
N~ro l15
R=dtado lSI ES MULTIPLO DE 3Y 5
Algoritmo
Diagrama de flujo
( Inicio )
¡
n . Entero
.
r . Cadena
.
¡
1 Leer n
1
1
n Mod 3-0 y n Mod s-o
r - " SI ES MULTIPLO DE 3 Y 5" r - " NO ES
Pseudocódigo
Inicio
//Variables
n Entero
r : Cadena
//Entrada
Leer n
//Proceso
l
/ Escribir r /
¡
( Fin )
Si n Mod 3 = O Y n Mod 5 = O Entonces
r - " SI ES MULTIPLO DE 3 y 5"
SiNo
r - " NO ES MULTIPLO DE 3 y 5"
Fin Si
1/Salida
Escribir r
Fin
MULTIPLO DE 3 Y 5"

Codificación:
.................................................................................................................' ............................................................................................
; ' Variabl es
: Di m n As
r As
: Di m
' Entrada
I n teger
String
¡ n = Val (M
e . t xtn . Tex t )
' Proceso
If n Mod 3 = O And n Mod 5 = O Then
r = " SI ES MULTIPLO DE 3 Y 5''
: El se
r = " NO ES MULTIPLO DE 3 Y 5''
: End I f
' Salid a
: M
e . t x tr . Tex t = r
'. . .......................................................................................................................................................................................................... ..
Problema n.o15
Enunciado: Determinar si un número entero es par o impar.
luego, que el sistema verifique si el número es par o impar.
Expresión
Si n Mod 2 =O~
PAR
SiNo
IMPAR
Entrada
• Número (n)
Diseño:
Salida
• Resultado (r)
-PAR
- IMPAR
Interfaz de usuario
., Problema 15 rJ@rBJ
Número js
Aedodo jiMPAR

Diagrama de flujo
n
r
Inicio
Entero
Cadena
Leer n
V
r - " IMPAR" r - "PAR"
Escribir r
Fin
Codificación:
' Variables
Di m n As Integer
Di m r As String
' Entrada
n = Val (Me . txtn .Text )
' Proceso
If n Mod 2 - o Then
r = "PAR"
Else
r = " IMPAR"
End If
' Salida
Me. t x tr . Text = r
Algoritmo
Pseudocódigo
Inicio
//Variables
n Entero
r : Cadena
//Entrada
Leer n
//Proceso
Si n Mod 2 = O Entonces
r - "PAR"
SiNo
r - " IMPAR"
Fin Si
//Salida
Escribir r
Fin

Problema n.o 16
Enunciado: Dado tres números enteros, devolver el número mayor.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese tres números enteros nl,
n2 y n3; luego, que el sistema verifique y devuelva el número mayor.
Entrada Salida
• Tres números (nl, n2, n3) • Número mayor (m)
Diseño:
Interfaz de usuario
'" Problema 16 ~@](8]
NúrMto 1 122 ICco~cur~l
Núme~o 2 ls
Núme~o3
1
45
Mayor 145
Algoritmo
Diagrama de flujo
(I nicio
~
1 nl , n2 , n3 , m . Entero 1
.
~
1 Leer nl , n2 , n3 1
l
F nl > n2 V
F
n2 > n3
V E"
nl > n3
V
m - n3 m - n2 m - n3 m - nl
j Escribi r mj
~
( fi n

Pseudocódigo
Inicio
//Variables
nl , n2 , n3 : Entero
//Entrada
Leer nl , n2 , n3
//Proceso
Si nl > n2 Entonces
Si nl > n3 Entonces
m - nl
SiNo
m - n3
Fin Si
SiNo
Si n2 > n3 Entonces
m - n2
SiNo
m - n3
Fin Si
Fin Si
//Salida
Escribir m
Fin
Codificación:
............................................................................................................................................................................................................
' Variables
Dim nl As I nteger
Dim n2 As Integer
Dim n3 As Integer
Dim m As Integer
' Entrada
nl- Val(Me . txtnl . Text)
n2- Val(Me . txtn2 . Text)
' Proceso
If nl > n2 Then
If nl > n3 Then
m = nl
Else
m - n3
End If
Else
If n2 > n3 Then
m - n2
Else
m - n3
End If
End If
' Salida
Me . txtm . Te xt = Str(m)
............................................................................................................................................................................................................

Capítulo 3: Estructura selectiva simple y do ble
Problema n.o 17
Enunciado: Dado un número, devolver el doble si el número no es par; caso contrario, el triple.
luego, que el sistema verifique y devuelva el doble o el triple del número.
Expresión
Si -(n Mod 2 =O)=>
r = n * 2
SiNo
r =n * 3
Entrada
• Número entero (n)
Diseño:
Salida
• Resultado (r)
Interfaz de usuario
., Problema 17 ~]Q)(RJ
Número 1
7
Re...tado 114
Diagrama de flujo
( Inicio
!
1 n' r . Ent ero 1
.
~
1 Leer n
1
l
F
o (n Mod 2- 0)
V
r ·- n*3 r - n*2
/ Escri bir r /
!
Fi n
Algoritmo
Pseudocódigo
Inicio
//Variables
n , r : Entero
//Entrada
Leer n
//Proceso
Si No(n Mod 2 =0 ) Entonces
r - n * 2
SiNo
r - n * 3
Fin Si
//Salida
Escribir r
Fin

Codificación:
.............................................................................................................................................................................................................
.
' Variables
Dim n As Integer
Dim r As Int eger
' En t rada
n = Val (Me . txt n . Text )
' Proceso
I f Not (n M
od 2 - 0) Then
r = n * 2
El se
r = n * 3
End I f
' Salida
M
e . t xtr . Text = St r( r )
Enunciado: Dados 3 números, devolver los números en orden ascendente.
Análisis:Para la solución de este problema, se requiere que el usuario ingrese tres números (nl, n2 y n3);
luego, que el sistema verifique y devuelva los númerosordenados en forma ascendente.
Primero se debe encontrar el número mayor, luego el número menor y, al final, el número intermedio;
este resulta de sumar los tres números y luego restar el resultado de (mayor + menor).
Entrada Salida
• Números (nl, n2, n3) • Números ordenados (ma, int, me)
Diseño:
Interfaz de usuario
,. Problema 18 ~§rE)
OrdenA$c.
Número 1 ls lm ll Calcular ll
Número2 1
22 122
Número3 1
111 ls

Algoritmo
Diagrama de flujo
( I nicio )
~
1 nl , n2 , n3, mayor , inter, menor . Entero 1
.
1 Leer nl , n2 , n3 1
1
F nl>n2 y nl>n3
V
F n2>nl y n2>n3 V
mayor - n3 mayor - n2 mayor - nl
F nl<n2 y nl<n3
V
F n2<nl y n2<n3 V
menor - n3 menor - n2 menor - nl
1 ínter - (nl+n2+n3)-(mayor+menor)
~
1 Escribir mayor, inter ,
Pseudocódigo
Inicio
/ / Variables
nl , n2 , n3 , mayor , i nter, menor
//Entrada
Leer nl , n2 , n3
/ /Proceso
Si nl > n2 Y nl > n3 Ent onces
mayor - nl
SiNo
(
Si n2 > nl Y n2 > n3 Entonces
mayor - n2
SiNo
mayor - n3
Fin Si
Fin Si
¡
Fin )
Ente r o
menor 1

Si nl < n2 Y nl < n3 Entonces
menor ~ nl
SiNo
Si n2 < nl Y n2 < n3 Entonces
menor - n2
SiNo
menor - n3
Fin Si
Fin Si
inter ~ (nl+n2+n3)-(mayor+menor)
//Salida
Escribir mayor , inter, menor
Fin
Codificación:
' Variables
Dim nl As Integer
Dim n2 As Integer
Dim n3 As Integer
Dim mayor As Integer
Dim inter As Intege r
Dim menor As Intege r
' Entrada
nl - Val(Me . t xtnl . Text)
n2 = Val(Me . t x tn2 . Text)
n3 = Val(Me . t x tn3 . Text)
' Proceso
If nl > n2 And nl > n3 Then
mayor - nl
Else
If n2 > nl And n2 > n3 Then
mayor - n2
Else
mayor = n3
End If
End If
If nl < n2 And nl < n3 The n
menor = nl
Else
Else
If n2 < nl And n2 < n3 Then
menor - n2
menor = n3
End If
End If
inter = (nl + n2 + n3) - (mayor + menor )
' Salida
Me . txtMayor .Text - Str(mayor)
Me . txtlnter . Text - Str(inter)
Me . txtMenor . Text - Str(menor)
·............................................................................................................................................................................................................

Problema n.o19
Enunciado: Un restaurante ofrece un descuento del 10 % para consumos de hasta S/.100.00; y un
descuento del 20% para consumos mayores. En ambos casos se aplica un impuesto del 19 %. Determinar
el monto del descuento, el impuesto y el importe a pagar.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el consumo; luego, que el
sistema verifique y calcule el monto del descuento, el impuesto y el importe a pagar.
Entrada Salida
• Consumo (e) • Monto del descuento (m_d)
• Impuesto (m_igv)
• Importe a pagar (p)
1
., Problem• 19 rJ@(8)
Constm>
Mo<olodescuento
ImpuestoIGV
~-~··-
Diagrama de flujo
( Inicio )
l
Dl - 0 . 1 . Real
.
02 - 0 . 2 . Real
.
IGV- 0 . 19 . Real
.
!
e , m_d, m_i gv, p . Real
.
l
¡_ Leer e
1
1
F
c<~lOO
V
m_d - c*D2
1 1
m_d - c*Dl
!
m_ igv - (e - m_ d) * I GV
P- e - m_d + m_igv
¡
j Escribir m_d, m_ igv,
P
/
!
( Fin )
j¡ooo 1
1 cacu.. 1
1
1
200
11
52
1952
Algoritmo
1
Pseudocódigo
Inicio
//Constantes
01 = 0 . 1 : Real
02 = 0 . 2 : Re al
IGV = 0 . 19 · Re al
//Variables
e , m_ d , m_ig v , p
//Entrada
Leer e
//Proceso
Rea l
Si e <= 100 En tonces
m_ d - e * 01
SiNo
m_d - e * 02
Fin Si
m_igv - (e - m_d) * IGV
p - e - m_d + m_igv
//Salida
Escrib i r m_d, m_i gv , p
Fin

Codificación:
............................................................................................................................................................................................................
· ' Constante
Const Dl As Singl e = 0 . 1
Const D2 As Si ngle = 0 . 2
Const IGV As Single= 0 . 19
' Variables
Di m e As Single
Dim m_ d As Single
Di m m_igv As Single
Di m p As Single
' Ent r ada
e = Val (Me . t xt c . Text )
' Proceso
I f e <= 100 Then
m_d = e * Dl
El se
m_d = e * D2
End If
m_ igv = (e - m_d ) * I GV
p = e m_d + m_igv
' Salida
M
e . t xtm_d . Text = Str (m_ d )
M
e . t xtm_ igv . Text = Str (m_ igv)
Me . t xt p . Text = Str(p)
.. ..........................................................................................................................................................................................................
Problema n.o20
.
Enunciado: Debido a los excelentes resultados, el restaurante decide ampliar sus ofertas de acuerdo a
la siguiente escala de consumo (ver tabla). Determinar el monto del descuento, el importe del impuesto
y el importe a pagar.
Consumo (S/.) Descuento (%)
Hasta 100
Mayor a 100
Mayor a 200
10
20
30
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el consumo; luego, el
sistema verifique y calcule el monto del descuento, el impuesto y el importe a pagar.
Entrada Salida
• Consumo (e) • Monto del descuento (m_d)
• Impuesto (m_igv)
• Importe a pagar (p)

Diseño:
Interfaz de usuario
.. Problema 10 ¡;;jrg)~
Consumo lum 11 c.lcW!
ll
Monlode.- 1
300
lmpuestoiGV 1133
lrrcxwt••- 1833
Algoritmo
Diagrama de flujo
( Inicio
!
01 - 0 . 1 . Real
.
02 - 0 . 2 . Real
.
03 -0 . 3 . Real
.
I GV - 0 . 19 . Real
.
!
e , m_d, m_igv, p : Real
!
/ Leer e /
1
F
> 200
V
e
F
e > lOO V
1 m_d - e * 01
Pseudocódigo
Inicio
//Constantes
01 - 0 .1 : Real
02 ; 0 . 2 : Real
03 ; 0 . 3 : Real
IGV ; 0 . 19 : Real
1 m_d - e * 02 1
¡
P - e - m_d + m_igv
!
j Escribir m_d, m
_ igv,
~
( Fin
m_d ·- e * 03 1

//Variables
e , m_d , m_igv , p
//Entrada
Leer e
//Proceso
Si e > 200 Entonces
m_d - e * 03
SiNo
Real
Si e > 100 Entonces
m_d - e * 02
SiNo
m_d - e * 01
Fin Si
Fin Si
p - e - m_d + m_igv
//Salida
Escribir m_d , m_igv , p
Fin
Codificación:
' Constante
Const 01 As Single
Const 02 As Single
Const 03 As Single
Const IGV As Single
' Variables
Oim e As Single
Oim m_d As Single
Oim m_igv As Single
Oim p As Single
' Entrada
=
=
-
=
e= Val(Me . txtc . Text)
' Proceso
If e > 200 The n
m_d = e * 03
Else
0 . 1
0 . 2
0 . 3
0 . 19
If e > 100 Then
m_d = e * 02
El se
m_d = e * 01
End If
End If
m_igv = (e - m_d) * IGV
p = e - m_d + m_igv
' Salida
Me . txtm_d . Text = Str(m_d)
Me . txtm_igv . Text = Str(m_igv)
Me . txtp . Text = Str(p)

Capítulo 3: Estructura selectiva simple y do ble
Problema n.o21
Enunciado:Al ingresar el valor de una temperatura, obtener el tipo de clima según la siguiente tabla.
Temperatura Tipo de clima
Temp. < 10 Frío
Temp. entre 10 Y 20 Nublado
Temp. entre 21 Y 30 Calor
Temp. > 30 Tropical
Análisis: Para la solución de este problema, se requiere que el usuario ingrese la temperatura; luego, que
el sistema verifique y determine el clima.
Entrada
• Temperatura {t )
Diseño:
Salida
• Clima {e)
Interfaz de usuario
.. Problema 21 (g@J~
TerfClOialura 128
Cima !CALOR
Diagrama de flujo
In i cio
Algoritmo
l
t . Ent ero
.
e . Cadena
.
~
1 Leer t
1
l
F
t < 10
V
-
F
b=u 'f t< ~
V e - "FRIO"
F - V " NUBLADO"
>- 21 'f t<=w e -
-
e - " TROPICAL" e - "CALOR"
1 Escribir e
1
~
eFi n )

Pseudocódigo
Inicio
//Variables
t : Entero
e : Cadena
//Entrada
Leer t
//Proceso
Si t < 10 Entonces
e - " FRIO"
SiNo
Si t >= 11 Y t <=20 Entonces
e - " NUBLADO"
Fin
SiNo
Fin
Fin Si
1/Salida
Escribir e
Codificación:
Si t
SiNo
Fin
Si
>= 21 y t <=20 Entonces
e - " CALOR"
e - " TROPICAL"
Si
..................................................................................................'....................................................................................................... ...
' Variables
Dim t As Integer
Dim e As String
' Entrada
t = Val(Me . txtt . Text)
' Proceso
If t < lO Then
e = " FRIO"
El se
If t >= 10 And t <= 20 Then
e = " NUBLADO"
El se
If t >= 21 And t <= 30
e - "CALOR"
El se
e - " TROPICAL"
End If
End If
End If
' Salida
Me . txtc . Text = e
Then
.............................................................................................................................." ..............................................................................

Problema n.o 22
Enunciado: Un negocio tiene dos tipos de cliente: cliente general (G) y cliente afiliado (A). También
acepta dos formas de pago: al Contado (C) y en plazos (P). Nos piden crear un programa que al ingresar el
monto de la compra se obtenga el monto del descuento o el monto del recargo y el total a pagar, según
la siguiente tabla.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el monto de la compra, el
tipo de cliente y la forma de pago; luego, que el sistema verifique y determine el monto de descuento o
recargo y el total a pagar.
Tipo
Contado (C) Plazos {P)
Descuento Recargo
Cliente general (G) 15% 10 %
Cliente afiliado (A) 20% 5%
Entrada Salida
• Monto de la compra (me) • Monto de descuento o recargo (m)
• Tipo de cliente (te) • Total a pagar (tp)
• Forma de pago (fp)
Diseño:
Interfaz de usuario
'" Problema 22 [)[Q]rBJ
Monlo de lacom
Pfa 1
100 rca~J
T~ de cliente lA
F01ma de pago le
IDESOJENTO 2w. 1
20
Totala pag<~~ leo

Algoritmo
Diagrama de flujo
( Inicio )
!
DESC_G - 0 . 15 . Real
.
DESC_A- 0 . 2 . Real
.
REC_G - 0 . 10 . Real
.
REC_A - 0 . 05 . Real
.
!
me , m, tp . Real
.
te , fp, r . Cadena
.
¡
/ Leer me , te, to/
1
¡;-
tc="G"
V
)_ )_
F
fp="C"
V ¡;-
fp="C"
V
~ ~
m-mc*REC_A m-mc*DESC_A m-mc*REC_G m-mc*DESC_G
tp-mc+m tp-mc-m
r - " REC. 5%" r - " DESC . 20% "
/ Leer
Pseudocódigo
Inicio
//Constantes
DESC_G = 0 . 15 : Rea l
DESC_A = 0 . 2 : Real
REC_G = 0 . 10 Real
REC_A = 0 . 05 Real
//Variables
me , m, tp : Real
te , fp , r Cadena
//Entrada
Leer me , te, fp
//Proceso
Si te = "G" Entonces
Si f p = "C" Entonces
(
tp-mc+m tp-mc-m
r - " REC . 10%" r - " DESC . 15%"
r , m, tp /
!
FIN )

m - me * DESC_G
tp - me - m
r - " DESCUENTO 15%"
SiNo
m - me * REC_G
tp - me + m
r - " RECARGA 10%"
Fin Si
SiNo
Si fp - "C" Entonces
m - me * DESC_A
tp - me - m
SiNo
m - me * REC_A
tp - me + m
r - " RECARGA 5%"
Fin Si
Fin Si
1/Salida
Escribir r , m, tp
Fin
Codificación:
' Constantes
Const DESC_G As Single = 0 . 15
Const DESC_A As Single = 0 . 2
Const REC_G As Single - 0 . 1
Const REC_A As Single - 0 . 05
' Variables
Dim me As Single
Dim te As String
Dim fp As String
Dim r As String
Dim m As Single
Dim tp As Single
' Entrada
me- Val(Me . txtme . Text)
te- Me . t xttc . Text
fp- Me . t xtfp . Text
' Proceso
If te = "G" Then
If fp = "C" Then
m = me * DESC_G
tp = me - m
•., ...........................................................................................................................................................................................................

.............................................................................................................................................................................................................
r = "DESCUENTO 15%"
Else
m = me * REC_G
tp = me + m
r = " RECARGO 10%"
End If
El se
If fp = "C" Then
m - me * DESC_A
tp - me - m
Else
m - me * REC_A
tp - me + m
r - " RECARGO 5%"
End If
End If
' Salida
M
Me . txtm . Tex t = Str (m)
M
e . t x ttp . Tex t = Str (tp )
... .......................................................................................................................................................................................................... ..
Enunciado: Elabore un algoritmo que resuelva una ecuación de primer grado.
ax + b = O
-b
x = -
a
Considerar si a es diferente a O
, no es una ecuación de primer grado.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el valor de a y b; luego, que
el sistema verifique y determine el valor de x.
Entrada Salida
• Coeficiente a (a)
• Término independiente b (b)
Diseño:
• Raíz x (x)
Interfaz de usuario
._ Problema 23 ~@t8]
a 1·5
b 115
X IJ
Calcular

Diagrama de flujo
Inicio
a , b , x : Real
Leer a , b
Algoritmo
Pseudocódigo
Inicio
//Variables
a , b , x : Real
//Entrada
Leer a , b
//Proceso
X - 0 x ·- - b 1 a
Si a <> O Entonces
x - -b 1 a
SiNo
Escribir x
Fin
Codificación:
X - 0
Fin Si
//Salida
Escribir r
Fin
..........................................................................................................................................................................................................··.
' Variables
Dim a As Single
Dim b As Single
Dim x As Single
' Entrada
a= Val(Me . txta . Text)
b - Val(Me . txtb . Text )
' Proceso
If a <> O Then
x = - b 1 a
Else
X = 0
End If
' Salida
Me . t xtx . Text = Str(x)
............................................................................................................................................................................................................

Problema n.o 24
Enunciado: Elabore un algoritmo que obtenga las raíces reales de una ecuación de segundo grado.
ax2 + bx +e = O
- b +.Jb2
- 4ac
xl = --'----
2a
• Considerar que a ~O, para poder dividir.
• Considerar b2 - 4ac ~O, para obtener la raíz cuadrada.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el valor de a, by e; luego,
que el sistema verifique y determine el valor de xl y x2.
Entrada Salida
• Coeficiente a (a)
• Coeficiente b (b)
• Término independiente e (e)
Diseño:
• Primera raíz x (xl)
• Segunda raíz x (x2)
Interfaz de usuario
"' Problema 24 [J[QJ(E)
a ¡,
b 1·15
e 1
44
., 111
•2 14

Algoritmo
Inicio
( Inicio )
!
a, b, e, d , xl , x2 o Real
o
!
/ Leer a, b , e/
!
d - (b A 2) - 4 * a * e
1
F a <> o y d > V
u
~ ~
xl -o xl-(-b+dA(l/2))/2*a
x2 o
- o x2-(-b- dA(l/2))/2*a
¡
~scribir xl , x2/
~
( Fin )
Codificación:
//Variables
a , b , e , x l , x2
//Entrada
Leer a , b, e
//Proceso
Rea l
d - (b A 2) - 4 * a * e
Si a <> O Y d >= O Entonces
x l- (-b + dA (1 1 2 )) 1 2 *a
x 2- (-b- dA (1 1 2)) 1 2 *a
Si No
x l - O
x2 - O
Fi n Si
//Salida
Escribir x l , x 2
Fin
.......................................................................................................................................................................................................... ··.
' Variables
Dim a As Single
Di m b As Single
Dim e As Single
Dim d As Single
Di m xl As Si ngle
Dim x2 As Single
' Entrada
a - Val (Me otxta oText )
b- Val(Me ot x tb oText )
e= Val (Me ot xte oTex t )
' Proceso
d = (b A 2 J - 4 * a * e
If a <> O And d >= O Then
El se
x l - (-b + d A ( 1 1 2)) 1 2 * a
x 2 - ( - b - d A (1 1 2) ) 1 2 * a
x l = O
x2 - O
End If
' Salida
Me ot x t xlo Tex t = Str (xl)
Me ot x t x2 oText = Str(x2)

Enunciado: Dadas la hora, minuto y segundo, encuentre la hora del siguiente segundo.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese la hora, minuto y segundo;
luego que el sistema verifique y determine la hora, minuto y segundo del siguiente segundo.
Entrada Salida
• Hora (h) • Hora (h)
• Minuto (m) • Minuto (m)
• Segundo (s) • Segundo (s)
Diseño:
Interfaz de usuario
"' Problema 25 ~]Q)~
H01a Minuto Segundo
13 1
59 1
59 [ Ca~~~
H01a Minuto Segundo
14 1o lo

Diagrama de flujo
( Inicio )
l
h, m, S : Entero
¡
¡Leer h, m,
o/
!
S • S + 1
1
F
S • 60 >
V
S • o
m . m + 1
1
F m • 60 :::>
Jv
S - 0
m - m + 1
l_V
F
h ~ 24
l
h . o
/Escribir h, m, s/
¡
Fin
Algoritmo
Pseudocódigo
Inicio
//Variables
h , m, s : Entero
//Entrada
Leer h , m, s
//Proceso
S - S + 1
Si s = 60 Entonces
S - 0
m - m + 1
Si m • 60 Entonces
m - O
h - h + 1
Si h - 60 Entonces
h - o
Fin Si
Fin Si
Fin Si
//Salida
Escribir h , m, s
Fin

Codificación:
.· ·········································································································································································································· ..
' Variables
Dim h As Integer
Dim m As Integer
Dim s As Integer
' Entrada
h = Val(Me . txthl . Text)
m - Val(Me . txtml . Text)
s = Val(Me . txtsl . Text)
' Proceso
S = S + l
If S = 60 Then
S = o
m = m + l
If m = 60 Then
m - o
h = h + 1
If h - 24 Then
h - o
End If
End If
End If
' Salida
Me . t xth2 . Text- Str(h)
Me . t xtm2 . Text - Str(m)
Me . t xts2 . Text - Str(s)
.............................................................................................................................................................................................................

Propuesto n.o 11
Enunciado: Dada la edad de una persona, determinar si es mayor o menor de edad; considere que son
mayores de edad aquellas personas que tienes de 18 años a más.
Propuesto n.o12
Enunciado: Si tenemos dos números enteros, devolver el número menor.
Propuesto n.o13
Enunciado: Si tenemos dos números, determinar si son iguales o son diferentes.
Propuesto n.o14
Enunciado: Dado un número entero, devolver el doble del número si este es positivo; el triple, si es
negativo; y cero si el número es neutro.
Propuesto n.o15
Enunciado: Crear un programa que al ingresar tres números enteros, los devuelva ordenados en forma
ascendente y en forma descendente.
Propuesto n.o16
Enunciado: Después de ingresar 4 notas, obtener el promedio de la tres mejores y mostrar el mensaje
«Aprobado>>, si el promedio es mayor o igual a 11; caso contrario, mostrar «Desaprobado>>.
Propuesto n.o17
Enunciado: Dados los siguientes datos de entrada: «saldo anterior>>, tipo de movimiento «R» (retiro) o
«D>> (depósito) y <<monto de la transacción>>, obtener como dato de salida el saldo actual.
Propuesto n.o18
Enunciado: Dados 2 números enteros a y b, determinar cuál es mayor con respecto al otro.
a es mayor que b
b es mayor que a
a es igual a b

Propuesto n.o 19
Enunciado: Dado que se tienen tres longitudes, diga si forman un triángulo.
Teorema: En todo triángulo, cada lado es menor que la suma de los otros dos, pero mayor que su diferencia.
Propuesto n.o20
Enunciado: Dado que tenemos tres longitudes; si forman un triángulo, devolver el tipo de triángulo según
sus lados.
T. equilátero: Sus 3 lados son iguales.
T. isósceles: 2 lados iguales.
T. escaleno: 3 lados diferentes.

Estructura selectiva múltiple
4.11ntroducción
Sabemos que en la actualidad existen muchos sistemas financieros que ofrecen préstamoscon condiciones
diferentes; usted, al solicitar un préstamo, tiene que evaluar diversas alternativas y decidirse por una de
ellas.
En los lenguajes de programación se cuenta con una implementación similar, la cual recibe el nombre de
estructura selectiva múltiple, que permite evaluar varias alternativas y realizar el proceso para comprobar
si cumple o no con la condición elegida.
Muchas veces, para solucionar este tipo de problemas, se utilizan estructuras selectivas dobles anidadas
(en cascada), dando una solución muy complicada y confusa para analizar; es recomendable que cuando
se tenga que evaluar varias alternativas se utilice estructuras selectiva múltiple porque es más legible,
eficiente y fácil de interpretar.
4.2 Estructura selectiva múltiple
Permite comparar un valor con diversas alternativas; si la comparación tiene éxito, se ejecuta el grupo de
instrucción que contenga la alternativa seleccionada y, luego, sale de la estructura.
Muchas se pueden implementar, en forma opcional, una alternativa por defecto; es decir, si al comparar
con todas las alternativas propuestas no se tiene éxito con ninguna, entonces se ejecuta la alternativa por
defecto.
En Caso que <Exp.> Sea
Caso Valorl
<Instrucciones>
valorl
Caso Valor2
Instrucciones <Instrucciones>
Valor2
Caso Valor3
<Instrucciones>
Instrucciones Fin Caso
Valor3
Instrucciones

Sintaxis 1 Visual Basic
................' ......................................................................................................................................................................................... ...
Select Case <Exp. >
Case Valorl
<Instrucciones>
Case Valor2
<Instrucciones>
Case Valor3
<Instrucciones>
End Select
..................., ......................................................, ........................................................................, ........................................................ ..
F
F
Va l o r 1
Instrucciones
,-----.,.----.,.---, V
Va l o r 2
Inst r ucc i o nes
SiNo
Instrucc iones
En Caso que <Exp.> Sea
Caso Valorl
<Instrucciones>
Caso Valor2
<Instrucciones>
SiNo
<Instrucciones>
Fin Caso
.......................................................................................................................................................................................................... .•.
Select Case <Exp.>
Case Valorl
<Instrucciones>
Case Valor2
<Instrucciones>
Case Else
<Instrucciones>
End Select
.. ..........................................................................................................................................................................................................
4.2.1 Estructura selectiva múltiple usando rangos
.
La estructura selectiva múltiple permite comparar un valor (igualdad), pero cuando se requiere manejar
rangos(>= Y <=) se puede usar una estructura selectiva múltiple similar a la estructura selectiva doble
anidada.

Capítulo 4: Estructura selectiva múltiple
Si <Exp.Log.> Entonces
V
Exp . Log . <Instrucciones>
F 1 Instrucciones SiNoSi <Exp.Log.> Entonces
V
<Instrucciones>
Exp . Log .
F 1 Instrucciones
SiNoSi <Exp.Log.> Entonces
V <1nstrucciones>
Exp . Log .
SiNo
F 1 Instrucciones
<Instrucciones>
1
Instrucciones 1
Fin Si
.................................................................................................' ........' ............................................................................................... ...
lf <Exp. Log.> Then
<Instrucciones>
Elself <Exp. Log.> Then
<Instrucciones>
Elself <Exp. Log.> Then
<Instrucciones>
Else
<Instrucciones>
End lf
En el caso de Visual Basic, las sentencias múltiples usando Select Case permiten manejar rangos.
.' .......................................................................................................................................................................................................... ..
Select Case <Exp.>
Case Valor1 To Valor2
<Instrucciones>
Case Valor3 To Valor4
<Instrucciones>
Case Else
<Instrucciones>
End Select
'·· .......................................................................................................................................................................................................... .
Enunciado: Al ingresar un número entre 1 y 4 devolver la estación del año de acuerdo a la siguiente tabla:
Número Estación
1 Verano
2 Otoño
3 Invierno
4 Primavera

que el sistema realice el proceso para devolver la estación.
Entrada Salida
• Número (n) • Estación (e)
. ,. Problema 26 [g[QJ(EJ
Número
Estación
Diagrama de flujo
( Inicio
~
n . Entero
.
e . Cadena
.
!
/ Leer n /
l
n
--..¡ 1 :
V
f e-"VERANO "
V
--.¡ 2 1
!
f e-"OTOÑO "
V
--.¡ 3 1
!
f e-" INVIERNO"
---+ 4
V
!
f e-"PRIMAVERA"
¡
1 Escribir e
1
!
( fin
jiNVIERNO
IC-~1
~
-1
Algoritmo
Pseudocódigo
Ini cio
/ / Variables
n Entero
e : Cadena
//Entrada
Leer n
//Proceso
En Caso que n Sea
Caso 1
e -
Caso 2
e -
Caso 3
e -
Caso 4
e -
Fin Caso
//Sal ida
Escribir e
Fin
" VERANO"
" INVIERNO"
" OTOÑO"
" PRIMAVERA"

Codificación:
' Variabl es
Di m n As I nteger
Di m e As String
' Entrada
n = Val (M
e . t xt n . Te xt )
' Proceso
Select Case n
Case 1
e - "VERANO"
Case 2
e - "OTOÑO"
Case 3
e - " INVI ERNO"
Case 4
e - " PRI MAVERA"
End Sel e c t
' Salida
M
e . t xte . Te xt = e
'•' ....................................................................................................································.......................································..............
Problema n.o27
Enunciado: Dado un número entero de un dígito (O al 9), devolver el número en letras.
que el sistema verifique y devuelva el número en letras.
Entrada Salida
• Número (n) • Resultado (r)
Diseño:
Interfaz de usuario
"' Problema 27 (g[Q)[8)
Númeto ls
Letra jNUEVE

Diagrama de flujo
( Inicio
!
n . Entero
.
1 . Cadena
.
!
/ Leer n /
l
n
--.¡ o V
!
F
1-"CERO"
___, 1 V
+
F
1-"UNO"
--.J z V
+
F
1-"DOS "
___,. 3
V
+
F
1-"TRES "
V
-...¡ 4
!
F
1- "CUATRO "
--.¡ 5
V
+
F
1-"CINCO"
--.¡ 6
V
+
F
1-'' SEIS "
--.¡ 7 V
J.
F
1-" SIETE "
-...¡ 8
V
+
F
1-"0CHO"
___,. 9 V
+
F
1-"NUEVE "
1 Escribir r
1
( Fin
Algoritmo
Pseudocódigo
Inicio
//Variables
n Entero
1 Cadena
//Entrada
Lee r n
//Proceso
En Caso que n Sea
Caso o
1 - "CERO"
Caso 1
1 - "UNO"
Caso 2
1 - "DOS"
Caso 3
1 - "TRES"
Caso 4
1 - "CUATRO"
Caso 5
1 - "CINCO"
Caso 6
1 - " SEIS"
Caso 7
1
-" SIETE"
Caso 8
1
-"OCHO"
Caso 7
1
-"NUEVE"
Fin Caso
//Salida
Escribir 1
Fin

Codificación:
............................................................................................................................................................................................................ ..
' Variables
Di m n As I nteger
Dim 1 As String
' Entrada
' Proceso
Select Case n
Case O
1 = "CERO"
Case 1
l - "UNO"
Case 2
l - "DOS"
Case 3
l - "TRES"
Case 4
1 = "CUATRO"
Case 5
l - "CINCO"
Case 6
l - " SEIS"
Case 7
l - " S IETE"
Case 8
1 - "OCHO"
Case 9
l - " NUEVE"
End Select
' Salida
M
e . t xtl . Text = l
... .......................................................................................................................................................................................................... .
Problema n.o 28
Enunciado: Dados dos números enteros y un operador {+, -, * y/), devolver la operación de los dos
números según el operador ingresado. Considere que si el segundo número es cero y el operador es / , no
es divisible con el primer número, entonces devolver como resultado O.
Análisis:Para la solución de este problema, se requiere que el usuario ingrese un operador y dos números;
luego, que el sistema verifique la operación y devuelva el resultado de la operación.
Entrada Salida
• Operador (op) • Resultado (r)
• Número {nl y n2)

Diseño:
Interfaz de usuario
'" Problema 28 ~(Q)['g)
Operación
Númerol
Número2
Resulado
Diagrama de flujo
Inicio
!
op . Caracter
.
n1 , n2 , r . Entero
.
~
/ Leer op, nl , n2
/
l
op
~ ' +' :
V
!
F
nl + n2
r -
V
~ , _ , 1
~
F
r - nl - n2
~ '*' 1
V
~
F
r - nl * n2
~ ' / ' 1
V
l_
F
N2<>0
! !
r - o r-nl/n2
1 1
1
l
1 Escribir r 1
!
Fin
"
jls
13
ls
lc.~~
-=n
Algoritmo
Pseudocódigo
Ini cio
//Variables
op : Caracter
nl , n2 , r : Entero
/ / Entrada
Leer op, nl , n2
//Proceso
En Caso que op Sea
Caso ' +'
r .... nl + n2
Caso ' - '
r - nl - n2
Caso ' *'
r .... nl * n2
Caso ' / '
Si n2 <> O Entonces
r - nl + n2
SiNo
r - O
Fin Sin
Fin Caso
/ / Sal ida
Escrib i r r
Fin

Codificación:
............................................................................................................................................................................................................
. ' Variables
Dim op As String
Dim nl As Integer
Dim n2 As Integer
Dim r As Integer
' Entrada
op- Me . txtop . Text
nl- Val(Me . t xtnl . Text)
n2- Val(Me . t xtn2 . Text)
' l?roceso
Select Case op
Case " +"
r - nl + n2
Case " - "
r - nl n2
Case " *"
r = nl * n2
Case " / "
I f n2 <> O Then
El se
End If
End Select
' Salida
Me . t x tr . Text = r
r = nl n2
r = O
................................................................................................................................................" ............................................................
Enunciado: Dada una letra, determinar si es una vocal.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese una letra «1
»; luego, que el
sistema analice y determine si es una vocal.
Entrada Salida
• Letra (1) • Resultado (r)

Diseño:
Interfaz de usuario
'" Problema 29 [J[QJ[8)
Leua fE
ResuRado fES VOCAL
Algoritmo
( Inicio
¡
1 . Caracter
.
r . Cadena
.
+
/ Leer 1 /
l.
< 1 - ' a ' o 1 , A' V
F
1 r-"ES
< 1 - ' e ' o 1 - ' E'
V
F
1 r-"ES
< 1 1 • 1
- 1 o 1-' I '
V
F
1 r-"ES
< 1- ' o ' o 1- ' 0 '
V
F 1 r-"ES
V
< 1 - ' u1
o l - 1
U'
F
1 r-"ES
r- "NO ES VOCAL"
1 Escribir r 1
+
( Fin
VOCAL"
VOCAL"
VOCAL"
VOCAL" -J
VOCAL" J
Inicio
//Variables
1 Caracter
r : Cadena
//Entrada
Leer 1
//Proceso
Si 1 = ' a ' O 1 = ' A' Enton ces
r - " ES VOCAL"
SiNoSi 1 = ' e ' O 1 = ' E' Entonces
r - " ES VOCAL"
SiNoSi 1 = ' i ' O 1 = ' I ' Entonces'
r - " ES VOCAL"
SiNoSi 1 = ' o ' O 1 = ' O' Entonces
r - " ES VOCAL"
SiNoSi 1 = ' u' o 1 = ' U' Entonces
r - " ES VOCAL"
SiNo
r - " NO ES VOCAL"
Fin Si
//Salida
Escribir r
Fin

Codificación:
............................................................................................................................................................................................................
' Variables
Dim 1 As String
Dim r As String
' Entrada
1 = Me . t xtl . Text
' Proceso
If 1 - "a" Or 1 - "A"
r - " ES VOCAL"
Elseif l - "e" Or l -
r - " ES VOCAL"
Elseif l - "i " Or l -
r - " ES VOCAL"
Elseif l - ''o" Or 1 -
r - " ES VOCAL"
Elseif 1 - "u" Or 1 -
r - '' ES VOCAL"
Else
r - "NO ES VOCAL"
End If
' Salida
Me . t xtr . Text = r
Problema n.o 30
Then
"E" Then
"I " Then
"O" Then
" U" Then
Enunciado:Al ingresar el número de un mes, devolver la estación del año de acuerdo a la siguiente tabla:
Mes Estación
1, 2,3 Verano
4,5,6 Otoño
7,8,9 Invierno
10,11,12 Primavera
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el número del mes; luego,
que el sistema verifique y determine la estación.
Entrada Salida
• Mes (m) • Estación (e)

Diseño:
Interfaz de usuario
" Problema 30 ~rQJ[EJ
Diagrama de flujo
( Inicio )
¡
m . Entero
.
e . Cadena
.
¡
/ Leer m /
1
- m
-
H LV
1 , 2 , 3 1
F e ·- "VERANO"
H LV
4 , 5 , 6 1
F e-"OTOÑO"
H LV
7 , 8 , 9 1
F e-" INVIERNO "
H1o,11 , 12Jl
F e-" PRIMAVERA "
1 Escribir e
¡
( Fin )
M!!$ la
Es1aci6n jiNVIERNO
Algoritmo
1
Pseudocódigo
Inicio
//Variables
m Entero
e : Cadena
//Entrada
Leer m
//Proceso
En Caso que m Sea
Caso 1 , 2 , 3
e - " VERANO"
caso 4, 5 , 6
e - " OTOÑO"
caso 7, 8 , 9
e - " INVIERNO"
Caso 10 , 11, 12
e - "PRIMAVERA"
Fin Caso
//Salida
Escribir e
Fin

Codificación:
' Variables
¡ Dim m As
i Dim e As
' En t rada
Integer
String
1 m = Val (Me . txt m . Text )
' Pr oceso
Select Case m
Case 1 , 2 , 3
e = " VERANO"
Case 4 , 5 , 6
e = " OTOÑO"
case 7 , 8 , 9
e = " INVIERNO"
Case 10, 11 , 12
e = " PRIMAVERA"
i End Select
' Salida
1 Me . t x t e . Text = e
Capítulo 4: Estructura selectiva múlt iple
............................................................................................................................................................................................................
Enunciado: Dada la nota promedio de un alumno, obtener la categoría según la siguiente tabla:
Promedio Categoría
Entre Oy 5 Pésimo
Entre 6 y 10 Malo
Entre 11 y 14 Regular
Entre 15 y 17 Bueno
Entre 18 y 20 Excelente
.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el promedio; luego, que el
sistema verifique y devuelva la categoría.
Entrada Salida
• Promedio (p) • Categoría (e)

Diseño:
/
<
<
1
Interfaz de usuario
,. Problema 31 rJLQ]l'EJ
Promedio !13
Categoría !REGULAR
Algoritmo
Diagrama de flujo
( Inicio
¡
p o
Caracter
o
e o
Cadena
o
!
Leer p /
l_
p> o y p< 5
V
F
1
c-" PESIMO" 1
p> 6 y p< 10
V
F
1
c- "MALO"
> 11 y p< 1
V
F 1 e- " REGULAR"
> 15 y p> 1/
V
F 1 e-"BUENO"
> 18 y p< 2u
V
F 1 c-" EXCELENTE" :
Escribir e 1
~
( Fin
Pseudocódigo
Inicio
//Variables
p Entero
e : Cadena
//Entrada
Leer p
//Proceso
Si p >; O Y p <; 5 Entonces
e - " PESIMO"
SiNoSi p >= 6 Y p <= 10 Entonces
e - "MALO"
SiNoSi p >= 11 Y p <; 14 Entonces
e - " REGULAR"
SiNoSi p >= 15 Y p <; 17 Entonces
e - " BUENO"
SiNoSi p >; 18 Y p <; 20 Entonces
e - " EXCELENTE "
Fin Si
//Salida
Escribi r e
Fin

Codificación:
........................................................................................................................................................................................................... ...
: ' Variables
¡ Dim p As Integer
: Di m e As St ri ng
: ' Entrada
i p = Va l (Me . t xtp . Tex t )
' Proceso
If p >= O And p <= 5 Then
e = " PES I MO"
Elseif p >= 6 And p <= 10 Then
e - "MALO"
El self p >= 1 1 And p
e = " REGULAR"
Elseif p >= 15 And p
e - " BUENO"
.
El self p >= 18 And p
e - " EXCELENTE"
End If
¡ ' Salida
: M
e . t xtc . Tex t =e
<= 14 Then
<= 17 Then
<= 20 Then
Enunciado:Al ingresar el día y el número de un mes, devolver la estación del año de acuerdo a la siguiente
tabla:
Estación Tiempo
Verano Del 21 de diciembre al 20 de marzo
Otoño Del 21 de marzo al 21 de junio
Invierno Del 22 de junio al 22 de septiembre
Primavera Del 23 de septiembre al 20 de diciembre
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el día y el mes; luego, que
el sistema verifique y devuelva la estación.
Entrada Salida
• Dia (d) • Estación (e)
• Mes (m)
Diseño:
Interfaz de usuario
'" Problema 32 LJ[QJ(8)
Día ,,8 11 CabAol
11
Met ls
Estocién IDToRo

Diagrama de flujo
Inicio )
!
d , m . Entero
.
e . Cadena
.
l
L Leer d , m/
l
...--- m
H ¡ V
1 , 2 , 3 1 l
F e-"VERANO"
1
F m 3 Y d >2c
Tv
e-"OTOÑO"
J
H LV
4, 5, 6_] !
F e-"OTOÑO"
J
j_
F
m 6 Y d>2
¡v
e•- " INVIERNO"
H 7 , s , 9J
V
l
F e-" INVIERNO"
F
J.
m-9 Y d>2
lv
e-" PRIMAVERA"
J
H1o,11 , 1p¡
F e-" PRIMAVERA"
1
F m-12 y d>2
Tv
l e-"VERANO"
J
J
l
L Escribir e /
l
Fin )
Algoritmo
Pseudocódigo
Inicio
//Variables
d , m : Entero
e : Cadena
//Entrada
Leer d , m
//Proceso
En Caso que m Sea
Caso 1 , 2, 3
e - "VERANO"
Si m = 3 Y d > 20 Entonces
e - "OTOÑO"
Fi n Si
Caso 4, 5, 6
e - "OTOÑO"
e - " INVI ERNO"
Fin Si
Caso 7, 8 , 9
e - " INVIERNO"
e - " PRIMAVERA"
Fin Si
Caso 10 , 11, 12
e - " PRIMAVERA"
e - " VERANO"
Fi n Si
Fin Caso
//Salida
Esc r ib i r e
Fin

Codificación:
.' .......................................................................................................................................................................................................... ...
' Variabl es
Di m d As I nteger
Dim m As Integer
Di m e As String
' Entrada
d- Va l(Me . t xtd . Text )
m= Val (Me . t xtm . Text )
' Proceso
Sel ect Case m
Case 1, 2 , 3
e = "VERANO"
I f m = 3 And d > 20 Then
e = "OTOÑO"
End If
Case 4 , 5 , 6
e = "OTOÑO"
If m = 6 And d > 2 1 Then
e = " INVIERNO"
End If
Case 7, 8 , 9
e = " INVI ERNO"
If m = 9 And d > 22 Then
e = " PRIMAVERA"
End If
Case 10, 11 , 12
End Sel ect
e = " PRIMAVERA"
If m = 12 And d > 20 Then
e = "VERANO"
End If
' Salida
M
e . t xte . Text =e
...............................................................' ............................................................................................................................................
Enunciado: En una universidad se ha establecido los siguientes puntajes de ingreso a sus respectivas
facultades.
Facultad Puntaje mínimo
Sistemas 100
Electrónica 90
Industrial 80
Administración 70
De acuerdo al puntaje obtenido por un postulante, determinar la facultad a la cual ingresó o dar un
mensaje correspondiente en caso no ingrese.

Análisis: Para la solución de este problema, se requiere que el usuario ingrese el puntaje; luego, que el
sistema verifique y devuelva la facultad a la que ingresó.
Entrada Salida
• Puntaje (p) • Facultad (f)
Diseño:
Interfaz de usuario
.. Problema 33 [J[QJ(EJ
Priaje ,,20
FacUtod !SISTEMAS
Diagrama de flujo
Algoritmo
Pseudocódigo
( rnicio)
¡
p . Entero
.
f . Cadena
.
¡
/ Leer p /
J.
p>-70 y p<~J
V
<
F
1
f .- " CI ENC lAS"
p>-80 y p<-8
V
F 1 f-" INDUSTRIAL"
> 90 y p< g,
V
F l t-"ELECTRONICA"
< p> lOO
V
F
1
f.- " SISTEMAS"
r-" NINGUNA"
/ Escribir f /
¡
( Fin
1
1
Ini cio
//Variables
p Entero
f : Cadena
//Entrada
Leer p
//Proceso
Si p >= 70 Y p <= 79 Entonces
f - " CIENCIAS"
f - " INDUSTRIAL"
f - " ELECTRONICA"
SiNoSi p >= 100 Entonces
f - " SISTEMAS"
SiNo
f - " NINGUNO"
Fin Si
/ / Salida
Escribir f
Fin

Codificación:
' Variables
Dim p As Integer
Dim f As String
' Entrada
p = Val (Me . txtp . Text )
' Proceso
If p >= 70 And p <= 79 Then
f = "CIENCIAS"
El seif p >= 80 And p <= 89 Then
f = " INDUSTRIAL"
El sei f p >= 90 And p <= 99 Then
f = " ELECTRONICA"
El seif p >= 100 Then
f - " SISTEMAS"
Else
f = "NINGUNA"
End If
' Salida
Me . t xtf . Text = f
............................................................................................................................................................................................................
Problema n.o 34
Enunciado: Determine el importe a pagar para el examen de admisión de una universidad, cuyo valor
depende del nivel socioeconómico y el colegio de procedencia.
Nacional
Particular
300 200 100
400 300 200
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el colegio y el nivel
socioeconómico; luego, que el sistema verifique y determine el monto a pagar.
Entrada Salida
• Colegio (e) • Monto a pagar (mp)
• Nivel (n)

Codificación:
.............................................................................................................................................................................................................
' Variables
Dim e As String
Dim n As String
Di m mp As Integer
' Entrada
e= Me . txtc . Text
n = Me . t xtn . Text
' Proceso
Select Case e
Case " N"
Select Case
Case
Case
Case
End Sel ect
Case "P"
Select Case
case
Case
Case
End Select
End Select
' Salida
n
"A"
mp
" B"
mp
"C"
mp
n
"A"
mp
" B"
mp
"C"
mp
Me . t xt mp . Text = Str(mp)
- 300
- 200
= lOO
- 400
= 300
- 200
... ...........................................................................................................................................................................................................·
Problema n.o 35
Enunciado: Dado el número del mes y el año (cuatro dígitos) de una fecha, determinar, en letras, el
nombre del mes y cuantos días tiene. Considerar que febrero tiene 28 o 29 días si el año es bisiesto, un
año es bisiesto si es múltiplo de 4, pero no de 100 y sí de 400.
Análisis: Para lasolución de este problema se requiere que el usuario ingrese el número del mes y el año;
luego, que el sistema verifique y determine cuántos días tiene y el nombre del mes.
Entrada Salida
• Mes (m) • Dias (d)
• Año (a) • Mes letras (mi)

,. Problema 35 [gtQJ['8]
Me• lz u c.bJol 1
1
llilo 12008
M.. !FEBRERO
Oías lzs
Diagrama de flujo
Algoritmo
( Inicio 1
A B
¡
m, a , d . Entero
.
1 V
· ¡ 6 1
ml . Cadena
.
¡
/ Leer m, a /
l
E" d - 30
ml-" JUNIO"
7 V
m
E" d -31
.1 1
¡V
ml-" JULIO"
F d- 31 .1
8 1 V
1
ml-"ENERO"
E" d - 31
2 ml-" AGOSTO"
.1
9 1 V
!
Mod 4 = o Y E" d - 30
(a Mod 100 <> o
o a Mod 400 = 0)
ml-" SET IEMBRE"
1d--281 lct-2 9-1
V
.1 10 1
¡
ml - " FEBRERO"
E" d ·- 31
ml. "OCTUBRE"
. 1
3 1 V
1
l
.1 11 1 V
· ¡ 1
E" d - 30
F d - 31 ml-"NOVIEMBRE"
ml-"MARZO"
.1 4 1 V
.1 1
12 V
!
E" d ·- 31
F d - 30 ml.-" DICIEMBRE"
ml-" ABRIL"
5 V
·¡ 1 r
F d - 31 / Escribir d, ml /
m!-"MAYO" ¡
E"in
./
A B

Pseudocódigo
Inicio
//Variables
m, a , d : Entero
ml : Cadena
//Entrada
Leer m, a
//Proceso
En Caso que m Sea
Caso 1
d - 31
ml - "ENERO"
Caso 2
Si a Mod 4 = O Y (a Mod 100 <> O O
d - 29
SiNo
d - 28
Fin Si
ml - "FEBRERO"
Caso 3
d - 31
ml - "MARZO"
Caso 4
d - 30
ml - "ABRIL"
Caso 5
d - 31
ml - "MAYO"
Caso 6
d - 30
ml - " JUNIO"
Caso 7
d - 3 1
ml - "JULIO"
Caso 8
d - 31
ml - "AGOSTO"
Caso 9
d - 30
ml - ''SEPTIEMBRE"
caso 10
d - 3 1
ml - "OCTUBRE"
caso 11
d - 30
ml - ''NOV I EMBRE''
Caso 12
d - 3 1
m1 - ''DICI EMBRE''
Fi n Caso
1/Salida
Escribir d , ml
Fin
a Mod 400 = 0) Entonces

Codificación:
.· .............................................................................................................................................................................................................
' Variables
Dim m As I nteger
Dim a As I nteger
Dim d As Integer
Dim ml As String
' Entrada
m- Val (Me . txtm . Tex t )
a= Val (Me . txta . Tex t )
' Proceso
Select Case m
Case 1
d = 31
ml - " ENERO"
Case 2
If a Mod 4 = O And (a Mod 100 <> O Or a Mod 400 = 0) Then
d - 29
Else
d - 28
End If
ml = "FEBRERO"
Case 3
d = 31
ml = "MARZO"
Case 4
d = 30
ml = "ABRIL"
Case S
d = 31
m1 = "MAYO"
Case 6
d = 30
m1 = "JUNIO"
Case 7
d = 31
m1 = "JULIO"
Case 8
d = 31
m1 = "AGOSTO"
Case 9
d = 30
m1 = " SEPTIEMBRE''
Case 10
d = 31
m1 = "OCTUBRE"
Case 11
d = 30
m1 = " NOVIEMBRE"
Case 12
d = 31
m1 = "DICIEMBRE"
End Se1ect
' Salida
Me . t xtd . Text = Str(d)
Me . t x t ml . Text = ml
.. ...........................................................................................................................................................................................................

Problema n.o 36
Enunciado: Una empresa ha establecido diferentes precios a sus productos, según la calidad.
Calidad
Producto
1
2
3
1
5000
4500
4000
2 3
4500 4000
4000 3500
3500 3000
Cree un programa que devuelva el precio a pagar por un producto y una calidad dada.
Análisis: Para la solución de este problema se requiere que el usuario ingrese la calidad y el producto;
luego, que el sistema verifique y determine el precio.
Entrada Salida
• Calidad (e) • Precio (precio)
• Producto (p)
Diseño:
Interfaz de usuario
'" Problema 36 (g§(8}
Co&dod f2 l! CalcUarJ
Proructo f3
Ptecio f3500

Diagrama de flujo
eI nicio
!
e , p : Entero
precio : Entero
!
/ Leer e , P/
l
e
-
---4 1 1
V
F
p
~ 1
V
precio-5000 ~
~ 2 ~ precio-4500 ~
r; 3 ~ precio-4 00 O f--o
---4 2 1
V
F
p
~ 1
V
precio-4500 ~
7 2 ¡.! precio-4 00 O ~
r; 3 ~ precio-3500 ro
---4
V
3 1
F
-p
~ 1
V
precio-4 00 oro
7 2 ¡.! precio-3500 ~
r; 3 ~ precio-3000 ro
l
/ Escribir precio/
!
eFin )
Algoritmo
Pseudocódigo
Inicio
//Variables
e , p : Entero
precio : Entero
//Entrada
Leer e , p
//Proceso
En Caso que e Sea
Caso 1
Caso 2
Caso 3
Fin Caso
En Caso que p Sea
Caso 1
pr eci o - 5000
Caso 2
pr eci o - 4500
Caso 3
precio - 4000
Fin Caso
En Caso que p Sea
Caso 1
precio - 4500
Caso 2
precio -4000
Caso 3
pr eci o - 3500
Fin Caso
En Caso que p Sea
Caso 1
pr eci o - 4000
Caso 2
preci o - 3500
Caso 3
precio - 3000
Fin Caso
//Salida
Escribir precio
Fin

Codificación :
.· .............................................................................................................................................................................................................
' Variables
Dim e As Integer
Di m p As Integer
Di m preci o As Integer
' Entrada
e- Val (Me . t xtc . Text )
p = Val (Me . t xtp . Text )
' Proceso
Sel ect Case e
Case 1
Sel ect Case p
Case 1
preci o = 5000
case 2
p r ecio = 4500
Case 3
preci o = 4000
End
End Sel ect
Case 2
Case 3
Select
Sel ect Case p
Case 1
preci o
Case 2
preci o
Case 3
precio
End Sel ect
Sel ect Case p
Case 1
precio
Case 2
precio
Case 3
precio
End Sel ect
' Salida
-
-
-
-
=
-
Me . t xtprecio . Text = Str (precio)
4500
4000
3500
4000
3500
3000
·............................................................................................................................................................................................................
Enunciado: Diseñe un algoritmo que califique el puntaje obtenido en el lanzamiento de tres dados en
base a la cantidad de seis obtenidos, de acuerdo a lo siguiente:
Tres seis: Oro
Dos seis: Plata
Un seis: Bronce
Ningún seis: Perdió
Análisis: Para la solución de este problema se requiere que el usuario ingrese el puntaje de los dados;
luego, que el sistema verifique y determine el premio.

Entrada Salida
• Primer dado (dl ) • Premio (p)
• Segundo dado (d2)
• Tercer dado (d3)
Diseño:
Interfaz de usuario
., Problema 37 rg(QJ[8)
Dado l
Dado2
Dado3
Premio
Diagrama de flujo
Inicio
dl , d2 , d3 : Entero
p Cadena
Leer dl , d2 , d3
dl=6 y d2=6 y d3=6
F
(d1=6 y d2=6)
o (dl=6 y d3=6 )
o (d2=6 y d3=6 )
F
dl=6 o d2=6 o d3=
F
p- " PERDIO"
Escribir p
Fin
V
p-"ORO"
p-" PLATA"
V
p- " BRONCE"
1
3 1! CalcoAal ']1
ls
ls
!PlATA
Algoritmo
Pseudocódigo
Inicio
//Variables
dl , d2 , d3 · Entero
p : Cadena
//Entrada
Lee r dl , d2 , d3
//Proceso
Si dl=6 Y d2=6 Y d3=6 Entonces
p - "ORO"
SiNoSi (d1=6 Y d2=6 ) O (d1=6 Y d3=6)
O (d2=6 Y d 3=6 ) Entonces
p ·- " PLATA"
SiNoSi d1=6 O d2=6 O d3=6 Entonces
p - " BRONCE"
SiNo
p - " PERDIO"
Fin Si
//Salida
Escribir p
Fin

Codificación:
.............................................................................................................................................................................................................
'Variables
Dim dl As Integer
Dim d2 As Integer
Dim d3 As Integer
Dim p As String
' Entrada
dl = Val (Me .txtdl . Text)
d2 = Val(Me . t x td2 . Text)
d3 = Val (Me .txtd3 . Text)
' Proceso
If d l = 6 And d2 = 6 And d3 = 6 The n
p = "ORO"
Elseif (dl = 6 And d2 = 6) Or (dl = 6 And d3 = 6 ) _
Or (d2 = 6 And d3 = 6) Then
p = " PLATA"
Elself d l • 6 Or d2 • 6 Or d3 • 6 Then
p = " BRONCE"
El se
p - " PERDIO"
End If
' Sal ida
Me . t xtp . Text • p
... ...........................................................................................................................................................................................................
Enunciado: Dado el día, mes y año, determine si es una fecha correcta, considere los años bisiestos.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el día, mes y año; luego,
que el sistema verifique y determine si el resultado es o no una fecha correcta.
Entrada Salida
• Día (d) • Respuesta (r)
• Mes (m)
• Año (a)
Diseño:
Interfaz de usuario
"' Problema 38 ~(QJ(8}
Oía j29 1
LCalc_ulal J1
Mes 1
2
w.:. j2008
Respuesta jCORRECTO

Algoritmo
Diagrama de flujo
Inicio
d , m, a , dmax
r : Cadena
Entero
Leer d , m, a
1 , 3, 5 , 7 , 8 , 10, 12
4, 6, 9 , 11
2
V
a Mod 4 = O
{a Mod 100 <> O
a Mod 400 = 0)
V
dmax - 28 dmax - 29
{d>O Y d<=dmax) Y
{m>O Y m<13) Y a>O
V
r-" INCORRECTO" r-" CORRECTO"
Escribir r
Fin
Pseudocódigo
I nicio
//Vari abl es
d , m, a , dmax
r : Cadena
Entero
//Entrada
Leer d , m, a
//Proceso
En Caso que m Sea
Caso 1 , 3, 5 , 7, 8 , 10, 12
dmax •- 31
Caso 4, 6 , 9, 11
dmax - 30
Caso 2
Si a MOd 4 = o Y (a Mod 100 <> o
O a Mod 400 = 0) Entonces
dmax ·- 29
SiNo
dmax - 28
Fin Si
Fin Caso
Si d>O Y d<=dmax) Y (m>O Y m<l3)
Y a>O Entonces
r - "CORRECTO"
SiNo
r - " INCORRECTO"
Fin Si
//Salida
Escribir r
Fin

Codificación:
..........................................................................................................................................................................................................··.
: ' Var i ables
; Di m d As Integer
: Di m m As Integer
! Dim a As Integer
: Di m dmax As I ntege r
; Di m r As Str i ng
: ' Entrada
! d ~ Val (Me . txtd . Text)
¡ m = Val (Me . t xtrn . Tex t)
: a = Val (Me . t x ta . Tex t )
: ' Proceso
: Select Case m
case 1, 3 , 5, 7, 8 , 1O, 12
drnax ~ 31
Case 4 , 6 , 9, 11
drnax = 30
Case 2
If a Mod 4 ~ O And (Not (a Mod 100 ~ 0 ) _
; End Se l ect
dmax = 29
El se
dmax = 28
End I f
Or a Mod 400 = 0 ) Then
If (d > O And d <= dmax ) And (m > O And m < 13 ) _
And a > O Then
r ~ " CORRECTO"
El se
r - " INCORRECTO"
! End If
: ' Salida
; Me . txtr . Text = r
... ...........................................................................................................................................................................................................
Problema n.o 39
Enunciado: Dada una fecha válida, halle la fecha del siguiente día.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el día, mes y año; luego,
que el sistema devuelve la fecha del siguiente día.
Entrada Salida
• Día (d) • Día (d)
• Mes (m) • Mes (m)
• Año (a) • Año (a)
Diseño:
Interfaz de usuario
.. Problema 39 ~[Q]r8]

F
F
F
Diagrama de flujo
Inicio
d , m, a , dmax
r : Cadena
Entero
Leer d , m, a
dmax - 31
V
4 , 6 , 9 , 11~--~--,
2
V
a Mod 4 = O Y
(a Mod 100 <> O
O a Mod 400 = 0)
V
Algoritmo
Pseudocódigo
Inicio
//Variables
d , m, a , dmax
r : Cadena
//Entrada
Leer d , m, a
//Proceso
Entero
En Caso que m Sea
Caso 1 , 3 , 5 , 7, 8 , 10 , 12
dmax .... 31
Caso 4, 6 , 9, 11
dmax .... 30
Caso 2
Si a Mod 4 = O And (a Mod 100 <> O
Or a Mod 400 = 0 ) Entonces
dmax - 29
SiNo
dmax - 28
dmax - 28 dmax - 29 Fin Si
F
F
d - d + 1
d - 1
m - m + 1
V
m - 1
a - a + 1
Escribir d , m , a
Fin
Fin Caso
d = d + 1
Si d > dmax Entonces
d - 1
m - m + 1
Si m = 13 Entonces
m - 1
Fin Si
Fin Si
//Salida
a - a + 1
Escribir d , m , a
Fin

Codificación:
.. .......................................................................................................................................................................................................... ..
'Var iables
Dim d As Integer
Dim m As Integer
Dim a As Integer
Dim dmax As Integer
' Entrada
d ~ Val (Me . txtd1 .Text)
m~ Val (Me . t xtm1 . Text)
a~ Val (Me . t xta1 .Text)
' Proceso
Se1ect Case m
ca se 1, 3 , 5, 7, 8 , 1O, 12
dmax ~ 31
Case 4 , 6 , 9, 11
dmax ~ 30
Case 2
If a Mod 4 ~ O And (Not (a Mod 100 ~ 0 ) _
Or a M
od 400 ~ 0 ) Then
dmax ~ 29
El se
dmax ~ 28
End Select
d ~
d + 1
If d > dmax Then
d ~
1
m = m + 1
If m = 13 Then
m
-1
a ~
a + 1
End If
End If
' Sal ida
Me . t xtd2 . Text = Str(d)
Me . txtm2 . Text • Str (m)
Me . t xt a2 . Text = St r( a )
End I f
............................................................................................................................................................................................................
Problema n.o 40
Enunciado: Convierta a números romanos, números menores a 4000.
.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el número; luego, que el
sistema convierta y devuelva el número en romano.
Entrada Salida
• Número decimal (n)
Diseño:
• Número romano (r)
Interfaz de usuario
" Problema 40 ~[QJ~
N(rne(o l115o
Romono lt.tCL
11 CobD 11

Algoritmo
Diagrama de fluío
( Inicio ) A
L
n, u , d , e , m . Entero
.
r . Cadena
.
r-r+"X"
/ Leer n /
l
F
n<-3999>
r·-r+ "XX"
r-r+"XXX"
V
u - n Mod 10 r-r+"XL"
n - n 10
d - n Mod 10 r-r+ "L"
n - n 10
e -n Mod 10
n - n 10 r ·-r+ " LX"
m - n Mod 10
r-r+"LXX"
m r-r+"LXXX"
H 1
V
r-"M
" H r-r+"XC"
F
V
H 2 r-"MM" f-<
F
V
~ 3 r-"MMM" ¡........
F d
r-r+"X"
e r ·-r+"XX"
-oj 1
V
r-r+"C" ¡-. r-r+"XXX"
F
V
H 2 r-r+"CC" _¡-. r ·-r+ "XL"
F
V
H 3 r-r+"CCC"
r r-r+ " L"
F
V
~ 4 r.- r+"CD"
1- r-r+ "LX"
F
V
~ 5 r-r+"D"
~ r-r+"LXX"
F
V
H 6 r-r+"DC" _¡-. r-r+"LXXX"
F
H
V
r -r+"DCC" _¡-.
7 r-r+"XC"
F
V
~ 8 r .- r+" DCCC" ~
F V
H 9 r-r+"CM"
~
F
Escribir r
A B Fin

Pseudocódigo
Inicio
//Variables
n, u, d , e , m
r : Cadena
Entero
//Entrada
Leer n
//Proceso
Si n <= 3999 Entonces
u - n Mod 10
n - n 10
d - n Mod 10
n - n 10
e - n Mod 10
n - n 10
m - n Mod 10
En Caso que
Caso
Caso
Caso
Fin Caso
En Caso que
Caso
Caso
Caso
Caso
Caso
Caso
Caso
Caso
Caso
Fin Caso
En Caso que
1
2
3
1
2
3
4
5
6
7
8
9
m
r
r
r
e
r
r
r
r
r
r
r
r
r
d
Sea
- "M
"
- "MM"
- "MMM"
Sea
- r + "C"
- r + "CC"
- r + " CCC"
- r + "CD"
- r + "D"
- r + "OC"
-r + "DCC"
- r + " DCCC"
- r + "CM"
Sea

Caso 1
r - r + ''X"
Caso 2
r - r + "XX"
Caso 3
r - r + "XXX"
Caso 4
r - r + "XL"
Caso 5
r - r + ''L"
Caso 6
r - r + "LX"
Caso 7
r - r + "LXX"
Caso 8
r - r + "LXXX"
Caso 9
r - r + "XC "
Fin Caso
En Caso que u Sea
Caso 1
r - r + "I "
Caso 2
r - r + " II "
Caso 3
r -r + " III "
Caso 4
r - r + " IV"
Caso 5
r - r + "V"
Caso 6
r - r + "VI "
Caso 7
r -r + "VII "
Caso 8
r - r + "VIII "
Caso 9
r - r + "IX"
Fin Caso
Fin Si
1/Salida
Escribir r
Fin

Codificación:
' Variables
Di m n As Integer
Dim u As Integer
Di m d As Integer
Dim e As Integer
Dim m As Integer
Di m r As String
' Entrada
n = Val (Me . t xtn . Tex t )
' Proceso
If n <= 3999 Then
u = n Mod 10
n = n 10
d = n Mod 10
n = n 10
e = n Mod 10
n = n 10
m - n Mod 10
Select Case m
Case 1
r
Case 2
r
Case 3
r
End Select
Select Case e
Case 1
r
Case 2
r
Case 3
r
Case 4
r
Case S
r
Case 6
r
Case 7
r
Case 8
r
Case 9
r
End Se1ect
Sel ect Case d
-
-
=
-
=
-
=
-
-
-
=
-
Capítulo 4: Estructu ra selectiva múltiple
"M
"
"MM"
"MMM"
r + 'C "
r + "CC"
r + "CCC"
r + "CD''
r + "D"
r + "DC"
r + "DCC"
r + " DCCC"
r + "CM"
·., ..........................................................................................................................................................................................................

................................................................................................ ......................................................................................................... ..
Case 1
r - r + "Xn
Case 2
r = r + " XX ''
Case 3
r - r + "XXX"
Case 4
r - r + ''XL "
Case 5
r - r + "L"
Case 6
r = r + "LX"
Case 7
r - r + "LXX"
Case 8
r - r + ''LXXX"
Case 9
r - r + "XC"
End Sel ect
Sel ect Case u
Case 1
Case 2
Case 3
Case 4
Case 5
Case 6
Case 7
Case 8
Case 9
End Select
End If
' Salida
r = r + " ! "
r=r +'' II "
r r + " I I I "
r - r + " IV"
r - r + "V"
r = r + "VI "
r + "VI I "
- r
r - r + "VI I I"
r = r + " IX ''
... ...........................................................................................................................................................................................................

Propuesto n.o 21
Enunciado: Dado el número de un mes, devolver el mes en letras.
Propuesto n.o22
Enunciado: Lea un número del1 al 7 y devuelva el día de la semana, considere que 1 es domingo.
Propuesto n.o 23
Enunciado: Dado los siguientes operadores aritméticos+,-, • y 1, devuelva el nombre del operador.
Propuesto n.o 24
Enunciado: Dado el número de un canal de televisión, determine cual es el nombre del canal.
Propuesto n.o25
Enunciado: En una empresa se ha determinado la siguiente política de descuento.
Hombres Mujeres
Obrero 15% 10%
Empleado 20% 15%
Determine mediante un programa cuál será el monto del descuento al sueldo ingresado de un trabajador.
Propuesto n.o 26
Enunciado: Una frutería ofrece las manzanas con descuento, según la siguiente tabla:
Kilos %Descuento
0-2 0%
2.01- S 10%
5.01- 10 20%
Mayor a 10 30%
Determinar cuánto pagará una persona que quiera compra manzanas en esa frutería.

Propuesto n.º 27
Enunciado: Obtenga el nombre del estado civil, según la siguiente tabla:
Código Estado civil
o Soltero
1 Casado
2 Divorciado
3 Viudo
Propuesto n.o28
Enunciado: Determinar el monto que recibirá un trabajador por utilidades, después de ingresar el tiempo
de servicio y el cargo, según la siguiente tabla.
~Administrador Contador Empleado
Entre Oy 2 años 2000 1500 1000
Entre 3 y 5 años 2500 2000 1500
Entre 6 y 8 años 3000 2500 2000
Mayor a 8 años 4000 3500 1500
Propuesto n.o29
Enunciado: Según la siguiente tabla, obtener la ciudad que visitará, después de ingresar su sexo y el
puntaje obtenido en un examen.
Masculino Femen1no
Entre 18 y 35 Arequipa Cuzco
Entre 36 y 75 Cuzco !quitos
Mayor a 75 !quitos Arequipa
Propuesto n.o30
Enunciado: Dada una fecha, determine cuantos días faltan para que acabe el año.

Estructura repetitiva «Mientras»
5.11ntroducción
Muchas veces se requiere repetir una o varias instrucciones para llevar a cabo una tarea; en la programación
se cuenta con estructuras que permiten realizar este proceso, llamadas también: bucles, iterativas, lazos,
entre otros.
bucle
Dependiendo del lenguaje de programación, estas incorporan dos o más estructuras repetitivas, dentro de
las cuales las infaltables son mientras (w hile) y para (for), con las cuales se puede resolver todo problema
que involucre procesos repetitivos.
Cuando se trabaja con estas estructuras se utiliza términos como: contadores, acumuladores, forzar la
salida del bucle y continuar al inicio del bucle.
5.2 Contador
Son variables enteras que se incrementan(+) o decrementan(-) con un valor constante, por ejemplo, una
variable «C», cuyo valor se incrementa de 1 en 1; se conoce como variable <<contador».
Ejemplos pseudocódigo
...............................................................................................................................................................................................................
e - e + 1
i - i + 2
j - j - 1
'•· ··········································································································································································································•
Visual Basic
. ............................................................................................................................................................................................................,
e = e + 1
i = i + 2
j = j - 1
..............................................................................................................................................................................................................

5.3 Acumulador
Son variables de cualquier tipo que almacenan valores variables; por ejemplo, la variable «c», cuyo valor
se incrementa por el valor que va tomando otra variable llamada «X>>.
........................................................................................................................................................................................................... ...
e - e + x
i - i + e
... .......................................................................................................................................................................................................... .·
Visual Basic
.............................................................................................................................................................................................................
e = e + x
i = i + e
j = j - i
5.4 Salir del bucle
Es una instrucción que permite forzar la salida de un bucle, para esto los lenguajes de programación
incorporan una instrucción que permite realizar dicha operación.
Pseudocódigo
.............................................................................................................................................................................................................
Salir
Visual Basic
...................................................., .......................................................................................................................................................
' Para Salir del Do While
Exit Do
' Para Salir del For
Exit For
5.5 Continuar al inicio del bucle
Es una instrucción que permite saltar al inicio del bucle para volver a ejecutarse; para esto, los lenguajes
de programación incorporan una instrucción que permite realizar dicha operación.
Pseudocódigo
Continuar
..............................................................................................................................................................................................................
VB
.........' ' ................' .......................' .......' .......................' ......................'........................'' ....' ' ...............................................' .............' ...
' Para Cont i nuar al inicio de l Do While y For
Continue
.. ...........................................................................................................................................................................................................

Capítulo 5: Estructura re petitiva «Mientras»
5.6 Estructura repetitiva «Mientras»
Permite repetir una o más instrucciones hasta que la condición (expresión lógica) sea verdadera; cuando
la condición es falsa sale del bucle.
Instrucción 1
Instrucción n
F
Mientras Exp . Lógica
Instrucción 1
Instrucción n
Fin Mientras
,' .......................................................................................................................................................................................................... ...
Do While <Exp . Log . >
<instrucción 1>
<instrucción n>
Loop
............................................................................................................................................................................................................
5.7 Estructura repetitiva <<Mientras» anidada
Dentro de la estruct ura repetitiva es posible colocar una o más estructuras repetitivas, así como otras
estructuras.
Instrucción 1
Instrucción n
F
F
Do While <Exp . Log . >
Do Whil e <Exp. Log . >
<ins truccion1>
<inst r uccionn>
Loop
Mientras Exp. Lógica
Mientras Exp . Lógica
Instrucción 1
Instrucc ión n
Fin Mientras
Fin Mientras
Loop ,
..........................................................' .......' ' ......' ...............................' ......' ...............' ........' ............................''........................' ........' ..

Problema n.o 41
Enunciado: Obtener la suma de los primeros N números naturales positivos.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número; luego, que el
sistema realice el proceso para devolver la suma de los N primeros números.
Entrada Salida
• Número (n) • Suma (s)
Diseño:
Interfaz de usuario
'" Problema 41 ~LQ)[EJ
Diagrama de flujo
( Inicio
¡
i , n, S . Entero
.
¡
1 Leer n
1
¡
i - 1
1
i<=n
Tv
S - S + 1
i - i + 1
¡
j_Escr i bi r s /
¡
Fin
F
Número js
Suma jts
Algoritmo
Pseudocódigo
Inici.o
//Vari.ables
i, n , s : Ent e ro
//Entrada
Lee r n
//Proceso
i - 1
Mie nt ras i <=n
S - S + 1
i - i + 1
Fi n Mi e nt ra s
//Sali.da
Escribir s
Fi.n

Codificación :
.
' Variables
Dim i As Integer
Dim n As Integer
Dim s As Integer
' E:ntrada
' Proceso
~ - 1
Do While ~ <= n
S - S + 1
1 - ~ + 1
Loop
' Salida
Capítulo 5: Estructura repetitiva «Mientras»
..............................................................................................................................................................................................................
Problema n.o 42
Enunciado: Dado un rango de números enteros, obtener la cantidad de números enteros que contiene.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el número inicial y final;
luego, que el sistema procese y devuelva la cantidad de números enteros que contiene el rango.
Entrada Salida
• Número inicial (ni) • Cantidad (e)
• Número final (nf)
Diseño:
Interfaz de usuario
- - - - - -
.. Problema 42 ~[QJ~
Numlnioiel ls ICCa~M~ !1
Nunt r~nlll
19
Conbdad j3

Diagrama de flujo
Inicio
i , e , ni , nf, Entero
Codificación:
' Variables
Leer ni , nf
i - ni + 1
C•- C+l
i ·- i+l
Escribir e
Fin
Dim i As Integer
Dim ni As Integer
Dim nf As Integer
Dim e As Integer
' Entrada
ni- Val(Me . t xtni . Text}
nf- Val(Me . t xtnf . Text}
' Proceso
i = ni + 1
Do While ~ < nf
e = e + 1
i - i + 1
Loop
' Salida
Me . t x tc . Tex t = Str(c)
F
Algoritmo
Pseudocódigo
Inicio
//Variables
i , e , ni , nf : Entero
//Entrada
Leer ni , nf
//Proceso
i - ni + 1
Mientras i < nf
e - e + 1
i - i + 1
Fin Mientras
//Salida
Escribir e
Fin
..................................' ...........................................................................................................................................................................

Problema n. o43
Enunciado: Dado un rango de números enteros, obtener la cantidad de números pares que contiene.
luego, que el sistema procese y devuelva la cantidad de números pares que contiene el rango.
Entrada Salida
• Número inicial (ni) • Cantidad de pares (cp)
'" Problema 43 ~@~
Num. lróciol 13 ¡cc.u.. JI
Nt.rn. Filol jJ3
Cant.P.,.. ls
Algoritmo
( I nicio
!
i , cp, ni , nf,
~
/ Leer ni ,
!
i - ni +
l
i<nf
V
F Mod 2 =
V
cp - cp +
i - i +
!
/ Escribir
( Fin
)
. Entero
.
ntj
1
F
o
1
1
cp/
)
Inicio
//Variables
i , cp, ni , nf : Entero
//Entrada
Leer ni , nf
//Proceso
i - ni + 1
Mi e nt r as i < n f
Si J. M
od
cp
Fin Si
i - i + 1
Fin Mient r as
//Salida
Escrib i r cp
Fin
2
-
- O Entonces
cp + 1

Codificación:
.......................................................................................................................................................................................................... ··.
' Variables
Di m i As Long
Dim ni As Long
Di m n f As Long
Dim cp As Long
' En t rada
ni - Val (Me . t x tni . Text)
nf = Val (Me . txtnf . Text)
' Proceso
l. - ni + 1
Do While l. < nf
If l. Mod 2 - o
cp - cp
End If
l. - l. + 1
Loop
' Salida
M
e . t x tcp . Tex t = cp
Then
+ 1
............................................................................................................................................................................................................
Problema n.o 44
Enunciado:Obtener la cantidad de los primeros N números múltiplos de S.
sistema devuelva la cantidad de números múltiplos de S.
Entrada Salida
• Número (n) • Cantidad (e)
Diseño:
Interfaz de usuario
"' Problema 44 ~[QJ(g}
ILCalcui;.-JI
Cantidad 1
3

Diagrama de flujo
( Inicio )
J.
i e, n : Entero
¡
1 Leer n
1
J.
i - 1
j_
i<=n
I v
F i Mod 5 = o
Tv
e ·- e + 1
i - i + 1
¡
/ Escribir e /
¡
( Fin )
Codificación:
F
Algoritmo
Pseudocódigo
Inicio
//Variables
i, e , n : Entero
//Entrada
Leer n
//Proceso
i - 1
Mientras i <= n
Si i Mod 5 = O Entonces
e - e + 1
Fin Si
i - i + 1
Fin Mientras
//Salida
Escribir e
Fin
............................................................................................................................................................................................................ ...
' Variables
Dim i As Long
Dim n As Long
Di m e As Long
' Entrada
n = Val (Me . t xtn . Tex t )
' Proceso
i = 1
Do While i <= n
If i Mod 5 = O Then
e - e + 1
End If
i = i + 1
Loop
' Salida
Me . t xtc . Text = Str(c)

Problema n.o 45
Enunciado: Dado un número, determinar cuantos dígitos tiene.
que el sistema verifique y determine la cantidad de dígitos que contiene.
Entrada Salida
• Número (n) • Cantidad de dígitos (e)
Diseño:
Interfaz de usuario
"' Problema 45 ~[QJ[8)
NírneJO 1123456
C,nl cigltO$ 1S
Diagrama de flujo
Inicio
i , n, e : Entero
Leer n
n - n 10
e - e + 1
Escr i bi r e
Fi n
F
Algoritmo
Pseudocódigo
Inicio
//Variables
i , n , e : Entero
//Entrada
Leer n
//Proceso
Mientras n>O
n - n 10
e - e + 1
Fin Mien t ras
//Salida
Escribir e
Fin

Codificación :
..........................................................................................." ................................................................................................................
' Variabl es
Di m i As Lo ng
Di m n As Long
Di m e As Long
' E:ntrada
n = Val (M
e . t xtn . Tex t )
' Proceso
Do While n > O
n = n 10
e = e + 1
Loop
' Salid a
¡ M
e . t x tc . Tex t = St r (e )
... ............................................................................................................................................................................................................
Problema n.o 46
Enunciado: Dado un número, determinar la cantidad de dígitos pares que contiene.
que el sistema verifique y devuelva la cantidad de dígitos enteros que contiene el número.
Entrada Salida
• Números (n) • Cantidad de dígitos pares (e)
Diseño:
Interfaz de usuario
'" Problema 46 ~§[8]
Númefo 1123456
ILcaw... d

Diagrama de flujo
( Inicio )
¡
i , d , e , n . Entero
.
¡
1 Leer n
1
1
n>O
F
Tv
d- n Mod 10
l V
F
Mod 2 = o
Tv
e - e + 1
n - n 10
¡
/ Escrib ir e/
l
( Fin )
Codificación:
Algoritmo
Pseudocódigo
Inicio
//Variables
i, d , e , n
//Entrada
Leer n
Entero
//Proceso
Mientras n > O
d - n Mod 10
Si d Mod 2 = O
Entonces
e - e + 1
Fin Si
n - n 10
Fin Mientras
//Salida
Escrib i r e
Fin
.·............................................................................................................................................................................................................
' Variables
Di m J. As Long
Dim d As Long
Dim e As Long
Di m n As Long
' Entrada
n = Va l(Me . t xtn . Text )
' Proceso
Do While n > o
d = n M
od 10
If d Mod 2 = O Then
e = e + 1
End I f
n = n 10
Loop
' Salida
M
e . t xtc . Text = St r( c )
... ...........................................................................................................................................................................................................

Enunciado: Dado un número, devolver el dígito mayor.
que el sistema verifique y devuelva el dígito mayor.
Entrada Salida
• Número entero (n) • Dígito mayor (m)
Diseño:
Interfaz de usuario
., Problema 47 ~(Q)r8}
Númelo j123456
D~omayor ls
Algoritmo
1 I nicio
¡ Inicio
d , m, n . Entero
.
¡
1 Leer n
.1
n>O
¡ v
d - n Mod
l v
F d > m
Tv
m ·- d
n - n
¡
/ Escribir
t
Fin
1
F
10
10
m/
//Variables
d , m, n : Entero
//Entrada
Leer n
//Proceso
Mientras n > O
d - n Mod 10
Si d > m Entonces
m - d
Fin Si
n - n 10
Fin Mientras
//Salida
Escrib i r m
Fin

Codificación:
' Variables
Dim d As Long
Di m m As Long
Dim n As Long
' Ent rada
n = Val (Me . t x t n . Text )
' Proceso
Do While n > O
L oop
d = n Mod 10
If d > m Then
m = d
End If
n = n 10
' Salida
Me . t x t m. Text = Str(m)
...............................................................................................................' .................................................'............................................
Problema n.o 48
Enunciado: Dados 2 números, diga si son amigos. Recuerde que dos números son amigos si la suma de
sus divisores de uno de ellos es igual al otro y viceversa, por ejemplo, 220 y 284 son amigos.
Divisores de 220 son:
1 + 2 + 4 +S+ 10 + 11 + 20 + 22 + 44 +55+ 110 = 284
Divisores de 284 son:
1 + 2 + 4 + 71 + 142 = 220
Análisis: Para la solución de este problema, se requiere que el usuario ingrese dos números (n1 y n2);
luego, que el sistema verifique y devuelva si son o no número amigos.
Entrada Salida
• Números (nl, n2)
Diseño:
• Respuesta (r)
-SON AMIGOS
- NO SON AMIGOS
Interfaz de usuario
.. Problema 48 [)@)~
N...,. l 1220 ICS.~!.JI
Nllll 2 1
284
Resultado ISDNAMIGOS

Algoritmo
Inicio Inicio
Fin
r ·- " NO SON AMIGOS" r-" SON AMIGOS"
Escribir r
Fin

Codificación:
' Variables
Di m i As I nteger
Dim n1 As Integer
Di m n2 As Integer
Dim s1 As Integer
Dim s2 As Integer
Di m r As String
' E:ntrada
nl- Val (Me . t xtnl . Text}
n2 = Val(Me . t xtn2 . Text }
' Proceso
i = 1
Do While i <= nl 2
Loop
If n 1 Mod i = O Then
s1 = s l + i
E:nd If
l. = i + 1
i = 1
Do While i <= n2 2
Loop
If n2 Mod i = O Then
s2 = s2 + i
E:nd If
l. - i + 1
If n 1 = s 2 And n2 = s1 Then
r = " SON AMIGOS"
Else
r = " NO SON AMIGOS"
End If
' Salida
... ....................................................' .........................................' ...........................................................................................................
Enunciado: Dado un número, devuelva el inverso del número.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el número; luego, que el
sistema procese y devuelva el inverso del número.
Entrada Salida
• Número (n) • Número inverso (i)

• Problema 49 [J[QJ[EJ
Diagrama de flujo
Inicio
d , n, i Entero
Leer n
d - n Mod 10
n - n 10
i - i * 10 + d
Escribir i
Fin
Codificación:
Nllnero 1
123456
l-.$0 1654321
Algoritmo
Pseudocódigo
Inicio
//Variables
d , n , i : Entero
//Entrada
Leer n
//Proceso
Mientras n > O
d - n Mod 10
n - n 10
i - i * 10 + d
Fin Mientras
//Salida
Escribir l.
Fin
.......................................................................................................................................................................................................... ...
,. ' Variables
Dim d As Long
Di m n As Long
Dim i As Long
' Entrada
n = Val(Me . txtn . Text)
' Proceso
Do While n > O
Loop
d = n Mod 10
n = n 10
i - i * 1 0 + d
' Salida
: Me . txti.Tex t = Str(i)
..............................................................................................................................................................................................................

Problema n.o 50
Enunciado:Crear un algoritmo que indique si un número es cubo perfecto (anstrong) o no; se dice que
un número es cubo perfecto si al sumar los cubos de sus dígitos dan el mismo número. Por ejemplo: 153,
los cubos de sus dígitos 13
+ 53
+ 33
= 153. Por lo tanto, el número 153 es cubo perfecto.
Análisis: Para la solución de este problema se requiere que el usuario ingrese el número; luego, que el
sistema procese y determine si es o no un cubo perfecto.
Entrada Salida
• Número (n) • Respuesta (r)
Diseño:
- CUBO PERFECTO
- NO ES CUBO PERFECTO
Interfaz de usuario
.. Problema 50 ~§C8)
Aes¡jado !CUBO PERFECTO
Diagrama de flujo
Algoritmo
Pseudocódigo
Inicio
t , d , s , n : Entero
r Cadena
Leer n
t - n
d - t Mod 10
t - t 10
S - S + d A 3
F
//Variables
t , d , s , n Entero
r : Cadena
//Entrada
Leer n
//Proceso
t - n
Mientras t > O
d - t Mod 10
t - t 10
S - S + d " 3
Fin Mientras
Si n = s Entonces
r - " CUBO PERFECTO"
SiNo
r - " NO ES CUBO PERFECTO"
Fin Si
r-" NO ES CUBO PERFECTO" r-"CUBO PERFECTO"
Escribir r
Fin
1/Salida
Escribir r
Fin

Codificación:
' Variables
Di m t As I n teger
Di m d As I n teger
Di m s As Integer
Di m n As I n teger
Di m r As String
' Ent r ada
n = Va l(Me . t x t n.Te x t )
' Proceso
t = n
Do Whi le t > O
Loop
d - t M
od 10
t = t 10
S = S + d A 3
If n = s Then
r = "CUBO PERFECTO"
El se
r = " NO ES CUBO PERFECTO"
End I f
' Salida
M
................................................................................................................................................'.............................................................
Problema n.o 51
Enunciado: Obtenga el cociente y el residuo de una división mediante restas sucesivas, por ejemplo, si el
dividendo es 3989 y el divisor es 1247, entonces:
3989 -1247 = 2742 R(l)
2742-1247 = 1495 R(2)
1495 -1247 = 248 R(3)
Ya no se puede seguir restando, pues 248 es menor a 1247; entonces el cociente es el número de veces
restado (3) y el residuo es el último número obtenido (248).
Análisis: Para la solución de este problema, se requiere que el usuario ingrese la temperatura; luego, que
el sistema verifique y determine el clima.
Entrada Salida
• Numerador (n) • Cociente (e)
• Denominador (d) • Residuo (r)

Diseño:
Diagrama de flujo
l Inicio
!
Interfaz de usuario
-. Problemd 51 ~@rg}
N"""'ado! 13989
0..........,.. 11247
Cocierte 13
Re~ 1248
Algoritmo
Inicio
Pseudocódigo
n , d , e , r . Entero
. //Variables
l
j Leer n , ct j
l
n>=d
Tv
n - n - d
e - e + 1
l
r - n
l
j Escr ibi r e , r /
l
l Fin
Codificación:
F
n , d , e , r · Entero
//Entrada
Leer n , d
//Proceso
Mient r as n >= d
n - n - d
e - e + 1
Fin Mien t r as
r - n
//Salida
Escrib i r e , r
Fin
............................................................................................................................................................................................................ ..
'Vari a b les
Di m n As I ntege r
Di m d As I ntege r
Di m e As I nteger
Dim r As Integer
' Ent r a da
n = Val (Me . t xtn . Text)
d = Va l (Me . t xtd . Text )
' Proceso
Do ~hi l e n >= d
n • n - d
e = e + 1
Loop
r = n
' Salida
Me . t xtc . Text = Str( c )
Me . t xt r . Text = Str(r)

Problema n.• 52
Enunciado: Determine si un número es capicúa o no. Se dice que un número capicúa es aquel cuyas
cifras, al ser invertidas, dan el mismo número. Por ejemplo, 12 321 invertido es 12 321, entonces es un
número capicúa.
sistema verifique y determine si es o no capicúa.
Entrada Salida
• Número (n)
Diseño:
• Respuesta (r)
- ES CAPICUA
- NO ES CAPICUA
Interfaz de usuario
., Problema 52 IIJ(QJ[8)
Núme<o ¡,2321
R~ lES CAPICUA
Algoritmo
Diagrama de flujo
n , i , d : Entero
r : Cadena
Leer n
t - n
d t Mod 10
t - t 10
i - i * 10 + d
n = i
F
r-"NO ES CAPICUA r-"ES CAPICUAu
Fin
Pseudocódigo
Inicio
//Variables
n, i , d : Entero
r : Cadena
//Entrada
Leer n
//Proceso
t - n
Mientras t > O
d - t Mod 10
t - t 10
i - i * 10 + d
Fin Mientras
Si n = i Entonces
r - " ES CAPICUA"
SiNo
r - " NO ES CAPICUA"
Fin Si
//Salida
Escribir r
Fin

Codificación:
.
' Variables
Di m n As Integer
Dim i As Integer
Di m d As Integer
Dim r As String
' Entrada
' Proceso
t = n
Do While
d =
t =
l. -
Loop
t > o
t Mod
t 10
l. * 10
I f n = i Then
10
+ d
r = " ES CAPICUA"
E1se
r = " NO ES CAPICUA"
End If
' Salida
Me. t x tr . Text = r
..............................................................................................................................................................................................................
Problema n.o 53
Enunciado: Dado un número, determine si es primo, recuerde que un número primo es aquel que solo
es divisible por 1 y por sí mismo.
sistema determine si es primo o no.
Entrada
• Número (n)
Diseño:
Salida
• Respuesta (r)
- ES PRIMO
- NO ES PRIMO
Interfaz de usuario
., Problema 53 !rJ[QJt:8]
Númeto 17
Respuesta !ES PRIMO
IL ~J]

Diagrama de flujo
Inicio
!
n, i . E:ntero
.
flag . Logico
.
r . Cadena
.
¡
1 Leer n
1
!
flag -Verdadero
i 4- 2
i<~n2
F
V
F
n Mod i o
-
¡v
flag-Falso
salir
i - i + 1
F l V
!
flag
r-"NO E:$ PRIMO" r- "ES PRIMO"
/ Escri bir r/
!
( Fin )
Algoritmo
Pseudocódigo
Inicio
//Variables
n , i : Entero
flag : Logico
r : Cadena
//Entrada
Leer n
//Proceso
flag - Verdadero
i - 2
Mientras i <= n2
Si n Mod i = O
flag - Falso
Salir
Fin Si
i - i + 1
Fin Mient ras
Si flag Entonces
r - " ES PRIMO"
SiNo
r - " NO ES PRIMO"
Fin Si
//Salida
Escrib i r r
Fin

Codificación:
........................................................................................................................................................................................................... ...
' Variables
Dim n As Integer
Dim i As Integer
Dim flag As Boolean
Dim r As String
' Entrada
n = Val(Me . t xt n.Tex t )
' Proceso
flag = True
i = 2
Do While i <= n 2
Loop
If n Mod i = O Then
flag = False
Exi t Do
End If
i - i + 1
If flag Then
r = " ES PRIMO"
Else
r = " NO ES PRIMO"
End If
' Salida
'•· ............................................................................................................................................................................................., ............ .
Problema n.o54
Enunciado: Dado un número y su base, determine si el número pertenece a la base ingresada. Recuerde
que un número pertenece a un base si sus dígitos son menores a su base.
sistema verifique y determine si pertenece a la base o no.
Entrada Salida
• Base (b) - BASECORRECTA
- BASE INCORRECTA

Diseño:
lr-" BASE
Interfaz de usuario
., Problema 54 rJ[QJ(g)
Número j12345
Base ls
Resulado !BASE CORRECT
A
Diagrama de flujo
(Inicio)
¡
n, b, d . Entero
.
flag . Logico
.
r . Cadena
.
!
j Leer n, b /
!
flag- verdadero
1
n>O
V
d ·- n Mod 10
n - n 10
l_
F
Algoritmo
Pseudocódigo
Inicio
//Variables
n , b , d : Entero
.tlag : Logico
r : Cadena
//Entrada
Leer n , b
//Proceso
.tlag - verdadero
Mientras n > O
d - n Mod 10
n - n 10
F
d b
Si d >= b Entonces
.tlag - Falso
Salir
>=
V
flag- Falso
Salir
F
l_
V
nag
INCORRECTA" 1
1
r - " BASE CORRECTA" 1
/ Escri bir r/
!
eFin
Fin Si
Fin Mien t ras
Si .tlag Entonces
r - wBASE CORRECTA"
SiNo
r - wBASE INCORRECTA"
Fin Si
//Salida
Escribir r
Fin

Codificación:
.·
.
............................................................................................................................................................................................................
' Variabl es
Di m n As Long
Di m b As Long
Di m d As Long
Dim flag As Boolean
Dim r As String
' Entrada
n = Val (Me . t xt n. Tex t )
b = Va l(Me . t xtb . Tex t )
' Proceso
flag = T r ue
Do While n > o
L oop
d = n Mod 10
n = n 10
If d >= b Then
flag = Fa l se
E:xi t Do
End If
If flag Then
r = "BASE CORRECTA"
El se
r = "BASE I NCORRECTA"
End If
' Salida
Enunciado: Dado un número entero en base 10, convertir el número a otra base menor que 10.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el número entero y la base
a convertir; luego, que el sistema devuelva el número convertido a su nueva base.
Entrada Salida
• Número (n) • Número convertido (r)
• Base (b)

Diseño:
n ,
Interfaz de usuario
"' Problema 55 ~I:Q)[RJ
Númeto base 1O
Converir•bose
Res'-*ado
Diagrama de flujo
(I nicio
~
d , i , r . Entero
.
!
1 Leer n, b /
l
n>O
F
V
d ·- n Mod b
n - n b
i - i * 10 + d
l
i>O
F
Tv
d -i Mod 10
i
-i 10
r - r * 10 + d
!
j Escribir rj
~
( Fin
1123 IQ •IcUarJI
12
11111011
Algoritmo
Pseudocódigo
Ini cio
//Variables
n , d , i , r : Entero
//Entrada
Leer n , b
//Proceso
Mientras n > O
d - n Mod b
n = n 10
i = i * 10 + d
Fin Mientras
Mientras i > O
d - i Mod 10
i - i 10
r = r * 10 + d
Fin Mientras
//Salida
Escribir r
Fin

Codificación:
......................................' ...............................................................................................................................' .......................................
' Variables
Di m n As Long
Di m d As Long
Dim ~ As Long
Di m r As Long
' Entrada
n = Val (Me . t xtn . Text )
b- Val (Me . t xt b . Text )
' Proceso
Do While n > O
d - n Mod b
n = n b
~ - ~ * 10 + d
Loop
Do While i > o
Loop
d = i Mod 10
~ - ~ 10
r = r * 10 + d
' Salida
M
e . t xtr . Text = Str (r )
............................................................................................................................................................................................................ .

Capítulo 5 : Estructura repetitiva «Mientras»
Propuesto n.o 31
Enunciado: Obtener el factorial de un número; recuerde que el factorial de un número es el producto de
1 X 2 X 3 X .. . X N.
Propuesto n.o32
Enunciado: Dado un rango de números enteros, obtener la cantidad de números pares e impares que
contiene el rango, sin considerar los múltiplos de 5.
Propuesto n.o33
Enunciado: Calcular la suma y el producto de los N primeros números naturales múltiplos de 3.
Propuesto n.o34
Enunciado: Dado un número, determinar cuantos dígitos «O» contiene.
Propuesto n.o35
Enunciado: Se requiere saber si existe un determinado dígito en un número dado.
Propuesto n.o36
Enunciado: Dado un número, determinar cual es el porcentaje de números pares, impares y neutros (0).
Propuesto n.o37
Enunciado: Dado un rango de números, determine cuántos números primos contiene.
Propuesto n.o38
Enunciado: Dado un rango de números, determine cuántos números capicúa hay.
Propuesto n.o 39
Enunciado: Dados 2 números, obtener el MCD (máximo común divisor); utilice el método de Euclides
(divisiones sucesivas).
Propuesto n.o40
Enunciado: Dados 2 números, obtener el MCD (máximo común divisor), utilice el método factorización
simultánea.
Recuerde: El máximo común divisor es el divisor mayor común de todos ellos.

Estructura repetitiva «Para»
6.11ntroducción
Cada vez que requiere repetir un proceso una determinada cantidad de veces, deberá usar la estructura
repetitiva «Para>
>(for), que permitirá realizar en forma simple este trabajo.
Esta estructura usa una variable «contador», donde se establece el valor inicial (vi), valor final (vf) y el
valor de incremento (inc), que determina las veces a repetir la instrucción
6.2 Estructura repetitiva "Para,
Permite repetir una o más instrucciones una cantidad de veces.
• i Es nuest ra variable contador, donde establecemos el valor inicial.
• vf Representa el valor final de la variable contador.
• +1 Valor de incremento.
!
i - vi
F
i<-vf
i-i+l
~V
Instrucciones
1
+
............................................................................................................................................................................................................
For i=vi To vf Step 1
<instrucciones>
Next
..............................................................................................................................................................................................................
La palabra Step es opcional; por defecto, en Visual Basic, su valor de incremento es de 1.

6.3 Estructura repetitiva «Para» anidada
Dent ro de la estructura repetitiva es posible colocar una o m ás estructuras repetitivas, y también otras
estructuras.
!
i-v i
i<-vf F
i - i +l
¡v Para ~
-vi Hasta vf Ine +1
j-vi
F
j< vf
Para J - V ~ Hasta vf Ine +1
j -j+l Instrucciones
¡v Fin Para
Instrucciones Fin Para
¡
.............................................................................................................................................................................................................
For i=vi To vf
For j =vi To vf
<inst rucc i ones>
Next
Next
•............................................................................................." ......, ................·······················..................................····························· .·
Problema n.o 56
Enunciad o : Obtener la sum a de los primeros N números naturales positivos.
A n álisis: Para la solución de este problema, se requiere que el usuario ingrese un núm ero; luego, que el
sistem a realice el proceso para devolver la suma de los N primeros números.
Entrada Salida
Diseñ o:
Interfaz de usuario
- - - - - - - - - - -
.. Problema 56 ~(Q)r8)
Númeto js 1
[ cacut.. ]1
St.~~~a l 15

Diagrama de flujo
( Inicio
~
i , n, S . Entero
.
~
1 Leer n
1
~
i - 1
i<- n
i-i +l
lV
S - S + i
~
1 Escribir S 1
~
( Fin
Codificación:
F
Capítulo 6: Estructura re petitiva «Para»
Algoritmo
Pseudocódigo
Inicio
//Variables
i, n , s : Entero
//Entrada
Leer n
//Proceso
Para i-1 Hasta n Inc 1
S - S + i
E'in Para
//Salida
Escribir s
Fin
.......................................................................................................................................................................·····...............................'•
' Variables
Dim ~ As Integer
Di m n As I n teger
Dim S As Integer
' Ent rada
n = Val (Me . t x t n . Tex t )
' Proceso
For i = 1 To n
S = S + i
Next
' Salida
Me . t x ts . Text = Str (s )

Problema n.o 57
Enunciado: Dado un rango de números enteros, obtener la cantidad de números enteros que contiene.
luego, que el sistema procese y devuelva la cantidad de números enteros que contiene el rango.
Entrada Salida
• Número inicial (ni) • Cantidad (e)
Diseño:
Interfaz de usuario
i ,
,. Problema 57 ~[Q]rRJ
Numfnicj,¡
Num. Fina
Conbdad
Diagrama de flujo
( Inicio
¡
e , ni , nf . Ente ro
.
¡
/Leer ni , ntj
!
ni - ni + 1
nf - nf - 1
¡
i< nf
i-ni
F
i-i+l
¡v
e - e + 1
¡
1 Escribir e 1
¡
( Fin
ls !Le~ JI
ls
13
Algoritmo
Pseudocódigo
Inicio
//Variables
i, e , ni , nf : Entero
//Entrada
Leer ni, nf
//Proceso
ni - ni + 1
nf - nf - 1
Para i-ni Hasta nf Inc 1
e - e + 1
Fin Para
//Salida
Escribir e
Fin

Capítulo 6: Estructura repetitiva «Para»
Codificación:
......................................................................................................................................." ....................................................................
' Variables
Di m i As I nteger
Dim ni As Integer
Di m n f As Integer
Dim e As I nteger
' Entrada
ni - Val (Me . t xtni . Text)
nf = Val (Me . t xtnf . Text)
' Proceso
ni - ni + 1
nf - nf 1
For l. - ni To nf
e = e + 1
Next
' Salida
Me . t xtc . Text = Str (c )
.. ..........................................................................................................................................................................................................
Problema n.o58
Enunciado: Dado un rango de números enteros, obtener la cantidad de números pares que contiene.
.
luego, que el sistema procese y devuelva la cantidad números pares que contiene el rango.
Entrada Salida
• Número inicial (ni) • Cantidad de pares (cp)
Diseño:
Interfaz de usuario
'" Problema 58 ~©Jrgj
Num.l~l
13 le~~~~
Num. tonal ,,3
c..nt. Pares ls

Diagrama de flujo
( Inicio 1
!
i , cp, ni , nf . Entero
.
¡
/ Leer ni , ntj
!
ni - ni + 1
nf -nf - 1
!
i-ni
i< nf F
i-i+l
l V
F
i Mod 2 = o
V
cp ·- cp + 1
!
1 Escribir cp 1
!
( Fin 1
~ ~
Codificación:
Algoritmo
Pseudocódigo
Inicio
//Variables
i, cp, ni , nf
//Entrada
Leer ni , nf
//Proceso
ni - ni + 1
nf - nf - 1
Entero
Si i Mod 2 = O Entonce s
cp - cp + 1
Fin Si
Fin Pa r a
//Salida
Escribir cp
Fin
............................................................................................................................................................................................................
~
' Variables
Di m i As Long
Dim ni As Long
Di m nf As Long
Di m cp As Long
' Entrada
n i - Va l( Me . t xtni . Tex t)
nf = Val(Me . t xtnf . Tex t )
' Proceso
ni = ni + 1
nf = nf - 1
For i=n i To nf
Next
If i Mod 2 = O Then
cp = cp + 1
End If
' Salida
M
e . t x tcp . Tex t = cp

Problema n.o59
Enunciado: Obtener la cantidad de los primeros N números múltiplos de S.
sistema devuelva la cantidad de números múltiplos de S.
Entrada Salida
Diseño:
Interfaz de usuario
"' Problema 59 (g[Q)@
Numeco !Js
C...nlidad 13
Algoritmo
Inicio
i
1
i , e , n . Entero
.
!
1 Leer n
1
l
i - 1
i<- n
i - i+S
lV
e - e + 1
l
1 Escribir e
1
i
Fin
1
F
Inicio
//Variables
i, e , n : Entero
//Entrada
Leer n
//Proceso
e - e + 1
Fin Para
//Salida
Escribir e
Fin

Codificación:
.
......................................................' ......................................................................................................................................................
' Variables
Di m i As Long
Dim n As Long
Di m e As Lo ng
' Ent r ada
n = Val (M
e . t xt n . Text )
' Proceso
For i=l To n St ep 5
e = e + 1
Next
' Salida
M
e . t xtc . Text = Str (e )
Problema n.o 60
Enunciado: Obtener la suma de pares e impares de los primeros N números enteros positivos.
sistema devuelva la suma de pares e impares.
Entrada Salida
• Número (n)
Diseño:
• Suma pares (sp)
• Suma impares (si)
Interfaz de usuario
- - - - - - - - - - - - - - · · ·
.. Problema 60 ~[Q)~
Númeto js
Suma pares j 12
Suma impares js
caouw.

Diagrama de flujo
(In icio
~
i , sp , si , n o
Entero
o
~
1 Leer n
1
~
i< n
i-1
F
i - i+2
~ V
si - si + i
~
i - 2
i<-n
F
i-i+2
~V
sp - sp + i
~
/Escribir sp, si/
~
Fin
Codificación:
Capítulo 6: Estructura re petitiva «Para»
Algoritmo
Pseudocódigo
Ini cio
//Variables
i , sp, si, n : Entero
//Entrada
Leer n
//Proceso
si - si + i
Fin Para
sp - sp + i
Fin Para
//Salida
Escribir sp, si
Fin
.............................................................................................................................................................................." .............................
' Variables
Dim i As Long
Dim sp As Long
Dim si As Long
Dim n As Long
' Ent rada
n = Val (Me otxtn oText )
' Proceso
For i =1 To n Step 2
si = si + 1
Next
sp = sp + 1
Next
' Salida
M
e ot xtsp oText = Str (sp)
Meo t xtsioText = Str(si)
............................................................................................................................................................................................................o

Enunciado: Hallar el cuadrado de un número usando la siguiente relación: N2
=1 + 3 + S+ . ... . + 2N-1.
sistema devuelve el cuadrado del número.
Entrada Salida
• Número (n) • Cuadrado (e)
Diseño:
Interfaz de usuario
.. Problema 61 ~§[8]
Diagrama de flujo
e
Inicio
L
i, n, e . Entero
.
¡
1 Leer n
1
L
i-1
i< n
i-i+l
LV
Cuadrado ls
Algoritmo
F
Pseudocódigo
Inicio
/ /Variables
i , n , e : Entero
/ / Entrada
Lee r n
//Proceso
e - e + (2 * i - 1)
Para i-1 Hasta n Ine 1
e - e + (2 * i - 1 )
Fin Para
¡
1 Escribir
L
Fin
e
1
)
//Salida
Escribir e
Fin

Codificación :
.
' Variabl es
Di m l. As Long
Dim e As Long
Di m n As Lo ng
' Ent r a da
n = Va l(Me . t xt n . Tex t )
' Pro ceso
e = e + ( 2 * i - 1 )
Nex t
' Salid a
M
e . t x tc . Tex t = Str(c )
.. ...........................................................................................................................................................................................................
Enunciado: Crear el algoritmo que indique si un número es perfecto o no; se dice que un número es
perfecto si la suma de sus divisores es igual al número. Por ejemplo, 6 tiene como divisores 1, 2 y 3;
entonces 1 + 2 + 3 =6, el número 6 es perfecto. Si el número es 9, tiene como divisores 1 y 3; entonces 1
+ 3 = 4, por lo tanto no es perfecto.
sistema devuelva si el número es o no perfecto.
Entrada Salida
Diseño:
Interfaz de usuario
"' Problema 62 ~[Q)(g)
Número ls
Reopuesta !PERFECTO

Alg
Diagrama de flujo
( Inicio )
~
n , S , i . Entero
.
r . Cadena
.
~
1 Leer n
1
~
i< n2
i-1
F
i-i+l
j_v
F
n Mod i o
=
Iv
S - S + i
1
F V
n = S
r-" NO ES PERFECTO" r-" PERFECTO"
~
1 Escribir r
1
~
( Fin )
oritmo
Pseudocódigo
Inicio
//Variables
n , s , i : Entero
r : Cadena
//Entrada
Leer n
//Proceso
Para i-1 Hasta n 2 Inc 1
Si n M
od i = O Entonces
S - S + i
Fin Si
Fin Para
Si n = s Entonces
r - " PERFECTO"
SiNo
r - " NO ES PERFECTO"
Fin Si
//Salida
Escribir r
Fin

Codificación:
............................................., ..............................................................................................................................................................
' Variabl e s
Di m n As I ntege r
Di m s As I ntege r
Dim i As I nteger
Di m r As String
' Ent r ada
n = Val (M
e . t xt n . Text )
' Proceso
For i = 1 To n 2
Next
If n Mod i = O Then
S = S + i
End I f
If n = s Then
r = " PERFECTO"
El se
r = "NO ES PERFECTO"
End If
' Salid a
M
e . t xtr . Text = r
... .......................................................................................................................................................................................................... .
Problema n.o 63
Enunciado: Dados 2 números, diga si son amigos o no. Recuerde que dos números son amigos si la suma
de los divisores de uno de ellos es igual al otro y viceversa, por ejemplo 220 y 284 son amigos.
Divisores de 220 son: 1 + 2 + 4 + 5 + 10 + 11 + 20 + 22 + 44 +55+ 110 = 284
Divisores de 284 son: 1 + 2 + 4 + 71 + 142 = 220
Análisis: Para la solución de este problema, se requiere que el usuario ingrese dos números; luego, que
el sistema devuelva el resultado para saber si los números son amigos o no.
Entrada Salida
• Números (n 1, n2)
Diseño:
• Resultado (r)
Interfaz de usuario
.. Problema 63 [J[QJ~
N..,.. 1 1220
N""- 2 !284
Res<Aado ISDN AMIGOS

Alg
Diagrama de flujo
( Inicio )
¡
i, nl , n2 , sl , s2 . Entero
.
r . Cadena
.
/ Leer nl , n2 /
¡
i-1
i< nl2
F
i-i+l
l V
F
nl Mod i ~
Iv
sl ·- sl + i
¡
i - 1
i<-nl2
F
i-i+l
l V
F
n2 Mod i -
¡v
s2 ·- s2 + i
1
F V
nl~s2 Y n2~s
r-" NO SON AMI GOS" r •-" SON AMIGOS"
¡
/ Escribir r
/
¡
Fin )
oritmo
Pseudocódigo
Inicio
//Variables
i, n1 ,n2 , s1 , s2 : Enter o
r : Cadena
//Entrada
Lee r n1, n2
//Proceso
Para i-1 Hasta n2 Inc 1
Si n1 Mod i ~ O Entonces
s1 - s1 + i
Fin Si
Fin Par a
Para i-1 Hasta n 2 Inc 1
Si n2 Mod i ~ O Entonces
s2 - s2 + i
Fin Si
Fin Par a
Si n1~s2 Y n2=s1 Entonces
r - " SON AMIGOS"
SiNo
r - " NO SON AMI GOS "
E'in Si
//Salida
Escribir r
Fin

Codificación:
.
' Variables
Di m i As I n teger
Dim nl As Integer
Di m n 2 As Integer
Dim sl As Integer
Di m s2 As Integer
Dim r As String
' Entrada
n l = Va l( Me . t x tnl . Tex t)
n2 = Val (Me . t x tn2 . Text)
' Proceso
For i = 1 To nl 2
Nex t
If n l Mod i = O Then
sl = s l + i
End If
For i = 1 To n2 2
Nex t
If n2 M
od i = O Then
s2 = s2 + i
End I f
If nl = s2 And n2 = sl Then
r = " SON AMIGOS"
El se
r = " NO SON AMI GOS"
End If
' Salida
M
... .......................................................................................................................................................................................................... .

Problema n.o 64
Enunciado: Escriba un algoritmo que calcule la suma de la siguiente serie, hasta el número entero
positivo N ingresado.
1 2 3 4 . l .N
3
- +- +-+- , por e¡emp o sr es entonces:
2 3 4 N
1 2 7
- +- +- = 11666667
2 3 6 '
sistema devuelva el resultado de la suma de quebrados.
Entrada Salida
Diseño:
Interfaz de usuario
"' Problema 64 []@[8]
Nímero 13
1
1 ~u
St.~~M 11.166667
Diagrama de flujo
( Inicio J
¡
n, i , S . Entero
.
!
1 Leer n
1
¡
i< n 1
i-1
F
i-i+l
¡v
S -S + (i 1 (i + 1) l
1
¡
1 Escribir S
1
¡
( Fin
Algoritmo
Pseudocódigo
Inicio
//Variables
i , n , s : Ente r o
//Entrada
Lee r n
//Proceso
Pa r a i-1 Hasta n - 1 Inc 1
S - S + ( i 1 ( i + 1 ))
Fin Pa r a
//Salida
Escribir s
Fin

Codificación:
' Variables
Di m n As Single
Dim i As Single
Di m s As Single
' Ent r ada
n = Val (M
e . t xt n . Text )
' Proceso
For i = 1 To n - 1
S = S + ( i / (i + 1))
Next
' Salida
M
e . t xts . Text = Str (s )
Enunciado: Dado un rango numérico entero (número inicial y número final), obtener la cantidad de
números positivos y negativos que existen en el rango.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese dos números; luego, que
el sistema devuelva la cantidad de números positivos y negativos.
Entrada Salida
• Número inicial (ni)
Diseño:
• Cantidad positivos (cp)
• Cantidad negativos (en)
Interfaz de usuario
" Problema 65 ~[QJI'EJ
NúmeroInicial 1
·8
N<mero Final ls
Canlidad Positivos ls
CaOOdad Negativo:la

Diagrama de flujo
Inicio
!
ni , nf, cp, en, i o
Entero
o
!
/ Leer ni , nf/
!
i-ni
F
i< nf
~ - i+l
¡ F
j_V
i <> o >
F
Jv V
i < o
~ ~
1
cp-cp+l
1 1
cn-cn+l
¡ 1 1
¡
jÉscribir cp, en
/
!
( Fin
Codificación:
1
Algoritmo
Pseudocódigo
Inicio
//Variables
ni , nf , cp, en , ~ E:ntero
//Entrada
Leer ni , nf
//Proceso
Si i <> O Entonces
Si i<O Entonces
SiNo
Fin Si
Fin Si
Fin Para
//Salida
E:scribir cp, en
Fin
en - en + 1
cp - cp + 1
.. .......................................................................................................................................................................................................... .'
' Variables
Dim ni As Integer
Di m nf As Integer
Dim cp As Integer
Di m en As Integer
Dim i As Integer
' E:ntrada
ni- Val(Me otxtni oText)
nf - Val(Me ot x tnf oTex t )
' Proceso
For ~ = ni To nf
If i <> O Then

End If
Next
' Salid a
I f i < O Then
en = en + 1
E1se
ep = ep + 1
End If
M
e . t x tep . Tex t - St r(ep )
M
e . t x ten . Tex t - Str (en )
•., ..........." ............................................................................................................................................................................................. .
Problema n.o 66
Enunciado: Hallar cuántos múltiplos de M hay en un rango de números enteros.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese tres números (num. inicial,
num. final y num. múltiplo); luego, que el sistema devuelva la cantidad de múltiplos que hay en el rango.
Entrada Salida
• Número inicial (ni)
• Número múltiplo
Diseño:
• Cantidad (e)
Interfaz de usuario
.. Problema 66 ~[Q)rg)
Num. lnic;,l 12
Num. Final 1
15
Nllll. M,.;plo 13
Cariidad ls

Diagrama de flujo
(Inicio
~
ni , nf, nm, e , i . Entero
.
!
/Leer ni , nf, nm/
~
i -ni
i<- nf
F
Í · i+l
l V
F
i Mod nm = o
rv
e - e + 1
!
1 Escribir e
1
~
( Fin
Codificación:
' Variables
Dim ni As Integer
Dim nf As Integer
Dim nm As Integer
Dim e As Integer
Dim 1 As Integer
' E:ntrada
ni- Val(Me . txtni . Text)
nf- Val(Me . t xtnf . Text)
nm - Val(Me . t xtnm . Text)
' Proceso
For i = ni To nf
Next
If i Mod nm - O Then
e = e + 1
End If
' Salida
Me . t xtc . Text = Str(c)
Algoritmo
Pseudocódigo
Inicio
//Variables
ni , nf , nm, e , 1 : Entero
//Entrada
Leer n i, nf , nm
//Proceso
Si i Mod nm - O Entonces
e - e + 1
Fin Si
Fin Para
//Salida
Escribir e
Fin
..............................................................................................................................................................................................................

Enunciado: Crear un algoritmo para hallar el factorial de un número; el factorial es el producto de todos
los números consecutivos, desde la unidad hasta el número. Por ejemplo, factorial de 3! (se denota !) es
1 X 2 X 3 = 6.
sistema devuelva el factorial del número.
Entrada
o Número (n)
Diseño:
Salida
o Factorial (f)
Interfaz de usuario
- - - - - - - - - - -
.. Problema 67 ~IQJ~
Diagrama de flujo
(Inicio
!
n, f , i . Entero
.
!
1 Leer n
1
~
f - 1
~
i-ni
i<-nf
i -i+l
~V
f - f • i
~
F
Algoritmo
Pseudocódigo
Inicio
//Variables
n , f , i : Enter o
//Entrada
Leer n
//Proceso
f - 1
Pa r a i-1 Hasta n Inc 1
f - f * i
Fin Para
1 Escribir f
1
//Salida
Es cri bi r f
!
eFin )
Fin

Codificación:
............................................................................................................................................................................................................
· ' Variables
Di m n As Long
Dim f As Long
Di m i As Long
' Ent r ada
n = Val (Me . t xt n . Text )
' Proceso
f = 1
For i = 1 To n
f = f * i
Next
' Salida
M
e . t xt f . Text = Str(f)
Enunciado: Determine si un número es primo; se dice que un número es primo si es divisible entre 1 y
entre sí mismo.
sistema devuelva si el número es o no primo.
Entrada
• Número (n)
Diseño:
Salida
• Respuesta (r)
Interfaz de usuario
- - - -
.. Problema 68 ~@(8]
Núme<o 1
7
Aespue$1a !ES PRIMO
IL~l]

Diagrama de flujo
Inicio
!
n, i . Entero
.
flag . Logico
.
r . Cadena
.
!
/ Leer n 7
!
flag - Verdadero
!
i-2
F
i<-n2
i-i+l
Jv
n Mod i = o
1
flag - Falso
Salir
1
F ag=Verdadero V
r. "NO ES PRIMO" r. " ES
1 Escribir f
1
!
j Fin )
Capítulo 6: Estructura re petitiva «Para>>
Algoritmo
PRIMO"
Pseudocódigo
Inicio
//Variables
n , i : Entero
flag : Logico
r : Cadena
//Entrada
Leer n
//Proceso
flag - Verdadero
Para i-1 Hasta n2 Inc 1
Si n Mod i • O Entonces
flag - Falso
Salir
Fin Si
Fin Para
Si flag = Verdadero Entonces
r - " ES PRIMO"
SiNo
r - " NO ES PRIMO"
Fin Si
1/Salida
Escribi r r
Fin

Codificación:
' Variabl es
Dim n As I nteger
Dim i As Integer
Di m flag As Boolean
Di m r As String
' Entrada
n = Val (Me . t x t n . Te x t )
' Proceso
flag = True
For i = 2 To n 2
Nex t
If n Mod i = O Then
flag = Fa l se
Exi t For
End I f
If flag Then
r = " ES PRIMO"
El se
r = " NO ES PRIM
O"
End If
' Salida
Problema n.o 69
Enunciado: Determine cuántos números primos hay en los primeros N números enteros positivos.
sistema devuelva la cantidad de números primos; por ejemplo, si ingresa 7, hay 4 números primos 1, 3, 5
y 7.
Entrada Salida
Diseño:
Interfaz de usuario
,. Problema 69 ~@(8]
Número j7
l~il
~ticlbd 14

Diagrama de flujo
( Inicio )
L
n, e, i , j : Entero
Jlaq : Loqico
L
1 Leer n 1
L
i· 2
F
i<•n
i· -i+1
L
nag . Verdadero
!
i · 2 F
j<-i2
i· i +1
.lv
F i Mod j = g>
V
Jlag- Falso
Salir
.1
F Jlag
1v
e . e + 1
!
1 Escribir e 1
L
( Fin )
Algoritmo
Pseudocódigo
Inicio
//Variables
n, e , i , j : Entero
flag : Logico
//Entrada
Leer n
//Proceso
flag - Verdadero
Para j-2 Hasta i2 Inc 1
Si i Mod j = O Entonces
flag - Falso
Salir
Fin Si
Fin Para
Si flag Entonces
e - e + 1
Fin Si
Fin Para
//Salida
Escribi r e
Fin

Codificación:
............................................................................................................................................................................................................
.
' Variables
Dim n As Integer
Dim e As Integer
Dim i As Integer
Dim j As Integer
Dim flag As Boolean
' Entrada
n = Val(Me . txtn . Text)
' Proceso
For l. - 2 To n
flag = True
For J - 2 To l. 2
If l. Mod j - o Then
flag - False
Exit For
End If
Next
If flag The n
e - e + 1
End If
Next
' Salida
Me . txtc . Text = Str(c)
..............................................................................................................................................................................................................
Enunciado: Dado un número y un divisor, determine cuál es el número múltiplo antecesor al número
ingresado; por ejemplo, si ingresa N = 21 y O = 3, entonces R = 18, porque es el número múltiplo de 3
antecesor de 21.
sistema devuelva el número múltiplo antecesor.
Entrada Salida
• Divisor (d)

Diseño:
Interfaz de usuario
"' Problemd 70 ~@~
Ntrnero 121 IL.Cacu'!_]l
Oívi$or 13
Ae$pue$ta 11
8
Algoritmo
eInicio
l
n , d , i , r . Entero
.
l
1 Leer n , d 1
l
i-n-1
i> 1 F
i-i-1
j_
V
F
i Mod d = o
T
v
r- i
Salir
l
1 Escribir r
1
l
eFin
Inicio
//Variables
n, d , i , r · Entero
//Entrada
Leer n , d
//Proceso
Para i-n-1 Hasta 1 Inc -1
Si i Mod d = O Entonces
Fin Si
Fin Para
r - i
Salir
//Salida
Escribir r
Fin

Codificación:
o
' Variables
Dim n As Integer
Dim d As I nteger
Dim i As Integer
Dim r As I n teger
' Entrada
d = Val(Me . t x td . Text)
' Proceso
For i = n - 1 To 1 Step -1
If i Mod d = O Then
r = i
Exi t For
End If
Next
' Salida
Me . t x tr . Text = Str(r)

Propuesto n.0
41
Enunciado: Calcule la suma de los cuadrados y cubos de los N primeros números naturales.
Propuesto n.o42
Enunciado: Obtener la suma y la cantidad de los números divisibles por 3 y 5 a la vez, de los N primeros
números naturales.
Propuesto n.o43
Enunciado: Dado un rango numérico entero positivo a y b, obtener la suma y la cantidad de los números
pares, impares y múltiplos de 3.
Propuesto n.o44
Enunciado: Calcule la suma y la cantidad de números de la serie de fibonacci, menores a N. La serie de
fibonacci es una secuencia de números cuya característica es que cada número de la serie debe ser igual
a la suma de los 2 números anteriores; la serie empieza con O y 1, entonces, si el número N ingresado es
30, la serie sería menor a 30. Esto equivale a O 11 2 3 5 8 13 21, y lo que se pide es la suma y la cantidad
de números de la serie.
Propuesto n.o45
Enunciado: Dado un rango de números, determine cuántos números capicúa hay.
Propuesto n.o46
Enunciado: Dada la cantidad de cifras y un divisor, determine cuántos números múltiplos del divisor con
dichas cifras existen.
Propuesto n.o47
Enunciado: Calcule la suma de la siguiente serie:
[
1 x x2
x3
x• x"
s=- +-+-+-+-+...+-
0! 1! 2! 3! 4! n!
1
Propuesto n.o48
Enunciado: Calcule de cuántas formas se pueden ordenar n objetos.
Propuesto n.o49
Enunciado: Obtenga la cantidad de los números primos den cifras.
Propuesto n.o50
Enunciado: Obtenga la cantidad de los números capicúas de n cifras.

Estructuras de datos.
Arreglos (vectores y matrices)
7.1 1ntroducción
En muchas situaciones se necesita procesar una colección de datos que están relacionados entre sí,
por ejemplo, la lista de notas de los alumnos, los participantes de una carrera deportiva, etc. Procesar
ese conjunto de datos en forma independiente con variables simples (primitivas), es tremendamente
difícil, por eso los lenguajes de programación incorporan un mecanismo que facilita la manipulación y
organización para una colección de datos llamada «estructura de datos».
Para explicar todo lo relacionado a estructura de datos se necesita escribir todo un libro que detalle los
temas involucrados, para este capítulo solo se está considerando una parte básica e importante en la
estructura de datos, llamada array (arreglos).
Vector
o 1 2
15 12 18
3
14
4
12 o
1
2
Matriz
o 1 2 3
25 10 15 32
52 10 4 18
18 22 3 9
Las estructuras de datos están subdivididas por estáticas (espacio fijo establecido en memoria) y dinámicas
(sin restricciones y limitaciones en el espacio usado en memoria).
Estructuras de datos estáticas
• Arrays (vectores y matrices)
• Cadenas
• Registros
• Ficheros
Estructuras de datos dinámicas
• listas (pilas y colas)
• listas enlazadas
• Árboles
• Grafos
La diferencia entre cada estructura es la forma en cómo se almacena y manipula el conjunto de datos,
permitiendo así su eficiencia en el resultado de una operación sobre dichos datos.

7.2 Arrays (Arreglos)
Es un conjunto finito (tamaño fijo) y ordenado (usa un índice) de datos homogéneos (datos del mismo
tipo). Los arreglos pueden ser de una dimensión (vector), dos dimensiones (matriz) y n dimensiones
(multidimensional).
En todos los lenguajes de programación, los arrays usan un índice numérico para cada elemento que
contiene, los cuales por lo general inician con el índice O, llamado« Limite Inferior>> (U); y el último elemento
tendrá el índice llamado «Limite Superior>> (LS), que en sí es la cantidad de elementos del array menos 1.
Arreglo de una dimensión Arreglo de dos dimensiones
(Vector de S ítems) (Matriz de 3x4)
o 1 2 3 4 ll 2da dimensión LS
15 12 18 14 12 t (columnas) ¡
o 1 2 3
Ll -+ o 25 10 15 32
u - o 15
lra dimensión
1
(filas) 52 10 4 18
1 12 LS -+ 2 18 22 3 9
N
o 2 18
Selementos
1 (ítems)
e 3 14
E
LS -+ 4 12
7.3 Operaciones con arrays
Las operaciones son el procesamiento y el tratamiento individual de los elementos del array, las cuales
son las siguientes.
• Asignación
• Lectura/ escrit ura
• Recorrido
• Actualización (insertar, borrar, modificar)
• Ordenación
• Búsqueda

Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
7.4 Creación de arrays
Para la creación de un array se requiere conocer el nombre, las dimensiones, el tamaño de elementos y
el tipo de dato.
Pseudocódigo
........................................................................................................................................................................................................... ...
//Ar r ay de una dimensi ó n (Vector)
11 5 elementos LI = O y LS = 4
N[5) : Entero
//Array de dos dimens i o nes (Matriz )
11 3X4 elementos
/1 lera Dim . LI = O y LS = 2
// 2da Dim . LI = O y LS = 3
N[3) [ 4 ) : Entero
... ...............................................................................................' ...............................................................................' .......................... .
Visual Basic
··················......................, ................................................................................................................................................................. ··.
' Array de una dimensión (Vector)
' 5 e l ementos LI = O y LS = 4
Dim N(4) As Integer
' Array de dos dimensiones (Matriz)
' 3X4 elementos
' lera Dim . LI = O y LS = 2
' 2da Dim . LI = 0 y LS = 3
Dim N(2 , 3) As Integer
'•• .......................................................................................................................................................................................................... .

7.5 Recorrido por los elementos del array
Para realizar un recorrido por cada elemento del array utilizaremos la estructura repetitiva «Para» (For).
En el siguiente diagrama se tiene el vector N de Selementos, y se asigna el valor 10 a cada elemento.
i< 4
N [ i 1
For i=O To 4
N( i ) = 1 0
Next
!
!V
·-
l
¡
i-0
F
Para L- O Hasta 4 Inc +1
i-i+l
N[i] - 10
10
Fin Para
En el siguiente diagrama se tiene la matriz N de 3x4 elementos y se asigna el valor 10 a cada elemento.
!
i-0
i<-2
i -i+l
¡v
j-0
j<-3
j-j+l
¡v
N[i l [ j]- 10
t
¡
F
F
Para i- O Hasta 2 Inc +1
Para j- O Hasta 3 Inc +1
N[i] [j] - 10
Fin Para
Fin Para
.. .......................................................................................................................................................................' .................................. ..
For i=O To 2
For j=O To 3
N(i , j ) - 10
Next
Next

Enunciado: Dados S números, obtener la suma.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese S números; luego, que el
sistema realice el proceso para devolver la suma.
Entrada Salida
• S Números n[S] • Suma (s)
Diseño:
Interfaz de usuario
,. Problema 71 ~[QJ(8)
Diagrama de flujo
Inicio
l
i , S . Entero
.
l
n[S) . Entero
.
!
~Leer n[O) , n(l ) ,~
n(2],n(3],n(4)
l
i-1
i<-4
F
i-i+l
!V
S - s + n[i )
!
1 Escribir S
1
J
1 Fin
Núm
ero 1
Númeto2
Núm
eto3
Númeto4
Núme1o S
So.ma
12 IC§.w..r.JJ
l2
12
12
12
l1o
Algoritmo
Pseudocódigo
Inicio
//Variables
i , s : Ent e r o
//Arreglos (Vector)
n [ S] : Ent ero
//Entrada
Lee r n[ O],n [ l ],n[ 2],n [ 3 ],n[ 4]
//Proceso
Para i-0 Hasta 4 Inc 1
S - S + n[ i)
E'in Para
//Salida
Escribir s
Fin

Codificación:
,' .......................................................................................................................................................................................................... ...
' Variables
Dim s As Integer
Dim i As Integer
' Arreglos (Vector)
Dim n(4) As Integer
' Entrada
n (O) - Val(Me . txtnl . Te xt )
n(l) - Val(Me . txtn2 . Te xt )
n (2 ) - Val(Me . txtn3 . Te xt )
n (3 ) - Val(Me . t xtn4 . Te xt)
n (4 ) - Val(Me . txtnS . Te xt)
' Proceso
For i = O To 4
S = S + n (i )
Next
' Salida
... .......................................................................................................................................................................................................... .
Enunciado: Dados 5 números, obtener el número mayor.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese 5 números; luego, que el
sistema realice el proceso para devolver el mayor.
Entrada Salida
• 5 números n[5] • Mayor (m)
Diseño:
Interfaz de usuario
'" Problema 12 [J(Q)rEJ
Número 1 ls I!~~JI
Número 2 12
Número 3 134
Número 4 lss
Número 5 1
3
Mayor lss

Diagrama de flujo
( Inicio
~
i , m . Entero
.
!
n[S] . Entero
.
~
~ Leer n[O ) , n[l] , ~
n[2 J. n[3 J.n[4 )
!
i< 4
i . o
F
i-i+l
1V
F n [ i) > m
1v
m- n[i]
~
1 Escribir m 1
!
( Fin
Codificación:
Algoritmo
Pseudocódigo
Inicio
//Variables
i, m : Entero
//Arreglos (Vector)
n[5] : Entero
//Entrada
Leer n[O] , n[l ].n[ 2].n[3].n[ 4]
//Proceso
Si n[i] > m Entonces
m- n[i]
Fin Si
Fin Para
//Salida
Escrib i r m
Fin
.......................................................................................................................................................................................................... ··.
· ' Variables
Dim m As Integer
Dim i As Integer
' Arreglos
Dim n(4) As Integer
' Entrada
n(O) = Val(Me . txtnl . Text)
n(l ) = Val(Me . txtn2 . Text)
n(2) = Val(Me . txtn3 . Text)
n(4) - Val(Me . txtn5 . Text)
' Proceso
For i = O To 4
Next
If n (i) >m Then
m = n (i)
End If
' Salida
Me. t xtm . Text = Str(m) ,
... .............................................................................' ............................................................................................................................

Problema n.o 73
Enunciado: Dados S números y un divisor, determinar cuántos números múltiplos hay del divisor en los
S números ingresados.
sistema procese y devuelva la cantidad de números múltiplos que hay.
Entrada Salida
• S números (n(SJ) • Cantidad (e)
• Divisor (d)
- Problema 13 rD©J@
N(mero 1 13 !~:=JI
Númefo2 17
N~3
le
Ntínero e ls
NWncroS ls
OMtot 13
Criclod 13
Diagrama de flujo Algoritmo Pseudocódigo
Inicio
l Inicio
d , i , e . Entero
.
l //Variables
n (Sl . Entero
. d , i , e : Entero
~
~
1Leer n(Ol , n!l l,
1~
n(2 J, n[3 J, n[4J,d
//Arreglos (Vector)
n [S] : Entero
+ i-0
i<-4
i -i+l
1V
F
n(il Mod d=
Tv
e - e + 1
!
1 Escribir e
1
l
eFin )
F
//Entrada
Leer n [O), n [ 1), n [ 2), n [ 3 ), n [ 4), d
//Proceso
Si n[i] M
od d- O Entonces
e - e + 1
Fin Si
Fin Para
//Salida
Escribir e
Fin

Codificación :
............................................................................................................................................................................................................
' Variabl es
Di m d As I nteger
Dim i As I nteger
Di m e As I nteger
' Arreglos
Di m n( 4) As I nteger
' Entrada
n( O) - Val (Me . txtnl . Te xt )
n(1) - Va1 (Me . t xtn2 . Text)
n (2 ) - Va1 (Me . txtn3 . Tex t )
n( 3 ) - Val (Me . t xtn4 . Te xt )
n( 4 ) - Val (Me . txtnS . Te xt )
d = Val (M
e . t xtd . Text )
' Proceso
For i = O To UBound (n , 1)
If n (i ) Mod d - O Then
e = e + 1
End If
Next
' Salida
M
e . t xtc . Text = Str (c )
.
... .......................................................................................................................................................................................................... .
Problema n.o74
Enunciado: Dados 5 números, obtener la cantidad de números primos ingresados.
sistema procese y devuelva la cantidad números primos.
Entrada Salida
• 5 números (n[S)) • Cantidad (e)
Diseño:
Interfaz de usuario
, ., Problema 74 ~[Q)t:8]
N(rne<o1 17 1
1 CaictJiJ
Número 2 13
N(rne<o3 1
4
N(rne<o 4 ls
Número5 In
Contid<ld 13

Diagrama de flujo
( Inicio )
¡
e , i , j . Entero
.
flag . Logico
.
¡
n[Sl . Entero
.
¡
~~eer n[Ol , n[ l lÍ~
n[2]. n[3 ]. n[41
¡
i-0
i< 4 F
1-i+l
¡
F
flag - verdadero
j< n [ i 12
j-2
F
j-j+l
l V
F
n[il Mod j=O
¡v
Jlag - Falso
Salir
1
F flag
V
e - e + 1
1 Escribir e
1
¡
( Fin )
Algoritmo
Pseudocódigo
Inicio
//Variables
e , i, j : Entero
flan : Logico
//Arregl os (Vect or)
n[5] : Entero
//Entrada
Leer n[O),n[l ), n [ 2),n[3 ), n [ 4]
//Proceso
flag - Verdadero
Para j-2 Hasta n[i]2 Inc 1
Si n [i) Mod j=O Entonces
flag - Falso
Salir
Fin Si
Fin Pa r a
Si flag Entonces
e - e + 1
Fin Si
Fi n Par a
//Salida
Escribir e
Fin

Capítulo 7: Estructuras de datos. Arreglos (vectores y matr ices)
Codificación:
............................................................................................................................................................................................................
.
' Variabl es
Di m e As I nteger
Dim i As Integer
Di m j As I nteger
Di m flag As Boolean
' Arregl os
Dim n(4 ) As Integer
' En t rada
n (Ol = Val (Me . txtnl . Tex t )
n(l) - Val (Me . t x tn2 . Te x t )
n( 2 ) = Va l (Me . t x tn3 . Te xt )
n( 3 ) - Val(Me . t x tn4 . Tex t)
n( 4 ) - Val (Me . t x tnS . Te xt )
' Proceso
Fo r i = O To 4
flag = True
Next
For J = 2 To n (i) 2
Nex t
If n (i ) M
o d j =O Then
flag = False
Exi t For
End I f
I f flag Then
e = e + 1
End If
' Salida
Me . t x t c . Tex t = Str (c )
Enunciado: Busque un número en 7 números ingresados y determine la posición, y si existe o no el
número buscado, use el método de búsqueda secuencial.
sistema devuelva la respuesta, si existe o no el número y la posición del número encontrado.
Entrada Salida
• 7 números (n[7J) • Respuesta (r)
• Numero a buscar (nb) • Posición (p)

Diseño:
Interfaz de usuario
,. Problema 75 ~]QJ[8]
Número 1 [4
Número 2 la
Número 3 [3
Número4 [2
Número5 ,,
Número6 ls
Número7 17
Diagrama de flujo
Inicio
L
nb, p , i . Entero
.
r . Cadena
.
!
n (7) . Entero
.
L
~Leer n[O) , n(ll , n(21 , .~
( 31 , n ( 4 1, n (5 1, n [6 1, nb
L
r - " NO EXISTE"
p - - 1
L
i-0
F
i< 6
i -i+l
J.V
F n [i) bn >
lv
r - 'EXISTE"
p ·- i
Salir
1
/ Escribir r , P/
L
( Fin
Númefo abuscar [2
Respu&$1a [EXISTE
Posición [3
lca.~...JI
Algoritmo
Pseudocódigo
Inicio
//Variables
nb, p, i : Entero
r : Cadena
//Arregl os (Vector)
n[7] : Entero
//Entrada
Leer n [O), n [1 ), n [ 2), n [3 ), n [ 4),
n [ 5] , n [ 6] , nb
//Proceso
r - " NO EXISTE"
p - -1
Si n[i] = nb Entonces
r - "EXISTE"
Fin Si
Fin Para
p - i
Salir
//Salida
Escribir r , p
Fin

Capítulo 7: Estructuras de datos. Arreglos (vectores y matr ices)
Codificación:
' Variabl es
Di m nb As Integer
Dim r As String
Di m p As I nteger
Di m 2 As I nteger
' Arregl os (Vector)
Dim n(6 ) As Integer
' En t rada
n (O) = Val (Me . txtn1 . Tex t )
n (1) - Val (Me . t x tn2 . Te x t )
n (2 ) = Val (Me . t x tn3 . Te xt)
n (3 ) - Val(Me . t x tn4 . Tex t)
n (4 ) - Val (Me . t x tnS . Te xt )
n (5 ) = Va l (Me . t x tn6 . Te xt )
n (6 ) - Val (Me . t x tn7 . Te xt )
nb = Va l( Me . t x tnb . Tex t )
' Proceso
r =
p -
For
Next
" NO EXI STE"
- 1
2 - o To UBound (n ,
I f n (i ) = nb The n
r - " EXISTE"
p - i
Exi t For
End If
' Salida
M
e . t x t r . Tex t = r
M
e . t x tp . Tex t = St r( p )
1 )
.' ............................................................................................................................................................................................................
Enunciado: Lea 4 números y almacénelos en un vector llamado A; lo mismo con otros 4 números en un
vector llamado B, y determine cuantos números de A se encuentran en B.
sistema devuelve la cantidad.
Entrada Salida
• 4 números (a[4)) • Cantidad (e)
• 4 números (b[4))

Diseño:
Interfaz de usuario
" Problema 76 [J(Q)[gl
Nl 1
3
N
2 ls
N
3 lz
N4 b
Diagrama de flujo
( Inicio )
e , i , j . Entero
.
¡
a [41 . Entero
.
b [41 . Entero
.
l
A
Nl
N
2
N
3
N4
B
ls Cantidad 12
la ¡u..~·J.I
ls
1
3
Algoritmo
Pseudocódigo
Inicio
//Variables
e , i , j : Entero
//Arreglos (Vector)
a[4] , b[4 ] : Entero
/a Leer a[OJ,a[ll , a[2], ,¡
a[31 , b[Ol , b[l l , b[2 J , b [3
¡
i-0
i<- 4
i-i+l
V
j-0
j< 4
j-j+l
l V
F
a [i J b [ j 1
T
e - e + 1
l
1 Escribir e
¡
( Fin )
F
F
>
1
//Entrada
Leer a[O],a[l ], a[2],a[3 ),
b!OJ , b[1J , b[2J , b [ 3J
//Proceso
Para j-0 Hasta 4 Inc 1
Si a[i ]=b[ j] Entonces
e - e + 1
Fin Si
Fin Para
Fin Para
//Salida
Escribir e
Fin

Codificación:
.......'.................................................................................................................................................................................................. ..
:
' Variables
Di m e As I n teger
Dim ~ As Integer
Di m j As I n teg e r
' Arregl os
Dim a (3 ) As I n teger
Di m b( 3 ) As Integer
' Ent r ada
a (O) = Val (Me . t x ta1 . Tex t)
a <1 l - Val (Me . txta2 . Te xt )
a (2 l - Val (Me . t x ta3 . Text )
a (3 l - Val (Me . txta4 . Te xt )
b ( o ) - Val (Me . t x tb1 . Tex t)
b (1) - Val (Me . t x tb2 . Te xt )
b (2 ) - Val (Me . t x tb3 . Te xt)
b (3 ) - Val (Me . tx tb4 . Te xt )
' Proceso
For i - o To UBound (a , 1 )
For j = o To UBound (b , 1)
I f a (i) - b ( j ) Then
e - e + 1
End If
Nex t
Nex t
' Salid a
M
e . t x tc . Te x t = Str (c )
... ....................................................' .........................................' ...........................................................................................................
Problema n.o77
Enunciado: Ordene 4 números usando el método de ordenación por intercambio (burbuja).
sistema devuelva los números ordenados.
Entrada Salida
• 4 números (n(4)) • 4 números ordenados (n[4))

"' Problema 71 ~]Q)(8]
N
1 1
4
N
2 1
1
N
3 13
N4 17
Diagrama de flujo
( Inicio )
~
tmp, i , j , LI , LS ' Entero
'
~
n [41 ' Entero
'
~
/ Leer n[O l , n[ll , n[2] , n[3J /
~
LI - 0
LS - 3
~
i-LI
i< LS-1
F
i-i+ l
~ V
j-LI
F
j< LS 1
j-j+1
l_
V
n[j]>n[j+l ] >
F
T
tmp- n[j ]
n [ j l - n [ j+l]
n [j+ ll - tmp
~
~
/ Escribir n[Oj , n[l],n [2 ] , n[3] /
~
( Fin )
Ordenado
11
1~."JI
13
14
17
Algoritmo
Pseudocódigo
Ini cio
/ / Variables
tmp, i , j , LI , LS : Enter o
n [4 ] : Ent e ro
//Entr ada
Leer n[ O] , n [1 ] , n[ 2] , n [3]
//Proceso
LI - O
LS - 3
Para i - LI Hasta LS - 1 Inc 1
Para j-LI Hasta LS -1 I nc 1
Si n [j ] >n(j +l ] Entonces
t mp - n [ j J
n [j ] - n[j +l]
n [j +l ] - t mp
Fin Si
Fin Par a
Fin Pa r a
/ / Salida
Escrib i r n [O ], n[ l],n [2 ], n(3 ]
Fi n

Codificación:
..........................................................................................................................................................................................................··.
' Variables
Dim tmp As Intege r
Dim i As Integer
Dim j As Integer
Dim LI As Integer
Dim LS As Integer
' Arreglos (Vector)
Dim n(3) As Integer
' Entrada
n(O) - Val(Me . txtn1 . Te xt)
n(2) - Val(Me . txtn3 . Te xt)
' Proceso
LI - LBound(n , 1)
LS - UBound(n , 1)
For i - LI To LS -
For j - LI To
If n ( j l
1
LS - 1
> n ( j +
tmp = n ( j)
n ( j ) = n ( j
n ( j + 1) -
End If
Next
Next
' Salida
Me . t x tno1 . Text = Str(n(O))
Me . t xtno2 . Text - Str(n(1))
Me . t x tno3 . Text = Str (n (2))
Me . t xtno4 . Text - Str (n (3))
1) Then
+ 1)
tmp

Problema n.o 78
Enunciado: Ingrese 6 números en un arreglo de dos dimensiones (matriz) de 3x2, y obtenga la suma de
los números ingresados.
sistema devuelva la suma de los números.
Entrada Salida
• 6 números (n[3)[2]) • Suma (s)
Diseño:
Interfaz de usuario
• Problema 78 r;J§['g]
N
Diagrama de flujo
( I ni cio )
~
s , i , j . Entero
.
~
n[31 [2 1 . Entero
.
~
1
Leer n [ O1 [ O1, n [ O1 [11 ,
n[l l [01 , n[ll [1 1,
n[21(0],n[21111
~
i-0
i< 2
F
i-i+l
~V
j-0
F
j< 1
j-j+l
~V
S •- S + n[i l [jl
*
*
!
1 Escribir s
1
!
( Fin )
o 1
o
r r s..,. [12
1
r r 11 ~ 1
1
2r r
Algoritmo
Pseudocódigo
1
Inicio
//Variables
s , i , j : Entero
//Arreglos (Matriz)
n [3] [2] : Entero
//Entrada
Leer n[O ] [0 ], n[0] [1],
n[1] [O] , n[O] [1] ,
n[2] [O J,n[O J [1] ,
//Proceso
S - S + n ( i] ( j]
Fin Para
Fin Para
//Salida
Escribir s
Fin

Codificación:
.
' Variables
Di m S As I n teger
Dim i As Integer
Di m j As I n teger
' Arreglos
Dim n(2 , 1 ) As Integer
' Entrada
n (O, 0 ) - Va l(Me . t x t nOO . Tex t )
n (O, 1) - Val (Me . txtn01 . Text)
n (1 , 0 ) - Val(Me . t x t n1 0 . Tex t)
n (1, 1) - Val(Me . txtn11 . Tex t)
n (2, 0 ) - Val(Me . t x tn20 . Tex t)
n (2, 1) - Val(Me . txtn21 . Tex t)
' Proceso
For i = O To 2
For j - O To 1
S = S + n ( i , j )
Nex t
Nex t
' Salida
M
e . t x ts . Tex t = Str (s )
...............' ............................................................................................................................................................................................
Problema n.o79
Enunciado: Ingrese 12 números en un arreglo bidimensional (mat riz) de 4x3, y obtenga la suma de cada
columna.
sistema devuelva la suma de cada columna.
Entrada Salida
• 12 números (n[4][3]) • Suma columna 1 (sO)
• Suma columna 2 (s1)
• Suma columna 3 (s2)

Diseño:
Interfaz de usuario
.. Problema 79 (g[Q)I:8J
N
o
o~
1~
2~
3~
Suma re--
Diagrama de flujo
( Inicio )
T
s0 , sl , s2 , i , j . Entero
.
1
n[41 (3] : Entero
T
Leer n[OJ (OJ,n[Ol [ll , n[OJ (2],
n [ll [ O], n [ll [ l],n[ll [ 2],
n[21 [Ol , n[21 [l) , n[21 [2) ,
n [3) [0], n [31 [1], n [3) [2)
1
i .- 0
F
i< 4
i-i+l
1v
sO - sO + n(il [01
sl - sl + n(il [11
s2 - s2 + n(il [21
-¡
1
/ Escribir sO, sl , s 2j
1
( Fin
1 2
[3 ¡¡- IC~~!:JI
[3 ¡¡-
[3 ¡¡-
[3 ¡¡-
f12 fi6
Algoritmo
Pseudocódigo
Inicio
//Variables
sO , sl , s2 , i , j : Entero
//Arreglos (Matriz)
n[ 4 ] [3] : Entero
//Entrada
Leer n [0) [O ]. n [0) [1]. n [0) [2 ].
n[1) [O ]. n[1) [1 ]. n[1 ] [2].
n[2 ] [O ]. n[2) [1 ]. n[2 ] [ 2].
n[3 ] [O ]. n[3) [1 ]. n[3 ] [ 2].
//Proceso
sO- sO + n[i] [0]
s1 - s1 + n[i] [1]
s2 - s2 + n[i] [2]
Fin Para
//Salida
Escrib i r sO , s1 , s2
Fin

Codificación:
' Variables
Dim sO As Integer
Dim s1 As Integer
Dim s2 As Integer
Dim i As Integer
Dim j As Integer
' Arreglos
Dim n(3 , 2) As Integer
' Entrada
n (0 , 0) - Val (Me . txtnOO . Text)
n (O , 1) - Val (Me . txtn01 . Text)
n (0 , 2) = Val(Me . txtn02 . Text)
n (1 , 0) - Val(Me . txtn10 . Text)
n (1, 1) - Val(Me . txtn11 . Text)
n (2 , 0) - Val (Me . t x t n20 . Text)
n (2 , 1) = Val(Me . txtn21 . Text)
n (3 , 0) = Val (Me . txtn20 . Text)
n (3 , 1) - Val(Me . t x t n21 . Text)
n (3 , 2) - Val (Me . t x t n22 . Text)
' Proceso
For i - o To 3
so - sO + n (i , 0)
s1 - sl + n (i , 1)
s2 - s2 + n (i , 2)
Next
' Salida
Me . t x tsO . Text = Str(sO)
Me . t x tsl . Text = Str(s1)
Me . t x ts2 . Text - Str(s2)
..............................................................................................................................................................................................................
Problema n.o 80
Enunciado: Almacene en una matriz de 3x2, 6 números y obtenga la cantidad de pares e impares.
sistema devuelva la cantidad de pares e impares.
Entrada Salida
• 6 número (nl3)(21) • Cantidad de pares (cp)
• Cantidad de impares (ci)

Diseño:
1
F
Interfaz de usuario
• Problema 80 ~§rE)
N
o
or
l p
2
r
Diagrama de flujo
( Inicio )
l
cp, ci , i , j o
Entero
o
l
n [3 1 [2] o
Entero
o
l
Leer n[Ol [O],n[O] [1 ],
7
n[l] [OJ,n [1] [1],
n[2] [0 J,n[ 2] [1]
l
i-0
F
i< 2
i - i+l
!V
j-0
F
j< 1
J-j+1
j_V
n[i ] [j l Mod 2=0
V
1
16 Cantidad Pares
f4
[8 Cantidad Impares ~
14 IIT~JI
Algoritmo
Pseudocódigo
Inicio
//Variables
cp, ci, i,j : Entero
//Arreglos (Matriz)
n [3) [2 ) : Entero
//Entrada
Leer n [ OJ [O], n [O ) [1 ) ,
n[1 ) [0 J,n[1) [1 ],
n [2 ) [0 ], n [2 ) [ 1 )
//Proceso
Para i -0 Hasta 2 I n c 1
Si n[i] [ j ] Mod 2=0 Entonces
cp - cp + 1
SiNo
ci-ci+l cp-cp+l
ci - ci + 1
Fin Si
1
I
/ Escribir
l
( Fin
1
cp, ci j
)
Fin Para
Fin Para
//Salida
Escribir cp, ci
Fin

Codificación:
.............................................................................................................................................................................................................
'Variables
Di m cp As Integer
Di m c i As Integer
Di m i As Integer
Di m j As I nteger
' Arreglos (Matri z)
Dim n (2 , 1) As Integer
' Ent r a da
n (O, 0 ) = Va l (Me . t xtnOO . Text)
n( O, 1) = Va l (Me . t xt n01 . Text)
n (1, 0 ) - Va l (Me . t xt n10 . Text )
n (l , 1) = Va l (Me . t xt n11 . Te xt )
n (2 , 0) s Val (Me . t xt n20 . Te xt )
n (2 , 1) a Val (Me . t xt n2l . Te xt )
' Proceso
For i = O To 2
For j = O To 1
If n ( i , j) Mod 2 = O Then
cp = cp + 1
El se
ci = ci + 1
End If
Ne xt
Next
' Salida
Me . t xtcp . Text • Str (cp )
Me . t xtci . Text • Str (ci )
............................................................................................................................................................................................................
Problema n.o81
Enunciado: Busque un número dent ro de una matriz de 4x3 y determine la posición, y si existe o no el
número buscado. Use el método de búsqueda secuencial.
Análisis: Para la solución de este problema se requiere que el usuario ingrese dos números; luego, que el
sistema devuelva la cantidad de números positivos y negativos.
Entrada Salida
• Matriz (n(4)[3))
• Número a buscar (nb)
Diseño:
• Respuesta (r)
• Posición l.ra dim. (pl)
• Posición 2.da dim. (p2)
lnteñaz de usuario
,. Problema 81 ~[§[El
N
o 1 2
o¡¡- 1215 N(rnero a buie41
IBILcacu..
_jl
1 j8 1912 R. _to JSI EXISTE
2 r r r Posicíén 1eraOin. ~
3¡;---- r r Posicíén2doOin. ¡-z-

Diagrama de flujo
( Inicio }
1
nb, i , j , p1 , p2 . Entero
.
r . Cadena
.
1
n[4) [3] . Entero
.
1
Leer n [O J [O L n [O J [ 1 L n [O J [ 2 L
n[1] [01 , n(1] [11 , n(1] [21 ,
n[2] (0] , n[2] [11 , n[2] [21 ,
n [31 [0 1, n [31 [1 ], n [3] [2 )
1
r - "NO EXISTE"
pl - -1
p2 - -1
1
i-0
i< 3
F
i-i+l
1
j-0
F
j< 2
j-j+l
_1V
F
[i] (j] no >
¡v
r - 'SI EXISTE"
pl - i
p2 - j
Salir
1
F
" SI EXI STE
1v
Salir
!
1 Escribir r ,pl , p2 1
¡
( Fin }
Algoritmo
Pseudocódigo
Inicio
//Variables
nb, i , j , p1 , p2
r : Cadena
//Arregl os (Matri z)
n[4][3] : Entero
//Entrada
Entero
Leer n [0] [0 ], n [0] [1], n [0] [2 ],
n[l] [O ], n[l] [l ], n[l] [2],
n[2] [0 ], n[2] [l ], n[2] [2],
n[3] [O ], n[3] [l ], n[3] [2]
//Proceso
r - " NO EXISTE"
p1 - - 1
p2 - -1
Pa r a j-0 Hasta 2 I nc 1
Si n[i] [j]=nb Entonces
r - " SI EXISTE"
pl - i
p2 - j
Sali r
Fin Si
Fin Para
Si r=''SI EXISTE" Entonces
Salir
Fin Si
Fin Para
//Salida
Escribir r , p1 , p2
Fin

Codificación:
........................................................................................................................................................................................................... ...
' Variables
Dim nb As Integer
Dim i As Integer
Dim j As Integer
Dim r As String
Dim p1 As Integer
Dim p2 As Integer
' Arreglos
' Entrada
n (0 , 0) = Val(Me . txtnOO . Text)
n (O , 1) - Val(Me . txtn01 . Text)
n (O , 2) - Val(Me . txtn02 . Text)
n (1, 0) = Val(Me . txtn10 . Text)
n(1 , 1) - Val(Me . txtn11 . Text)
nb = Val(Me . t xtnb . Text)
' Proceso
r = " NO EXISTE"
p1 = -1
p2 - - 1
For i = O To 3
For j = O To 2
If n(i , j) = nb Then
r = " SI EXISTE"
Next
p1 - l.
p2 - j
Exit For
End If
Next
If r = " SI EXISTE" Then
Exit For
End If
' Salida
Me . t x tpl . Text = Str(p1)
Me . t xtp2 . Text = Str(p2)
... ...........................................................................................................................................................................................................

Problema n.o 82
Enunciado: Dada la matriz A de 2x2, la matriz B de 2x2, obtenga la suma de dichas matrices.
sistema devuelva la suma de matrices.
Entrada Salida
• 4 números matriz A (a(2][2)) • 4 números matrizC (cl2][2))
• 4 números matriz B (b(2][2))
Diseño:
Interfaz de usuario
.. Problema 82 ~(QJ[EJ
A
o 1 B
o 1
orr- rr- o¡¡- ¡¡-
1rr- rr- 1¡¡- ¡¡-
e o 1
or r
1r r 1
[_ 6íé.ular J
I

Diagrama de flujo
( Inicio }
1
i , j : Entero
!
a(11 111 . Entero
.
b[1] [1] . Entero
.
e [1] [1] : Entero
1
Leer a[OJ [OJ,a[OJ [1],
a[l) [OJ,a[l] [1],
b[OJ [O] , b[O) [1] ,
b[l] [O] , b[l) [11
1
i· o
i<-1 F
i· i+l
V
j . o
F
j<• 1
)• j +1
!V
c[i] [j). a[il [j]+b[il [j]
tv
!
AEscnbir : /
c[OJ [OJ,c[O) [1)
c[l) [OJ,c[1) [1)
!
Fin
Algoritmo
Pseudocódigo
Inicio
//Variables
i , j : Entero
//Arreglos (Matriz )
a[1] [1] Entero
b[1] [1] Entero
c[1] [11 Entero
//Entrada
Lee r a [ O1 [ O], a [O1 [ 11 ,
a[11 [O],a[1 ) [1) ,
b [O ) [0) , b[O) [1 ],
b[1) [0] , b[1) [1)
//Proceso
Para i -0 Hasta 1 Inc 1
c[i] [j]-a[i1 [j]+b[i) [j)
Fin Para
Fin Para
1/Salida
Escribir c[O) [0], c[O) (1),
c[1] [0] , c[1) [1)
Fin

Codificación:
' Variabl es
Di m i As I n teger
Di m j As I n teger
' Arreglos
Dim a (1 , 1 ) As Integer
Dim b( 1 , 1 ) As Intege r
Dim c (1 , 1 ) As Integer
' Ent r ada (Matri z)
a (O, 0 ) - Va1(Me . t x ta00 . Tex t )
a (O, 1) - Va1(Me . t x ta01 . Tex t )
a (1 , 0 ) - Val(Me . t x ta10 . Tex t )
a (1 , 1) - Val(Me . t x ta11 . Text )
b (O, 0 ) - Val(Me . t x t bOO . Tex t )
b (0, 1) - Val (Me . t x t b01 . Te x t )
b (1 , 0 ) - Val(Me . t x t b1 0 . Te x t )
b (1, 1) - Val (Me . t x t b11 . Tex t )
' Proceso
For i = O To 1
For j = O To 1
c (i , j l = a (i , j i+ b (i , j l
Nex t
Nex t
' Salida
M
e . t x tcOO . Text = e (O, 0 )
Me. t x tc01 . Text = e (O, 1 )
M
e . t x tc10 . Text = e <1 , 0 )
M
e . t x tc l 1 . Text = e (1 , 1)
•............................................................................................................................................................................................................ •
Problema n.o 83
Enunciado: Ingrese 6 números en una matriz de 3x2, y obtenga el número mayor ingresado.
sistema devuelva el número mayor.
Entrada Salida
• 6 números (n(3)[2]) • Mayor (m)

Diseño:
Interfaz de usuario
'" Problem" 83 lr](Q)[g)
N
Diagrama de flujo
( Inicio )
!
m, i , j . Entero
.
!
n(3) (2] . Entero
.
l
o
o¡¡-
1 rs-
2¡s-
1
12 Ma¡oor ls
19 1
L~~""" JI
[1
Algoritmo
Pseudocódigo
Inicio
//Variables
m, i , j : Entero
//Arreglos (Matriz)
n[3] [2] : Entero
~ Leer n[OJ [O] , n[OJ [ 1] ,~
n[1] [0 ] , n[1] [1 ] ,
n (2] (0 ] , n (2] (1 ]
//Entrada
Leer n[O] [OJ,n[O] [1],
n[1) [0J,n[1) [1) ,
n[2) [OJ,n[2) [1)
!
m- n (O ] [0]
!
i-0
i< 2
F
i-i+l
!V
j.-o
F
j< 1
j-j+l
l V
F n[i] [j l > m..::>
T
v
m- n[i] [j ]
¡
l
/ Escribir m
/
!
( Fin )
//Proceso
m- n[O] [0)
Si n[i] [j )>m Entonces
m- n[i] [j]
Fin Si
Fin Para
Fin Para
//Salida
Escrib i r m
Fin

Codificación:
.......................................................................................................................................................................................................... ..
' Variables
Dim m As I nteger
Dim 1 As Integer
Dim j As Integer
' Arreglos
' Entrada
n (O , 0) - Val(Me . txtnOO . Text)
n (1 , 1) - Val (Me . txtn11 . Text)
n (2, 1) - Val (Me . t x t n21 . Text)
' Proceso
m = n (0 , 0)
For i = O To 2
For j = O To 1
Nex t
Next
' Salida
I f n (i , j) > m Then
m = n(i , j)
End If
Me. t x tm . Text = Str(m)
... .......................................................................................................................................................................................................... .
Enunciado: Ingrese 6 números en una matriz de 3x2, y ordene los números de cada columna.
sistema devuelva las columnas ordenadas.
Entrada Salida
• 6 números (nl3)[2]) • Cada columna ordenada (nl3ll2])
Diseño:
Interfaz de usuario
'" Problema 84 ~I:QJ[g)
N
o 1
o¡-;- ¡-;- 1
[_Or~enar JI
1 ~ ~
2 ~ ~

Diagrama de flujo
( Inicio )
l
tmp, i , j , LS : Entero
¡
n[3] [2] . Entero
.
l
1Leer n [O] [O J, n [O J [1 ),1
n[1] [OJ,n[1] [1),
n[2] [O J,n [2 ] [1]
¡
LS - 2
l
i-0
i< LS 1
F
i-i+l
¡ v
j-0
F
j< LS 1
j-j+l
l V
F
n[j ] [0]>n[j+1] [0 ]
¡ v
tmp- n[j] [O ]
n[j) [01- n[j +11 [01
n[j+11 [0 ] - tmp
F
n [jl [11>n [j+1 1 [1)
l
tmp - n [ j 1[1 1
n[j] [ 1 1- n[j +l] [1]
n [ j + 1 1 [ 1 ] - tmp
l
¡
~ Leer n[OJ [O] , n[OJ [ 1:~
n[11 [0 1, n[11 [1 1,
n [2 1 [0 1, n [2 1 [1 1
l
( Fin )
Algoritmo
Pseudocódigo
Inicio
//Variables
tmp, i , j , LS Entero
//Arreglos (Matriz)
n[3] [2] : Entero
//Entrada
Leer n[O] [O ], n[O ] [ 1],
n[1] [ O],n[ 1] [1 ],
n[2] [ O],n[ 2] [1]
//Proceso
LS - 2
Para i-0 Hasta LS- 1 Inc 1
Para j-0 Hasta LS-1 Inc 1
Si n[j] [0 ]>n[j+1 ] [0 ] Enton ces
tmp - n [ j] [O ]
n [j ] [0] - n[j+1 ] [0]
n [j +l ] [0] - tmp
Fin Si
Si n[j] [1 ]>n[ j+1 ] [1 ] Entonces
tmp - n [ j] [ 1]
n [j ] [1] - n[j+1] [1]
n [j+ l ] [1) - tmp
Fin Si
Fin Para
Fin Para
//Salida
Escribir n[O) [O],n [O ] [1],
n[1 ] [ O], n[1) [1 ],
n[2] [ O], n[2) [1]
Fin

Codificación:
' Variables
Dim tmp As Intege r
Dim i As Integer
Dim j As Integer
Dim LS As Integer
' Arreglos (Matriz )
' Entrada
n (O , 0) - Val (Me . t x t n OO . Text)
n (O , 1)
n(l , 0)
n (1 , 1)
n (2 , 0)
n (2 , 1)
' Proceso
LS = 2
- Val (Me . t x t nOl . Text)
- Val(Me . t x t n10 . Text)
- Val(Me . t xt n11 . Text)
- Val(Me . txtn20 . Text)
- Val (Me . txtn21 . Text)
For i = O To LS - 1
For j = O To LS - 1
If n ( j ' 0) > n ( j +
tmp = n ( j ' 0 )
n ( j ' 0) - n( j
n ( j + 1, 0) =
End If
If n ( j ' 1) > n ( j +
tmp - n ( j ' 1 )
n ( j ' 1 ) - n ( j
n ( j + 1, 1) -
End If
Next
Next
' Salida
Me . t xtn OO . Text = Str (n (0 , 0))
Me . t x tn01 . Text - Str (n (0 , 1))
Me. t x tn10 . Text - Str (n (1 , 0 ))
Me. t xtn11 . Text - Str (n (1 , 1))
Me . t x tn20 . Text - Str(n(2 , 0))
Me . t x tn2 1 . Text - Str(n(2 , 1))
1 , 0 ) Then
+ 1, 0)
tmp
1 , 1) Then
+ 1 ' 1 )
tmp

Problema n.o85
Enunciado: Almacene 9 números en una matriz de 3x3, y obtenga los númerosordenados.
sistema devuelva la matriz con los números ordenados.
Entrada Salida
• 9 números (n[3][3]) • 9 números ordenados (n[3][3])
Diseño:
Interfaz de usuario
,. Problema 85 ~(Q]r8)
N
o 1 2
or;--- rz- ~ I!~·~.:JI
1 ¡-¡- rs--- rs
2 ~ re-- [9

Algoritmo
Diagrama de flujo
( Inicio )
l
m, i , j . Entero
.
cp
! X • o
n[3 ] [2 ] . Ent ero
. L
!
~,,,, "'''''' · "''''''·"'''~
n[1] [OJ,n[1] [l) , n[1] [2)
n(2] [O] , n(2] [1] , n(2] [2)
!
i-0
i<-2
F
i-i+1
LV
j-0
F
r j<-2
X - 0 j-j+1
l !v
i-0 n[i) (j]· o[x]
i<-2 ., X • X + 1
i-i+l
! V
j -0 ~
.......... j< 2 •
j-j+1 !
l v 1 Escribir
o(x] - n(i) (j) n[O] (O] , n(O) (1) , n[O] (2] ,
X - X + 1 n(1(0J,n[l) (1) , n[1) [2) ,
¡ 1 n(2] (0] , n[2) [1) , n(2] [2]
!
( Fin J
LS - 8
l
i-0
., i<-LS 1 .,
i-i+l
lV
j . .o
j< LS 1
j-j+l
1V
o ( j l > o(j+l >
T
tmp ·- o[j+l]
o(j+ll - o[j)
o ( j 1 - tmp
¡
~

Pseudocódigo
Inicio
//Variables
t mp , i , j , x , LS Entero
flag : Logico
//Arreglos (Matriz y Vector)
n [3 ) [3 ) : Entero
0[9) : Entero
//Entrada
Leer n [O) [ O) , n [O) [1) , n [O ) [ 2 ) ,
n[1) [O ], n[1) [1],n[1) [2 ],
n[2) [O J,n[2] [1J,n[2] [2]
//Proceso
X - 0
o[ x] - n[i] [j]
X - X + 1
Fin Para
Fin Para
LS - 8
Para i-0 Hasta LS-1 Inc 1
Para j-0 Hasta LS-1 Inc 1
Si o [j ] > o[j +l ) Entonces
tmp - o ( j + 1)
o ( j + 1) - o(j )
o ( j ) - tmp
Fin Si
Fin Para
Fin Para
X - 0
Para j-0 Hasta 2 I nc 1
n[i] [j] - o[ x]
X - X + 1
Fin Para
F in Para
//Salida
Escri bir n[O) [OJ,n[O ) [ 1J,n[O] [2],
n[l) [O ],n[l) [l],n[l) [2 ),
n[2) [O ],n[2) [1],n[2) [2)
Fin

Codificación:
' Variables
Dim tmp As Integer
Dim ~ As I n teger
Dim j As Integer
Dim x As I n teger
Dim LS As Integer
' Arreglos (Ma t riz)
Dim o(8) As Integer
' Entrada
n (O , 0) - Val(Me . t x t nO O. Text )
n (O , 1) - Val(Me . t x t n01 . Text)
n (O , 2) - Val(Me . t x t n02 . Text )
n (1, 1) - Val(Me . t x t n11 . Text )
n (1 , 2) - Val (Me . t x t n12 . Text)
n (2 , 0) - Val (Me . t x t n2 0 . Text )
n (2 , 1) - Val (Me . t x t n2l . Text)
n (2 , 2) - Va1 (Me . txtn22 . Tex t)
' Proceso
X = 0
For i = O To 2
Next
For j = O To 2
Nex t
o(x) = n(i , j )
X = X + 1
LS = UBound (o , 1)
For i = 0 To LS - 1
For j = O To LS - 1
Next
If o ( j ) > o ( j + 1) Then
tmp = o(j + 1)
o ( j + 1) = o (j)
o(j) = t mp
End If

.. .......................................................................................................................................................................................................... ...
Nex t
X = o
For l. - o To 2
For j - o To 2
n (i, j ) - 0 ( X )
X = X + 1
Nex t
Nex t
' Salid a
M
e . t x tnOO . Text - Str (n ( 0 , 0 ))
M
e . t x tnO l . Tex t - Str (n ( 0 , 1 ))
M
e . t x tn02 . Text = Str (n ( 0 , 2 ))
M
e . t x tn l O. Text - Str (n (1 , 0 ))
M
e . t x tnl1 . Tex t - Str (n (1 , 1 ))
M
e . t x tn l2 . Tex t - Str (n (1 , 2 ))
M
e . t x tn20 . Text = Str (n ( 2 , 0 ))
M
e . t x tn2 1 . Tex t - Str (n ( 2 , 1 ))
M
e . t x tn22 . Tex t = Str (n ( 2 , 2 ))
.

Propuesto n.o 51
Enunciado: Dados 4 números, almacénelos en un vector, luego obtenga la suma y el promedio de los
valores almacenados.
Propuesto n.o52
Enunciado: Dados 4 números, almacénelos en un vector, el número mayor y menor.
Propuesto n.o53
Enunciado: Dado 6 números y almacénelo en un vector, luego obtenga cuantos números múltiplos de n
ha ingresado.
Propuesto n.o54
Enunciado: Ordene 5 números según la forma que se indique: «A» (ascendente) o «D» (descendente).
Propuesto n.o55
Enunciado: Ingrese 6 números y determine cuántos números repetidos existen.
Propuesto n.o56
Enunciado: Ingrese 6 números en una matriz de 3x2 y obtenga la suma de cada fila.
Propuesto n.o57
Enunciado: Ingrese 6 números en una matriz de 3x2 y obtenga el promedio aritmético.
Propuesto n.o58
Enunciado: En una matriz de 2x3 ingrese 6 números, múltiplique su contenido por un valor Ky obtenga la
suma de los números de la matriz.
Propuesto n.o59
Enunciado: Cree una matriz «A» de 2x2, otra «B» de 2X2, y obtenga una matriz C =A * B.
Propuesto n.o60
Enunciado: Cree una matriz de 4x3 y obtenga los números mayores de cada columna.

Cadenas de caracteres
8.11ntroducción
Inicialmente, las computadoras fueron creadas con la finalidad de resolver problemas aritméticos; sin
embargo, hoy en día el manejo de datos alfanuméricos (texto) es importante y de gran utilidad para el
procesamiento de operaciones con caracteres (cadenas). Una cadena de caracteres es una secuencia de
cero o más símbolos, que incluye letras del alfabeto, dígitos y caracteres especiales.
8.2 Juego de caracteres
Los lenguajes de programación utilizan un conjunto de caracteres paracomunicarse con lascom putadoras,
dentro de las cuales existen diferentes tipos de juego de caracteres, de los que destacan el ASCII,
UNICODE, etc.
Standard ASCII (Caracteres alfanuméricos)
33 ! 49 1 65 A 81 Q 97 a 113 q
34 .. 50 2 66 B 82 R 98 b 114 r
35 # 51 3 67 e 83 S 99 e 115 S
36 $ 52 4 68 D 84 T 100 d 116 t
37 % 53 S 69 E 85 u 101 e 117 u
38 & 54 6 70 F 86 V 102 f 118 V
39 ' 55 7 71 G 87 w 103 g 119 V
40 ( 56 8 72 H 88 X 104 h 120 X
41 ) 57 9 73 l 89 y 105 1 121 y
42 * 58 . 74 J 90 z 106 J 122 z
.
43 + 59 . 75 K 91 [ 107 k 123 (
'
44
'
60 < 76 L 92 108 1 124 1
45 - 61 - 77 M 93 l 109 111 125 }
46 62 > 78 N 94 A
110 11 126 -
.
47 1 63 ? 79 o 95 - 111 o 127 o
48 o 64 @ 80 p 96 ' 112 p

Caracteres extendidos de ASCII
128 € 144 • 160 176 o
193 '
A 209 N 225 á 241
" o '
129 145 . 161 177 + 194 A 210 226 242
• 1 a
- ó
130 146 ' 162 <t 178 2
195 A 211 227 ¡¡ 243
'
131 f 147 " 163 t 179 3 196 A 212 ó 228 a 244
132 148 " 164 ll 180 ' 197 Á 213 6 229 • 245
"
a
133 149 • 165 y 181 ~ 198 fE 214 6 230 re 246
...
134 j· 150 166 ' 182 11 199 <; 215 X 231 r; 247
- '
135 :¡: 151 - 167 § 183 . 200 E 216 0 232 '
e 248
136 ' 152 - 168
.. 184 • 201 É 217 ¡) 233 '
e 249
137 %o 153 ·n.t 169 © 185 1
202 ~ 218 ú 234 "
e 250
138 s 154 V
S 170 • 186 V 203 E 219 o 235 e 251
139 (
156 ce 171 << 187 >> 204 l 220 ü 236 '1 252
140 (E 157 • 172 .., 188 1,4 205 f 221 '
y 237 '
1 253
141 • 158 z 173 189 V2 206 í 222 ]:> 238 '1 254
142
V
z 159 y 174 ® 190
* 207 1 223 B 239 1 255
143 • 192 '
A 175 - 191 ¿ 208 D 224 a 240 o
8.3 Carácter (char)
Representa un solo valor de tipo carácter; por lo general, se representa con comillas simples.
Pseudocódigo
//Crear una variable caracter
e : Caracte r
//Asigna r un valo r
e - 'A'
ñ
'
o
'
o
'
o
o
o
.
~
'
u
'
u
'
u
ü
'
y
p
y
.............................................................................................................................................................................................................
Visual Basic
• • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • .. • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • 1 •
' Uno o má s c aracte r e s
Dim e As St ri ng
' Asig nar un valor
e = "A"
... ............................................................................................................................................................................................................

Capítulo 8: Cadenas de caracteres
8.4 Cadena de caracteres (string)
Representa un conjunto de caracteres y, por lo general, lo representamos entre comillas dobles.
Pseudocódigo
.............................' ...............................................................................................................................' ...............................................
//Crear una variable cadena
e : Cadena
//Asignar un valor
e - "ABC"
Visual Basic
' Uno o más caracteres
Dim e As String
' Asignar u n valor
e = ''ABC"
............................................................................................................................................................................................................
8.5 Operaciones con cadena
.
Para la manipulación de las cadenas, los lenguajes de programación incorporan una variedad de funciones
y/o métodos que permiten realizar operaciones con cadenas.
Las operaciones con cadenas más usadas son:
• Concatenación
• Comparación
• Cálculo de longitud
• Extracción de cadenas (subcadenas)
• Búsqueda de cadenas
• Conversiones
8.6 Concatenación
Unir varias cadenas en una sola.
Pseudocódigo
.............." ......................................................................................................................................................................................... ··.
//Un ir cadenas
e - ''ABC'' + ''XYZ ''
Visual Basic
.......................................................................................................................................................................................................... ··.
. ' Unir cade nas
e = "ABC'' & ''XYZ ''
e = ''ABC'' + ''XYZ ''

8.7 Comparación
Igualdad y desigualdad de cadenas.
Pseudocódigo
.............................' ...............................................................................................................................' ...............................................
//Igualdad (Falso)
"AAA" = "aaa"
//Desigualdad (Verdadero)
" LUISA" > " LUIS"
... .......................................................................................................................................................................................................... .
Visual Basic
' Igua ldad (Falso)
"AAA" = "aaa"
' Desigualdad (Verdadero)
"LUISA" > " LUIS"
......................, ..................................................................................................................................................................................... .
8.8 Cálculo de longitud
Obtener la cantidad de caracteres de una cadena.
Pseudocódigo
//Retorna 3
i 1 - Longitud ("aaa" )
..............................................................................................................................................................................................................
Visual Basic
............................................................................................................................................................................................................
.
' Retorna 3
1 = Len( "aaa" )
............................................................................................................................................................................................................

8.9 Extracción de cadenas (subcadenas)
Extraer una parte especifica de la cadena, por lo general cada carácter de una cadena se representa por
una posición que inicia con O
, es decir "JUAN" consta de 4 caracteres J es el primer carácter cuya posición
es O, U segundo carácter posición 1, así sucesivamente.
En Visual Basic las posiciones de los caracteres de una cadena inician con 1.
Pseudocódigo
........................................................................................................................................................................................................... ...
//Extraer e l primer caracter A
11 1 cantidad a extraer
e- I zquierda( "ABC" , 1 )
//También se usa
11 O pos i cion
11 1 cantidad a extraer
e- subcadena ("ABC" , 0 , 1)
//Extraer el último caracter C
11 1 cantidad a e xtraer
e- Derecha( "ABC", l)
//También se usa
11 2 posicion
11 1 cantidad a e xtraer
e - subcadena ("ABC'', 2 , 1)
//Extraer e l segundo caracter B
11 2 posicion
1/ 1 cantidad a e xtraer
e- Extraer( "ABC", l , l)
e- subcadena ("ABC", l , ll
.......................................................................................................................' ..................................................................................... ..
Visual Basic
.......................................................................................................................................................................................................... ··.
' ' Ext raer el prime r car acter A
e= Left( "ABC", l )
' También se usa
' 1 posicion
' 1 cantidad a e xtraer
e = Mid( "ABC", l , l)
'•· .......................................................................................................................................................................................................... .

.......................................................................................................................................................................................................... ..
' Extrae r e l últ i mo caracte r C
e= Right( "ABC", l)
' Ta mbién se us a
' 3 pos i c i on
' 1 ca ntidad a extraer
e - Mi d (" ABC", 3 , 1)
' Ext r ae r e l s egundo caracter B
' 2 posici o n
' 1 cant idad a extra e r
e = Mid ("ABC",2,1)
8.10 Búsqueda de cadenas
Buscar si una cadena se encuentra dentro de otra cadena mas grande, si fuera así la función devuelve la
posición de la cadena encontrada caso contrario retorna-l.
En Visual Basic la función que cumple la tarea de buscar retorna Osi no encuent ra la otra cadena, porque
las cadenas inician con posición l.
Pseudocódigo
//Retorna 1
p- I ndice (''ABC", "B" )
............................................................................................................................................................................................................
Visual Basic
' Reto rna 2
¡ p = InStr ("ABC '',''B")
.............." .........................................'.'"" ' ....""..."""..........""............" ......." .....""............" .....""....................." .............." ....." .......
8.11 Conversiones
Convertir números a cadena o cadena de números a números, es una tarea frecuente en los lenguajes de
programación, así como convertir a mayúscula o minúscula una cadena de caracteres u obtener el valor
ASCII de un carácter, o devolver el carácter de un código ASCII.
Pseudocódigo
.............................................................................................................................................................................................................
//Conve rtir a cadena un número, de 32 a ''32"
e - Cade na (32)
/ / Conve r t i r una cade na de números a dato numérico, de " 32" a 32
n - Valor( " 32" )
............................................................................................................................................................................................................

.. .......................................................................................................................................................................................................... ...
//Convertir a mayúscula (ABC)
e- Mayus( " abc" l
//Convertir a minúscula (abe)
e - Minus( "ABC" )
//Obtener el valor ASCII (A- 65)
e - Codigo ("A" )
//Obtener el carácter de un código ASCII (65 - A)
e- Ca racter (65)
.. ..........................................................................................................................................................................................................
Visual Basic
.
................................................................................................' ................................'.......................................................................... ...
' Convertir a cadena un número, de 32 a " 32"
e = Str(32 )
' Convertir una cadena de números a dato numérico , de " 32" a 32
n = Val( " 32" )
' Convertir a mayúscula (ABC)
e= ucase( " abc" l
' Convertir a minúscula (abe )
e = LCase( "ABC" )
' Obtener el valor ASCII (A - 65)
e = Ase ("A" )
' Obtener el carácter de un código ASCII (6 5 = A)
e = Chr (6 5)
..............................................................................................................................................................................................................

Problema n.o 86
Enunciado: Dado un nombre, obtener la cantidad de caracteres que contiene.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese una cadena de caracteres;
luego, que el sistema devuelva la cantidad de caracteres que contiene.
Entrada Salida
• Cadena de caracteres (nom) • Cantidad (can)
Diseño:
Interfaz de usuario
.. Problema 86 ~rg)~
Diagrama de flujo
Inicio
!
nom . Cadena
.
can . Cantidad
.
!
1 Leer nom
1
!
can - Longitud (nom)
!
1 Escribir
!
( Fin
Codificación:
' Variables
Dim nom As String
Dim can As In tege r
' Entrada
can 1
nom = Me . t xtnom . Text
' Proceso
can= Len(nom)
' Salida
Nombfe IRic<!rdo
Cantidad 1
7
Algoritmo
Pseudocódigo
Inicio
//Variables
nom · Cadena
can : Entero
//Entrada
Leer nom
//Proceso
can - Longitud(nom)
//Salida
Escrib i r can
Fin
Me . t xtcan . Text = Str(can)
..........................................................................................................................." ................................................................................

Enunciado: Ingrese su nombre y apellido, y obtenga su nombre y apellido en mayúscula separado por
una coma XXXXX, XXXXX.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese su nombre y apellido;
luego, que el sistema devuelva su nombre y apellido separado por una coma y en mayúscula.
Entrada Salida
• Nombre (nom)
• Apellido (ape)
Diseño:
• Nombre y apellido (nom_ape)
Interfaz de usuario
• Problema 87 ~]Q)(8]
Nombfe
IRica~do
NombfeyApellido
Apeldo
IMarcelo
!RICARDO, MARCELO
Algoritmo
( Inicio
~
nom, ape , nom_ape ' Cadena
.
l
/ Leer nom, ape/
~
nom_ape-Mayus(nom + " " + a pe)
'
l
~Escribir nom_ape~
~
( Fin
Inicio
//Variables
nom, ape ,nom_ape
//Entrada
Leer nom, ape
//Proceso
Cadena
nom_ape-Mayus (nom + ", " + ape)
//Salida
Escribir nom_ape
Fin

Codificación:
.......................................................................................................................................................................................................... ...
. ' Variables
Dim nom As String
Di m ape As String
Di m nom_ape As String
' Ent r ada
nom - Me . t x tnom . Tex t
ape = Me . txtape . Text
' Proceso
nom_ape - UCase(nom & ", " & ape)
' Salida
M
e . t x tnomape . Tex t = nom_ape
.............................................................................................................................................................................................................
Enunciado: Dado un carácter, devolver su código ASCII.
sistema devuelva el ASCII.
Entrada
• Carácter (e)
Diseño:
Diagrama de flujo
l Inicio )
¡
e . Caracter
.
a . Entero
.
¡
1 Leer e
1
¡
a - Codigo (e)
¡
Salida
• ASCII (a)
Interfaz de usuario
'" Problema 88 [g[QJ[8)
Algoritmo
Pseudocódigo
Inicio
//Variables
e Caracater
a : Entero
//Entrada
Lee r e
//Proceso
a ~ Codigo (c )
1 Escribir a
1 //Salida
Escribir a
¡
Fi n ) Fin

Codificación:
......................................' ...............................................................................................................................' .......................................
' Variabl e s
Dim e As St ri ng
Di m a As I ntege r
' E:nt r ada
e = Me . t xtc . Text
' Proceso
a= Asc (c )
' Salida
M
e . t xta . Text =a
... .......................................................................................................................................................................................................... .
Problema n.o 89
Enunciado: Al ingresar una letra, determine si es una vocal.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese una letra; luego, que el
sistema devuelva si es o no una vocal.
Entrada
• Letra (1)
Diseño:
Salida
• Respuesta (r)
Interfaz de usuario
--- - - - - - - - -
.. Problema 89 ~]Q)~
Letra le
Respuesta lES VOCAL

Diagrama de flujo
( rnicio )
!
l . Caracter
.
r . Cadena
.
!
/ Leer l
/
l
l - Mayus (l)
l_
l
V
< ' A'
F
1
r-" ES VOCAL"
l , E ' V
<
F
1
r-" ES VOCAL"
1- ' I ' V
<
F
1
r-" ES VOCAL"
l ' O'
V
<
F
1 r-"ES VOCAL"
V
< 1- ' U'
F
1
r-"ES VOCAL"
r-"NO ES VOCAL"
1 Escribir r
1
l
( Fin )
Algoritmo
Pseudocódigo
Inicio
//Variables
1 Car acter
r Cadena
//Entrada
Leer 1
/ / Proceso
1 - Mayus (1 )
Si 1=' A' Entonces
R - " ES VOCAL"
Si NoSi 1=' E' Ent onces
R - " ES VOCAL"
Si NoSi l =' I ' Ent onces
R - " ES VOCAL"
SiNoSi 1=' 0 ' Entonces
R - " ES VOCAL"
SiNoSi l =' U' Entonces
R - " ES VOCAL"
SiNo
R - " NO ES VOCAL"
Fin Si
//Salida
Esc rib i r r
Fin

Codificación:
: ................................................................................................................................., ..............................................., ..........................•
: ' Variables
: Dim 1 As String
: Dim r As String
' Entrada
1 = Me . txtl . Text
' Proceso
1 = UCase(! )
If 1 = " A" Then
r = " ES VOCAL"
! E l seif l = " E" Then
r = " ES VOCAL"
! E l seif l = " ! " Then
r = " ES VOCAL"
: Else!f 1 = "O" Then
r = " ES VOCAL"
! Elseif 1 = " U" Then
r = " ES VOCAL"
! Else
r = "NO ES VOCAL"
End If
' Salida
! Me . t x tr . Text = r
'•· ...........................................................................................................................................................................................................
Problema n.o 90
Enunciado: Dado un carácter, determine si es una letra, número o símbolo.
sistema devuelva si es letra, número o símbolo.
Entrada Salida
• Caracter (e) • Respuesta (r)
Diseño:
Interfaz de usuario
"' Problema 90 rg(Q)[8]
Car~er l:r.
Resulado !ES SIMBOLO

Algoritmo
Diagrama de flujo
(rnicio
¡
e . Caracter
.
r . Cadena
.
a . Entero
.
~
/ Leer e /
¡
a- Codigo(Mayus(c))
1
< a> 48 y a< 5
V
F
1 r- "ES NUMERO"
V
< a> 65 y a< 90
F
1 r- "ES LETRA"
r-" ES SIMBOLO"
1 Escribir r
1
¡
Fin
Codificación:
Pseudocódigo
Inicio
//Variables
e Caraeter
r Cadena
a Entero
//Entrada
Leer e
//Proceso
a- Codigo(Mayus(e))
Si a>=48 Y a<=57 Entonces
r - " ES NUMERO"
SiNoSi a>=65 Y a<=90 Entonces
r - " ES LETRA"
SiNo
r - " ES SIMBOLO"
Fin Si
//Salida
Escrib i r r
Fin
.............................................................................................................................................................................................................
' Variables
Dim e As String
Dim r As String
Dim a As Integer
' Entrada
e = Me . t xte . Text
' l?roceso
a= Asc(UCase(c))
If a >= 48 And a <= 57 Then
r = " ES NUMERO"
Elseif a >= 65 And a <= 90 Then
r = " ES LETRA"
Else
r = " ES SIMBOLO"
End If
' Salida
.............................................................................................................................................................................................................

-
Problema n.o 91
Enunciado: Se desea obtener los N primeros caracteres de un nombre.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese un nombre y una cantidad;
luego, que el sistema devuelva los primeros caracteres indicados por la cantidad.
Entrada Salida
• Nombre (n) • Respuesta (r)
• Cantidad (e)
Diseño:
Interfaz de usuario
- - - - - - - - - - - -
.. Problema 91 ~I:QJ~
Nombre IRic«do
Respuesta IRic
Algoritmo
( Inicio )
~
n , r . Cadena
.
e : Entero
¡
1 Leer n , e
1
~
1 r ·- Izquierda (n , e) 1
~
1 Escribir r 1
¡
( Fin )
Inicio
//Variables
n , r : Cadena
e : Entero
//Entrada
Leer n , e
//Proceso
r- I zquier da (n, c )
//Salida
Escribir r
Fin

Codificación:
.............................................................................................................................................................................................................
' Variables
Di m n As String
Dim e As I nteger
Di m r As String
' Ent r ada
· n = Me . t x t n . Tex t
: e - Va 1 (Me . t x te . Tex t )
' Proceso
r = Left (n , e)
' Salida
M
... .......................................................................................................................................................................................................... .
Problema n.o 92
Enunciad o: Según las siguientes especificaciones, genere un código basado en el nombre ingresado.
Especificaciones para generar el código:
¡_er carácter del código: Primer carácter del nombre.
2.0
carácter del código: Tercer carácter del nombre.
3!' carácter del código: Último carácter del nombre.
4.0
carácter del código: Cantidad de caracteres del nombre..
Análisis: Para la solución de este problema, se requiere que el usuario ingrese un nombre; luego, que el
sistema procese y obtenga el código generado.
Entrada Salida
• Nombre (n) • Código (e)
Diseño:
Interfaz de usuario
'" Problema 92 [J(g)(8]
Nombre JPeg¡¡y
I!~~·J
Cóógo J
PGYS

Diagrama de flujo
( Inicio
!
p , t , u, l , n , c . Cadena
.
~
1 Leer n
1
~
p -Izquierda(n, l)
t -Extraer(n, 2, 1)
u - Derecha(n, 1 )
1 - Cadena(Longitud (n))
e - Mayus(p + t + u + 1)
~
/ Escribir r j
~
eFin
Codificación:
Algoritmo
Inicio
Fin
Pseudocódigo
//Variables
p , t , u , l , n , c
//Entrada
Leer n
//Proceso
Cadena
p- Izquierda(n, l)
t- Extraer (n , 2, 1)
u- Derecha(n, 1)
1 - Cadena(Longitud(n))
e- Mayus(p + t +u+ 1)
//Salida
Escribir e
............................................................................................................................................................................................................
' Variables
Dim p As String
Dim t As String
Dim u As String
Dim 1 As String
Dim n As String
Dim e As String
' Entrada
n = Me . t x t n . Text
' Proceso
p - Le ft ( n, 1 )
t - Mid (n , 3 , 1)
u = Right (n , 1)
1- Str(Len(n))
e = UCase(p & t & u & 1)
' Salida
Me . t xtc . Text =e
..........' ..............................................................................................................................................................'....................................

Problema n.o 93
Enunciado: Determine cuántas veces se repite una letra en una frase dada.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese una frase y una letra;
luego, que el sistema devuelva la cantidad de veces que se repite la letra en la frase.
Entrada
• Frase (f)
• Letra (1)
Diseño:
i<
F
Salida
• Cantidad (e)
lnteñaz de usuario
- - - - - -
., Problemél 93 (g@(g)
Frase
Leúa le
C<lriidad 13
Diagrama de flujo
{ Inicio )
¡
f , l . Cadena
.
c ,i . Entero
.
1 Leer f , 1
1
¡v
i-0
Longitud(f) 1
i-i+l
1
Algoritmo
Pseudocódigo
Inicio
//Variables
f , l : Cadena
c , i : Entero
//Entrada
Leer f , l
//Proceso
Para i -0 Hasta Longitud(f) -1 Inc 1
Mayus(Extraer(n, i, l))aMayus(l
Si Mayus(Extraer(n , i , 1))=Mayus(l)
Entonces
Tv
e - e +
¡
1 Escribir
¡
( Fin
1
e
1
)
e - e + 1
Fin Si
Fin Para
//Salida
Escribir e
Fin

Codificación:
' Variables
Di m f As String
Dim 1 As Stri ng
Di m e As I n teger
Dim i As I n teger
' Entrada
f - Me . t x tf . Te x t
1 = M
e . t x tl . Text
' Pro ceso
For i = 1 To Len (f )
If UCas e (Mid (f , 1 , 1 )) - UCase( l l Th e n
e = e + 1
End If
Nex t
' Salida
M
e . t x tc . Te x t = St r( c )
... .......................................................................................................................................................................................................... .·
Enunciado: Dado una frase, devolver la frase sin espacio en blancos.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese una frase; luego, que el
sistema devuelva la frase sin espacios en blancos.
Entrada Salida
• Frase (fl) • Frase sin espacios en blanco (f2)
Diseño:
Interfaz de usuario
"' Problema 94 [J[Q)r8)
Frase
lp
aso a paso se llega a lejos
Frase sinespacios
lp
asoapasosellegaalejos

Diagrama de flujo
( Inicio
¡
fl , f2 , t . Cadena
.
i , p . Entero
.
¡
1 Leer f1
1
¡
p - o
fl - Recortar(fl}
¡v
i-0
i< Longitud (f l }-1
i-i+l
l_v
F
Extraer(fl , i , l} - " "
¡v
t - Extraer(fl , p , i-p }
p ·- i + 1
f2 - f2 + t
!
t - Ext raer(fl , p , i-p}
f2 ·- f2 + t
!
1 Escribir f2 1
!
<in )
Algoritmo
F
Pseudocódigo
Inicio
//Variables
fl , f2 , t : Cadena
i , p : Entero
//Entrada
Leer f1
//Proceso
p- o
fl - Recortar(fl)
Para i-0 Hasta Longi tud(f)-1 Inc 1
Si Extraer(f1 , i , 1) =" " Entonces
t - Extraer(f1 , p , i - p)
p - i + 1
f2 - f2 + t
Fin Si
Fin Para
t - Ex traer (f1 , p , i - p)
f2 - f2 + t
//Salida
Escribir f2
Fin

Codificación:
.·............................................................................................................................................................................................................
' Variables
Dim f1 As String
Dim f2 As String
Dim t As String
Dim i As Integer
Dim p As Integer
' Entrada
fl = Me . txtfl . Text
' Proceso
p = 1
f1 = T r im (f1)
For i = 1 To Len(fl)
If Mid (fl , ~ , 1)
t - Mid (fl , p ,
p - i + 1
f2 - f2 &
End If
Next
t = Mid(fl , p , i - p)
f2 = f2 & t
' Salida
Me . txtf2 . Text = f2
= " " Then
~ - p)
t
..............................................................................................................................................................................................................

Problema n.o 95
Enunciado: Dada una frase, devuelva la frase en forma encriptada usando el método de convertir al
siguiente caracteres del ASCII; ejemplo si el carácter es A= 65, devolverá 6=66.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese una frase; luego, que el
sistema devolverá la frase en formato encriptado.
Entrada Salida
• Frase (fl)
Diseño:
• Frase encriptada (f2)
Interfaz de usuario
"' Problema 95 ~(Q]r8]
Ftase
Ricatdo MatceloV.
ticatdodomatcelo@hotmai.com
Ftaseenctiptada

Diagrama de flujo
( Ini cio )
!
f l , f2 , c : Cadena
i . Entero
.
!
1 Leer fl 1
l
fl - Recortar(fl}
1
i-0
i<-Longitud (f1} 1
i · i+1
!v
e - Ext rae r (f l , i , 1) 1
l
F
e <> " " >
1v
e .. Caracter(Codigo(c} + 1}
f2 - f2 + e
1
1 Escribi r f2 1
1
( E'in )
Algoritmo
Pseudocódigo
Inicio
//Variables
fl , f2 , c : Cadena
i : Entero
F
//Entrada
Leer f1
//Proceso
fl - Recortar ( f1 )
Para i - 0 Hasta Longitud(f1 )-1 Inc 1
e - Ex traer ( f1 , i , 1 l
Si e <> '' " Entonces
e - Caracter(Codigo (c) + 1)
Fin Si
f 2 - f2 + e
Fin Para
//Salida
Es c rib i r f2
Fin

Codificación:
' Variables
Di m fl As String
Dim f2 As String
Di m e As St r ing
Dim i As Integer
' Entrada
f 1 = Me . t xtf1 . Tex t
' Proceso
fl = Trim(fl)
For i = 1 To Len (f1 )
e = Mid (fl , i , 1)
If e <> " " Then
e = Chr (Ase ( e ) + 1)
End If
f2 = f2 & e
Next
' Salida
M
e . t x tf2 . Tex t = f2
...........................................................................................................················................" ·······················.........................................
·

Propuesto n.o61
Enunciado: Dado el nombre de una persona, obtenga el mensaje: «Bienvenido, Sr(a) Gustavo, a su tienda
de preferencia>>.
Propuesto n.o62
Enunciado: Dado un nombre, obtenga el nombre en forma invertida; por ejemplo, «Julio» invertido es
«OiluJ>>.
Propuesto n.o63
Enunciado: Dada una frase, devuelva la frase con asteriscos en lugar de espacios en blanco.
Propuesto n.o64
Enunciado: Dada una letra, determine si está en minúscula o mayúscula.
Propuesto n.o65
Enunciado: Lea una frase y una palabra, y determine si existe o no la palabra en la frase.
Propuesto n.o66
Enunciado: Dada una palabra, determinar si es palíndromo (una palabra es palíndromo si se lee igual de
izquierda a derecha o de derecha a izquierda), por ejemplo ANA.
Propuesto n.o67
Enunciado: Dada una frase, determine cuántas palabras palíndromos ha ingresado.
Propuesto n.o68
Enunciado: Dada una frase, determine cuántas palabras se repiten.
Propuesto n.269
Enunciado:Cree el algoritmo para encriptar una frase con el valor del carácter ASCII, sumando 2 posiciones.
Propuesto n.o70
Enunciado: Cree el algoritmo para desencriptar la frase generada por el algoritmo anterior.

9.11ntroducción
SubAigoritmos
(procedimientos y funciones)
Una frase bastante usada en el mundo de la informática, para resolver problemas complejos, es: «Divide
y vencerás>>. Esta es aplicada al tema de subalgoritmos (subprogramas), y consiste en dividir un problema
grande en problemas más pequeños que se encargarán de resolver temas específicos. Los subalgoritmos
(subprogramas) se dividen en dos de tipos procedimientos (subrutinas) y funciones, que evitarán la
duplicidad de código y ayudarán a crear módulos más pequeños para un mejor mantenimiento, y permite
reutilizarlo muchas veces.
El método para diseñar la solución de un problema principal (main) en subproblemas se conoce como
diseño descendente (top-dow design), difundida por la programación modular.
Problema
Principal
1 1
SubProblema SubProblema SubProblema
El problema principal corresponde al programa o algoritmo principal, y la solución de los subproblemas
mediantes subprogramas (procedimientos y funciones), en el lenguaje algorítmico se conoce como
subalgoritmos.
El subprograma recibe datos y es invocado desde el programa principal, después de terminar el proceso
que tuvo que realizar el subprograma devuelve el resultado correspondiente al programa principal.
Programa
principal
SubPrograma

9.2 Procedimientos
Los procedimientos se caracterizan por realizar una tarea específica y no retornar un resultado; sin
embargo, sí es posible implementar que devuelva resultados por intermedio de parámetros llamados de
salida o por referencia.
Pseudocódigo
//Crear un p rocedimiento
Procedimiento Procl( E : Paraml : Entero )
<Inst r ucci ones>
Fin Proced imi e nto
// I nvoc ar el proc edimiento
Llama r Procl(lO )
... ..........................................................................................................................................................................................................
Visual Basic
' Crear un pr oced imi e nto
Prívate Sub Pr ocl (ByVal Paraml As I ntege r)
<Inst r uccio nes>
End Sub
' Invocar el procedimiento
Cal l Procl (lO )
9.3 Funciones
Son másconocidos pordevolver un valorcomo resultado de latarea realizada; los lenguajes de programación
incorporan funciones que realizan algunas tareas ya programadas, conocidas como funciones internas,
pero las funciones programadas por el usuario (programador) se conocen como externas o funciones
definidas por el usuario (FDU).
Pseudocódigo
//Crear una fu nción
Funcion Funcl (E : Paraml : Entero ) :Cadena
<Inst r ucci ones>
Retorna <Valor>
Fin Funcion
//Invocar la función
e- Fu nc 1( 10 )
.........................................................................................·····..............................................................................................................

Capítulo 9: SubAigoritmos (procedimientos y funciones)
Visual Basic
..................................................................................................················...........................................................................................
' Crear una función
Prívate Function Funcl(ByVal Paraml As I nteger) As String
<Instrucciones>
Funcl = <Valor>
End Function
' Invocar la f unción
e= Func1(10)
..............................................................................................,..........................................., ......, ...........................................................·
9.4 Paso de parámetros
M uchas veces los procedimientos y funciones requieren que le envíen una lista de valores llamados
parámetros (argumentos), para usarlos en la solución de la tarea encomendada. Los parámetros son
variables, muchas veces de entrada (reciben valores) y de salida (devuelven resultados) o ambos de
entrada/salida.
Estos parámetros también toman el nombre de parámetros por valor (ent rada) y parámetros por
referencias (salida).
9.5 Parámetros por valor (entrada)
Los valores que se envían a los parámetros son asignados como una copia de los valores originales,
desconectando el programa principal con el subprograma; es decir, si los valores de los parámetros
cambian dentro del subprograma no afecta al programa principal.
Pseudocódigo
................................................"""............" .........." ..........." ..." ......................." ....................." .............." ................" ............"".........
//Crear una f unción
Funcion Increment ar (E : N: Entero) : Entero
N- N + 1 //Modinca e l valor de N
Retorna N
Fi n Funcion
//Invocar la función
Num - 5
Res - Incrementar(Num) //El valor de Num se copia en N
Imprimir Num //su valor sigue siendo 5
Imprimir Res //su valor es 6
.. ...........................................................................................................................................................................................................

Visual Basic
' Cre ar una función
Prívate Function Incrementar (ByVa1 N As Integer ) As Integer
N = N + 1 ' Modiñca el valor de N
Incrementar - N
End Function
' Invoca r l a f unción
Num = 5
Res- Incrementar (Num) ' El valor de Num se copia e n N
Pri nt Num
Pri nt Res
' su valor s i gue s i e ndo 5
' su valor es 6
9.6 Parámetros por referencia (salida)
Se asignan las referencias de las variables (dirección de memoria de la variable) a los parámetros,
conectando el programa principal con el subprograma; es decir, si los valores de los parámetros cambian
dentro del subprograma, afecta a las variables del programa principal.
Pseudocódigo
.............................................................................................................................................................................................................
//C r ear una f unción
Funcion I ncrementar (S : N: Entero) :Entero
N- N + 1 //Modiñca el valor de N
Retorna N
Fin Funcion
// I nvocar la función
Num - 5
Res - Incrementar (Num) //El parámetro N hace referencia a Num
Imprimir Num //su valor a hora es 6
Imprimir Res //su valor es 6
............................................................................................................................................................................................................
Visual Basic
' Crear una función
Prívate Function Incrementar( ByRef N As I nteger ) As Int e ger
N = N + 1 ' Modiñca el valor de N
... ..........................................................................................................................................................................................................

Incrementar = N
End Function
' Invocar la función
Num - 5
Res - Incrementar(Num) ' El parámetro N hace referencia a Num
es 6
Print Num ' su valor ahora
Print Res ' su valor es 6
... ..........................................................................................................................................................................................................
En Visual Basic los arreglos (array) y los objetos son enviados siempre como parámetros por referencia.
Enunciado: Dados dos números enteros, hallar la suma. Cree una función para resolver el problema.
Principal
Sumar(E :Num! :Entero, E:Num2:Entero):Entero
"' Problemd 96 [J[QJ['8)
Número 1
Número 2
Suma
Diagrama de flujo
Inicio
l
nl , n2 , S . Entero
.
!
/ Leer nl , n2/
l
s ·- Sumar (nl , n2)
!
1 E:scribir S
1
!
Fin
1
568 lt CalclAar
~
j454
j 1022
Algoritmo
Pseudocódigo
Principal
Inicio
//Variables
nl , n2 , s
//Entrada
Leer nl , n2
//Proceso
Entero
s- Sumar(nl + n2)
//Salida
Escribir s
Fin

Diagrama de flujo
Sumar
( Inicio )
~
Numl , Num2 , s . Entero
.
~
~Leer Numl , Num~
~
S - Numl + Num2
~
/ Escribir
~
( Fin
Codificación Principal:
' Variables
Di m nl As Integer
Dim n2 As Integer
Dim s As Integer
' Entrada
S
/
)
nl - Val(Me . t x tnl . Text)
n2- Val(Me . t xtn2 . Text)
' Proceso
s = Sumar(nl , n2)
' Salida
Me . t x ts . Text = Str(s)
Codificación Sumar:
SubAigoritmo
Pseudocódigo
Funcion Sumar(E:Numl : Entero ,
E : Num2:Entero) : Entero
//Variables locales
s : Entero
//Proceso
s - Numl + Num2
//Salida
Retornar s
Fin Funcion
............................................................' ............................................................................................................................................. ..
Private Function Sumar(ByVal Numl As Integer ,
ByVal Num2 As Integer) As Integer
' Variables locales
Dim s As Integer
' Proceso
s = Numl + Num2
' Salida
Sumar = s
End Function
............................................................................................................................................................................................................

Enunciado: Dado dos números enteros diferentes, devolver el número mayor. Cree una función para
resolver el problema.
Mayor(E:nl:Entero, E:n2:Entero):Entero
Interfaz de usuario
., Problema 97 ~]Q)rg)
Diagrama de flujo
Principal
( Inicio
¡
nl, n2, m :Entero
!
Nlinerol
Nlinero 2
Mayor
1 Leer nl , n2 1
!
m f- M ayor(nl ,n2)
!
1 Escribir m 1
!
( Fin )
la lc~a~Jl
ls
la
Algoritmo
Pseudocódigo
Principal
Inicio
1
/Variables
nl, n2, m :Entero
1/Entrada
Leer nl, n2
//Proceso
m f- Mayor(nl,n2)
1/Salida
Escribir m
Fin

Diagrama de flujo
Mayor
Inicio
nl , n2 , m Entero
Leer nl , n2
F
m - nl
F
m - n2
Escribir m
Fin
. ' Variables
Dim nl As Integer
Dim n2 As Integer
Dim m As Integer
' Entrada
nl - Val(Me . t xtnl . Text)
' Proceso
m= Mayor(nl , n2)
' Salida
Me . txtm . Text = Str(m)
SubAigoritmo
Pseudocódigo
Funcion Mayor(E :nl:Entero,
E:n2:Entero) :Entero
//Variables locales
m : Entero
//Proceso
Si nl > n2 Entonces
m - nl
Fin Si
Si n2 > nl Entonces
m - n2
Fin Si
//Salida
Retorna m
Fin Funcion
....................................................................................................................................................................' ........................................

Codificación Mayor:
............................................................................................................................................................................................................
Private Function Mayor(ByVal nl As Integer, _
ByVal n2 As Integer) As Integer
' Variabl es locales
Dim m As Integer
' Proceso
If nl > n2 Then
m = nl
End If
I f n2 > nl Then
m - n2
End I f
' Sal ida
Mayor = m
End Function
... .......................................................................................................................................................................................................... .
Problema n.o 98
Enunciado: Determinar si un número entero es par o impar. Cree un procedimiento para resolver el
problema.
Parlmpar(E:num:Entero, S:res:Entero)
Interfaz de usuario
.. Problema 98 ~@(8]
Número j9
Redodo !IMPAR

Diagrama de flujo
Principal
{ Inici o
!
nl , n2 , m . Entero
.
l
/ Leer nl , n2/
!
m- Mayor(nl , n2)
l
1 Escribir m
1
l
{ Fin
Diagrama de flujo
Parlmpar
( Inicio )
~
num . Entero
.
res , r . Cadena
.
l
1 Leer num j
l
F
~Mod 2=
V
l l
r - " IMPAR" r - " PAR"
1 1
/ Escribir res -r /
!
( Fin )
Algoritmo
Pseudocódigo
Principal
Inicio
//Variables
n Entero
r : Cadena
//Entrada
Lee r n
//Proceso
Parimpar (n , r )
//Sal.ida
Escrib i r r
Fin
SubAigoritmo
Pseudocódigo
Proced.im.iento Parimpar(E:num:Entero,
S : res:Cadena)
//Variables locales
r : Cadena
//Proceso
Si num Mod 2 = O Entonces
r - PAR"
SiNo
r - " IMPAR"
Fin Si
//Salida
res - r
Fin Procedimiento

.....................................................'...................................................................................................................................................... ...
' Variables
Dim n As Integer
Dim r As String
' E:ntrada
' Proceso
Call Parimpar (n , r)
' Salida
M
e . t xtr . Text = r
... .......................................................................................................................................................................................................... '
Codificación Parlmpar:
........................................................................................................................................................................................................... ...
Private Sub Parimpar(ByVal num As Integer, ByRef res As String)
' Variab l es
Di m r As String
' Procesar
If num Mod 2 = O Then
r = "PAR"
El se
r = " IMPAR"
End If
' Salida
res = r
End Sub
............................................................................................................................................................................................................
Problema n.o 99
Enunciado: Dado un número, determinar cuántos dígitos tiene. Cree una función para resolver el
problema.
CantidadDigitos(E:num:Entero):Entero
Interfaz de usuario
- - - - - - - - -
" Problema 99 ~]QJ(EJ
N<mero jJ23456
Cant. digitoo Js

Diagrama de flujo
Principal
( Inici o )
L
n, e . Entero
.
¡
1 Leer n
1
L
e - CantidadDigitos(n)
¡
1 Escribir e
1
¡
( Fin )
Diagrama de flujo
CantidadDigitos
Inicio
num, e Entero
Leer num
num- num 10
C·- C+l
Escribir e
Fin
F
Algoritmo
Pseudocódigo
Principal
Inicio
//Variables
n , e : Entero
//Entrada
Leer n
//Proceso
e- CantidadDigitos ( n )
//Salida
Escribir e
Fin
SubAigoritmo
Pseudocódigo
Funcion CantidadDigitos
(E:num : Entero) :Entero
//Variables local es
e : Entero
//Proceso
Mientras n um>O
num - num 10
e - e + 1
Fin Mient r as
//Salida
Retornar e
Fin Funcion

............................................................................................................................................................................................................
.
' Variables
Dim n As Long
Dim e As Long
' Ent r ada
n = Val (Me . t xt n.Te x t )
' Proceso
e= Cant idadDigi tos (n)
' Salida
Me . t x tc . Text = Str(c)
..............................................' ...............................................................................................................................................................
Codificación CantidadDigitos:
.............................................................................................................................................................................................................
· Prívate Function CantidadDigitos(ByVal num As Long) As Long
' Variables locales
Dim e As Long
' Proceso
Do While num > O
num = n um 10
e = e + 1
Loop
' Salid a
CantidadDigitos = e
End Function
Problema n. o100
Enunciado: Crear un algoritmo para hallar el factorial de un número, el factorial es el producto de todos
los números consecutivos, desde la unidad hasta el número. Por ejemplo, factorial de 3! (se denota!) es 1
X 2 X 3 = 6. Cree una función para resolver el problema.
Factoriai(E:num:Entero):Entero
Interfaz de usuario
., Problema 100 ~[QJ~
Número j3
Factori11l js
ülcular ;
[
·--·--·-···-·-···-·,
··- -···- ·- ···-···- ··;i

Diagrama de flujo
Principal
( Inicio )
~
n, f : Entero
!
1 Leer n
1
~
f - Factorial(n)
11
~
1 Escribir f
1
!
( Fin )
Diagrama de flujo
Factorial
( Inicio )
~
num, f , i . Entero
.
!
1 Leer num
1
!
f - 1
!
i-1 F
i<-n
i-i+l
~V
f - f * i
1
!
1 Escribir f
1
!
( Fin )
Algoritmo
Principal
Inicio
Pseudocódigo
//Variables
n , f : Entero
//Entrada
Leer n
//Proceso
f- Factorial(n)
//Salida
Escribir f
Fin
Algoritmo
Pseudocódigo
Funcion Factorial(E:num:Entero) :Entero
//Variables locales
f , i : Entero
//Proceso
f - 1
Para i-1 Hasta num Inc 1
f - f * i
Fin Para
//Salida
Retornar f
Fin Funcion

.. .......................................................................................................................................................................................................... ...
; ' Variabl es
¡ Dim n As Long
~ Dim f As Long
; ' Entrada
¡ n = Val (Me . t xtn . Text )
' Proceso
f = Factorial (n)
' Salida
¡ Me . txtf.Text = Str(f)
............................................................................................................................................................................................................
Codificación Factorial:
.
,' ......................................................................................................................................................................................................... ...
~ Private Function Factorial(ByVal num As Long) As Long
' Variables locales
Di m ~ As Long
Di m f As Long
' Proceso
f = 1
For i - 1 To num
f - f * i
Next
' Salida
Factorial - f
~ End Function
'·· .......................................................................................................................................................................................................... .
Enunciado: Dados S números, obtener la suma. Cree una función para resolver el problema.
Sumar(E:num[]:Entero):Entero
Interfaz de usuario
- - - - - - - - - -
.. Problema 101 ~[QJL8J
Número 1 12 I@.~~JI
Númeto2 12
Númeto3 12
Númeto4 12
NúmeroS 12
S"'"" 110

Diagrama de flujo
Principal
( Inicio 1
!
S . Entero
.
!
n[SJ : Entero
¡
¡Leer n[O] , n[l/
n[2).n[3 ). n[4)
!
s- Surnar(n)
!
1 Escribir s
1
!
( Fin )
Diagrama de flujo
Sumar
(I nicio
!
i , S . Entero
.
!
nurn [ J . Entero
.
¡
1 Leer nurn 1
!
i· o F
i< 4
i-i+l
!v
S - S + nurn [ i )
!
1 Escribir S
1
!
Fin
Algoritmo
Principal
Ini cio
Pseudocódigo
//Vari abl es
s : Entero
/ / Arregl os (Vect or)
n[5] : Entero
/ / Entrada
Leer n[O].n[l].n[2].n[3].n[4 ]
/ / Proceso
s - Sumar (n)
//Sal ida
Escribir s
Fin
SubAigoritmo
Pseudocódigo
Funcion Sumar(E:num[] :Entero): Entero
/ /Variables local es
i, s : Entero
//Proceso
s - s + num [i ]
Fin Para
//Sal ida
Retornar s
Fin Funcion

.. ...................................................................................................................................................................'...................................... ...
' Variables
Dim s As Integer
' Arreglos (Vector)
Dim n(4) As Integer
' Entrada
n (O) - Val(Me . txtnl . Text)
n (1) = Val(Me . txtn2 . Te xt)
n (2) - Val(Me . txtn3 . Te xt)
n (3) - Val(Me . txtn4 . Text)
n (4) - Val(Me . txtn5 . Te xt)
' Proceso
s = Sumar(n)
' Salida
Codificación Sumar:
.............................................................................................................................................................................................................
· Private Function Sumar(ByRef num() As Integer) As Integer
' Variables locales
Dim s As Integer
Dim ~ As Integer
' Proceso
For ~ - O To UBound (num, 1)
s = s + num(i)
Next
' Salida
Sumar = s
End Function

Problema n.o 102
Enunciado: Ordene 4 números usando el método de ordenación por intercambio (burbuja). Cree un
procedimiento para resolver el problema.
Principal
/Leer
Ordenar (S:num(]:Entero)
Interfaz de usuario
.. Problema 102 ~(Q]r8J
N
1 1
4
N2 1
3
N
3 1
1
N4 1
7
Diagrama de flujo
( Inicio )
!
n[41 : Entero
!
n[Ol , n[ll , nl2l , nl3y/
!
Ordenar(n)
!
Ordenado
11 1
! ~~JI
13
14
17
Algoritmo
Pseudocódigo
Principal
Inicio
n[4] : Entero
//Entrada
Leer n[0) , n[l) , n[2) , n[3]
/ / Proceso
Ordenar(n )
/ Escribir n[O) , n[l) , n[2) , n[3y/
//Salida
!
Fin )
Escribir n[OJ,n(l],n[2J,n(3]
Fi n

Ordenar
Diagrama de flujo
( Inicio )
tmp, i , j , LI , LS . Entero
.
!
num [4) . Entero
.
¡
1 Leer num
1
¡
LI - o
LS - 3
i-LI F
i<-LS-1
i-i+l
¡v
j-LI
j<-LS-1
F
j-j+l
lv
F
num[j)>num[j+l)
V
tmp ·- num [ j 1
num [ j 1 ·- num [ j+11
num[j+l) - tmp
,¡.
!
/ Escribir num/
¡
( E"in )
SubAigoritmo
Pseudocódigo
Proced1miento Ordenar{S:num[) :Entero)
//Variables locales
tmp,i, j , LI ,LS : Enter o
//Proceso
LI - O
LS - 3
Para i-LI Hasta LS-1 Inc 1
Pa r a j-LI Hasta LS -1 Inc 1
Si num(j)>num[j+1) Entonces
tmp- n um(j)
num[j) - num(j+1]
num[j+l) - tmp
Fin Si
Fin Para
Fin Para
//Salida
Escribir num
Fin Procedimiento

........................................................................................................................................................................................................... ...
' Arreglos (Vector)
Dim n(3) As Integer
' Entrada
n(O) - Val(Me . txtn1 . Te xt)
' Proceso
Ordenar(nl
' Salida
Me . t xtno1 . Text- Str(n(O))
Me . t xtno2 . Text = Str(n(l))
Me . t xtno3 . Text- Str(n(2))
Me . t xtno4 . Text - Str(n(3))
Codificación Ordenar:
Private Sub Ordenar(ByRef num() As Integer)
' Variables locales
Dim tmp As Integer
Dim i As Integer
Dim J As I nteger
Dim LI As Integer
Dim LS As Integer
' Proceso
LI - LBound(num, 1)
LS - UBound(num , 1)
For ~ - LI To LS - 1
Next
End Sub
For j = LI To LS - 1
Next
If num(j) > num( j + 1) Then
tmp = num(j)
num(j) = num(j + 1)
num(j + 1) = tmp
End If

Problema n.o103
Enunciado: Ingrese 6 números en una matriz de 3x2 y obtenga el número mayor ingresado. Cree una
función para resolver el problema.
Mayor{E:num[] :Entero):Entero
Interfaz de usuario
.. Problema 103 ¡g[Q)~
N
o
o¡¡-
1 ¡s-
2
r
Diagrama de flujo
( Inicio )
!
m : Entero
¡
n[3] [2] : Entero
+
~Leer n[OJ (O J , n[OJ [1 ~~
n[l] [O],n[l] [1],
n[2] [O],n[2] [1]
¡
m- Mayor(n)
!
/ Escribir num/
!
( Fin )
1
r Ma)IOI ls
19 ll Calcula< ¡]
11
Algoritmo
Pseudocódigo
Inicio
//Variables
m : Entero
//Arreglos (Matriz)
n[3] [2] : Entero
//Entrada
Leer n[O] [OJ,n[O] [1],
n[1] [0 J,n[1 ] [1] ,
n[2] [0],n[2] [1]
//Proceso
m~ Mayor(n)
//Salida
Escribir m
Fin

Diagrama de flujo
Mayor
( Inicio
!
m, i , j . Entero
.
!
num[31 [21 . Entero
.
!
1 Leer num 1
!
m - num [O1 [O 1
!
i-0 F
i < 2
i-i+l
!V
j-0 F
j< 1
j-j+l
jv
F
num[i)[jl > m
Jv
m - num [i 1 [ j 1
!
!
j Escribir m/
!
( Fin
SubAigoritmo
Pseudocódigo
Funcion Mayor(E:num[] []:Entero) :Entero
//Variables locales
m, i, j : Entero
//Arreglos (Matriz)
n um[3) (2) : Entero
//Proceso
m - num[O) [0 )
Si num [ i) [j)>m Entonces
m- num[i) [ j)
Fin Si
Fin Para
Fin Para
//Salida
Escri bi r m
Fin Funcion

' Variables
Dim m As Integer
' Arreglos
Dim n(21 1) As Integer
' Entrada
n (0 1 0) - Val(Me . txtnOO . Text)
n (O 1 1) - Val(Me . txtn01 . Text)
n (1 1 0) - Val(Me . txtn10 . Text)
n (11 1) - Val(Me . txtn11 . Text)
n (2 1 0) = Val(Me . t x tn20 . Text)
n (2 1 1) - Val(Me . txtn21 . Text)
' Proceso
m= Mayor(n)
' Salida
Me . t xtm . Text - Str(m)
Codificación Mayor:
.
Private Function Mayor(ByRef num() As Integer) As Integer
' Variables locales
Dim m As Integer
Dim i As Integer
Dim J As Integer
' Proceso
m = num(01 0)
For i = O To 2
For j = O To 1
Next
Next
If num(i1 j) > m Then
m= num(i , j)
End If
' Salida
Mayor = m
End Function
.............................................................................................................................................................................................................

Enunciado: Dado la matriz A de 2X2, la matriz B de 2X2, obtenga la suma de dichas matriz. Cree una
función para resolver el problema.
Principal
1
Mayor{E:num[] :Entero):Entero
Interfaz de usuario
" Problema 104 ~@(8]
A
o
or
1r
e o
or
~ r
Diagrama de flujo
( Inicio
l
a [ 1) [ 11 . Entero
.
b[1) [ 11 . Entero
.
c[1) [1 ] . Entero
.
l
/Leer a(Ol [O),a(Ol [ 1),
a[l) [O),a(l) [ 1),
b[O] (OJ,b[O] (1),
b[l] (OJ,b[ l ] ( 1 1
!
e- SumaArreglos(a, b , )
!
~ Escribir :~
c(O] (OJ,c(O] ( 1 1
c [1] (O),c(1] ( 1 )
!
( Fin
1 B
o 1
r o¡¡- ¡¡-
r 1¡¡- ¡¡-
1
r
r lt....~
~JI
Algoritmo
Pseudocódigo
Principal
Inicio
//Arreglos (Matriz)
a [1] [1] Entero
b[1] [1] Entero
c[1] [1] Entero
//Entrada
Leer a [0 ) [0 ), a [0 ] [1),
a[1) [0),a[1 ) [ 1),
b [O ) [O) , b[O) [ 1) ,
b [1 ) [0) , b[l) [ 1)
//Proceso
e- SumaArreglos(a , b)
//Salida
Escribir c[O) [OJ,c [ O) [1],
c[1) [OJ,c[1] [1 )
Fin

Diagrama de flujo
SumaArreglos
Inicio )
l
i , j . Entero
.
l
ArrA [ l) [l) . Entero
.
ArrB[l) [1) . Entero
.
S(l) [1) . Entero
.
L
/ Leer ArrA, ArrB/
l
i · o F
i<-1
i - i+l
!V
j·- 0
F
j< 1
j - j +l
!V
s[i] [ j]-ArrA [ i ) [j] +ArrB [i] [j ]
l
1 Escribir s j
l
Fin )
Algoritmo
Funcion
[]:Entero,
[l
Pseudocódigo
SumaArreglos (E :ArrA[]
E:ArrB[] []:Entero) :Entero[]
//Vari abl es local es
i, j : Entero
//Arregl os (Matriz)
s [1] [1] : Entero
//Proceso
Para j - 0 Hasta 1 I n c 1
S [i] [ j ]-ArrA[i] [ j ] +ArrB [i ] [ j]
Fin Para
E'in Para
//Salida
Retor nar s
Fin Funcion
...........................................................................................................' ..'..............................................................................................
' Variables
Dim i As Integer
Dim J As Integer
' Arreglos
Dim a (1 , 1) As Integer
Dim b (1 ' 1 ) As Int eger
Dim e (1 , 1 ) As Integer
' Entrada (Matriz )
a (0 , 0) - Val (Me . t x taOO . Text)
a (0 , 1) = Val (Me . txtaOl . Text)
a (1 , 0) - Val (Me . t x talO . Text)
a (1, 1) = Val (Me . t xtall . Text)
'

............................................................................................................................................................................................................
i b(O , 0) - Val(Me . txtbOO . Text)
b(O , 1) = Val(Me . t x t bOl.Text )
b(1 , 0) - Val(Me . txtb10 . Text)
b (1 , 1) - Val (Me . t x t b11 . Text )
' Proceso
e= SumaArreglos(a, b)
' Salida
i Me . t x tcOO . Text = e (O , 0 )
j Me . t x tc01 . Text = e (O , 1)
! Me . t x tc10 . Text = e (1 , 0 )
: Me . t x tc11 . Text = e (1 , 1)
·........................................................................................................................·····...........................·····............................................... .
Codificación SumaArreglos:
.............................................................................................................' ....................................................................................'..........
¡ Private Function SumaArreglos{ByRef ArrA{) As Integer, ByRef ArrB () i
i As Integer) As Integer ()
' Variables
Dim i As Integer
Dim j As I n teger
' Arreglos
Dim s(l , 1 ) As Integer
' Proceso
For i = O To 1
Fo r j = O To 1
S ( i , j) = ArrA (i , j ) + ArrB ( i , j)
Next
Next
' Salida
SumaArreglos = s
i End Function
..............................................................................................................................................................................................................

Enunciado: Dada una frase, devolver la frase sin espacio en blanco. Cree una función para resolver el
problema.
Principal
FraseSinEspacios(E:Frase:Cadena):Cadena
Interfaz de usuario
.. Problema 105 ~(Q}(8)
Frase
r-a pa$0 • • llega lejos
Frase sin espacios
Algoritmo
Inicio
!
fl ,f2 . Cadena
.
l
1 Leer fl
1
l
Principal
Inicio
//Variables
f l , f 2 : Cadena
//Entrada
Lee r f l
f2-FraseSinEspacios (fl l //Proceso
l
1 Escribir
l
Fin
f2 1
f 2- Fr aseS inEspacios (f l)
//Salida
Escr ib i r f2
Fin

Diagrama de flujo
FrasesSinEspacios
( Inicio )
l
Frase, f , t . Cadena
.
i,p . Entero
.
l
1 Leer Frase 1
l
P • 1
Frase . Recortar(Frase)
l
i-0
i<-Longitud(Frase) -1
i-i+l
J.
Extraer(Frase, i , l) • " "
l
t • Extraer(Frase, p, i-p)
p - i + 1
f - f + t
!
t - Extraer(Frase, p, i-p)
f - f + t
!
1 Escribir f
1
!
Fin
Algoritmo
Pseudocódigo
Funcion FraseSinEspacios
(E: Frase :Cadena) :Cadena
//Variables
f2 , t : Cadena
i , p : Entero
//Proceso
p - 1
Frase - Recortar(Frase)
Para i -0 Hasta Longitud(Frase)-1
Inc 1
Si Extraer(Frase, i , 1) • " " Entonces
t- Extraer(Frase, p , i-p )
p - i + 1
f - f + t
Fin Si
Fin Para
t- Extraer(Frase, p , i-p)
f - f + t
//Salida
Retornar f
Fin Funcion

........................................................................................................................................................................................................... ...
; ' Variables
Dim fl As String
.
Dim f2 As String
' Entrada
fl = Me . txtfl . Text
' Proceso
f2 = ~raseSinEspacios(fl)
' Salida
~ Me . t xtf2 . Text = f2
.. ...........................................................................................................................................................................................................
Codificación FraseSinEspacios:
.................................................................................' ........................................................................................................................ ··.
Private Function FraseSinEspacios(ByVal Frase As String) As String
' Variables locales
Dim f F<.s String
Dim t As String
Dim ~ As Integer
Dim p As Integer
' Proceso
p - 1
Frase - Trim(~rase)
~or ~ = 1 To Len (~ rase )
If Mid(~rase , i , 1 ) - Then
t = Mid(~rase , p , i - p)
p - ~ + 1
f - f & t
End If
Next
t = Mid(Frase , p , i - p)
f - f & t
' Salida
FraseSinEspacios = f
End Function
'•· .......................................................................................................................................................................................................... .

Propuesto n.o 71
Enunciado: Hallar el área y el perímetro de un de un cuadrado, cree un procedimiento para realizar dicha
tarea.
Cuadrado (E:Lado:Real, S:Area:Real, S:Perimetro:Real)
Propuesto n.o 72
Enunciado: Dadas tres notas, obtenga el promedio de las dos notas mayores, cree un procedimiento para
realizar dicha tarea.
Promedio(E:N1:Real,E:N2:Rea1,E:N3:Rea1,5:Promedio:Real)
Propuesto n.o73
Enunciado: Dada la edad de una persona, determine en qué etapa de su vida se encuentra. Cree un
procedimiento para realizar dicha tarea.
Etapa (E Edad Entero, S:Etapa:Cadena)
Edad Etapa
Entre Oy 2 Bebé
Entre 3 y S Niño
Entre 6 y 12 Pubertad
Entre 13 y 18 Adolescente
Entre 19 y 25 Joven
Entre 26 y 60 Adulto
Mayor a 60 Anciano
Propuesto n.o74
Enunciado: Dado un número, obtener la suma de sus dígitos pares e impares.
Recuerde: Crear un procedimiento que realice la tarea.
Propuesto n.o75
Enunciado: Dado un carácter, determinar si es vocal, letra mayúscula, letra minúscula, número o símbolo.
Recuerde: Crear un procedimiento que realice la tarea.
Propuesto n.o76
Enunciado: Hallar el área de un rectángulo, cree una función para realizar dicha tarea.
AreaRectangulo(E:Base:Rea1
, E:Altura:Rea1):Real

Propuesto n.o 77
Enunciado: Un negocio tiene dos tipos de cliente: publico en general (G) y cliente afiliado (A). Acepta dos
formas de pago: al contado (C) o en plazos (P). Nos piden crear un programa que al ingresar el monto de
la compra se obtenga el monto del descuento o el monto del recargo y el total a pagar, según la siguiente
tabla:
Tipo Contado (C) descuento
Público en general (G) 15%
Cliente afiliado (A) 20%
• Cree una función para obtener el% de recargo
Recargo(E:Tipo:Carácter):Rea1
• Cree una función para obtener el % del descuento
Descuento(E:Tipo:Carácter):Rea1
Propuesto n.o78
Plazos (P) recargo
10%
5%
Enunciado: Lea un número y devuelva el número en forma inversa. Por ejemplo, si ingresa 123, su número
invertido es 321; si ingresa 12345, su número invertido 54321.
Recuerde: Crear una función que realice la tarea.
Propuesto n.o79
Enunciado: Dada una palabra, determinar si es palíndromo (una palabra es palíndromo si se lee igual de
izquierda a derecha o de derecha a izquierda), por ejemplo ANA.
Propuesto n.o80
Enunciado: Cree una matriz de A de 2x2 y otra B de 2x2, y obtenga una matriz C =A * B.

Impreso en los talleres gráficos de
EDITORIAL
MACRO®
Surquillo

00040_eMacro_Fundamentos_de_programacion_Visual_Basic.pdf

Más contenido relacionado

La actualidad más candente (20)

Similar a 00040_eMacro_Fundamentos_de_programacion_Visual_Basic.pdf (20)

Más de LeonardoCarillo (11)

Último (20)

00040_eMacro_Fundamentos_de_programacion_Visual_Basic.pdf