Unidad2 2

Carrera Profesional de Computación e Informática
2) Sentencia SELECCIÓN-CASO
Esta es una estructura de decisión múltiple, evaluará una expresión que podrá
tomar uno de los “n” valores distintos que para algunos casos puede tratarse de
rangos o valores individuales, según cumpla con uno de estos.
Esta sentencia puede ser tratada también como si fuera sentencias si anidadas,
deberá tener en cuenta que los rangos o valores se expresarán como condiciones.
Diagrama de Flujo
Rango_Valor_1
Expresión_ Rango_Valor_4
Variable
Rango_Valor_2
Rango_Valor_3
Acción 1 Acción 4
Acción 2 Acción 3
Pseudocodigo
Seleccionar Cuando (Expresión_Variable)

Sea (Rango_Valor_1)
Acción 1
Sea (Rango_Valor_2)
Acción 2
Sea (Rango_Valor_3)
Acción 3
Sea (Rango_Valor_4)
Acción 4
...
Fin Seleccionar
a) Problema #1
Un movil recorre un tramo de la carretera con Movimiento Rectilíneo
Uniforme (MRU), determinar y mostrar cual es el espacio recorrido:
Espacio = Velocidad * Tiempo
adicionalmente mostrar un mensaje que indique el consumo de gasolina según

la tabla:
Fundamentos de Programación Pag. 98

Espacio Recorrido Gasolina

0 y 30 1 galón
31 y 60 2 galones
61 y 200 3 o mas galones
Solución:
1. Análisis.
i. ¿Qué te piden que realices?
Calcular el espacio recorrido y en base a ello mostrar cuanta
gasolina se consume.
ii. ¿Qué datos necesito conocer?
La velocidad y el tiempo (según formula).
2. Planteamiento Lógico.
El desarrollo es simple, solamente deberá ingresar la velocidad y el
tiempo para calcular el espacio recorrido, en base a ello deberá observar
la tabla para que desarrolle la estructura correspondiente y muestre el
mensaje solicitado.
Ejemplo:
Si el espacio recorrido es de 25 kilómetros
El mensaje es 1 galón.
3. Definición de variables de entrada.

Se requerirán dos variables, V y T que representen a la velocidad y el
tiempo respectivamente.
4. Definición de variables de salida.
La variable de salida estará representada por E.
5. Diseño de la Solución.
- Visión Estructurada
Pseudocodigo
INICIO
Declaración de variables
V, T, E: entero
Escribir(‘Ingrese la velocidad:’)
Capturar(V)
Escribir(‘Ingrese el tiempo:’)
Capturar(T)
E=V*T
Seleccionar Cuando (E)
Sea 0 y 30
Mostrar(‘Debe usar 1 galón’)
Sea 31 y 60
Mostrar(‘Debe usar 2 galones’)
Sea 61 y 200
Mostrar(‘Debe usar 3 o más galones’)

Fin Seleccionar
Mostrar(‘El espacio recorrido fue:’, E)
FIN
Diagrama de Flujo
INICIO
V, T, E: entero
V, T
E=V*T
0 y 30 E
60 y 200
31 y 60
Debe usar 1 Debe usar 2 Debe usar 3 o

galón galones mas galones
FIN
- Visión Orientada a Objetos

Diseño del Formulario

Codificación del Programa
b) Problema #2
En un hotel los costos por día de las habitaciones son de acuerdo al tipo, según
la tabla:
Tipo Costo
A 35
B 25
C 15
Además dependiendo el número de días que se pueda quedar se le otorga un

descuento sobre el pago diario a realizar, según la tabla:
Días Dscto
1..3 2%
4..7 10%
8 a mas 25%
Realizar un algoritmo en donde se ingrese el tipo de habitación y el número de

días que se quedará en el hotel, de modo que se pueda calcular y mostrar el
total a pagar por la persona al momento de que se retire del hotel.
Total a pagar = Costo por día * número de días
Solución:
1. Análisis.
Hallar cuanto pagará el cliente por los días que estuvo en el hotel.
El tipo de habitación y el número de días que se quedará.

Para poder determinar el total a pagar por el cliente inicialmente se
deberá saber cuanto le costará la habitación para ello deberá escoger el
tipo de habitación a usar(ver cuadro 1), luego deberá de mencionar el
número de días que se quedará de modo que se le pueda otorgar un
descuento(ver cuadro 2) y posteriormente se obtenga el total a pagar.
Ejemplo:
Si el tipo es B, el costo será de 25 soles
Si se queda 5 días, le corresponde un descuento del 10%
Es decir el costo de la habitación será de:
25 – 25/100 = 22.5
El total a pagar finalmente será:
22.5 * 5 = 112.5

Se usarán dos variables de entrada: TIP para el tipo y ND para el número
de días.
El total a pagar se mostrará en la variable TP.
Pseudocodigo
INICIO
TIP: caracter
ND, PRE: entero
TP: real
Escribir(‘Ingrese el tipo de habitación a usar:’)
Capturar(TIP)
Escribir(‘Ingrese el número de días que se quedará:’)
Capturar(ND)
Seleccionar Cuando (TIP)
Sea ‘A’
PRE = 35
Sea ‘B’
PRE = 25
Sea ‘C’
PRE = 15
Fin Seleccionar
Seleccionar Cuando (ND)
Sea 1..3
DSCT = 0.02
Sea 4..7
DSCT = 0.1
Otro caso
DSCT = 0.25
Fin Seleccionar
PRE = PRE – (PRE * DSCT)
TP = PRE * ND
Mostrar(‘El total a pagar será de:’, TP)
FIN
Diagrama de Flujo
INICIO
TIP: caracter
ND, PRE: entero
TP: real
TIP, ND
A TIP
C
PRE = 35 PRE = 25 PRE = 15
1y3 ND
Otro Caso
4y7
DSCT = 0.02 DSCT = 0.1 DSCT = 0.25
PRE = PRE – (PRE * DSCT)

TP = PRE * ND
TP
FIN



III. Algoritmos de Estructura Repetitiva.

Este tipo de algoritmos se caracteriza por que entre sus instrucciones se
muestran estructuras secuenciales, estructuras selectivas y estructuras que forman
bucles, es decir un conjunto de instrucciones que se desarrollan un número
determinado de veces, dependiendo una condición o un
límite.
Las estructuras repetitivas son tres: la sentencia

PARA – HASTA, HACER – MIENTRAS, HACER –
HASTA.
Para el desarrollo de cualquiera de estas sentencias

se deberá tener en cuenta los siguientes conceptos:
- Bucle. Es denominado también lazo (Loop), es un segmento de un algoritmo o

programa, cuyas instrucciones se repiten un número determinado de veces
mientras se cumple una determinada condición o en todo caso se le ha dado un
límite de veces a ejecutar. En todo algoritmo se debe establecer cuales son las
sentencias que formaran las tareas repetitivas.
Inicio de Bucle
Instrucción 1
Instrucción 2
Instrucción N
Fin de Bucle
- Contador. Los procesos repetitivos por lo general lo utilizan, ya que necesitan

contar los sucesos o acciones internas del bucle. Una de las formas de controlar
un bucle es mediante un contador. Un contador es una variable cuyo valor se
incrementa o decrementa en una cantidad constante por cada vuelta (interacción)
que da el bucle.
Ej:
Inicio de Bucle
C=C+1
Fin de Bucle

- Acumulador. Es denominado también totalizador, es una variable cuya misión es

almacenar cantidades o valores resultantes de sumas sucesivas. Realiza la misma
función que un contador con la diferencia de que el incremento o decremento de
cada suma es variable en lugar de constante como en el caso del contador.
Inicio de Bucle
AC = AC + N
Fin de Bucle
1) Sentencia PARA – HASTA

Esta es una sentencia repetitiva, se caracteriza por tener un inicio y un fin
que serán establecidos vía programa y no tener condicionales (evaluaciones lógicas)
para la salida o ingreso al bucle; esta sentencia repetitiva es una de las mas fáciles
de aplicar.
Diagrama de Flujo
Para I
Hasta F
Acciones
Pseudocodigo
Para I = Número Hasta F

Acciones
Fin_Para
Casos de la Sentencia Desde – Hasta
Caso 1.- Cuando: INICIO < FIN

Es la forma normal de trabajo para la sentencia, el incremento será por
defecto de 1 o en todo caso podrá ser expresada por el programador.
Ej:

El valor de n asumimos como 10
Para i = 1 hasta n
Acciones
Fin_Para
Se ejecutará 10 veces
Para i = 6 hasta n step 2

Acciones
Fin_Para
Caso 2.- Cuando: INICIO > FIN

Esta vez no se tratará de un incremento sino de un decremento, de acuerdo a
la cantidad que se exprese.
Ej:
El valor de n asumimos como 2
Para i = 6 hasta n step -2

Acciones
Fin_Para
Para i = 8 hasta n step -3

Acciones
Fin_Para
a) Problema #1
Desarrollar un algoritmo que permita calcular y mostrar la suma de los n
primeros números naturales, deberá ingresar el límite de números a sumar.
S = 1 + 2 + 3 + 4 + 5 +... + n
Solución:
1. Análisis.
Calcular la suma de n números naturales.
La cantidad de números a sumar.
Este tipo de problemas se puede desarrollar aplicando la formula general
para la suma de números naturales o en todo caso haciendo uso de
acumuladores y contadores.

Se requerirán una variable que represente a la cantidad de números a

sumar(N).
La suma total estará representada por la variable AC.
Pseudocodigo
INICIO
I, N, AC: entero
Escribir(‘Ingrese la cantidad de números a sumar:’)
Capturar(N)
AC = 0
Para I = 1 hasta N
AC = AC + I
Fin_Para
Mostrar(‘El espacio recorrido fue:’, AC)
FIN
Diagrama de Flujo
INICIO
I, N, AC: entero
AC = 0
Para I=1
Hasta N
AC = AC + I
AC
FIN


Este Objeto lo
usaremos para
poder manejar
varios datos
(valores)

La codificación a partir de este tema
será directamente en el libro sin
observar el grafico contenedor de
Declaración de Variables código que maneja el Vbasic (ver
Dim i As Byte ejemplos anteriores)
Dim AC As Integer
Private Sub CmdProcesar_Click()

List1.Clear
Observará que a partir de ahora
AC = 0 todos los objetos en donde
For i = 1 To Val(Text1.Text) programaremos se les ha dado un
List1.AddItem Str(i) nombre descriptivo sobre la tarea
AC = AC + i que realiza.
Next i
Text2 = AC
End Sub
Private Sub CmdLimpiar_Click()

Text1 = 0
Text2 = 0
Text1.SetFocus
End Sub
Private Sub CmdSalir_Click()

If MsgBox("Desea salir?", vbInformation + vbYesNo, "SALIDA") = vbYes Then
End
End If
End Sub

b) Problema #2
Desarrollar un algoritmo que permita calcular y mostrar la suma de los n
primeros números en la siguiente progresión, deberá ingresar el límite de
números a sumar.
S = 2 + 4 + 6 + 8 +... + n
Solución:
1. Análisis.

Calcular la suma de n números de la progresión mostrada.

La cantidad de números a sumar.
Este tipo de problemas se puede desarrollar aplicando la formula general
para la suma de números pares o en todo caso haciendo uso de
acumuladores y contadores.

Se requerirán una variable que represente a la cantidad de números a
sumar(N).
La suma total estará representada por la variable AC.
Pseudocodigo
INICIO
I, N, AC, NUM: entero
Capturar(N)
AC = 0
NUM = 0
Para I = 1 hasta N
NUM = NUM + 2
AC = AC + NUM
Fin_Para
Mostrar(‘La suma es:’, AC)
FIN

Diagrama de Flujo
INICIO
I, N, AC, NUM: entero
AC = 0; NUM = 0
Para I=1
Hasta N
NUM = NUM + 2
AC = AC + NUM
AC
FIN


Declaración de Variables
Dim i As Byte
Dim NUM As Integer
Dim AC As Integer

List1.Clear
AC = 0
NUM = 0
For i = 1 To Val(Text1.Text)
NUM = NUM + 2
List1.AddItem Str(NUM)
AC = AC + NUM
Next i
Text2 = AC
End Sub

List1.Clear
Text1 = 0
Text2 = 0
Text1.SetFocus
End Sub

End
End If
End Sub
I
c) Problema #3
Se ingresarán 30 números (asumir que todos son positivos), determinar cuantos
fueron pares y cuantos fueron impares.
Solución:
1. Análisis.
Ingresar 30 números y mostrar cuantos fueron pares e impares.
Cada uno de los números a evaluar.
A medida que se van ingresando los números se deberán de ir evaluando
para que mediante contadores a través de la condición correspondiente
determinar cuantos eran pares y cuantos impares.
Se requiere ingresar los números, usaremos la variable N.
Las variables de salida serán 2 (para los impares y otra para los pares)
Pseudocodigo
INICIO
N, CI, CP, I: entero
CI = 0
CP = 0
Para I = 1 hasta 30
Escribir(‘Ingrese el número a evaluar:’)
Capturar(N)
SI (N mod 2 = 0) entonces
CP = CP + 1
Sino
CI = CI + 1
Fin_si
Fin_Para
Mostrar(‘El total números pares fue:’, CP)
Mostrar(‘El total números impares fue:’, CI)
FIN
Diagrama de Flujo
INICIO
I, N, CP, CI: entero
CP = 0
CI = 0
Para I=1
Hasta 30
N mod 2 = 0
CI = CI + N CP = CP + N
CP, CI
FIN

Dim i As Byte
Dim ACP As Integer
Dim ACI As Integer
Private Sub CmdGenera_Click()

List1.Clear
For i = 1 To 30
List1.AddItem Str(Round(Rnd() * 100, 0))
Next i
End Sub

List1.Clear
Text1 = 0
Text2 = 0
CmdGenera.SetFocus
End Sub

End
End If
End Sub

ACP = 0
ACI = 0
For i = 1 To 30
If (Val(List1.List(i - 1)) Mod 2 = 0) Then
ACP = ACP + Val(List1.List(i - 1))
Else
ACI = ACI + Val(List1.List(i - 1))
End If
Next i
Text1 = ACP
Text2 = ACI
End Sub
d) Problema #4
Diseñar un algoritmo que permita ingresar 100 números y que permita mostrar
al final cuantos de los números ingresados fueron positivos, cuantos fueron
negativos y cuantos fueron cero, además se deberá mostrar las suma de ellos en
cada caso.
Solución:
1. Análisis.
Hallar la suma y cuantos de los 100 números a ingresar fueron

negativos, positivos y cero.
Cada de uno de los 100 números a evaluar.

Se ingresaran los 100 números en un bucle, luego se deberán realizar las
preguntas respectivas(>0, <0 y =0) para finalmente ir contando y
acumulando los valores; deberá tener en cuenta que los ceros no se
podrán ir acumulando no tiene otro valor mas que cero pero si se puede
saber cuantos fueron.
Se requiere ingresar los números, usaremos la variable NM.
Las variables de salida son varias: SP(suma de positivos), CP(contador
de positivos); SN(suma de negativos), CN(contador de negativos) y
CC(contador de ceros).

Pseudocodigo
INICIO
SP, SN, CP, CN, CC, NM, I: entero
CN = 0
CP = 0
CC = 0
SP = 0
SN = 0
Para I = 1 hasta 100
Capturar(NM)
SI (NM > 0) entonces
CP = CP + 1
SP = SP + NM
Sino
SI (NM = 0) entonces
CC = CC + 1
Sino
CN = CN + 1
SN = SN + NM
Fin_si
Fin_si
Fin_Para
Mostrar(‘La cantidad de positivos es:’, CP)
Mostrar(‘La cantidad de ceros es:’, CC)
Mostrar(‘La cantidad de negativos es:’, CN)
Mostrar(‘La suma de positivos es:’, SP)
Mostrar(‘La suma de negativos es:’, SN)
FIN

Diagrama de Flujo
INICIO
SP, SN, CP, CN, CC, NM,I: entero
CP = 0; CC = 0;
CN = 0; SP = 0;
SN = 0
Para I=1
Hasta 30
NM
NM > 0
CP = CP + 1
N=0
SP = SP + N
CI = CI + 1 CC = CC + 1
SI = SI + N
CP, CC, CI, SP, SN
FIN

- Orientada a Objetos
Dim i As Byte
Dim CP As Integer
Dim CN As Integer
Dim CC As Integer
Dim SP As Integer
Dim SN As Integer

List1.Clear
For i = 1 To 100
If (Rnd() * 50 > i) Then
Else
List1.AddItem Str(-Round(Rnd() * 100, 0))
End If
Next i
End Sub


List1.Clear
Text1 = 0
Text2 = 0
Text3 = 0
Text4 = 0
Text5 = 0
CmdGenera.SetFocus
End Sub

End
End If
End Sub
Private Sub CmdProcesa_Click()

List1.Clear
CN = 0
CP = 0
CC = 0
SP = 0
SN = 0
For i = 1 To 30
If (Val(List1.List(i - 1)) > 0) Then
CP = CP + 1
SP = SP + Val(List1.List(i - 1))
Else
If (Val(List1.List(i - 1)) = 0) Then
CC = CC + 1
Else
CN = CN + 1
SN = SN + Val(List1.List(i - 1))
End If
End If
Next i
Text1 = CP
Text2 = CC
Text3 = CN
Text4 = SP
Text5 = SN
End Sub
e) Problema #5
Desarrolle un algoritmo que muestre los múltiplos de cada uno de los 50
números que se ingresaran por teclado.
Solución:

1. Análisis.
Mostrar los múltiplos de un número.
El número a evaluar.
Para determinar los múltiplos de un número, deberá de dividirse el
número entre todos sus antecesores positivos incluyéndose el mismo y si
la división devuelve resto igual a cero entonces se definirá como
múltiplo del número dividido. Para lograr esto se deberá utilizar dos
bucles, uno para los 50 números y otro para realizar las divisiones.
Se requiere ingresar el número, usaremos la variable N.
Los múltiplos estarán representados por la variable que controla el bucle
(J) de las divisiones.
Pseudocodigo
INICIO
I, J, N: entero
Para I = 1 hasta 50
Capturar(N)
Para J = 1 hasta N
SI (N mod J = 0) entonces
Mostrar(‘es múltiplo del número:’, J)
Fin_si
Fin_Para
Fin_Para
FIN

Diagrama de Flujo
INICIO
N, I, J: entero
Para I=1
Hasta 50
Para J=1
Hasta N
N mod J= 0
FIN
- Orientada a Objetos
MsFlexGrid1
Este Objeto lo
usaremos para poder
manejar varios datos
(valores) agrupados
en filas y columnas.

Dim i As Byte
Dim j As Byte
Dim c As Byte
Dim NUM As Byte

List1.Clear
For i = 1 To 50
Next i
End Sub

MSFlexGrid1.Rows = 1
For i = 0 To 49
MSFlexGrid1.TextMatrix(0, i) = Val(List1.List(i))
Next i
For i = 0 To 49
NUM = Val(List1.List(i))
c=0
For j = 1 To NUM
If (NUM Mod j = 0) Then
MSFlexGrid1.Rows = MSFlexGrid1.Rows + 1
c=c+1
MSFlexGrid1.TextMatrix(c, i) = j
End If
Next j
Next i
End Sub

End
End If
End Sub

List1.Clear
CmdGenera.SetFocus
End Sub

2) Sentencia HACER – MIENTRAS

Esta sentencia repetitiva evalúa una condición al inicio del bucle, si esta es
verdadera se ejecutaran una serie de acciones, las cuales seguirán realizándose hasta
que la condición se convierta en falsa, momento en el que se dejaran de evaluar las
acciones y se procederá a continuar con la siguiente línea de sentencias fuera del
bucle.
Diagrama de Flujo
F
¿?
Acciones
Pseudocodigo
Hacer Mientras (¿Condición?)

Acciones
Fin_Mientras
a) Problema #1
Desarrolle un algoritmo que permita observar la suma de los n primeros
números de la siguiente sucesión: (número impares)
S = 1 + 3 + 5 + 7 +...
Solución:
1. Análisis.
La suma de los n primeros números impares.
Cuantos números sumaré.
Primero deberemos ingresar o saber cuantos números vamos a sumar,
luego dentro del bucle se deberá realizar lo siguiente: controlar el bucle,
generar el número de manera tal que se pueda ir acumulando para
obtener la suma final.


Se requiere ingresar la cantidad de números a sumar, usaremos la
variable N.
La suma total de los números ingresados se obtendrá en la variable SN.
Pseudocodigo
INICIO
N, SN, CN, NUM: entero
CN = 0
SN = 0
NUM = -1
Capturar(N)
Hacer Mientras (CN < N)
CN = CN + 1
NUM = NUM + 2
SN = SN + NUM
Fin_Mientras
Mostrar(‘La suma de los números es:’, SN)
FIN
Diagrama de Flujo
INICIO
N, SN, CN, NUM: entero
CN = 0; SN = 0; NUM = -1
F
CN<N
V
SN
CN = CN + 1
NUM = NUM + 2
SN = SN + NUM
FIN

Dim NUM As Integer

Dim c As Byte
Dim AC As Integer
Private Sub Command1_Click()

List1.Clear
c=0
NUM = -1
AC = 0
Do While (c < Val(Text1.Text))
c=c+1
NUM = NUM + 2
List1.AddItem Str(NUM)
AC = AC + NUM
Loop
Text2 = AC
End Sub

End
End If
End Sub

List1.Clear
Text1 = 0
Text2 = 0
Text1.SetFocus
End Sub
b) Problema #2
Realizar un algoritmo que permita que permita leer los datos de 100 alumnos
(Num_Sección y Sexo), luego calcule y muestre:
Total de varones por cada sección.
Total de mujeres por cada sección.
Total general de varones.
Total general de mujeres.
Se sabe que solo existen 2 secciones: 1, 2 y 3

Para el sexo: H = varones y M = mujeres
Solución:
1. Análisis.
Calcular y mostrar una serie de totales (ver enunciado del problema).
El número de sección y el sexo del alumno.
Se deberá ingresar la sección y el sexo de cada alumno para realizar las
preguntas correspondientes e ir contando el número de alumnos por
sección teniendo en cuenta el sexo de estos.
La sección se captura en la variable SC y el sexo en la variable SX.
Para el total de varones por sección: TVS(1, 2, 3), para el total de
mujeres por sección: TMS(1, 2, 3), para el total general de varones:
TGV y para el total general de mujeres: TGM.
Pseudocodigo
INICIO
SC, TVS1, TVS2, TVS3, TMS1, TMS2, TMS3, TGV, TGM, CN: entero
SX: caracter
TVS1 = 0
TVS2 = 0
TVS3 = 0
TMS1 = 0
TMS2 = 0
TMS3 = 0
TGV = 0
TGM = 0
CN = 0

Hacer Mientras (CN < 100)

CN = CN + 1
Escribir(‘Ingrese la sección del alumno:’)
Capturar(SC)
Escribir(‘Ingrese el sexo del alumno:’)
Capturar(SX)
SI (SC = 1) entonces
SI (SX = ‘H’) entonces
TVS1 = TVS1 + 1
Sino
TMS1 = TMS1 + 1
Fin_si
Sino
SI (SC = 2) entonces
TVS2 = TVS2 + 1
Sino
TMS2 = TMS2 + 1
Fin_si
Sino
TVS3 = TVS3 + 1
Sino
TMS3 = TMS3 + 1
Fin_si
Fin_si
Fin_si
Fin_Mientras
TGV = TVS1 + TVS2 + TVS3
TGM = TMS1 + TMS2 + TMS3
Mostrar(‘El total de varones en la sección 1 es:’, TVS1)
Mostrar(‘El total de mujeres en la sección 1 es:’, TMS1)
Mostrar(‘El total general de varones es:’, TGV)
Mostrar(‘El total general de mujeres es:’, TGM)
FIN

Diagrama de Flujo
INICIO
SC, TVS1, TVS2, TVS3, TMS1, TMS2,
TMS3, TGV, TGM, CN: entero
SX: caracter
TVS1 = 0; TVS2 = 0; TVS3 = 0

TMS1 = 0; TMS2 = 0; TMS3 = 0
TGV = 0; TGM = 0; CN = 0
F
CN<100
V TGV = TVS1 + TVS2 + TVS3

CN = CN + 1
TVS1,TVS2,TVS3
TMS1,TMS2,TMS3
SC, SX TGV,TGM
FIN
SC = 1
SC = 2 SX=‘H’
TMS1 = TMS1 + 1 TVS1 = TVS1 + 1
SX=‘H’
TMS2 = TMS2 + 1 TVS2 = TVS2 + 1
SX=‘H’
TMS3 = TMS3 + 1 TVS3 = TVS3 + 1

Dim CN As Byte
Dim i As Byte
Dim TVS1 As Byte
Dim TVS2 As Byte
Dim TVS3 As Byte
Dim TMS1 As Byte
Dim TMS2 As Byte
Dim TMS3 As Byte
Dim TGV As Byte
Dim TGM As Byte

List1.Clear
List2.Clear
For i = 1 To 100
List1.AddItem Str(Round(Rnd() * 2 + 1, 0))
If (Round(Rnd() * 1 + 1, 0) = 1) Then
List2.AddItem "H"
Else
List2.AddItem "F"
End If
Next i
End Sub

TVS1 = 0: TVS2 = 0
TVS3 = 0: TMS1 = 0
TMS2 = 0: TMS3 = 0
TGV = 0: TGM = 0: CN = 0
Do While (CN < 100)
CN = CN + 1
SC = Trim(List1.List(CN - 1))
SX = Trim(List2.List(CN - 1))
If (SC = "1") Then
If (SX = "H") Then
TVS1 = TVS1 + 1
Else
TMS1 = TMS1 + 1
End If
Else
If (SC = "2") Then
If (SX = "H") Then
TVS2 = TVS2 + 1
Else
TMS2 = TMS2 + 1
End If
Else
If (SX = "H") Then
TVS3 = TVS3 + 1
Else
TMS3 = TMS3 + 1
End If
End If
End If
Loop
TGV = TVS1 + TVS2 + TVS3
Text1 = TVS1: Text2 = TVS2
Text3 = TVS3: Text4 = TMS1
Text5 = TMS2: Text6 = TMS3
Text7 = TGV: Text8 = TGM
End Sub

End
End If
End Sub

List1.Clear
List2.Clear
Text1 = 0: Text2 = 0: Text3 = 0: Text4 = 0
Text5 = 0: Text6 = 0: Text7 = 0: Text8 = 0
End Sub

c) Problema #3
La señorita Veronica tiene un problema: le han pedido que desarrolle un
algoritmo que sirva para poder calcular el ingreso total diariamente por los
pasajes que se pagan en un bus, si se sabe que el pasaje de los adultos es de 2
soles, de los universitarios es 1 sol y los niños no pagan. Se calcula que en
promedio diariamente viajan 500 personas.
Solución:
1. Análisis.
Hallar el ingreso diario por concepto de pasajes en un bus.
Los tipos de persona que suben al carro diariamente, ya que en base
a esto se sabe que pasaje cobrar.
Se deberá ingresar el tipo de pasajero que sube al bus para ir
contabilizando los pasajes.
El tipo de pasajero estará representado por la variable TP.
El total diario estará representado por la variable TD.
Pseudocodigo
INICIO
TD, I, CN: entero
TP: cadena
TD = 0
CN = 0
Hacer Mientras (CN < 500)
CN = CN + 1
Escribir(‘Ingrese el tipo de pasajero:’)
Capturar(TP)
SI (TP = ‘Adulto’) entonces
TD = TD + 2
Sino
SI (TP = ‘Universitario’) entonces
TD = TD + 1
Fin_si
Fin_si
Fin_Mientras
Mostrar(‘El total diario por concepto de pasajes es:’, TD)
FIN
Diagrama de Flujo
INICIO
TD, I, CN: entero
TP: cadena
TD = 0; CN = 0
F
CN<500
V
CN = CN + 1 TD
TP FIN
TP = ‘Adulto’
TP = ‘Universitario’
TD = TD + 2
TD = TD + 1

Dim CN As Integer
Dim TD As Integer
Dim i As Integer

List1.Clear
For i = 1 To 500
x = Round(Rnd() * 1 + 1)
If x = 1 Then
List1.AddItem "Adulto"
Else
List1.AddItem "Universitario"
End If
Next i
End Sub

CN = 0
TD = 0
Do While (CN < 500)
If List1.List(CN) = "Adulto" Then
TD = TD + 2
Else
TD = TD + 1
End If
CN = CN + 1
Loop
Text1 = TD
End Sub

End
End If
End Sub
Private Sub CmdNuevo_Click()

List1.Clear
Text1 = 0
End Sub
3) Sentencia HACER – HASTA

Esta sentencia repetitiva se caracteriza por ejecutar una serie de acciones
antes de realizar la evaluación de una expresión lógica, si esta evaluación resulta
falsa se continua con el proceso de evaluar el bucle hasta que la condición se haga
verdadera momento en el cual se continuara con el programa principal.
En esta estructura, se ingresará al bucle por lo menos una vez, no siendo

posible esto en las otras estructuras estudiadas.
Diagrama de Flujo
Acciones
F
¿?
Pseudocodigo
Hacer
Acciones
Hasta que (¿Condición?)

a) Problema #1
Desarrollar un algoritmo que permita el ingresar 20 números, luego muestre la
tabla de multiplicar (del 1 al 12) de cada uno de los números ingresados.
Solución:
1. Análisis.

Mostrar la tabla de multiplicar para cada uno de los 10 números a
ingresar.

Los números.
A medida que se ingresan cada uno de los números se deberán evaluar
para ir mostrando la tabla de multiplicar.
La variable para la captura de los números será N.
Los resultados de la tabla de multiplicar se vera en NM.
Pseudocodigo
INICIO
CN, N, NM, I: entero
CN = 0
Hacer
Capturar(N)
Para I = 1 hasta 12
NM = N * I
Mostrar(‘tabla de multiplicar:’, NM)
Fin_Para
CN = CN + 1
Hasta que (CN = 20)
FIN

Diagrama de Flujo
INICIO
CN, N, NM, I: entero
CN = 0
Para I=1
Hasta 12
NM = N * I
NM
CN = CN + 1
CN=20
F
V
FIN


Dim CN As Byte
Dim NM As Integer
Dim i As Byte

List1.Clear
CN = 0
Do
CN = CN + 1
Loop Until CN = 20
End Sub

CN = 0
Do
MSFlexGrid1.TextMatrix(0, CN) = List1.List(CN)
For i = 1 To 12
NM = Val(List1.List(CN)) * i
MSFlexGrid1.TextMatrix(i, CN) = NM
Next i
CN = CN + 1
Loop Until CN = 20
End Sub

End
End If
End Sub

List1.Clear
MSFlexGrid1.FixedRows = 1
End Sub
b) Problema #2
Desarrollar un algoritmo que permita ingresar 50 números enteros diferentes de
cero, luego muestre cuantos de estos números fueron pares y cuantos fueron
impares.
Solución:
1. Análisis.

Averiguar cuantos de los 50 números que se ingresarán fueron

pares y cuantos impares.
Los 50 números.
Inicialmente se deberá validar el ingreso de los números porque dice que
tendrán que ser enteros diferentes de cero, luego mediante una pregunta
simple ir contando cuales son pares e impares.
La variable en donde se ingresará el número es N.
Los números pares serán almacenados en NP y los impares en NI.
Pseudocodigo
INICIO
N, NP, NI, I: entero
NP = 0
NI = 0
Para I = 1 hasta 50
Hacer
Capturar(N)
Hasta que (N <> 0)
Si (N mod 2 = 0) entonces
NP = NP + 1
Sino
NI = NI + 1
Fin_Si
Fin_Para
FIN

Diagrama de Flujo
INICIO
N, NP, NI, I: entero
NP=0, NI=0
Para I=1
Hasta 50
V
N<>0
Nmod2=0
NI = NI + 1 NP = NP + 1
NP, NI
FIN


Dim i As Byte
Dim x As Byte
Dim NP As Byte
Dim NI As Byte

List1.Clear
For i = 1 To 50
Do
x = Round(Rnd() * 100, 0)
Loop Until (x <> 0)
List1.AddItem Str(x)
Next i
End Sub

NP = 0
NI = 0
For i = 1 To 50
If (List1.List(i - 1) Mod 2 = 0) Then
NP = NP + 1
Else
NI = NI + 1
End If
Next i
Text1 = NP
Text2 = NI
End Sub

End
End If
End Sub

List1.Clear
Text1 = 0
Text2 = 0
End Sub
c) Problema #3
Diseñar un algoritmo que permita ingresar 100 números positivos, luego
determinar cuantos de estos números fueron de 1, 2 y 3 cifras.
Solución:
1. Análisis.

Averiguar cuantos de los 100 números que se ingresarán fueron de 1 ,
2 y 3 cifras.

Los 100 números.
Deberá validar el ingreso de cada uno de los números, ya que estos
deben ser positivos, luego habrá que preguntar por los rangos iniciales y
finales de modo que se pueda saber cuantos fueron de 1, 2 y 3 cifras.
Ej:
Si (N >= 1) and (N <= 9) entonces................. rango de 1 a 9
La variable en donde se ingresará el número es N.
Los contadores para cada grupo son: 1C para una cifra, 2C para dos
cifras y 3C para tres cifras.

Pseudocodigo
INICIO
N, 1C, 2C, 3C, I: entero
1C = 0
2C = 0
3C = 0
Para I = 1 hasta 100
Hacer
Capturar(N)
Hasta que (N > 0)
Si (N >= 1 and N <= 9) entonces
1C = 1C + 1
Sino
2C = 2C + 1
Sino
3C = 3C + 1
Sino
Mostrar(‘No es un números de 1, 2 o 3 cifras’)
Fin_Si
Fin_Si
Fin_Si
Fin_Para
Mostrar(‘De 1 cifra:’,1C)
Mostrar(‘De 2 cifras:’,2C)
Mostrar(‘De 3 cifras:’,3C)
FIN

Diagrama de Flujo
INICIO
N, 1C, 2C, 3C, I: entero
1C=0; 2C=0; 3C=0
Para I=1
Hasta 100
V
N>0
N>=1 and
N<=9
1C = 1C + 1
N>=10 and
N<=99
2C = 2C + 1
N>=100 and
N<=999
No es un 3C = 3C + 1
números de 1, 2
o 3 cifras
1C, 2C, 3C
FIN


Dim N As Integer
Dim i As Byte
Dim C1 As Byte
Dim C2 As Byte
Dim C3 As Byte
Dim C4 As Byte
Private Sub CmdGenerar_Click()

List1.Clear
CN = 0
For i = 1 To 100
Do
N = Round(Rnd() * 10000, 0)
Loop Until (N > 0)
List1.AddItem N
Next i
End Sub

C1 = 0
C2 = 0
C3 = 0
C4 = 0

For i = 1 To 100
N = List1.List(i - 1)
If (N >= 1 And N <= 9) Then
C1 = C1 + 1
Else
If (N >= 10 And N <= 99) Then
C2 = C2 + 1
Else
If (N >= 100 And N <= 999) Then
C3 = C3 + 1
Else
C4 = C4 + 1
End If
End If
End If
Next i
Text1 = C1
Text2 = C2
Text3 = C3
Text4 = C4
End Sub

End
End If
End Sub

List1.Clear
Text1 = 0
Text2 = 0
Text3 = 0
Text4 = 0
End Sub

Unidad2 2

Cargado por

Copyright:

Formatos disponibles

También podría gustarte

Unidad2 2

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Unidad2 2

Cargado por

Copyright:

Formatos disponibles

Carrera Profesional de Computación e Informática

Seleccionar Cuando (Expresión_Variable)

Espacio = Velocidad * Tiempo

adicionalmente mostrar un mensaje que indique el consumo de gasolina según

Fundamentos de Programación Pag. 98

Espacio Recorrido Gasolina

3. Definición de variables de entrada.

Mostrar(‘Debe usar 3 o más galones’)

Debe usar 1 Debe usar 2 Debe usar 3 o

- Visión Orientada a Objetos

Fundamentos de Programación Pag. 100

Codificación del Programa

Además dependiendo el número de días que se pueda quedar se le otorga un

Realizar un algoritmo en donde se ingrese el tipo de habitación y el número de

Total a pagar = Costo por día * número de días

Fundamentos de Programación Pag. 101

3. Definición de variables de entrada.

PRE = 35 PRE = 25 PRE = 15

DSCT = 0.02 DSCT = 0.1 DSCT = 0.25

PRE = PRE – (PRE * DSCT)

Fundamentos de Programación Pag. 103

- Visión Orientada a Objetos

Codificación del Programa

Fundamentos de Programación Pag. 104

III. Algoritmos de Estructura Repetitiva.

Las estructuras repetitivas son tres: la sentencia

Para el desarrollo de cualquiera de estas sentencias

- Bucle. Es denominado también lazo (Loop), es un segmento de un algoritmo o

- Contador. Los procesos repetitivos por lo general lo utilizan, ya que necesitan

Fundamentos de Programación Pag. 105

- Acumulador. Es denominado también totalizador, es una variable cuya misión es

1) Sentencia PARA – HASTA

Para I = Número Hasta F

Casos de la Sentencia Desde – Hasta

Caso 1.- Cuando: INICIO < FIN

Fundamentos de Programación Pag. 106

El valor de n asumimos como 10

Para i = 6 hasta n step 2

Caso 2.- Cuando: INICIO > FIN

El valor de n asumimos como 2

Para i = 6 hasta n step -2

Para i = 8 hasta n step -3

3. Definición de variables de entrada.

Se requerirán una variable que represente a la cantidad de números a

Fundamentos de Programación Pag. 108

- Visión Orientada a Objetos

Codificación del Programa

Private Sub CmdProcesar_Click()

Private Sub CmdLimpiar_Click()

Private Sub CmdSalir_Click()

Fundamentos de Programación Pag. 109

i. ¿Qué te piden que realices?

ii. ¿Qué datos necesito conocer?

3. Definición de variables de entrada.

Fundamentos de Programación Pag. 110

- Visión Orientada a Objetos

Fundamentos de Programación Pag. 111

Codificación del Programa