Descargado 11 veces
![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.
lnstruccion 1 lnstruccion 1
l
lnstruccion 2 lnstruccion 2
l
lnstruccion n tnstruccion n
l
Problema n.o 1
·- - - - - - - - - -
Enunciado: Dado 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=nl+n2
Expresión algorítmica
s <- n1 + n2
Entrada
• Dos números (nl y n2)
Diseño: Interfaz de usuario
Salida
• La suma (s)
, ; C:ARCHIV-1XINOXS-1.J(.;~ I¡]EJ](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-34-2048.jpg)
![Algoritmos con java
Codificación:
import java . util . Scanner;
public class Problema02 {
}
public stati c void main(Stri ng[] args) {
//Variables
}
int nl , n2 , c , r ;
//Entrada
Scanner teclado= new Scanner (System . in ) ;
System . out . pr i nt( "Numero 1 : " ) ;
nl = teclado . nex tint() ;
System . out . pri nt ("Numero 2 : " ) ;
n2 = teclado . nextint() ;
//Proceso
e = n l 1 n2 ;
r = n l % n2 ;
//Salida
System . out . pr i ntln( "" ) ;
System . out . pri ntln( "Coci ente : " +e ) ;
System . out . println( " Residuo : " + r) ;
Problema n.o3
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 respectívo para hallar el IGV y el precio de venta. Para
esto use la siguiente expresión:
Expresión algorítmica
igv +- w * 0.19
pv <- w + igv
Entrada
• Valor de venta (vv)
Salida
• EIIGV (igv)
• El precio de venta (pv)](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-37-2048.jpg)
![Capítulo 2: Estructura secuencial
Diseño: Interfaz de usuario
'' C:ARCHIV- 1XINOXS-1JCR}J IIr:l f:l
Diagrama de flujo
Inicio
l
vv , igv , pv . Real
.
!
1 Leer vv 1
!
igv - vv * o.19
pv - vv + igv
!
/ Escribir igv , pv/
!
Fin
Codificación:
Algoritmo
Pseudocódigo
Inicio
//Variables
vv, igv , pv
//Entrada
Leer vv
//Proceso
Real
i gv- vv * 0 . 19
pv - vv + igv
//Salida
Escribir igv , pv
Fin
............'............................................................................................................................................................................................. ··.
import java . util . Scanner;
public class Problema03 {
)
public static void main(String(] args) {
//Variables
1
float vv , igv , pv;
//Entrada
Scanner teclado ; new Scanner(System . in ) ;
System . out . print( "Valor de venta : " ) ;
vv ; teclado . nextFloat() ;
//Proceso
igv ; V * Q. l9F;
pv ; vv + igv;
//Salida
System . out . println( " " ) ;
System . out . pr i ntln( " IGV : " + i gv) ;
System . out . println( " Precio de Venta : " + pv ) ;
·............................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-38-2048.jpg)
![Capítulo 2: Estructura secuencial
Codificación:
import java . util . Scanner;
public class Problema04 {
)
public stati c void main(Stri ng[] args) {
//Variables
)
short a , n ;
int p ;
//Entrada
Scanne r teclado= new Scanner(System . i n) ;
System . out . print( "a : ");
a = tecl ado . nextShort() ;
System . out . print ("n : ");
n = tecl ado . nextShort() ;
//Proceso
p = (int ) Math . pow ((double) a , (double) n) ;
//Salida
System . out . println( "" l ;
System . out . pri ntln( " Potencia : " + p ) ;
.............................................................................................................................................................................................................
Enunciado: Hallar la radicación de !l[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 obtienga la radicación «r>>.
Expresión matemática
1
r = !l[a = a~
Expresión algorítmica
r+- a A (1/n)
Entrada
• Dos números enteros (a, n)
Salida
• La radicación (r)](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-40-2048.jpg)
![Algoritmos con java
Diseño: Interfaz de usuario
n,
" C:ARCHIV- 1XINOXS- 1J, , llr;]EJ
·"": 9?6S6?.S
n: IJ.i
Potenc in: ~
a
-
P1·e:::: ''"'J kt~y tn contillne . .. _
a
Diagrama de flujo
Inicio )
l
r . Entero corto
.
a . Entero largo
.
l
j Leer a , nj
!
r.- a"' (1/n)
l
/ Escribir rj
!
( Fin )
Algoritmo
Pseudocódigo
Inicio
//Variables
n , r : Entero corto
a : Entero largo
//Entrada
Leer a , n
//Proceso
r - a A (1/n)
//Salida
Escribir r
Fin
Codificación:
............................................................................................................................................................................................................
import java . util . Scanner;
pub1ic class ProblemaOS {
)
public static void main(String[] args) {
//Variables
)
int a ;
short n , r ;
//Entrada
Scanner teclado = new Scanner(System . in) ;
System . out . print( • a : • ) ;
a= teclado . nextint() ;
System . out . print( • n : • ) ;
n = teclado . nextShort() ;
//Pr oceso
r = (short)Math . pow((double)a, (1/(double)n)) ;
//Salida
System . out . println( "''l ;
System . out . println( " Potencia : • + r) ;
'](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-41-2048.jpg)
![Algoritmos con java
Codificación:
......................................' ...............................................................................................................................' .......................................
import java. util . Scanner;
public class Problema07 {
}
public stati c void main (Stri ng[] args ) {
//Variables
J
i nt n, s ;
//Entrada
Scanner teclado= new Scanner (System . in ) ;
System . out . pr i nt( "Numero : " ) ;
n = t eclado . nex t int() ;
//Proceso
s = (n * (n + 1)) 1 2 ;
1/Salida
System . out . print ln("'') ;
System . out . pr i ntln( " Suma : " + s ) ;
Problema n.o 8
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.
Expresión matemática
M = {1 + r"lo)'.C
Expresión algorítmica
m <- ({1 + r1100) A t) * e](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-45-2048.jpg)
![}
)
Algoritmos con java
System . out . p rint ("Tasa de i nt eres : ");
r = t e clado . ne xtFloat () ;
System . out . p ri nt ("Ti empo : '' ) ;
t = t eclado . ne xtFl oat () ;
// Proceso
m - (.tloat )(Math . pow((double )(l + r 1 100), (doub le ) t )) *e;
i - m - e ;
1/Salida
System . out . p ri nt l n ("" ) ;
System . out . println ("I nteres : " + i) ;
System . out . println ("Monto : " + m) ;
... .......................................................................................................................................................................................................... .
Problema n.o 9
Enunciado:Crear un programa para encontrar el área de un círculo, use la 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 aritmética
Expresión algoritmica
A.- 3.14159 • r A 2
Entrada
• Radio (r)
Diseño:
A= n.r2
Salida
• Área (a).
Interfaz de usuario
" - C:ARCHIV-1XINOXS-1U.;~ I~EJ
R<,dio: ~ a
-
Jh·e<': ?B.!.,]<;/'/~,
P1•e:::~ <tny key to continue . .. _
a](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-47-2048.jpg)
![Diagrama de flujo
( Inicio )
!
PI - 3 . 14159 . Real
.
!
r , a : Real
~
/ Leer r
/
l
a - PI * r A 2
!
/ Escribir a
/
!
( Fin )
Capítulo 2: Estructura secuencial
Algoritmo
Pseudocódigo
Inicio
//Constantes
PI = 3 . 14159 · Real
//Variables
r , a : Real
//Entrada
Leer r
//Proceso
a - PI * r A 2
//Salida
Escrib i r a
Fin
Codificadón:
import java . util . Scanner;
public class Problema09 {
)
public static void main(String[] args) {
//Constantes
)
ñ nal float PI- 3 . 14159F;
//Variables
float a , r ;
//Entrada
Scanner teclado = new Scanner (System . in) ;
System . out . pri nt( "Radio : " ) ;
r = teclado . nextFloat () ;
//Proceso
a= (float) (PI* (Math . pow (( double)r , 2 . 0))) ;
1/Salida
System . out . println( "'' ) ;
System . out . println( "Area : " +a) ;
. .................'.........................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-48-2048.jpg)
![Algoritmos con java
Problema n.o 10
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 las horas, minutos y segundos restantes.
Entrada Salida
• Tiempo en segundos (t ) • Horas (h)
Diseño:
• M inutos (m)
• Segundos (s)
Interfaz de usuario
". C:ARCHIV-1XINOXS-1UC.~ 1!5Ja
lienpo en ~cgltllrlo~: 99999
HoPc:::;: 2?
Minuto:~: 1(,
.Segundo~:: ]9
Pt·t~~s .tny key to continttc ...
D
Algoritmo
Diagrama de flujo Pseudocódigo
Inicio
( Inicio )
!
//Constantes
HORA = 360 .
. Entero
HORA = 360 : Entero
MINUTO = 60 : En tero
MINUTO = 60 . Entero
.
!
t , h , m, S . Entero
.
!
/ Leer t /
!
h - t HORA
t - t Mod HORA
m - t MINUTO
S - t Mod MINUTO
!
/Escribir h , m, s/
!
( Fin )
//Variables
t , h , m, s · Entero
//Entrada
Leer t
//Proceso
h ~ t HORA
t - t Mod HORA
m - t MINUTO
S ~ t Mod MI NUTO
//Salida
Escribir h , m, s
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-49-2048.jpg)
![Diseño:
Algoritmos con java
Interfaz de usuario
'' C:ARCHIV-1XINOXS-1.JC.:~II:]J:I
Diagrama de flujo
Inicio
n l , n2 , m Ent ero
Leer nl , n2
F
m - nl
F
m - n2
Escribir m
Fin
Algoritmo
Pseudocódigo
Inicio
//Variables
nl , n2 , m : Entero
//Entrada
Leer nl , n2
//Proceso
Si nl > n2 Entonces
m - nl
Fin Si
Si n2 > nl Entonces
m - n2
Fin Si
//Salida
Escribir m
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-55-2048.jpg)
![Capítulo 3: Estructura selectiva simple y doble
Codificación:
...............................................................................................................................................................................................................
; import java . util.Scanner;
¡ public class Problemal3 {
public static void main(String[]
//Variables
args) {
}
}
char e ;
String r -
//Entrada
""·
'
Scanner teclado= new Scanner(System . in) ;
System . out . print( "Caracter : " ) ;
e= teclado . next() . charAt(OJ ;
//Proceso
r = " NO ES VOCAL";
if (C ' a ' 11 e == ' A' ) {
r = " ES VOCAL";
}
if (C ' e ' 1 1 e == ' E ' ) {
r = " ES VOCAL";
}
if (e ' i , 1 1 e == ' I ' ) {
r = " ES VOCAL";
}
if (e == ' o ' 1 1 e == ' O' l {
r = " ES VOCAL";
}
if (C ' u' 1 1 e == ' u' l {
r = " ES VOCAL";
}
1/Salida
System . out . println( "'' ) ;
System . out . println( " Resultado : " + r) ;
•.. ··········································································································································································································.](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-60-2048.jpg)
![Algoritmos con java
Problema n.º 14
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
Diseño:
- NO ES MULTIPLO
Interfaz de usuario
'' C:ARCHIV-1XINOXS-1UCREAT-1 ~~ I!I¡]EJ
Hunc ro: 1 ~
Hcoult.ulo: SI lOS Mlll.Tll'l.O DE :J Y'>
P1·1~:;:; rlllY key t(J c:cJrltirlllt~ ...
D
Algoritmo
Diagrama de flujo
( Inicio )
L
n . Entero
.
r . Cadena
.
¡
1 Leer n
1
1
n Mod 3-0 Y n Mod 5- 0
r - " SI ES MULTIPLO DE 3 Y 5" r - " NO ES
¡
j Escribir r /
L
l Fin )
e
MULTIPLO DE 3 Y 5"](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-61-2048.jpg)
![Pse udocódigo
Inicio
//Variables
n Entero
r : Cadena
//Entrada
Leer n
//Proceso
Capítulo 3: Estructura selectiva simple y doble
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
Escri bir r
Fin
Codificación:
import java . util . Scanner;
public class Problemal4 {
}
public static void main(String[] args) {
//Variables
1
int n;
String r ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . print( " Numero : '' ) ;
n = teclado . nextint() ;
//Proceso
if(n% 3 ==O && n% 5 == 0) {
r = " SI ES MULTIPLO DE 3 Y 5";
}else{
r = " NO ES MULTIPLO DE 3 Y 5";
}
1/Salida
System . out . println( "'' ) ;
System . out . println( " Resultado : " + r) ;](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-62-2048.jpg)
![Algoritmos con j ava
Problema n.2 15
Enunciado: Determinar si un número entero es par o impar.
Análisis: Para la solución de este problema se requiere que el usuario ingrese un número entero n; luego,
que el sistema verifique si el número es par o impar.
Expresión
Sin Mod 2 =O=>
PAR
SiNo
IMPAR
Entrada
• Número (n).
Diseño:
Salida
• Resultado (r)
-PAR
- IMPAR
Interfaz de usuario
" - C:ARCHIV-1XINOXS- 1UC..,] I!I¡JEJ
NLLncl'o:~ a
-
H1: ::u 1t .ulo: 111POH
Pt•e:;~; rlllY key tc1 c:or1tir1ttf! ..
a
Algoritmo
Diagrama de flujo Pseudocódigo
n
r
r - " IMPAR"
Inicio
Entero
Cade na
Le er n
E:scribir r
Fin
V
r - " PAR"
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](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-63-2048.jpg)
![Capítulo 3: Estructura selectiva simple y doble
Codificación:
........................'...................................................................................................................................................................................
· import java . uti l. Scanner;
public class ProblemalS {
}
public static void main (String[] args ) {
//Variables
}
int n ;
String r ;
//Entrada
Scanner teclado= new Scanner(System . i n) ;
System . out . pri nt( "Numero : " ) ;
n = tecl ado . nextint ();
//Proceso
i f ( n % 2 == O) {
r = "PAR";
}else(
r = " IMPAR" ;
}
1/Salida
System . out . println( "'') ;
System . out . println( " Resultado : " + r) ;
............................................................................................................................................................................................................
Problema n.2 16
Enunciado: Dados 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)
Diseño:
• Número mayor (m)
Interfaz de usuario
" . C:ARCHIV-1XINOXS- 1JCd l!lilEJ
Hun1: t•o
Nunel'o
Nun1: t•o
1 : 2?.
2: •
"
AC
] : ••••
M<lyot•: 15
J,t'f!:::: ,,flY kt:y 1.1l C;IJillilltlf: •••
B](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-64-2048.jpg)
![Capítulo 3: Estructura selectiva simple y doble
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el consumo; luego, que
elsistema verifique y calcule el monto del descuento, el impuesto y el importe a pagar.
Entrada Salida
• Consumo (e) • Monto del descuento (m_d)
Diseño:
• Impuesto (m_igv)
• Importe a pagar (p)
Interfaz de usuario
" . C:ARCHIV- 1XINOXS-1Ud JIII:JEJ
'Con ~: 11no: 1m1H 11
.Muntu th::..;cucntu: J~l1.~
1n lllW :; lo 1GU : 1] ] •n
lnpol•tc d ll•9<1': o:JJ_,,
P1•e :: :; •Hlt ke to continue . ..
a
Algoritmo
-
Diagrama de flujo
l I nicio
L
01 -0 . 1 . Real
.
02 - 0 . 2 . Real
.
03 - 0 . 3 . Real
.
I GV - 0 . 19 . Real
.
¡
e , m_ d , m_ igv, p . Rea l
.
!
1 Leer e 1
1
F
e > 200
V
F
e > lOO V
m_ d - e * 01 m_d - e * 02 m_d
¡
m_igv - (e - m_d) * I GV
P - e - m_d + m_igv
!
/ Escribir m_d, m_i gv, P
/
l Fin
·- e * 03](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-74-2048.jpg)
![Capítulo 3: Estructura selectiva simple y doble
Codificación:
.............................................................................................................................................................................................................
; impo rt java . uti l . Scanner ;
¡ public clas s Problema21 {
publ i c stati c void main (Stri ng []
//Variabl es
int t ;
St ri ng e ;
//Entrada
args ) {
Scanne r teclado= new Scanne r( System . i n) ;
System . out . print ("Temperatura : " ) ;
}
}
t = tecl ado . ne xtint () ;
//Proceso
if( t < 10) {
e = "FRIO";
}else{
if ( t >= 10 && t <= 20 ) {
e = " NUBLADO";
}else{
if (t >= 2 1 && t <= 30) {
e = "CALOR";
)e 1se{
e = " TROPICAL";
}
}
}
1/Salida
System . out . println ("") ;
System . out . p ri nt l n( "Clima : " + C ) ;
... .......................................................................................................................................................................................................... .·
Enunciado: Un negocio tiene dos tipos de cliente: cliente general (G) y cliente afiliado (A). 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.
Tipo
Contado (C) Plazos (P)
descuento recargo
Cliente general (G) 15 % 10%
Cliente afiliado (A) 20% 5%](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-78-2048.jpg)
![Algoritmos con java
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.
Entrada
• Monto de la compra (me)
• Tipo de cliente (te)
• Forma de pago (fp)
Diseño:
Salida
• Monto de descuento o recargo (m)
• Total a pagar (tp)
Interfaz de usuario
" C:ARCHIV-1XINOXS-1JC::~ I!I!:JEJ
Monto de conp•·~: 100
1 ipo dt: el iente: O
]:oi·na d e pago: e
DESCUENTO 2~%: 2H.H
llt.l ., )ld~l·''": RA.H
]>¡·e~~ •''l ke lo corltirlttt: •••
D
Algoritmo
a
-
Diagrama de flujo
( Inicio )
¡
DESC_ G ·- O. 15 . Real
.
DESC_A- 0 . 2 . Real
.
REC_G - 0 . 10 . Real
.
REC_ A - 0 . 05 . Real
.
¡
me , m, t p . Rea l
.
te , fp , r . Cad ena
.
¡
/Leer me , te, t¡y'
.1
F
tc="G"
V
1 1
F
fp="C"
V F
fp=" C"
V
~ ~
m-mc*REC_A m-mc*DESC_A m-mc *REC_G m-mc*DESC_G
t p-mc+m tp-mc-m t p -mc+m tp-mc-m
r - " REC . 5%" r-" DESC . 20% " r-" REC. 10%" r-" DESC . 15%"
·r
/ Leer r , m, tp /
¡
( FIN )](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-79-2048.jpg)
![Algoritmos con java
.............................................................................................................' ......................................' ........................................................
}
}
b = teclado . nextDouble (} ;
System . out . print( " c : " ) ;
e= teclado . nextDouble(} ;
//Proceso
d = Math . pow(b , 2 . 0 } - 4 . 0 * a * e ;
i f (a ! = O & & d >= O} {
xl- (-b + Math . pow(d, (1. 0 1 2 . 0))) 1 2 *a;
x 2 - (- b - Ma t h . pow (d , (l. O 1 2 . O}} } 1 2 * a ;
}else{
l
xl = O;
x2 = O;
1/Salida
System . out . println( " " };
System . out . pri ntln( " xl : " + xl} ;
System . out . pri ntln( " x2 : " + x2} ;
Problema n.2 25
Enunciado: Dado 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
• Hora (h)
• Minuto (m)
• Segundo (s)
Diseño:
Salida
• Hora (h)
• Minuto (m)
• Segundo (s)
Interfaz de usuario
,, C:ARCHIV-1XINOXS- 1U.,~ ~~EJ
Hot•.,: ]
.Minuto: ~)e¡
'St~~flttiiiO: ~.'/
Hot•.,: 4
Minuto: 1:1
Sequndo: H
Pl'e:;:; •'"' kt:' lo cont itllte . . _
a
a
-](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-85-2048.jpg)
![Algoritmos con java
Codificación:
............................................................................................................................................................................................................
.
import java . util . Scanner;
public class Problema25 {
}
public s t atic void main(S t ring[] args) {
//Vari ables
}
int h , m, s ;
//Entrada
Scanner tecl ado = new Scanner(System . i n) ;
System . out . print( " Hora : " ) ;
h = teclado . nextint() ;
System . out . print( "Minuto : " ) ;
m = teclado . nextint() ;
System . out . print( " Segundo : " ) ;
s = teclado . nextint() ;
//Proceso
S += 1 ;
if (S == 60) {
s = 0 ;
)
m += 1 ;
if(m == 60){
m = O;
h += 1 ;
)
if(h -- 24) {
h = O;
)
1/Salida
System . out . println( "" ) ;
System . out . println( " Hora : " + h) ;
System . out . println( "Minuto : " +m) ;
System . out . println( " Segundo : " + s) ;](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-87-2048.jpg)
![Capítulo 4: Estructura selectiva múltiple
Codificación:
;··¡;;;p·~·~ t....j ~~·~ :..~ú·i · ...s·~·~·~·~·e ·~ ;· ..............................................................................................................................···
¡public class Problema26 {
! public s t atic void main (String[] args) {
! //Variables
int n ;
St ring e = "";
// Entrada
Scanner teclado= new Scanner(System . in ) ;
System . out . print( " Numero : '' ) ;
n = teclado . nextint ();
//Pr oceso
. switch (n ) {
}
}
}
case 1 :
case
case
e = "VERANO";
break;
2 :
e = "OTOÑO";
break;
3 :
e = " I NVIERNO";
break;
case 4 :
e = " PRI MAVERA";
break;
1/Sa lida
System . out . pr i ntln( "'' ) ;
System . out . pr i ntln( " Estac i on : " + e) ;
.. ..........................................................................................................................................................................................................
Enunciado: Dado un número entero de un dígito (O al 9), devolver el número en letras.
.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número entero; luego,
que el sistema verifique y devuelva el número en letras.
Entrada Salida
• Número (n) • Resultado (r)
Diseño:
Interfaz de usuario
'' C:ARCHIV-1XINOXS-1U~~!S]I:J](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-94-2048.jpg)
![Algoritmos con java
Diseño:
Interfaz de usuario
e,- C:ARCHIV-1XINOXS-1U
_S:] I!IGJEJ
I.etl·<l: E 11
-
Rt! Sllltddo: ES UOCAI.
Pl't::::: .uty kt:y t. o c:onl i11111: .. __
Algoritmo
Diagrama de flujo Pseudocódigo
Inicio
1 . Caracter
.
r . Cadena
.
¡
/ Leer 1 /
l_
< l-' a ' o 1-' A'
V
F
1 r-" ES
- ' e ' o 1-' E'
V
F 1 r. " ES
1 i 1
o 1 , I , V
F 1 r-"ES
- ' o ' o 1-' 0 '
V
F
1 r .- " ES
' u ' o 1
V
, U '
F
1
r-" ES
r - " NO ES VOCAL"
1 Escribir r 1
~
Fin )
VOCAL"
VOCAL"
VOCAL"
VOCAL" 1
1
VOCAL" 1
1
Ini cio
//Variables
1 Caracter
r : Cadena
//Entrada
Leer 1
//Proceso
Si 1 = ' a ' O 1 = ' A' Entonces
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
Escrib i r r
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-99-2048.jpg)
![Capítulo 4: Estructura selectiva múltiple
Codificación:
.......................................................................................................................................................................................................... ··.
· import java . util . Scanner;
public class Problema29 {
}
public stati c void main(St ri ng[] args ) {
//Variables
l
char 1 ;
Stri ng r -
//Entrada
' ' 11 o
'
Scanner teclado= new Scanner{System . in) ;
System . out . print( "Letra : " ) ;
l = teclado . next() . charAt (O) ;
//Proceso
if(l -- ' a ' 1 1 l --
r = " ES VOCAL";
else if (1 -- ' e ' 1 1
r - " ES VOCAL";
else if (1 == 'i f
1 1
r - " ES VOCAL";
else if (1 == ' o ' 1 1
r - "ES VOCAL";
else if (l -- ' u ' 1 1
r = " ES VOCAL";
else
' A' )
1 --
l ==
l --
l --
r = " NO ES VOCAL";
//Salida
' E, )
' I , )
' O' )
' u' )
System . out . println( " '' ) ;
System . out . pr i ntln( " Resultado : " + r) ;
... ........................................................................................................'................' ................................................................................
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](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-100-2048.jpg)
![Capítulo 4: Estructura selectiva múltiple
Codificación:
.............................................................................·····...........................................................................................................................
; import java . util . Scanner;
: public c lass Problema30 {
: public static void main (String[]
: //Variables
int m;
String e =
//Entrada
11 •
'
args) (
Scanner teclado = new Scanner(System . in) ;
System . out . pr i nt( "Mes : '' ) ;
}
}
m= teclado . ne xtint() ;
//Proceso
swi tch (m) {
}
case 1 :
2 :
3 :
case
case
e = "VERANO";
break;
case 4 :
case 5 :
case 6 :
e = "OTOÑO";
break;
case 7 :
case 8 :
case 9 :
e = " INVIERNO";
break;
case 10 :
case 11:
case 12 :
e = " PRIMAVERA" ;
break;
1/Salida
System . out . println( "" ) ;
System . out . println( " Estacion : " + e) ;
............................................................................................................................................' ...............................................................
Problema n.2 31
Enunciado: Dado la nota promedio de un alumno, obtener la categoría, según la siguiente tabla.
Promedio Categoría
Entre OY S Pésimo
Entre 6 Y 10 Malo
Entre 11 Y 14 Regular
Entre 15 Y 17 Bueno
Entre 18 y 20 Excelente
.](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-102-2048.jpg)
![Capítulo 4: Estructura selectiva múltiple
Codificación:
..........................................................................................................................................................................................................- ..
import java . util . Scanner;
public class Problema31 {
)
public static void main(String[] args) {
//Variables
}
int p ;
String e -
//Entrada
11,
'
Scanner teclado= new Scanner(System . in) ;
System . out . print ("Promedio : '' ) ;
p = teclado . nextint() ;
//Proceso
if(p >= o && p <= 5) {
e= " PESIMO";
}else if(p >= 6 && p <= 10) (
e = " MALO";
}else if (p >= 11 && p <= 14) {
e = " REGULAR";
}else if(p >= 15 && p <= 17) {
e = "BUENO";
}else if(p >= 18 && p <= 20) {
e = " EXCELENTE";
}
1/Salida
System . out . print1n( "" ) ;
System . out . print1n( "Categoria : " +e) ;
'.. .................................................................................................................' .........................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-104-2048.jpg)
![Capítulo 4: Estructura selectiva múltiple
Codificación:
. ............................................' ..........................................................................................................................' .................................. ...
import java . util . Scanner;
public class Problema34 {
public static void main(String[] args) {
//Variables
}
}
char c , n;
int mp = O;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . pr i nt( " Col eg i o : ");
e = teclado . next () . charAt (O) ;
System . out . print( "Nivel : " ) ;
n = teclado . next () . charAt (Ol ;
//Proceso
if ( c-- 'N'){
if(n -- ' A' )
mp = 300 ;
else if (n == ' B' )
mp = 200;
else if (n == ' C' )
mp = 100;
}else if (e == ' P') {
}
//Salida
i f (n = = ' A' )
mp = 400;
else if (n == ' B' )
mp = 300;
else if (n == ' C' )
mp = 200;
System . out . println( "" ) ;
System . out . pri ntln( "Monto a pagar : " + mp) ;
... .......................................................................................................................................................................... ...............................
Enunciado: Dado el número del mes y el año (cuatro dígitos) de una fecha, determinar en letras qué mes
es y cuántos 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 si de 400.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese el 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) • Días (d)
• Año (a) • Mes letras (m1)](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-112-2048.jpg)
![Algoritmos con java
Codificación:
.......'.................................................................................................................................................................................................. ...
· import java . util . Scanner;
public class Problema35 {
public static void main(String[] args) {
//Variables
int m, a , d = O;
String ml = "";
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . print( " Mes : '' ) ;
m= teclado . nextint() ;
System . out . print( " Afto : " ) ;
a= teclado . nextint() ;
//Proceso
switch(m) {
case 1 :
d = 31 ;
ml = " ENERO";
break;
case 2 :
if (a % 4 == O && (a % 100 1 = O 1 1 a % 400
d - 29 ;
else
d - 28 ;
ml = " FEBRERO";
break;
case 3 :
d = 31 ;
ml = " MARZO";
break;
case 4 :
d = 30 ;
ml = " ABRIL";
break;
case 5 :
d = 31 ;
ml = " MAYO";
break;
case 6 :
d = 30 ;
ml = " JUNIO";
break;
case 7 :
d = 31 ;
ml = " JULIO";
break;
case 8 :
d = 31 ;
ml = " AGOSTO";
break;
case 9 :
d = 30 ;
ml = " SEPTIEMBRE'';
break;
0))](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-115-2048.jpg)
![Capítulo 4: Estructura selectiva múltiple
.............................................................................................................................................................................................................
}
}
}
case 10 :
d = 31 ;
ml = "OCTUBRE";
break;
case 1 1 :
d = 30 ;
ml = " NOV I EMBRE";
break;
case 12 :
d = 31 ;
ml = " DICIEMBRE";
break;
//Salida
System . out . println( "'' ) ;
System . out . println (" Mes : " + ml) ;
System . out . println( " Dias : '' + d) ;
..............................................................................................................................................................................................................
Enunciado: Una empresa ha establecido diferentes precios para sus productos, según la calidad.
5000 4500 4000
4500 4000 3500
4000 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 el sistema verifica y determina el precio.
Entrada
• Calidad (e)
• Producto (p)
Diseño:
Salida
• Precio (precio)
Interfaz de usuario
, ; C:ARCHIV- 1XINOXS-1JL~ lliJEJ
C. 1 i tl.ul : /.
P1•od.ucto: 3
'P1•ec io: ]~~HH
I'J•t::::: •'''~ kt:~ L11 c;IJitlirll(c •••
!!!](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-116-2048.jpg)
![Algoritmos con java
Codificación:
.............................................................................................................................................................................................................
· import java. util . Scanner;
public c lass Problema37 {
}
public static void main(String[] args) (
//Variables
}
int dl , d2 , d3 ;
String p = "";
//Entrada
Scanner teclado= new Scanner(System . in) ;
System. out . print( "Dado 1 : " ) ;
dl = tec lado . nextint() ;
System . out . print( "Dado 2 : " ) ;
d2 = tec lado . nextint() ;
System . out . print( "Dado 3 : " ) ;
d3 = teclado . nextint() ;
//Proceso
if (dl == 6 && d2 6 && d 3 == 6)
p = " ORO";
else if((dl == 6 && d2 == 6)
(d2 == 6 && d3 == 6))
p = " PLATA";
11 (dl
else if(dl == 6 11 d2 == 6 11 d3 - - 6)
p = " BRONCE";
else
p = " PERDIO";
1/Salida
System . out . println( "'' ) ;
System . out . println( "Premio : " + p) ;
6 && d3 6) &&
... ............·········································································......................................................, ..............................................., ··············
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
" C:ARCHIV-1XINOXS-1U._11 1!19 E!](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-121-2048.jpg)
![Algoritmos con java
Codificación:
......................................' ...............................................................................................................................' .......................................
import java . util . Scanner;
public class Probl ema38 {
}
public static void main(String[] args) {
//Variables
)
int d , m, a , dmax = O;
String r =
//Entrada
"lf •
1
Scanner teclado= new Scanner(System . i n) ;
System . out . pr i nt( " Dia : '' ) ;
d = t eclado . nextint () ;
System . out . print( " Mes : '' ) ;
m= teclado . next int() ;
System . out . print( " Afto : '' ) ;
a= teclado . next int() ;
//Proceso
swi tch (m) {
case 1 :
case 3 :
case 5 :
case 7 :
case 8 :
case 10 :
case 12 :
dmax -
break;
case 4 :
case 6 :
case 9 :
case 11 :
dmax =
break;
case 2 :
31 ;
30 ;
if (a % 4 == O && ( ! (a % 1OO == O) 11 a % 4OO == O) l
dma x - 29;
el se
dma x - 28 ;
}
if ( (d > O && d <= dmax) && (m > O && m < 13) && a > 0 )
r = " CORRECTO";
e l se
r = " INCORRECTO";
//Salida
System . out . pri ntln( "'' ) ;
System . out . println( " Respuesta : " + r) ;
.............................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-123-2048.jpg)
![Capítulo 5: Estructura re petitiva «Mientras»
Codificación:
.. .......................................................................................................................................................................................................... ...
import java . util . Scanner;
public class Problema41 {
}
public stati c void main (Stri ng[J args) {
//Variables
)
int i , n , s; O;
//Entrada
Scanner teclado ; new Scanner(System . in );
System . out . print( "Numero : " ) ;
n; t eclado . nex tint ();
//Proceso
i ; 1 ;
while(i <; n) {
)
1/Salida
S = S + i ;
i - i + 1 ;
System . out . println( "" ) ;
System . out . println( " Suma : '' + s) ;
..............................................................................................................................................................................................................
Problema n.2 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
e' C:ARCHIV-1XINOXS-1JCR.'~ IIri]I:J](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-140-2048.jpg)
![Algoritmos con java
Diagrama de flujo
i , e , ni , nf, Entero
Leer ni , nf
i - ni + 1
C •- C+l
i ·-i +l
Fin
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
Codificación:
.............................................................................................................................................................................................................
· import java . uti1 . Scanner;
pub1ic c1ass Prob1ema42 {
public static void main(String[] args) {
//Variables
1
int i , ni , nf , c =O ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . print( " Num . Incial : " ) ;
ni= teclado . next!nt() ;
System . out . print( " Num . Final : " ) ;
nf = teclado . nextlnt() ;
//Proceso
i = ni + 1;
while (i < nf) {
e +=1 ;
i++ ;
)
//Salida
System . out . println( "" ) ;
System . out . println( "Cantidad : " +e) ;
..t........................................................................................................................................................................................................ .](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-141-2048.jpg)
![Algoritmos con java
Codificación:
.· ..........................................................................................................' .................................................................................................
import java . util . Scanner;
public c lass Problema47 {
}
public static void main(String[] args) {
//Variables
}
int d , m = O,n;
//Entrada
Scanner teclado = new Scanner(System . in) ;
System . out . pri nt ("Numero : " ) ;
n = tecl ado . nextint() ;
//Proceso
while (n > 0 ) {
d = n % 10 ;
if (d > m) {
m = d ;
)
n / = 10 ;
}
1/Salida
System . out . pr i nt1n( "'' ) ;
System . out . pri nt1n( " Digi to Mayor : " +m) ;
... .......................................................................................................................................................................................................... .
Enunciado: Dados dos números, diga si son amigos. 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 {n1 y n2);
luego, que el sistema verifique y devuelva si son o no números amigos.
Entrada Salida
• Números (n 1, n2)
Diseño:
• Respuesta (r)
- SON AMIGOS
- NO SON AMIGOS
Interfaz de usuario
" . C:ARCHIV- 1XINOXS- 1J.;~ 1151EJ
Hune J•o 1 : ~/.H
,Nune1•o 2: 284
Reott ltado: SON AMIGOS
I'J•t::;:; c'''V kt:v lll l:tlrttirtltc ••• _
a
a
-](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-149-2048.jpg)
![Algoritmos con java
Diseño: Interfaz de usuario
" C:ARCHIV- 1XINOXS-1JCREA... 1!15JI:J
Diagrama de flujo
Inicio
n , d , e , r Entero
Leer n , d
n - n - d
e - e + 1
r - n
Escribir e , r
Fin
F
Algoritmo
Pseudocódigo
Inic.io
//Variables
n , d , e , r · Entero
//Entrada
Leer n , d
//Proceso
Mientras n >= d
n - n - d
e - e + 1
Fin Mientras
r - n
//Sal.ida
Escribir e , r
Fin
Codificación:
............................................................................................................................................................................................................
' import j ava . util. Scanner;
public class Problema51 {
public static void main(String[] args) {
//Variabl es
}
}
int n , d , c = O, r ;
//Entrada
Scanner teclado • new Scanner(System . in) ;
System .out . print( " Numerador : " ) ;
n = teclado . nextlnt() ;
System .out . print( " Denominador : " ) ;
d • teclado . nextlnt( ) ;
//Proceso
while (n >= d) {
n - = d ;
e++ ;
}
r = n;
1!Salida
System .out . println( ". ) ;
System .out . print l n( "Cociente : '' +e) ;
System .out . print l n( ''Residuo : " + r ) ;
...................................................................' ......................' ........................................................................."''..' ....." ......." ....' .." " ..' ....](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-155-2048.jpg)
![Diseño:
Capítulo 5: Estructura re petitiva «Mientras»
Interfaz de usuario
e' C:ARCHIV- 1XINOXS- 1UCR:~ 1115113
Hunt~t·o: 1/.]4!) l3
Rll~;e: () -
ll""" 1t.ulo : nns..: COHili·:CTn
P1·c~~ <llY kcy to c:(Jntilltle ...
a
Diagrama de flujo
I nicio
n, b, d : Ente ro
flag : Logico
r : Cadena
Leer n, b
flag - verdadero
d - n Mod 10
n - n 10
F
Algoritmo
Pseudocódigo
Inicio
//Variables
n , b , d : Entero
flag : Logico
r : Cadena
//Entrada
Leer n , b
//Proceso
flag - Verdadero
Mientras n > O
d - n Mod 10
n - n 10
F
Si d >= b Entonces
flag - Fal so
Salir
F
flag - Falso f------+1
Sali r
flag
V
Fin Si
Fin Mientras
Si flag Entonces
r - "BASE CORRECTA"
SiNo
r - " BASE INCORRECTA"
Fin Si
r-" BASE INCORRECTA" r-" BASE CORRECTA"
//Salida
Escribir r
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-160-2048.jpg)
![Diseño:
n,
Capítulo 5: Estructura re petitiva «Mientras»
Interfaz de usuario
'' C:ARCHIV- 1XINOXS-1JCR;~., ~¡] EJ
Nttnt~t·o ll.t::t~ tl-1: t?.:-1
Corlvct•tit• d hrl::e: 2
Re:;u) t.ulo: 1111 "11 1
J•t·c~~ <~ltY kcy lo (;llrttirtttc ••• _
a
Algoritmo
a
-
Diagrama de flujo Pseudocódigo
(Inicio
~
d , i , r . Ent ero
.
~
1 Leer n, b /
l
n>O
F
Tv
d - n Mod b
n - n b
i - i * 10 + d
l
i >O F
Jv
d - i Mod 10
i ·- i 10
r - r * 10 + d
~
j Escribir r /
¡
( Fin
Inicio
//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
E'in Mientras
Mientras i > O
d - i Mod 10
i - i 10
r = r * 10 + d
E'in Mientras
//Salida
Escribir r
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-162-2048.jpg)
![Diagrama de flujo
Inicio
l
i , n, S o
Entero
o
l
1 Leer n
1
l
i-1
i< n
i - i +l
lV
S - S + i
J
1 Escribir S
1
l
( Fin
F
Capítulo 6: Estructura re petitiva «Para»
Algoritmo
Pseudocódigo
Ini cio
//Variables
i , n , s : Entero
//Entrada
Leer n
//Proceso
Para i-1 Hasta n Inc 1
S - S + i
Fin Para
//Salida
Escribir s
Fin
Codificación:
...........................................................................................................................................' .............................................................. ...
o import java outil.Scanner ;
public class Problema56 {
)
public static void main(String[] args) {
//Variables
l
int i , n , s = O;
//Entrada
Scanner teclado = new Scanner(System oi n) ;
System oout oprint( " Nume r o : " ) ;
n = teclado onextint() ;
//Proceso
for (i = 1 ; i<=n ; i++)
S = S + i ;
1/Salida
System oout oprintln( "'' ) ;
System oout oprintln( " Suma : '' + s) ;
..................................................................................." .............................................................................." .......................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-168-2048.jpg)
![Algoritmos con java
Problema n.2 57
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:
i ,
Interfaz de usuario
',· C:ARCHIV- 1XINOXS-1JCRE.~ I!:J1:1
Nun.
Nun.
lniciol: S
Fin.tl : 9
(;,,nti<I,HI: ]
Pt·t~~::; <llY key to (:on titlltt! ••• _
a
Algoritmo
a
-
Diagrama de flujo Pseudocódigo
( Inicio
¡
e , ni , nf . Ente ro
.
~
/Leer ni, nf/
¡
ni - ni + 1
nf - nf - 1
¡
i< nf
i -ni
F
i-i+l
¡v
e - e + 1
l
¡
1 Escribir e 1
~
( Fin
Inicio
//Variables
i, e , ni , nf
//Entrada
Leer ni , nf
//Proceso
ni - ni + 1
nf - nf - 1
Entero
Para i -n i Hasta nf I nc 1
e - e + 1
!"in Para
//Salida
Escribir e
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-169-2048.jpg)
![Capítulo 6: Estructura repetitiva «Para»
Codificación:
• o• .............................................................................................................................. o. • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • .. • • • • • • • • • • • • • • • • • • • • • • • • • • • • ••
.
impo r t java . uti l . Scanner;
public class ProblemaS? {
}
publ i c stati c void main(St ri ng[J args ) {
//Variables
l
int i , ni , nf, c - O;
//Entrada
Scanner teclado = ne w Scanner (System . i n) ;
System . out . pri nt ("Num . Inicial : " ) ;
ni= teclado . nex t!nt () ;
System . out . p ri nt ("Num . Final : " ) ;
nf = teclado . nextint ( ) ;
//Pr oceso
ni = ni + 1;
nf - nf 1 ;
for (i = ni; i<=nf; i++)
e += 1 ;
//Salida
System . out . println ("") ;
System . out . p ri nt1n ("Cantidad : " +e ) ;
.
............................................................................................................................................................................................................. .
Problema n.2 58
Enunciado: Dado un rango de númerosenteros, obtener la cantidad de números pares 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 pares que contiene el rango.
Entrada Salida
• Número inicial (ni)
• Número final (nf)
Diseño:
• Cantidad de pares (cp)
Interfaz de usuario
". C:ARCHIV-1XINOXS-1UC~ I!ilEJ
Nttn. lrt i(: i.tl: :J
Nun. Fin<ll: 1]
Crtnt . P<tPe:;: ~~
l'1·c~;~ •''•V kev t{) curtlirlttc ••• _
a
E!](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-170-2048.jpg)
![Algoritmos con java
Diagrama de flujo
(Inicio 1
¡
i , cp, ni , nf . Entero
.
!
jLeer ni , nfj
¡
ni - ni + 1
nf - nf - 1
¡
i - ni
i< nf F
i-i+1
_lV
F
i Mod 2 o
=
¡v
cp - cp + 1
!
1 Escribir cp /
¡
( Fin l
Algoritmo
Pseudocódigo
Inicio
//Variables
i , cp, ni , nf · Entero
//Entrada
Leer ni , nf
//Proceso
ni - ni + 1
n f - nf - 1
Para i-ni Hasta nf Inc 1
Si i Mod 2 = O Entonces
cp - cp + 1
Fin Si
Fin Para
//Salida
Escribir cp
Fin
Codificación:
............................................................................................................................................................................................................
· import java . ut il . Scanner;
public class Probl ema58 {
1
public static void main(String[] args) (
//Variables
}
int i ,ni, nf , cp =O ;
//Entrada
Scanner teclado= new Scanner(System . i n) ;
System . out . print (" Num . Inicial : " ) ;
ni= teclado . nextint() ;
System . out . pri nt( " Num . Final : " ) ;
nf = teclado . nextint() ;
//Proceso
n i = ni + 1 ;
n f = nf - 1 ;
f o r(i - ni ; i <= nf ; i ++) {
if (i % 2 == o )
cp += 1;
1
1/Salida
System . out . pr i ntln( " '' ) ;
System . out . println( "Cant . Pares : " + cp ) ;
... ..........................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-171-2048.jpg)
![Capítulo 6: Estructura repetitiva «Para»
Codificación:
..........................................................................................................................................................................................................··.
impo r t java . uti l . Scanner ;
public class Problema64 {
publ i c stati c void main( St ri ng[J args ) {
//Variables
.tloat n , i , s - O;
//Entrada
Scanner teclado = new Scanner(System . i n) ;
System . out . pri nt ("Numero : " ) ;
)
)
n = teclado . nextint () ;
//Proceso
for (i - 1 ; l. <= n - 1 ; i++ )
S = S + (i / (i + 1 ));
1/Salida
System . out . pri ntln ("" ) ;
System . out . println( " Suma : '' + s) ;
............................................................................................................................................................................................................
Problema n.2 65
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)
• Número final (nf)
Diseño:
• Cantidad positivos (cp)
• Cantidad negativos (en)
Interfaz de usuario
e,- C:ARCHIV-1 XINOXS-1.~ l!ri]El
Hun. lnici<l.l: -- I:J
Hun. Fine:}: 9
·Cñnt. PoS;itivo: 9
:
C.mt. Ht:~f·'t ivo: B
PPe:;:; ony key to cont inue ...
a
a
-](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-182-2048.jpg)
![Algoritmos con java
Algoritmo
Diagrama de flujo Pseudocódigo
( Inicio ¡
I nicio
¡
ni , nf, cp, en, i . Entero
. / /Variables
¡ ni , nf , cp, en, i Entero
/ Leer ni , nf/
¡
i - ni
i< nf
~-i+l
F
//Entrada
Leer n i , n f
//Proceso
F
J.V
i <> o
lv
>
Para i-ni Hasta nf Inc 1
Si i <> O Entonces
Si i<O Entonces
F
i < o
¡
cp-cp+l
1
jÉscribir cp,
¡
( Fin
Codificación:
V
¡
cn-cn+l
1
en
/
SiNo
E'in Si
E'in Si
E'i n Par a
//Salida
Escrib i r cp, en
Fin
en - e n + 1
cp - cp + 1
: .......................................................................................................................................................................................................... ...
import java . util . Scanner;
pub1ic class Prob1ema65 {
public static void main (String[] args) {
//Variables
int ni , nf , cp=O , cn=O, i ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . print( "Num . Inicial : " ) ;
ni= teclado . nextint() ;
System . out . print( "Num . E'inal : " ) ;
nf = teclado . nextlnt() ;
//Proceso
for (i - ni ; i <= nf ; i ++) (
if (i ! = 0) {
if ( i < 0)
en += 1 ; .
' • ··········································································································································································································](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-183-2048.jpg)
![Algoritmos con java
Diagrama de flujo
Inicio
!
ni , nf, nm, e , i . Entero
.
!
/ Leer ni , nf, no/
!
i -ni
i<- nf
F
Í · i+l
lV
F
i Mod nm~
Jv
e - e + 1
!
1 Escribir e
1
!
eFin
Codificación:
Algoritmo
Pseudocódigo
Inicio
//Variables
ni , nf , nm , e , i : Entero
//Entrada
Leer ni , nf , nm
//Proceso
Para i - ni Hasta nf Inc 1
Si i M
od nm - O Entonces
e - e + 1
Fin Si
Fin Pa r a
//Salida
Escribir e
Fin
.............................................................................................................................................................................................................
import java . util . Scanner;
public class Problema66 {
l
public static void main(String[] args) {
//Variables
}
int ni , nf , nm, c=O, i ;
//Entrada
Scanner teclado= new Scanner(System . i n) ;
System . out . print( "Num . Inicial : " ) ;
ni= tec lado . nextint() ;
System . out . pr i nt( "Num . Final : " ) ;
nf = tec lado . nextint () ;
System . out . pr i nt( "Num . Multip l o : " ) ;
nm = tec lado . nextint() ;
//Proceso
for(i = ni ; i<=nf; i+ +) {
if(i % nm == 0)
e += 1 ;
}
1/Salida
System . out . p ri nt1n( "'' ) ;
System . out . pri nt1n( "Cantidad : " +e) ;
.. ....................................................................................................................................................' ......................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-185-2048.jpg)
![Algoritmos con java
Codificación:
.............................................................................................................................................................................................................
.
impo r t java . uti l . Scanner;
public class Problema67 {
l
public static void main(String[] args ) {
//Variables
l
int n, f , i ;
//Entrada
Scanner teclado= new Scanner(System . i n) ;
System . out . print( "Numero : " ) ;
n = teclado . nextint ();
//Proceso
f = 1 ·
1
for(i = 1 ; i<=n; i ++)
f *= 1 i
1/Salida
System . out . println( "'');
System . out . println( " Factorial : " + 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.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número; luego, que el
sistema devuelva si el número es o no primo.
Entrada Salida
• Número (n)
Diseño:
• Respuesta (r)
Interfaz de usuario
e' C:ARCHIV-1XINOXS-1JCRf~ lrsJ I:J
Hunt~ 1•o: '/ a
-
Rccp<<cctd: ES PRIMO
P1·e~;~ iWl) Xev to cont inuc ...](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-187-2048.jpg)
![Algoritmos con java
Codificación:
· import java. util . Scanner;
public c lass Problema68 {
}
public static void main(String[] args) (
//Variables
}
int n , i ;
boolean flag ;
String r = ''";
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . print( " Numero : " ) ;
n = teclado . nextint() ;
//Proceso
flag = t rue ;
i = 2;
f o r (i = 2 ; i<=n/2; i++) {
}
if ( n % i == O) {
}
flag = false ;
break;
if (flag)
r = "ES PRIMO";
else
r = " NO ES PRIMO";
1/Salida
System . out . println( "'' ) ;
System . out .println( "Respuesta : " + r) ;
Problema n.2 69
Enunciado: Determine cuántos números primos hay en los primeros N números enteros positivos.
Análisis: Para la solución de este problema se requiere que el usuario ingrese un número; luego, que el
sistema devuelva la cantidad de números primos; por ejemplo, si ingresa 7, hay 4 números primos 1, 3, S
y 7.
Entrada Salida
• Número (n) • Cantidad (e)
Diseño:
Interfaz de usuario
'' C:ARCHIV-1 XINOXS-1UCR(~ II¡JEJ](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-189-2048.jpg)
![Diseño:
Capítulo 6: Estructura repetitiva «Para»
Interfaz de usuario
'' C:ARCHIV-1XINOXS-1JCR;~., ~¡] EJ
Nttnt~ t•o : /. t a
Divio.ol': 3 -
Re:; JHU: :: t ( : 1n
J•t·c~~ <~llY kcy lo (:tlrltirltlc ••
a
Algoritmo
Diagrama de flujo Pseudocódigo
( Ini cio
!
n, d , i , r . Entero
.
!
1 Leer n , d 1
!
i-n 1
F
i> 1
i-i- 1
l_
V
F
i Mod d = o
T
v
r - i
Salir
!
1 Escribir r
1
¡
( Fin
Inicio
//Variables
n , d , i, r
//Entrada
Leer n , d
//Proceso
Entero
Para i-n-1 Hasta 1 Inc -1
Si i Mod d = O Entonces
r - i
Salir
Fin Si
Fin Para
//Salida
Escrib i r r
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-192-2048.jpg)
![Algoritmos con java
Codificación:
.............'..............................................................................................................................................................................................
.
import java . util . Scanner;
public class Problema70 {
}
public static void main(String[] args) {
//Variables
}
int n, d , i , r =O¡
//Entrada
Scanner teclado= new Scanner(System . i n) ;
System . out . print( "Numero : " ) ;
n = teclado . nextint() ;
System . out . print( "Divisor : " ) ;
d = teclado . nextint() ;
//Proceso
for(i- n- 1; i >= 1; i-=1 ) {
if(i%d 0){
r = i ;
break;
}
)
//Salida
System . out . println( "" l ;
System . out . println( " Respuesta : " + r) ;
•,, ...........................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-193-2048.jpg)
![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 d e una dimensi ó n (Vector)
11 5 elementos LI = O y LS = 4
N[5) : Ente r o
//Ar r ay d e dos dime ns i o nes (Mat r i z)
11 3X4 elementos
/1 l e r a Di m. LI = O y LS = 2
// 2da Dim . LI = O y LS = 3
N[ 3) [4) : Ente r o
Visual Java
.............................................................................................................................................................................................................
//Array d e una dimensión (Vector )
/1 5 elementos LI = O y LS = 4
i nt N[ ) = new int[ 5) ;
//Array d e dos dimens i o nes (Matriz )
11 3X4 e l ementos
/1 lera Dim . LI = O y LS = 2
// 2da Di m. LI = 0 y LS = 3
i n t N[ )[) = new i nt [3 ] [ 4 ) ;
... .......................................................................................................................................................................................................... ,•](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-198-2048.jpg)
![Algoritmos con java
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.
L
i-0 Para ~- o Hasta 4 Inc +1
i<-4
F
i-i+1
¡v N [i )
- 10
N [ i ] - 10
1 Fin Para
¡
Sintaxis Java
for (i=O ; i<=4 ; i++) {
N[i) = 10 ;
}
... ..............' ........................................................................................................' ...................................................................................
En el siguiente diagrama se tiene la matriz N de 3x4 elementos y se asigna el valor 10 a cada elemento.
L
i -0
i<-2 F
i-i+l
.¡.v
j-0 F
j<-3
j-j+1
¡v
N[i ] [j ] - 10
+
¡
Sintaxis Java
for (i=O ; i<=2 ; i++ ) {
for (j=O ; j<=3; j++ ) {
N[i] [ j) - 10;
}
}
Para i - O Hasta 2 Inc +1
Para j- O Hasta 3 Inc +1
N[i) [j ) - 10
Fin Para
Fin Para
'·· .......................................................................................................................................................................................................... .](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-199-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Enunciado: Dado Snú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 el proceso para devolver la suma.
Entrada Salida
• SNúmeros n[S] • Suma (s)
Diseño:
Interfaz de usuario
'' C:ARCHIV-1XINOXS-1UCR(:1 1!!1!5JE1
HuneI'O
HuneI'O
Nune I'O
Hunt! I'O
Nune l'O
Sun<l:
Pt·e~;!";
a
Diagrama de flujo
( I nicio
!
i , S . Entero
.
~
n [ 51 . Entero
.
!
~Leer n[O] , n(1 1,~
n(21 , n(31 , n(4]
~
i-1
i<-4
F
i -i+l
~V
S - S + n [i 1
l
!
1 Escribir S
1
!
( Fin
1 :
2:
3:
1:
S:
Hl
<ln y
2 a
2
-
2
2
2
~e y to r.ont inuc ... _
Algoritmo
Pseudocódigo
Inicio
//Variables
i , s : Ent e r o
//Arreglos (Vector)
n [ 5 ] : Ent e ro
//Entrada
Leer n[ OJ,n [ l ],n[ 2J,n [ 3 J,n[ 4]
//Proceso
Pa r a i-0 Hasta 4 I nc 1
S - S + n[i ]
Fin Par a
//Salida
Esc r ib i r s
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-200-2048.jpg)
![Algoritmos con java
Codificación:
........................................................................................................................................."..................................................................
· import java. util . Scanner;
public c lass Problema71 {
}
public static void main(String[] args) {
//Variables
J
int s = O, i ;
//Arreglos
int n [ ] - new int [ 5] ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . print( " Numero 1 : " ) ;
n [O J = teclado . nextint () ;
System . out . pri nt( " Nume r o 2 : " ) ;
n [l ] - teclado . nextin t () ;
System . out . print( " Numero 3 : " ) ;
n[2] - teclado . nextin t () ;
System . out . pri nt( " Nume r o 4 : " ) ;
n [3 ] = teclado . nextin t () ;
System . out . pr i nt( " Numero 5 : " ) ;
n [4] = teclado . nextin t () ;
//Proceso
for ( i = O; i <= 4 ; i++)
s += n[i] ;
1/Salida
System . out . pr i ntln( "'' ) ;
System . out .println( " Suma : " + s) ;
.............................................................................................................................................................................................................
Problema n.2 72
Enunciado: Dado S números obtener el número mayor.
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 el mayor.
Entrada Salida
• 5 Números n[S) • Mayor (m)
Diseño:
Interfaz de usuario
, ; C:ARCHIV- 1XINOXS- 1UCR(;.,1!5]EJ
Hune I'O 1 :
' a
••
Hnne I'O 2: 2
-
NuneI'O ) : 31
Nunel'o 1: ' '
J -·
Nune I'O S: )
Mayo1•: SS
Pt'e:::: d(l y kt: y to cnnt irnu: ...
a](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-201-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Diagrama de flujo
( Inicio l
¡
i , m : Entero
¡
n[S J . Entero
.
!
~ Leer n[ O) , n [l) , ~
n[2 J,n [3 J,n[4)
¡
i - 0
i<-4
F
i-i+l
J.V
F
n [i J > m
¡v
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[OJ,n[l),n[2 ) , n[3J,n[4)
//Proceso
Para i-0 Hasta 4 Inc 1
Si n[i) >m Entonces
m- n[i)
Fin Si
Fin Para
//Salida
Escribir m
Fin
........................................................................................................................................................................................................... ...
' i mport java . util . Scanner;
public class Problema72 {
public static void main{String [ ) args ) {
//Variabl es
}
int m= O, i ;
//Arreglos
int n[) = new int [S) ;
//Entrad a
Scanner teclado= new Scanner{System. in) ;
System . out . print( • Numero 1 : '' ) ;
n [ O] = teclado . nextlnt{) ;
System . out . print (• Numero 2 : • 1;
n ( l) = teclado . nextlnt{l ;
System . out . print (• Numero 3 : • ) ;
n [2) = teclado . nextlnt{) ;
System . out . print (• Nume r o 4 : • ) ;
n [ 3 J = t eclado . nextlnt{l ;
System . out . print{ • Numero 5 : • 1 ;
n [ 4) = t eclado . nextlnt{) ;
//Proceso
for{i = O; i <= 4 ; i ++ ) {
if {n[i) > m)
m=n [i ) ;
}
1/Salida
System . out . print l n( •• J ;
System . out . print l n( • Mayor : • +m) ;
...l..........................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-202-2048.jpg)
![Algoritmos con java
Problema n.2 73
Enunciado: Dado 5 números y un divisor, determinar cuantos números múltiplos hay del divisor en los 5
números ingresados.
Análisis: Para la solución de este problema se requiere que el usuario ingrese 5 números; luego, que el
sistema procese y devuelva la cantidad de números múltiplos que hay.
Entrada Salida
• 5 Números (n[S]) • Cantidad (e)
• Divisor (d)
Diseño: Interfaz de usuario
, ; C:ARCHIV-1XINOXS-1UC... l!lliJEJ
Diagrama de flujo
(Inicio
~
d , i , e : Ente ro
!
n[S) . Entero
.
~
~
1
Leer n[O] , n[l] ,
1
~
n(2 ],n[3],n[4],d
~
i-0
i<-4
F
i. i+l
l V
F
n(i ) Mod d=
¡v
e - e + 1
~
1 Escribir e
1
!
Fin
Algoritmo
Pseudocódigo
Inicio
//Variables
d , i , e : Entero
//Arreglos (Vector)
n[S] : Entero
//Entrada
Leer n [O), n [1), n [2), n [3), n [4), d
//Proceso
Para i - 0 Hasta 4 Inc 1
Si n[i] Mod d =O Entonces
e - e + 1
Fin Si
Fin Para
//Salida
Escribir e
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-203-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Codificación:
..........................................................................................................................................................................................................··.
· import java . ut il. Scanner;
public class Problema73 1
}
public static void main(String[] args) {
//Variables
}
int d , i , c=O ;
//Arreglos
int n [ ] = new int [5] ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . pr i nt( " Numero 1 : ");
n[O] = teclado . nextint() ;
System . out . print( " Numero 2 : '' ) ;
n[l] = teclado . nextint() ;
System . out . print( " Numero 3 : " ) ;
n[2] = teclado . nextint() ;
System . out . print( " Numero 4 : " ) ;
n[3] = teclado . next int() ;
System . out . print( " Numero 5 : " ) ;
n[4] = teclado . nextint() ;
System . out . print( " Divisor : ");
d = teclado . nextint();
//Proceso
for ( i - O; i <= n . l ength - 1 ; i++) {
i f ( n [ i ] % d == O)
e += 1 ;
}
//Salida
System . out . println( "'');
System . out . pri ntln( "Cantidad : " +e) ;
Problema n.o74
Enunciado: Dado S números, obtener la cantidad de números primos ingresados.
Análisis: Para la solución de este problema se requiere que el usuario ingrese S números; luego, que el
sistema procesa y devuelve la cantidad números primos.
Entrada Salida
• S Números (n[S]) • Cantidad (e)
Diseño:
Interfaz de usuario
'' C:ARCHIV- 1XINOXS- 1UCR... l!lilf3
Nune t•o 1 : "1
Nune t•o 2 : ] a
-
Nunet•o ] : 1
Nu ncro 1: 6
Huru~ t'o ' .
.' . 1 1
c.,ntict.Ht: 3
Pl'e:::: <HIY kt-:y to cnnt lnue .. . _
a](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-204-2048.jpg)
![Algoritmos con java
Diagrama de flujo
Inicio )
e , i , j . Entero
.
flag . Logico
.
n[S] . Entero
.
¡
~~eer n[O] , n[l] , /
n[2J. n [3 J. n[4]
¡
i-0
i<-4 F
~ -i+l
¡
F
flag ·- Verdadero
¡
)-¿
j< n ( i ] 2 F
j-j+l
lV
F
n (i ] Mod j=O
Tv
flag - 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
//Arreglos (Vector)
n [S] : Entero
//Entrada
Lee r n[ OJ,n[ l),n[2 J,n[3 J,n[ 4]
//Proceso
Para i-0 Hasta 4 Inc 1
.flag - Verdad e r o
Para j -2 Hasta n[i]2 Inc 1
Si n[i ] Mod j=O Entonces
flag - Falso
Salir
Fin Si
Fin Para
Si .flag Entonces
e - e + 1
Fin Si
Fin Para
//Salida
Esc rib i r e
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-205-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Codificación:
import java . util . Scanner;
public class Problema74 {
l
public static void main(String[J args) {
//Variables
}
int c=O , i , j ;
boolean flag ;
//Arreglos
int n [] = new int [5] ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . pri nt( "Numero 1 : " ) ;
n[O] = teclado . nextint() ;
System . out . print( "Numero 2 : " ) ;
n[l] = teclado . nextint() ;
System . out . print( "Numero 3 : '' ) ;
n[2] = teclado . nextint() ;
System . out . pri nt( "Numero 4 : " ) ;
n[3] = teclado . nextint() ;
System . out . print( "Numero 5 : " ) ;
n[4] = teclado . nextin t () ;
//Proceso
for(i = O; i<= 4 ; i+ +) {
flag = true ;
}
for(j = 2; j<=n[i]/2 ; j++){
l
}
if (n [ i J % j == O) {
flag = false ;
break;
if (flag)
e += 1 ;
1/Salida
System . out . pri ntln( "'' );
System . out . println( "Cantidad : " +e ) ;
......................................................................................................................................................................." .....................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-206-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Diagrama de flujo
( rnicio
~
nb, p , i . Entero
.
r . Cadena
.
!
n(7) . Entero
.
~
~Leer n(O) , n(11 , n(21 , .~
(31, n (41, n (5 1, n [61, nb
l
r - "NO EXISTE"
p - - 1
!
i-0
F
i< 6
i - i +l
1V
F
n [i 1 bn >
Tv
r - "EXISTE"
p - i
Salir
l
j Escribir r , P/
l
( Fin
Algoritmo
Pseudocódigo
Ini cio
//Vari ables
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
Para i-0 Hasta 6 Inc 1
Si n[i] = nb Entonces
r - "EXISTE"
Fin Si
Fin Par a
p - i
Salir
//Salida
Escribir r , p
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-208-2048.jpg)
![Algoritmos con java
Codificación:
.......'.................................................................................................................................................................................................. ...
· import java . uti l . Scanner;
public class Problema75 {
}
public static void main(Stri ng[J args) {
//Variables
}
int nb, p , i ;
St ring r =
//Arreglos
' ' 11 •
'
int n[ ] = new int[7] ;
//Entrada
Scanne r teclado= new Scanner(System . in) ;
System . out .print( "Numero 1 : " ) ;
n[O] = teclado . nextint() ;
System . out . print( "Numero 2 : " ) ;
n [1 ] - teclado . ne xtin t () ;
System . out . print( " Numero 3 : ") ;
n[2] - teclado . nextint () ;
System . out . pri nt( "Numero 4 : " ) ;
n[3] = teclado . nextint() ;
System . out . print( "Numero 5 : " ) ;
n [ 4] = teclado . nextin t () ;
System . out . print ("Numero 6 : " ) ;
n[S] = teclado . nextint () ;
System . out . pr i nt( "Numero 7 : " ) ;
n [6 ] = teclado . nextin t () ;
System . out . print( " Numero a buscar : " ) ;
nb = teclado . nextint() ;
//Proceso
r = " NO EXISTE";
p = -1 ;
fo r (i = O ; i <= n . length - 1 ; i++) {
if(n[i] ==nb ){
}
}
1/Salida
r = " EXISTE";
p = l. ;
break;
System . out . println( "'') ;
System . out . println( " Respuesta : " + r) ;
System . out . pri ntln( " Pos i cion : " + p) ;
.............................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-209-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Problema n.2 76
Enunciado: Lea 4 números y almacénelos en un vector de llamado A, y otros 4 números en un vector
llamado B, y determine cuántos números de A se encuentran en B.
Análisis: Para la solución de este problema se requiere que el usuario ingrese 8 números; luego, que el
sistema devuelva la cantidad.
Entrada Salida
• 4 Números (a(4)) • Cantidad (e)
• 4 Números (b[4])
Diseño:
Interfaz de usuario](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-210-2048.jpg)
![Algoritmos con java
Diagrama de flujo
l Inicio )
~
1 e , i , j . Entero 1
.
!
a [4] . Entero
.
b [4] : Entero
~
/a Leer a[O] , a(l],a[2J, ~ ~
[31 , b[OJ , b[l] , b[2J,b(3
!
i-0
i< 4 F
i-i+l
! V
j-0
F
j<-4
j-j+l
~V
F
a[il - b ( j l
l
e - e + 1
l
!
1 Escribir e
1
!
( Fin )
Algoritmo
Pseudocódigo
Ini c i o
//Variables
e , i , j : Entero
//Arregl os (Vector)
a[4], b[4] : Entero
//Entrada
Leer a[O],a[l],a[2],a[3],
b(O] , b[1] , b(2] , b (3 ]
//Proceso
Para i-0 Hasta 4 Inc 1
Para j-0 Hasta 4 Inc 1
Si a[i]=b[j] Entonces
e - e + 1
Fin Si
Fin Para
Fin Para
//Salida
Escrib i r e
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-211-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Codificación:
.. ............................................................................................................................................................................................................
import java . uti l . Scanner;
public class Problema76 {
)
public static void main(Stri ng[J args) {
//Variables
}
int c=O , i , j ;
//Arreglos
int a(] - new int[4] ;
int b (] = new int [ 4] ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . pr i ntln( "Arreglo A: " ) ;
System . out . println( " ==========" ) ;
System . out . print( " Numero 1 : " ) ;
a(OJ = teclado . nextint() ;
System . out . print( " Numero 2 : '' ) ;
a(1] = teclado . nextint() ;
System . out . pri nt( " Numero 3 : " ) ;
a(2] = teclado . nextint() ;
System . out . print( " Numero 4 : " ) ;
a(3] = teclado . nexti nt() ;
System . out . println( "" ) ;
System . out . pri ntln( "Arreglo B : " ) ;
System . out . println( " ==========") ;
System . out . print( " Numero 1 : " ) ;
b(OJ = teclado . nex tint() ;
System . out . print( " Numero 2 : " ) ;
b(l] = teclado . nextint() ;
System . out . pri nt( " Numero 3 : " ) ;
b (2] = teclado . nextint() ;
System . out . print( " Numero 4: " ) ;
b(3] = teclado . next int() ;
//Proceso
for ( i = O; i <=a . length - 1 ; i ++) {
for(j = O; j <= b . length-1 ; j++) {
if (a [ i J == b [ j J )
e += 1 ;
}
)
1/Salida
System . out . println( "'') ;
System . out . println( "Cantidad : " +el ;
... ..................................................................................................................... ....................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-212-2048.jpg)
![Algoritmos con java
Problema n.2 77
Enunciado: Ordene 4 números usando el método de ordenación por intercambio (burbuja).
Análisis: Para la solución de este problema se requiere que el usuario ingrese 4 números; luego, que el
sistema devuelva los números ordenados.
Entrada Salida
• 4 Números (n[4)) • 4 Números ordenados (n[4))
Diseño:
Interfaz de usuario
" - C:ARCHIV-1XINOXS-1JCRL.-, lli]EJ](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-213-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Diagrama de flujo
( Inicio )
¡
tmp, i , j , LI , LS : Entero
l
n [4 1 : Entero
l
/Leer n[OI , n[ll , n[21 , n[31 /
l
Ll · o
LS · 3
¡
i. LI
i<..LS 1 F
i· i+1
¡v
j. LI
F
j<-LS-1
j-j+1
J.V
F
n[jl>n[j+1¡
1
::>
tmp- n[jl
n [ j 1 · n[j+1)
n[j+ll · tmp
L
Algoritmo
Pseudocódigo
Inicio
//Variables
tmp , i , j , LI , LS : Entero
//Arreglos (Vector)
n[4) : Entero
//Entrada
Leer n [O],n[l ], n[2],n[3)
//Proceso
LI - O
LS - 3
Para i-LI Hasta LS-1 Inc 1
Para j-LI Hasta LS-1 Inc 1
Si n[j]>n[j+1) Entonces
tmp- n[j)
n[j) - n[j+1)
n [ j+1) - tmp
Fin Si
Fin Para
Fin Para
//Salida
Escribir n[O] , n[1) , n[2) , n[3)
/ Escribir n[O) , n[1) , n[2) , n[3J/ Fin
¡
( Fin )](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-214-2048.jpg)
![Algoritmos con java
Codificación:
.......................................................................................................'................................................................................................... ...
import java . util . Scanner;
public class Problema77 {
1
public static void main(String[J args) (
//Variables
)
int tmp , i , j , LI , LS ;
//Arreglos
int n () = new int [ 4) ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . print( " Numero 1 : " ) ;
n(O] = teclado . nextint() ;
System . out . print( " Numero 2 : " ) ;
n[l) = teclado . nextint() ;
System . out . print( " Numero 3 : " ) ;
n[2] - teclado . nextint() ;
System . out . print( " Numero 4 : " ) ;
n[3] = teclado . nextint() ;
//Proceso
LI - O;
LS = n . length-1 ;
f or (i = LI ; ~ <= LS - 1 ; i++) {
for(j = LI ; j <= LS - 1 ; j++) {
)
)
if(n[j] > n[j + 1 ]){
tmp = n(j) ¡
)
n (j) = n[j + 1) ;
n (j + 1 ] = tmp;
//Salida
System . out . println( "" l ;
System . out . println( "Ordenado" ) ;
System . out . println( " Numero 1 : " + n[O)l ;
System . out . println("Numero 2 : " + n[l)) ;
System . out . println( " Numero 3 : " + n[2]) ;
System.out . println( " Numero 4 : " + n[3)) ;
...................................................................................................................................................................................' .........................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-215-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Problema n.2 78
Enunciado: Ingrese 6 números en un arreglo de dos dimensiones (matriz) de 3x2 y obtenga la suma de
los números ingresados.
Análisis: Para la solución de este problema se requiere que el usuario ingrese 6 números; luego, que el
sistema devuelva la suma de los números.
Entrada
• 6 Números (n[3][2]).
Diseño:
Diagrama de flujo
( Inicio )
~
s , i , j . Entero
.
~
n[31 [2 ) . Entero
.
l
1
Leer n [ O1 [ O1, n [ O1 [1 1,
n[l] [0] , n[l] [1] ,
n[21 (0),n[21 11 1
~
i-0
i< 2
F
i-i+l
~V
j-0
F
j< 1
j-j+l
~V
S •- S + n[i] [j]
*
*
!
1 Escribir s
1
!
( Fin )
Salida
• Suma (s)
Interfaz de usuario
1
Algoritmo Pseudocódigo
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],n[OJ [1] ,
//Proceso
Para i-0 Hasta 2 Inc 1
Para j-0 Hasta 1 Inc 1
S - S + n (i] ( j]
Fin Para
Fin Para
//Salida
Escribir s
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-216-2048.jpg)
![Algoritmos con java
Codificación:
..............................................................................................................................................................................................' ...........- ...
· impo r t java . uti l . Scanner;
public class Problema78 {
)
public static void main (Stri ng[J args) (
//Variables
)
int s = O, i , j ;
//Arreglos
int n () [) = n ew int [ 3) ( 2) ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . print( " Numero (0 , 0 ): " ) ;
n(O] [0 ) = teclado . nextint () ;
System . out . pri nt( " Numero (0 , 1 ): " ) ;
n(O] [1) = t eclado . nextint() ;
System . out . pr i nt (" Nume ro (1, 0 ): " ) ;
n[1] [0) = tec l ado . nex tint () ;
System . out . print( " Numero (1 , 1 ) : " ) ;
n [1 ] [1) = tec l ado . nextint () ;
System . o ut . print( " Numero (2 , 0 ) : " ) ;
n [2 ) [0 ) = teclado . nextint ( ) ;
System . out . pri nt (" Nume r o (2 , 1 ) : " ) ;
n [2 ) [ 1) = t eclado . nextint () ;
//Proceso
for ( i = O; i <= 2 ; i++)
f or(j = O; j <= 1 ; j ++)
s += n [ i) [ j) ;
1/Sa lida
System . out . println( "'' ) ;
System . out . pri ntln( " Suma : " + s) ;
... .......................................................................................................................................................................................................... .](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-217-2048.jpg)
Diseño:
Salida
• Suma columna 1 (sO)
• Suma columna 2 (sl)
• Suma columna 3 (s2)
Interfaz de usuario
'' C:ARCHIV- 1XINOXS- 1UCRE... lf¡E'J
Nunel'o <1-1. {j) : 2
Hunc••o 01.1): 3
Hunt:••o 01.?.): 1
Nune ••o <LID: 2
Nune t•o (1.1): 3
Hu n•~ •·n (1,2): 1
Nune I'O <2.0): 2
Nune I'O <2,1): ]
Nune l'o (2,2): 4
Nune I'O U.H): 2
Nune l'O <3,1): 3
'Hune•·o 0 , 2): 1
Sunn Col. {!: 8
Sun•• Col . 1: 1?.
Sun~ Col. ?.: t(,
Pt•t!ss dny kt!y to continttc ••• _
a
a
•](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-218-2048.jpg)
![Algoritmos con java
Diagrama de flujo
( Inicio )
T
s0 , sl , s2 , i , j . Entero
.
1
n[4] [3) . Entero
.
1
Leer n[O] [O],n[O] [l] , n[O] [2],
n[l] [ OJ, n[l] [ l],n[l] [ 2],
n [2] [ 0] , n [2] [l] , n[2] [ 2] ,
n [3] [ 0), n [3] [1), n [3] [2]
1
i·- 0
F
i<-4
i-i+l
1v
sO - sO + n[i] [0]
sl - sl + n[i] [1]
s2 - s2 + n(i] [2]
-¡
1
/ Escribir sO, sl , sz/
1
1 E'in
Algoritmo
Pseudocódigo
Inicio
//Variables
sO , sl , s2 , i , j : Entero
//Arreglos (Matriz)
n [ 4] [ 3] : Entero
//Entrada
Lee r n [O) [O J, n [0) [1), n [O) [2 ),
n[l) [OJ,n[ l ) [ lJ, n[l) [2),
n[2) [0 J,n [2) [1 J, n[2) [2),
n[3) [O J, n[3) [1 J, n[3) [2),
//Proceso
Para i-0 Hasta 4 Ine 1
sO - sO + n [i) [0)
sl - sl + n[i) [1)
s2 - s2 + n[i) [2)
Fin Para
//Salida
Escribir sO , sl , s2
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-219-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matr ices)
Codificación:
...................................." .............................." ......." ......." ............................" .............' ................................" ............................" .........
~ impo r t java . ut i l . Scanner ;
: publi c cla ss Problema79 {
: public static void main(St ri ng[J
: //Vari ables
¡ i nt sO=O , s 1=0 , s2=0, i, j ;
//Ar regl os
i nt n [ J [] =
//Entrad a
ne w i nt[4 )[ 3] ;
args ) {
Scanne r tecl ado = new Scanner (Sys t em . i n ) ;
System . out . p ri nt (" Nume r o (0 , 0 ) : " ) ;
n [0 ) [ 0 ) = t e clado . nex t! nt () ;
}
)
System . out . p rint (" Nume r o (0 , 1 ) : " ) ;
n [OJ [1 ) = tec l ado . nex ti nt () ;
System . out . pr i nt (" Nume ro (0 , 2 ) : " ) ;
n [O) [ 2 ) = tecl ado . nex t int () ;
System . out . pri nt (" Nume ro (1 , 0 ) : ");
n [1 ) [O ) = tec l ado . ne x tint () ;
System . out . print (" Numero (1 , 1 ) : " ) ;
n [1) [1 ] = tec1ado . ne x tint () ;
System . out . print (" Numero (1 , 2 ) : " ) ;
n [1) [2 ] = tecl ado . ne x t !nt () ;
System . out . pri nt (" Numero (2 , 0 ) : " ) ;
n [2 ) [ 0 ] = tecl ado . nex t !nt () ;
System . out . p ri nt (" Nume r o (2 , 1 ) : " ) ;
n [2 ) [1 ] = t e c l ado . nex t !nt () ;
System . out . p ri nt (" Nume r o (2 , 2 ) : " ) ;
n [2 ) [ 2 ) = teclado . nex t! n t () ;
System . out . p rint (" Nume r o (3 , 0 ) : " ) ;
n [ 3 ) [ 0 ) = teclado . nexti nt () ;
System . out . pri nt (''Nume ro (3 , 1 ) : ");
n [3) [1 ) = tecl ado . ne x tint () ;
System . out . print (" Nume ro (3 , 2 ) : ") ;
n [3 ) [ 2 ] = tecl ado . ne x tint () ;
//Pr oceso
f or (i = O; i <=3; i ++)
sO+= n [ i) [O] ;
s1 += n [ i 1[ 1 1;
s2+ = n[i ] [ 2 ] ;
}
1/Salida
System . out . print1n ("" ) ;
System . out . pri ntln (" Suma
System . out . print 1n (" Suma
System . out . pr i ntln (" Suma
{
Col. O:
Col . 1 :
Col . 2 :
" +
" +
" +
sO ) ;
S 1 ) i
s2 ) ;
..............................................................................................................................................................................................................
Enunciado: Almacene en una matriz de 3x2, 6 números y obtenga la cantidad de pares e impares.
Análisis: Para la solución de este problema se requiere que el usuario ingrese 6 números; luego, que el
sistema devuelva la cantidad de pares e impares.
Entrada Salida
• 6 Número (n[3)[2)) • Cantidad de pares (cp)
• Cantidad de impares (ci)](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-220-2048.jpg)
![Diseño:
1
Algoritmos con java
F
Interfaz de usuario
' ' C:ARCHIV- 1XINOXS- 1JCR.:~ ~I:l El
Nune l'O
Nune t•o
Nun1~ t•n
Hunero
Huru~ t•o
Nune t•o
<11.11) : ?.
(¡l_¡): f,
( 1 .11) : :1
(1.1): 8
<?..Ji): '1
(2.1): 4
C.:u1t. Pctt•es: 4
C.ut t . 1rll)• t·t: :; : ?.
a
-
f•l•t::;~ dllY kcy tu (;ontirlttt: •••
a
Diagrama de flujo
( Inicio )
~
cp, ci , i , j . Entero
.
~
n [3 ] [2] : Entero
Leer n(O][O],n[O][l] ,
n(l) [O],n[l) [1],
n[2] [0],n[2) [1]
~
i - 0
i<- 2
F
i -i+l
~V
J- 0
F
j<- 1
j-j+l
J.V
n[i] [j i Mod 2=0
-
1
V
Algoritmo
Pseudocódigo
Inicio
//Variables
cp, ci, i , j : Entero
//Arreglos (Matriz)
n [3) [2 ) : Entero
//Entrada
Leer n [ O] [O],n[O ] [ 1],
n[l ) [O J,n[ l) [1],
n[2 ) [0 ],n[2) [1)
//Proceso
Para i-0 Hasta 2 I nc 1
Para j-0 Hasta 1 Inc 1
Si n[i) [j] Mod 2 =0 Entonces
cp - cp + 1
SiNo
ci-ci+l cp-cp+l
ci - ci + 1
Fi n Si
1
~
/ Escribir
!
( Fin
1
cp, ci j
)
Fin Para
Fin Para
1/Salida
Escribir cp, ci
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-221-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Codificación:
.· ................................................................................................................................., ..........................................................................•
· import java . util.Scanner ;
public class Problema80 {
)
public static void main(String[J args) (
//Variables
)
int cp=O , ci=O , i , j ;
//Arreglos
int n 1) [) = new int [ 3) 12) ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . print( " Numero (0 , 0) : " ) ;
niOJ [0 ) = teclado . nextint () ;
System . out . print ( " Numero (0 , 1) : " ) ;
n[O] [1) = teclado . nextint () ;
System . out . print( " Numero (1 , 0) : " ) ;
n[1] [0) = teclado . nextint () ;
System . out . print( " Numero (1 , 1) : " ) ;
n [1 ] [1 ) = teclado . nextint () ;
System . out . print ( " Numero (2 , 0) : " ) ;
n[2) [0) = teclado . nextint () ;
System . out . print ( " Numero (2 , 1) : " ) ;
n [2 ) [1) = teclado . nextint () ;
//Proceso
for (i = O; i<=2 ; i++) (
for (j = O; j<=1 ; j++) {
)
)
i f (n [ i) [ j) % 2 == O)
cp += 1;
else
ci += 1 ;
1/Salida
System . out . println( "" ) ;
System . out . println( " Cant . Pares : '' + cp) ;
System . out . println( " Cant . Impares : " + ci ) ;
.. ......................................................' .............' ........' ...............................' .............................................................................' .............' .](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-222-2048.jpg)
![Algoritmos con java
Enunciado: Busque un número dentro de una matriz de 4x3, 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
• Matriz (n[4)(3))
• Número a buscar (nb)
Diseño:
Salida
• Respuesta (r)
• Posición lera dim. (pl )
• Posición 2da dim. (p2)
Interfaz de Usuario
'' C:ARCHIV- 1XINOXS-1UCRL':!il l!i]EJ
Nune t•o <H.H>: 1
Nune t•o (1-1.1): /.
'Nune l'O <H.2): S
Nune J•o ( l.ll>: (,
Nune t•o (1,1): ~
Nune l'O (1,2): 2
Nune t·o <?. . H>: 7
'Nune t•o (2.1): 3
Nune ••o <2.2): S
Hune t•o <J.H>: 1
Nunt: ••o O.!): 1
Nune l'O <3.2): 8
Hun. •• hu:;c,tt•: R
Re!;pue::;tn: S 1 EX 1S TI::
Po::iciorl lt!l"ct Din . : ]
Pn!:icion /.ct,, Din.:?.
P1•ess dny key to continlte ... _
a
a
•](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-223-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Diagrama de flujo
( Inicio }
!
nb, i , j , pl , p2 . Entero
.
r . Cadena
.
!
n [ 4) [3) . Entero
.
!
Leer n [ OJ [ O], n [O J [ 1 1, n [O 1 [ 2 ],
n[l l [O] , n[l l [1] , n[l l [2] ,
n[2 1 [O] , n[2 1 [l] , n[2 1 [2] ,
n [3] [0) , n [3] [1) , n [3] [21
!
r - "NO EXISTE"
pl - -1
p2 - -1
J
i< 3
i - 0
F
i-i+l
!
j-0
F
j < 2
j ·- j +1
1V
F
[i l [j] no >
T
v
r - "SI EXISTE"
pl - i
p2 - j
Salir
J.
F " SI EXISTE'
¡v
Salir
!
1 Escribir r , pl , p2
1
!
( Fi n )
Algoritmo
Pseudocódigo
Inicio
//Variables
nb, i , j , p1 , p2
r : Cadena
//Arreglos (Matriz)
n[ 4 ] [3] : Entero
//Entrada
Entero
Leer n [0] [0 ], n [0] [1], n [0] [2 ],
n [l ] [O ], n[1] [l ], n[l] [2],
n[2] [O ], n[2] [l ], n[2 ] [2],
n[3] [O ], n[3] [l ], n[3] [2]
//Proceso
r - " NO EXISTE"
p1 - - 1
p2 - - 1
Para i-0 Hasta 3 Inc 1
Para j-0 Hasta 2 Inc 1
Si n[i] [j]=nb Entonces
r - " SI EXISTE"
pl - i
p2 - j
Sali r
Fi n Si
Fin Para
Si r =" SI EXISTE" Entonces
Salir
Fin Si
Fin Para
//Salida
Escribir r , p1 , p2
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-224-2048.jpg)
![Algoritmos con java
Codificación:
.· .......................................................................................................................................................................................................... ...
import java . util . Scanner;
public class Problema81 {
public static void main(St ring[J args) {
//Variables
int nb, i , j , pl , p2 ;
St ring r = "";
//Arreglos
int n (] [] - new int [ 4) ( 3 ] ;
//Entrada
Scanner teclado= new Scanner(System . i n) ;
System . out . print (" Numero (0 , 0) : " ) ;
n (O J [0 ) = tec l ado . nex tint () ;
System . out . print (" Numero (0 , 1 ) : " ) ;
n (O ) [1 ) = teclado . nexti n t () ;
System . out . print( " Numero (0 , 2) : " ) ;
n [0 ) [2 ) = t eclado . nextint () ;
System . out . pri nt( " Numero (1, 0) : " ) ;
n (1 ) [0 ) = teclado . nextint () ;
System . out . print ( " Numero (1 , 1) : " ) ;
n (1 ) [1 ) = tecl ado . nex tint () ;
System . out . print (" Numero (1 , 2) : " ) ;
n [1) [2 ] = teclado . nextint () ;
System . out . print( " Numero (2 , 0 ): " ) ;
n [2 ] [0 ] = t eclado . nextint () ;
System . out . pr i nt (" Numero (2 , 1 ): " ) ;
n[2) [1) = t eclado . nextint () ;
System . out . print ( " Numero (2, 2) : " ) ;
n (2 ) [2 ) = teclado . nex tint () ;
System . out . print (" Numero (3 , 0) : " ) ;
n [3) [0 ] = teclado . nextint () ;
System . out . print (" Numero ( 3 , 1 ): " ) ;
n[3) [1 ] = teclado . nextint () ;
System . out . pr i nt( " Numero ( 3 , 2) : " ) ;
n[3) [2 ) = teclado . nextlnt() ;
System . out . print (" Num . a buscar : '' ) ;
nb = tec lado . nextint() ;
//Proceso
r = " NO EXISTE";
p1 - - 1;
p2 - -1 ;
for (i = O; i<=3; i ++ ) {
f or (j = O; j<=2; j ++){
if (n [ i ] [j] == nb) {
r = " SI EXISTE";
•., ................. ········································..............................................................................··································································](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-225-2048.jpg)
) • 4 Números matriz C(c(2](2])
• 4 Números matriz B (b[2](2))
Diseño:
Interfaz de usuario
e; C:ARCHIV- 1XINOXS- 1JC..~ 11151EJ
Al'l'e~¡lo A:
Hune t•o <ll.ll): 2
Nune t•o <ll.l): ?.
Nunr~ 1'0 (1.11) : ?.
Nune.-o <1.1): ?.
Ot•J'e!Jln B:
- -- -
.
Nune r•o <ll.ll): 1
Hune t•o <ll.l): 1
Nune t•o <t.ll>: 4
Nunr~ t•o (1.1> : 1
At•••eylo C:
Nune t•o OL l1): IJ
Nune.-o <n~1): (,
'Hunct•o ( 1 ~ 11): L
Nunel'o (1 ~ 1): 6
.PI't!:::; •llV kt~y te) c:C)Ittirttlt: ... _
a
1](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-226-2048.jpg)
![Algoritmos con java
Algoritmo
Diagrama de flujo
( Inicio
!
i , j . Entero
.
¡
a [11 [11 . Entero
.
b[1] [1 ] . Entero
.
c[l] [1] . Entero
.
!
Leer a(O] [OJ,a(O] (1),
a[11 IOLal 1 1 111,
b(O] (OJ,b[O] l lL
b[1] (O],b[ 1 ] ( 1 ]
!
i-0
i< 1 F
i-i+1
¡v
j< 1
j-0
F
J-j+l
!V
e [i 1 [ j ]-a [ i] [ j ] +b [ i] [ j ]
+v
:1:
¡
A Escnna 1
e 101 101 , e 101 [11
c[1] [OJ,c[ 1] [1 ]
¡
( Fin
Codificación:
import java . util . Scanner;
pub1ic c1ass Problema82 {
Pseudocódigo
Inicio
//Variables
i, j : Entero
//Arreglos (Matriz)
a [1] [1] Entero
b[1] [ 1 ] Entero
c[1] [1] Entero
//Entrada
Leer a[O] [O J,a [O ] [1],
a[1] [OJ,a[1 ] [1 ],
b [O] [OJ,b[O ] [ 1],
b [1 ] [0] , b[1] ( 1]
//Proceso
Para i -0 Hasta 1 Inc 1
Para j-0 Hasta 1 Inc 1
c[i] [j ]-a[ i ] [j ]+b[i] [j ]
Fin Para
Fin Para
//Salida
Escribir c[O] [OJ,c[O] [1],
c[1] [0],c[1] [1 ]
Fin
public static void main(String[] args) {
//Variables
int i , j ;
//Arreglos
in t a [ ] [ ) - new int [ 2) [ 2] ;
int b[) [] = new int[2) [2] ;
int e[][] - new int [2) [2] ;
//Entrada](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-227-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
......................................................................................................................'....................................................................................'.
)
)
Scanner teclado= new Scanner (System . in ) ;
System . out . pr i ntln( " Arreglo A: " ) ;
System . out . println( " =========== : " ) ;
System . out . pri nt (" Numero (0 , 0 ) : " ) ;
a[O] [0] = teclado . nextint () ;
System . out . print( " Numero (0 , 1) : " ) ;
a[O] [1] = teclado . nextint() ;
System . out . pr i nt (" Numero (1 , 0 ) : " ) ;
a [ 1] [O ] = teclado . next Int () ;
System . out . print( " Numero (1 , 1 ) : " ) ;
a[1] [1] = tecl ado . nex tint () ;
System . out . println( "" ) ;
System . out . pri ntln( " Arreglo B : " ) ;
System . out . print1n( " =========== : '' ) ;
System . out . print (" Numero (0 , 0 ) : " ) ;
b [O] [0] = tec l ado . nex tint () ;
System . out . print( " Numero (0 , 1) : " ) ;
b[O] [1] = teclado . nextint () ;
System . out . print( " Numero (1 , 0 ) : " ) ;
b [1] [0] = teclado . nextint () ;
System . out . print (" Numero (1 , 1) : " ) ;
b[1] [1 ] = tecl ado . nextint () ;
//Proceso
f or ( i = O; i<=l ; i ++) {
for ( j = O; j<=1; j++)
c[i] [j ] = a[i] [j ] + b[i] [j ];
)
//Salida
System . out . println( "" ) ;
System . out . pri ntln( " Arreglo C : " ) ;
System . out . print1n( " =========== : '' ) ;
System . out . print1n (" Numero (0 , 0) " + e [0] [0] ) ;
System . out . pr i ntln( " Numero (0 , 1) " + c[O] [1]) ;
System . out . print1n( "Numero (1 , 0) " + c[1] [0] ) ;
System . out . println( " Numero (1 , 1) " + c[1][1] ) ;
Enunciado: Ingrese 6 números en una matriz de 3x2 y obtenga el numero mayor ingresado.
Análisis: Para la solución de este problema se requiere que el usuario ingrese 6 números; luego, que el
sistema devuelva el número mayor.
Entrada Salida
• 6 Números (n[3][2]) • Mayor (m)](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-228-2048.jpg)
![Algoritmos con java
Diseño:
Interfaz de usuario
, ; C:ARCHIV-1XINOXS-1JCRE. .. l!ilEI
Diagrama de flujo
( Inicio )
!
m, i , j . Entero
.
!
n(3) (2] . Entero
.
!
~ Leer n[O] [O) , n[O] [1] , ~
n[l) [0 ) , n[l) [1) ,
n (2) (0 ) , n [2) (1 )
!
m - n[OJ [0)
!
i-0
i< 2
F
i-i+1
!V
j-0
F
j<-1
j-j+l
l V
F
n[i) [j i > m >
T
v
m- n(i) (j)
l
l
1 Escribir m
1
l
( Fin )
Algoritmo
Pseudocódigo
Inicio
//Variables
m, i , j : Entero
//Arreglos (Matriz)
n[3] [2] : Entero
//Entrada
Leer n[O) [OJ,n[OJ (1),
n[1) [0 ),n[1 ) [1),
n[2) [O),n(2) [1)
//Proceso
m- n[O) [0)
Para i-0 Hasta 2 Inc 1
Para j-0 Hasta 1 Inc 1
Si n[i) [j)>m Entonces
m- n[i) [j)
Fin Si
Fin Para
Fin Para
//Salida
Escribir m
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-229-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Codificación:
........................................................................................................................................................................................................... ...
import java . util . Scanner;
public class Problema83 {
l
public static void main(String[J args) {
//Variables
}
int m, i , j ;
//Arreglos
int n 1] [] - new int [ 3] 12] ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System.out . print( " Numero (0 , 0) : " ) ;
niOJ [0] = teclado . nextint () ;
System . out . print (" Numero (0 , 1) : " ) ;
n 10 ] [1] = teclado . nextint () ;
System . out . print (" Numero (1 , O) : " ) ;
n[1] [0] = teclado . nextlnt () ;
System . out . print (" Numero (1 , 1 ) : " ) ;
n [1 ] [1 ] = teclado . nextint () ;
System . out . print( " Numero (2 , 0) : " ) ;
ni2J [0] = teclado . nextint () ;
System . out . print (" Numero (2 , 1) : " ) ;
n [2 ] [1] = teclado . nextint () ;
//Proceso
m = n[O ) [0 ) ;
for(i = O; i<=2; i++) {
}
}
1/Salida
for ( j = O; j<=1 ; j++) {
if (n [ i J [ j 1 > m)
m = n[i ) [j ) ;
System . out . println( "'' ) ;
System . out . println( "Mayor : " +m) ;
•,, ..........................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-230-2048.jpg)
![Algoritmos con java
Problema n.2 84
Enunciado: Ingrese 6 números en una matriz de 3x2 y ordene los números de cada columna.
Análisis: Para la solución de este problema, se requiere que el usuario ingrese 6 números; luego, que el
sistema devuelva las columnas ordenadas.
Entrada
• 6 números (n[3)[2])
Diseño:
Salida
• Cada columna ordenada (n[3)[2))
Interfaz de usuario
e' C:ARCHIV- 1XINOXS- 1JCREA
2J1'1 1!1liJEl
Nune t•o 01. ¡j): ]
Hunt: t•o <H.I): ]
Hunero <1.0): 2
Huru: t•o (1.1): ?.
Httnt~ t•n (/. • ¡1) : 1
Nune I'O <?..1): 1
Ot•<lt:n.(lo pot• coll~nrld~
Hunt:I'O 01,(.1): 1
Nunct•o <H .. 1): 1
Nune1•o ( 1 , ~D: ?.
Nune l'o ( 1 , 1 ) : 2
Hunero (2 .. ~D: 3
Hum:Po (2, 1): ]
Pl'e~:; <ny key to continue ... _
a
-](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-231-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Diagrama de flujo
( Inicio )
¡
tmp, i , j , LS : Entero
!
n[3] [2] . Entero
.
l
/ Leer n[O][O],n[0][ 1 ],/
n[1) [0],n[1) [1],
n[2 ) [O J, n[2 ) [1)
!
LS - 2
!
i-0
F
i< LS 1
i-i+1
!V
j-0
F
j< LS-1
j-j+1
l V
F
n(j] (0)>n[j+1) [0]
Tv
tmp - n[j) [ O]
n(j] [0]- n[ j+1] [0)
n(j+l ] (0 ] - tmp
F
n [j) [1)>n (j+1 ) (1)
T
tmp - n [ j l [ 1]
n(j) 111- n[ j+ l l [1)
n 1j+l 1[1 ) - tmp
!
~Leer n[OI (O) , n[O) ( 1 ~~
n[l ) (0 ) , n[1 ) (1 ) ,
n [2 ) [O ) , n [2 ) (1)
l
( Fin )
Algoritmo
Pseudocódigo
Inicio
//Variables
tmp, i , j , LS · Ent e ro
//Arreglos (Matriz)
n [ 3] [2] : Entero
//Entrada
Lee r n [ O] [ O] , n [ O] [ 1] ,
n[1] [ 0] , n[1 ) [1] ,
n[2) [ 0) , 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 ] [O] Entonces
tmp - n [ j 1 [O J
n [j ) [01- 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) - t mp
Fin Si
Fin Para
Fin Para
//Salida
Escribir n[ OJ [O),n[O] [1),
n[l) [0),n[1 ) [1] ,
n[2) [ 0) , n[2 ) [ 1]
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-232-2048.jpg)
![Algoritmos con java
Codificación:
.......................................................................................................................................................................................................... ..
· import java . uti l . Scanner;
public class Problema84 {
}
public static void main(Stri ng[J args) {
//Variables
}
int tmp , i , j , LS ;
//Arreglos
int n(] [] = new int[3] (2] ;
//Entrada
Scanner teclado= new Scanner(System . in ) ;
System . out . print (" Numero (0 , O) : " ) ;
n(OJ [0] = teclado . nextint () ;
System . out . print( " Numero (0 , 1) : " ) ;
n(OJ [1 ] = teclado . nextint () ;
System . out . pri nt (" Numero (1, 0 ): " ) ;
n(1] [0 ] = teclado . nextint () ;
System . out . print (" Numero (1 , 1 ): " ) ;
n (1] [1 ] = tec1ado . nextint () ;
System . out . print( " Numero (2 , 0) : " ) ;
n(2] [0 ] = teclado . nex tint () ;
System . out . pri nt( " Numero (2 , 1 ): " ) ;
n (2 ] [1 ] = tec1ado . nextint ( ) ;
//Proceso
LS = 2 ;
for( i = O; i<=LS - 1 ; i ++) {
)
//Salida
f or (j = O; j<=LS - 1 ; j ++) {
}
}
}
if(n ( j] [01 > n(j + 1 1 (0 1) (
tmp = n [ j 1 [ O1;
n ( j] [0 ] = n ( j + 1 ] (0 ] ;
n(j + 1 1 (0 1 = tmp ;
if(n ( j] [1] > n ( j + 1 ] (1] ) {
tmp = n [ j 1 [11 ;
n(j1 [11 = n(j + 11 (1 ];
n ( j + 1] ( 1 1 = t mp ;
System . out . println( "" l ;
System . out . pri nt1n( "Ordenado por columnas" ) ;
System . out . println ("Numero (0 , 0) : " + n [0 1 (01 l ;
System . out . println (" Numero (0 , 1) : " + n [0 ] (1] l ;
System . out . println( " Numero (1 , 0) : " + n[1 ] [0] ) ;
System . out . print1n( " Numero (1 , 1) : " + n[1 ][ 11J ;
System . out . println (" Numero (2 , 0) : " + n [2 1 (01 l ;
System . out . pri ntln (" Numero (2 , 1) : " + n [2 ] (1]) ;
..............................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-233-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Enunciado: Almacene 9 números en una matriz de 3x3 y obtenga los números ordenados.
Análisis: Para la solución de este problema se requiere que el usuario ingrese 9 números; luego, que el
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
" . C:ARCHIV- 1XINOXS- 1UCRL.. I!:II:J
Nune1•o <1-l,¡l): 9
a
Hune I'O <H.!): H
•
Htllli!I'O <H,/.): '/
Nune1·o (1 ,¡j): 6
Hune t•o (!,!): 'J
Hune I'O (1 ,/.): 1
Hunc1·o (2,11): J
Nune¡•o <2,1): 2
Hu ru: I'O <2,/.): 1
Ot•denddo
Huru:l'tl <H.H): 1
Nune I'O <H.!): /.
Hune t•o <H.2): ]
Htlllf'I'C) (1 ,H): 1
Nune t•o (1 ,1 ): ~
Hune I'O (1 ,2): 6
Hunt~ l'n <?.,H): '/
Nune t•o (2,1): 8
Nune t•o <2.2): 9
Pt·t~:::: dlll kt~ 1 lo conl in tu: .. .](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-234-2048.jpg)
![Algoritmos con java
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
¡
~](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-235-2048.jpg)
![Capítulo 7: Estructuras de datos. Arreglos (vectores y matrices)
Pseudocódigo
Inicio
//Variables
tmp, i , j , x , LS Entero
flag : Logico
//Arreglos (Matriz y Vector)
n [3 ] [3] : Entero
0[9 ] : Entero
//Entrada
Leer n[O] [OJ,n[OJ [1J,n[0] [2],
n[1] [OJ,n[1] [ 1J,n[1] [2],
n[2] [0J,n[2] [ 1J,n[2] [2 ]
//Proceso
X - 0
Para i-0 Hasta 2 Inc 1
Para j - 0 Hasta 2 Inc 1
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+1] Entonces
tmp - o ( j + 1)
o(j + 1) - o(j)
o(j) - tmp
Fin Si
Fin Para
Fin Para
X - 0
Para i-0 Hasta 2 Inc 1
Para j-0 Hasta 2 Inc 1
n[i] [j ] - o[x]
X - X + 1
Fin Para
Fin Para
//Salida
Escribir n[O] [ OJ,n[O] [1J,n[O] [ 2],
n[1] [0J,n[1] [ l],n(l] [2],
n[2] [OJ,n[2] [ l],n[2] [2 ]
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-236-2048.jpg)
![Algoritmos con java
Codificación:
.......................................................................................................................................................................................................... ...
. import java . util . Scanner;
public class Problema85 {
public static void main(String[J args) {
//Variables
int tmp , i , j , x , LS ;
//Arreglos
int n () [) = new int ( 3) ( 3) ;
int o () = new int [ 9] ;
//Entrada
Scanner teclado= new Scanner{System . in ) ;
System . out . print( " Numero (0 , 0) : " ) ;
n[O] [0] = teclado . nextint () ;
System . out . print( " Numero (0 , 1 ) : " ) ;
n(O] (1] = teclado . nextint () ;
System . out . print ( " Numero (0 , 2) : " ) ;
n [0 ] [2 ] = teclado . nextint () ;
System . out . print( " Numero (1 , 0) : " ) ;
n[1] [0] = teclado . nextint() ;
System . out . print ( " Numero (1 , 1) : " ) ;
n[1] [1] = teclado . nextint() ;
System . out . print (" Numero (1 , 2) : " ) ;
n[1] [2) = tec1ado . nextint () ;
System . out . print( " Numero {2, 0) : '' ) ;
n [2] [0 ) = teclado . nextint () ;
System . out . print ( " Numero (2 , 1) : " ) ;
n[2] [1] = tec1ado . nextlnt () ;
System . out . print ( " Numero (2 , 2) : " ) ;
n[2] [2] = teclado . nextint () ;
//Proceso
X = O;
for (i = O; i<=2 ; i++ ) {
for ( j = O; j<=2 ; j++) {
o(x] = n[i](j] ;
x++ ;
}
)
LS = o . length - 1 ;
f o r ( i = O; i <=LS - 1 ; i ++ ) {
for(j = O; j <= LS - 1 ; j++) {
if(o[j] > o(j + 1)) {
tmp = o[j + 1) ;
o[j + 1] = o[j] ;
o(j) = tmp ;
}
•., ...........................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-237-2048.jpg)
![Algoritmos con j ava
Caracteres extendidos de ASCII
128 € 144 • 160 176 o
193 '
A 209 N 225 á
" o '
129 145 . 161 177 + 194 A 210 226
• 1 a
- ó
130 146 ' 162 <t 178 2
195 A 211 227 ¡¡
'
131 f 147 " 163 t 179 3 196 A 212 ó 228 a
132 148 " 164 ll 180 ' 197 Á 213 6 229 •
"
a
133 149 • 165 y 181 ~ 198 fE 214 6 230 re
...
134 j· 150 166 ' 182 11 199 <; 215 X 231 r;
- '
135 :¡: 151 - 167 § 183 . 200 E 216 0 232 '
e
136 ' 152 - 168
.. 184 • 201 É 217 ¡) 233 '
e
137 %o 153 ·n.t 169 © 185 1
202 ~ 218 ú 234 "
e
138 s 154 V
S 170 • 186 V 203 E 219 o 235 e
139 (
156 ce 171 << 187 >> 204 l 220 ü 236 '1
140 (E 157 • 172 .., 188 1,4 205 f 221 '
y 237 '
1
141 • 158 z 173 189 V2 206 í 222 ]:> 238 '1
142
V
z 159 y 174 ® 190
* 207 1 223 B 239 1
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 earaet er
e : Caraete r
//Asigna r un valo r
e - 'A'
241 ñ
242 '
o
243 '
o
244 '
o
245 o
246 o
247 .
248 ~
249 '
u
250 '
u
251 '
u
252 ü
253 '
y
254 p
255 y
'•• ..........................................................................................................................................................................................................
Java
.......................................................................................................................................................................................................... ...
//Crear una va r iab l e e araet e r
ehar e ;
/ /As i gna r um va lor
e = ' A ';](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-241-2048.jpg)
![Diagrama de flujo
( Inicio )
¡
e . Caracter
.
a . Entero
.
¡
/ Leer e
/
¡
a - Codigo(c)
¡
/ Escribir a /
¡
Fin )
Capítulo 8: Cadenas de caracteres
Algoritmo
Pseudocódigo
Inicio
//Variables
e Caracater
a : Entero
//Entrada
Leer e
//Proceso
a - Codigo(c)
//Salida
Escribir a
Fin
Codificación:
.............................................................................................................................................................................................................
import java . util . Scanner;
public class Problema88 {
public static void main(String[] args) {
//Variables
}
}
String e ;
int a ;
//Entrada
Scanner teclado = new Scanner(System . in ) ;
System . out . pri nt( "Caracter : " ) ;
e= teclado . nextLine() ;
//Proceso
a = c . codePointAt(O) ;
1/Salida
System . out . println( "''J ;
System . out . println( "ASCII : " +a) ;
•,, ..........................................................................................................................................................................................................
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 Salida
• letra (1
) • Respuesta (r)](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-250-2048.jpg)
![Algoritmos con java
Diagrama de flujo
( rnicio )
¡
e . Caracter
.
r . Cadena
.
a . Entero
.
/ Leer e /
¡
a-Codigo(Mayus(c))
l_
48 y 5
V
< a> a<
F
1
r- "ES NUMERO"
<a> 65 y a< 90
V
F
1 r-"ES LETRA"
r-" ES SIMBOLO"
1 Escribir r
1
¡
eFin
Codificación:
Algoritmo
Pseudocódigo
Inicio
//Variables
e Caracter
r Cadena
a Entero
//Entrada
Leer e
//Proceso
a~ Codigo(Mayus(c))
Si a>=48 Y a<=57 Entonces
r - " ES NUMERO"
SiNoSi a>=65 Y a<=90 Entonces
r - " ES LETRA"
SiNo
r - " ES SIMBOLO"
E'in Si
//Salida
Escribir r
Fin
.............................................................................................................................................................................................................
import java . util . Scanner;
public class Problema90 {
}
public static void main(String[] args) {
//Variables
}
String c , r ;
int a ;
//Entrada
Scanner teclado= new Scanner(System . in ) ;
System . out . print( "Caracter : " );
e= teclado . nextLine() ;
//Proceso
a= c . toUpperCase (J . codePointAt(OJ ;
if(a >= 48 && a <= 57 )
r = " ES NUMERO";
else if(a >= 65 && a<= 90)
r = "ES LETRA";
else
r = "ES SIMBOLO";
1/Salida
System . out . println( "'' ) ;
System . out . println( " Resultado : " + r) ;
.............................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-253-2048.jpg)
![Capítulo 8: Cadenas de caracteres
Problema n.2 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
e,- C:ARCHIV-1 XINOXS-1 .JCREAT;~~ lit!]El
-- -
Hnnh1•e: Ric<H'Itn a
C.mt iddd: ] -
Respuestd: Hic
PI'e:;:; •Hll/ ke y t o (;011 t i IHU: _ • •
a
Algoritmo
Diagrama de flujo Pseudocódigo
( Inicio )
~
n , r . Cadena
.
e . Entero
.
!
/ Leer n , e
/
!
r - Izquierda (n , c)
!
1 Escribir r
1
!
( Fin
Inicio
//Variables
n , r : Cadena
e : Entero
//Entrada
Lee r n , e
/ / Proceso
r - Izquierda(n , c)
//Salida
Escribir r
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-254-2048.jpg)
![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)
l
/ Escribir rj
!
( Fin
Capítulo 8: Cadenas de caracteres
Algoritmo
Inicio
Fin
Pseudocódigo
//Variables
p , t , u , l , n , c
//Entrada
Leer n
//Proceso
Cadena
p- Izquierda(n, 1)
t- Extraer(n , 2, 1)
u- Derecha (n , 1)
1- Cadena(Longitud(n))
e- Mayus(p + t +u+ 1)
//Salida
Escribir e
Codificación:
import java . util . Scanner;
public class Problema92 {
}
public static void main(String[] args) (
//Variables
}
String p , t , u, l , n , c ;
//Entrada
Scanner teclado = new Scanner(System . in) ;
System . out . print( "Nombre : '' ) ;
n = teclado . next Line() ;
//Proceso
p- n . substring(0, 1) ;
t- n . substring(2, 3) ;
u = n . substring(n . length ()-1) ;
1- String . valueOf(n . trim() . length() ) ;
e = (p + t +u + 1) . toUpperCase() ;
//Salida
System . out . println( "'' ) ;
System . out . println( "Codigo : " +e) ;
., ........................................................................................................................................................................................................... .](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-256-2048.jpg)
![Algoritmos con java
Java
............................................................................" ...............................................................................................................................
//Crear un método
private static int I ncrementar (int N) {
N =N + 1 ; //Modiñ ca el valor de N
return N·
'
}
//Invocar el método
Num = 5 ;
Res= Incrementar(Num) ; //El valor de Num se copi a en N
System . out . println(N um) ; //su valor s i gue siendo 5
System . out . println(Res) ; //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
.......................................................................................................................................................................................................... ··.
· //Crear una función
Funcion Incrementar(S : N: Entero) : Entero
N- N + 1 //Modiñ ca el valor de N
Retorna N
Fin Funcion
// Invocar la función
Num - 5
Res- I ncrementar (Num) //El parámetro N hace referencia a Num
Imprimir Num //su valor ahora es 6
Imprimir Res //su valor es 6
Java
.......................................................................................................................................................................................................... ...
//Crear una función
private static int Incrementar(int N[ ] ) {
N[O] = N( O] + 1 ; //Modiñ ca el valor de N
return N( O] ;
}](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-269-2048.jpg)
![Capítulo 9: SubAigoritmos (procedimientos y funciones)
.......................................................................................................................................................................................................... ..
· // ' I nvocar la func i ó n
Num [O] = 5 ;
Res= Incrementar (Num) ; //El parámetro N hace referencia a Num
System . o ut . print l n (Num[ O] ) ; //su valor ahora es 6
System . out . pri nt l n (Res ) ; //su valor es 6
............................................................................................................................................................................................................
Problema n.2 96
Enunciado: Dados dos números enteros, hallar la suma. Cree una función para resolver el problema.
Sumar(E:Numl :Entero, E:Num2:Entero):Entero
Interfaz de usuario
, ' C:ARCHIV- 1XINOXS-1UCR~.:;'. l!:li:J
Algoritmo
Diagrama de flujo Pseudocódigo
Principal Principal
Inicio
//Variables
nl , n2 , S
. Entero nl , n2 , S Entero
.
Leer nl , n2
//Entrada
Leer n l , n2
s ·- Sumar (nl , n2)
//Proceso
Esc r ibir S ·- Sumar (nl + n2)
S
//Salida
Fin
Esc rib i r S
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-270-2048.jpg)
![Algoritmos con java
Diagrama de flujo
SubAigoritmo
Pseudocódigo
Sumar
( Inicio )
~
Numl , Num2 , s . Entero
.
~
~Leer Numl , Num~
~
S - Numl + Num2
~
/ Escribir S
/
~
( Fin )
Funcion Sumar(E:Numl:Entero,
E:Num2:Entero) :Entero
//Variables locales
s : Entero
//Proceso
s - Numl + Num2
//Salida
Retornar s
Fin Funcion
Codificación:
.......................................................................................................................................................................................................... ..
· import java . util . Scanner;
public class Problema96 {
//Principal
}
public static void main(String[] args) {
//Variables
}
int nl , n2 , s ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . print(" Numero 1 : " ) ;
nl = teclado . next!nt() ;
System . out . print( "Numero 2 : " ) ;
n2 = teclado . next!nt() ¡
//Proceso
s = Sumar(nl , n2) ;
//Salida
System . out . println( "" ) ;
System . out . println( " Suma : " + s) ;
//Método Sumar
private static int Sumar(int Numl , int Num2) {
//Variables
int s ;
//Proceso
s = Numl + Num2 ;
//Salida
return s ;
}
................................................................................................................'.............................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-271-2048.jpg)
![Algoritmos con java
Diagrama de flujo
Mayor
Inicio
nl , n2 , m Entero
F
m - nl
F
m - n2
Escribir m
Fin
Codificación:
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
........................................................................................................................................................................................................... ...
import java . util . Scanner;
public c lass Problema97 {
//Principal
public static void main(String[] args) {
//Variables
)
int nl , n2 , m=O ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . print ("Nume ro 1 : " ) ;
nl = teclado . next!nt() ;
System . out . print( " Numero 2 : " ) ;
n2 = tec lado . nextint() ;
//P r oceso
m = Mayor(n l , n2) ;
//Salida
System . out . println( "" ) ;
System . out . pri ntln( "Mayor : " + m) ;
'·· ...........................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-273-2048.jpg)
![Capítulo 9: SubAigoritmos (procedimientos y funciones)
........................................................................................................................................................................................................... ..
o
l
//Método Mayor
prívate static i nt M
ayo r( i nt nl , i nt n2) (
//Variables
l
int m = O;
//Proceso
if(n l > n2)
m - nl ·
'
if(n2 > nl)
m - n2 ·
'
//Salida
return m;
... .......................................................................................................................................................................................................... .
Problema n.2 98
Enunciado: Determinar si un número entero es par o impar. Cree un procedimiento para resolver el
problema.
Principal
Parlmpar(E:num:Entero, S:res:Entero)
Interfaz de usuario
, ' C:ARCHIV- 1XINOXS-1UCRf:~ l!lli]f!1
Diagrama de flujo
Inicio
nl, n2 , m : Entero
Leer nl , n2
m - Mayor(nl , n2)
Escribir m
Fin
Algoritmo
Pseudocódigo
Principal
Inicio
//Variables
n Entero
r : Cadena
//Entrada
Lee r n
//Proceso
Parimpar (n , r)
//Salida
Escrib i r r
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-274-2048.jpg)
![Algoritmos con java
SubAigoritmo
Diagrama de flujo Pseudocódigo
Parlmpar
( Inicio )
Procedimiento Parimpar(E:num:Entero,
S:res:Cadena)
!
num . Entero
.
res , r . Cadena
.
!
1 Leer num 1
1
F
~Mod 2=
V
! !
r - " IMPAR" r - "PAR"
1 1
/ Escribir res -r /
!
( Fin )
Codificación principal:
//Variables locales
r : Cadena
//Proceso
Si num Mod 2 = O Entonces
r - "PAR"
SiNo
r - " IMPAR"
Fin Si
//Salida
res - r
Fin Procedimiento
.........................................................,,,,...................................,,,,.......................................................................................' .............. ...
import java . util . Scanner;
public class Problema98 {
//Principal
publ i c stati c void main (Stri ng[) args) {
//Variables
1
int n;
Stri ng r[] - new String[l] ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . print( "Numero : '' ) ;
n = tecl ado . ne xtint () ;
//Proceso
Parimpar (n , r) ;
1/Salida
System . out . println( "" ) ;
System . out . println( " Resultado : " + r[O]) ;
.. .......................................................................................................................................................................................................... .](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-275-2048.jpg)
![Capítulo 9: SubAigoritmos (procedimientos y funciones)
.........................................................................................................o ••••••••••••••••••'..• • • • • • • • • • • • .. • • • • • • • • • • • • • • • • • • • • • • • • • ..• • • • • • • • • • • • • • • • ..• • • • • • • • .. • • • • • • • ••
//Método Parimpar
private static void Par l mpar (int num, String res[]) 1
//Variabl es
)
String r =
//Proceso
if (num % 2
""·
'
== o) 1
r - "PAR";
)else{
r = " IMPAR" ·
'
}
//Sal i da
res[O] = r ;
} .
... ...........................................................................................................................................................................................................
Problema n.2 99
Enunciado: Dado un número, determinar cuántos dígitos tiene. Cree una función para resolver el
problema.
Principal
CantidadDigitos(E:num Entero):Entero
Interfaz de usuario
, ' C:ARC
HIV- 1XINOXS- 1UCREAT.
:t)lt:Jf:l
Algoritmo
Diagrama de flujo Pseudocódigo
(
n,
1
Inicio )
¡
e . Entero
.
l
Leer n
1
¡
Principal
Inicio
//Variables
n , e : Entero
//Entrada
Leer n
e - CantidadDigitos(n)
//Proceso
l
1 Escribir
¡
( Fin
e
1
)
e- CantidadDigitos (n)
//Salida
Escrib i r e
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-276-2048.jpg)
![Algoritmos con java
Diagrama de flujo
CantidadDigitos
Inicio
num, e Entero
Leer num
num- num 10
C·- C+l
Escribir e
Fin
F
SubAigoritmo
Pseudocódigo
Funcion CantidadDigitos
(E:num:Entero) :Entero
//Variables locales
e : Entero
//Proceso
Mientras num>O
num - num 10
e - e + 1
Fin Mientras
//Salida
Retornar e
Fin Funcion
Codificación:
.
import java . util . Seanner;
public class Problema99 1
//Principal
public static void main(String[] args) {
//Variables
)
int n, e =O ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . print( "Numero
n = t eclado . nextint() ;
//Proceso
e= CantidadDigitos(n) ;
//Salida
. " ) .
• 1
System . out . println( "'' ) ;
System . out . println( "Cant . Digitos : " + e ) ;
............................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-277-2048.jpg)
![Capítulo 9: SubAigoritmos (procedimientos y funciones)
............................................................................................................................................................................................................
.
}
//Método Factorial
pr í vate static i nt Factorial(i nt num) {
//Variables
}
int i , f ;
//Proceso
f = 1;
f or (i = 1 ; i<=num; i++ )
f *= i ;
//Salida
return f ;
... .......................................................................................................................................................................................................... .
Problema n.2 101
Enunciado: Dado 5 números obtener la suma. Cree una función para resolver el problema.
Principal
Sumar(E :num [):Entero):Entero
Interfaz de usuario
'; C:ARCHIV- 1XINOXS-1UCR(;!J I!I¡]E3
Diagrama de flujo
( Inicio }
¡
S . Entero
.
~
n[S] : Entero
¡
Algoritmo
Principal
Inicio
Pseudocódigo
//Variables
s : Entero
//Arreglos (Vector)
n[5] : Entero
¡ Leer n[O ] , n [l/
n[2 ], n[3 ], n [4 )
//Entrada
Leer n [O] , n [ l ], n [ 2) , n[3 J, n [ 4)
!
s- Sumar(n)
!
1 Escribir s 1
¡
( Fin )
//Proceso
s- Sumar (n )
//Salida
Escribir s
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-280-2048.jpg)
![Algoritmos con java
Diagrama de flujo
Sumar
Inicio
J
i , S . Entero
.
l
num [ ] . Entero
.
~
1 Leer num 1
l
i - 0
i< 4
i - i+l
lV
S ·- S + num[i ]
1
~
1 Escribir S
1
l
( E'in
F
SubAigoritmo
Pseudocódigo
Funcion Sumar(E:num[] :Entero) :Entero
//Variables locales
i , s : Entero
//Proceso
Para i-0 Hasta 4 Inc 1
s - s + num[i1
Fin Para
//Salida
Retornar s
Fin Funcion
Codificación:
.· .......................................................................................................................................................................................................... ...
import java . util . Scanner;
public c lass ProblemalOl {
//Principal
public static void main(String[1 args) {
//Variables
int S= O, i ;
//Arreglos
int n ( 1 = new int [51 ;
//Entrada
Scanner teclado= new Scanner(System . in ) ;
System . out . pri nt( "Numero 1 : " ) ;
n(01 = t eclado . nextint() ;
System . out . print( "Numero 2 : " ) ;
n(11 = teclado . nextint() ;
System . out . print( "Numero 3 : " ) ;
n[21 = teclado . nextint() ;
System . out . print( "Numero 4 : " ) ;
n[31 = teclado . nextint () ;
System . out . print( "Numero 5 : " ) ;
n[41 = teclado . nextint() ;](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-281-2048.jpg)
![Capítulo 9: SubAigoritmos (procedimientos y funciones)
.·········································································································································································································· ..,
}
}
//Proceso
s = Sumar (n) ;
//Salida
System . out . println( "'') ;
System . out . pr i ntln( " Suma : " + s )¡
//Método Sumar
private static i nt Sumar(int num[]) {
//Variabl es
}
int s = O, i ;
//Proceso
for (i = O; i <= 4 ; i ++)
s += num[i ];
//Sal ida
return s ;
.' .......·····.........................................································.....................................................................................................................
Problema n.2 102
.
Enunciado: Ordene 4 números usando el método de ordenación por intercambio (burbuja). Cree un
procedimiento para resolver el problema.
Ordenar (S:num(]:Entero)
Interfaz de usuario
'' C:ARCHIV-1XINOXS-1 ucR!JIIIiJf:l](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-282-2048.jpg)
![Algoritmos con java
Diagrama de flujo
Principal
( Inicio )
¡
ln[4] : Entero!
!
j Leer n[O] , n[l] , n[2] , n[3 v
!
Ordenar(n)
!
/ Escribir n[O] , n[l] , n(2] , nl3y/
!
l E'in )
Algoritmo
Pseudocódigo
Principal
Inicio
//Arreglos (Vector)
n[4] : Entero
//Entrada
Leer n[O),n[l),n[2J,n[3]
//Proceso
Ordenar( n )
//Salida
Escrib i r n [O J, n( l],n [2],n(3]
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-283-2048.jpg)
![Capítulo 9: SubAigoritmos (procedimientos y funciones)
Diagrama de flujo
Ordenar
( rnicio
!
tmp, i , j , LI , LS . Entero
.
!
num (4] . Entero
.
!
1 Leer num j
!
LI - o
LS - 3
!
i-LI F
i< LS 1
i-i+1
¡v
j-LI F
j<-LS 1
j-j+l
l_v
F
num(j]>num(j+1...,_
V
tmp - num [ j l
num ( j J ·- num[ j+1)
num[j+1) - tmp
!
/Escribir num/
!
( Fin )
SubAigoritmo
Pseudocódigo
Procedimiento Ordenar(S:num[ ] :Entero)
//Variables locales
tmp, i , j , LI , LS : Entero
//Proceso
LI O
LS - 3
Para i-LI Hasta LS-1 Inc 1
Para j-LI Hasta LS-1 Inc 1
Si num[j ]>num[j+l] Entonces
tmp- num[j]
num(j] - num[j+ l ]
num[j+l] - tmp
Fin Si
Fin Para
Fin Para
//Salida
Escribir num
Fin Procedimiento](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-284-2048.jpg)
![Algoritmos con java
Codificación:
............................................................................................................................................................................................................
· import java . util . Scanner;
public class Problema102 {
//Principal
}
public static void main (Stri ng[) args) {
//Variables
}
int tmp , i , j , LI , LS ;
//Arreglos
int n () = new int ( 4) ;
//Entrada
Scanner teclado = new Scanner(System . in) ;
System . out . print(" Numero 1 : " ) ;
n(O] = teclado . nextint() ;
System . out . print( " Numero 2 : " ) ;
n[l) = teclado . nextint() ;
System . out . prin t( " Numero 3 : " ) ;
n [2 ) = teclado . nextin t () ;
System . out . pri nt( " Numero 4 : " ) ;
n [3 ] = teclado . nextin t () ;
//Proceso
Ordenar (n) ;
//Salida
System . out . pri ntln( "'' ) ;
System . out . pri ntln( "Ordenado" ) ;
System . out . println( " Numero 1 : " + n[O) ) ;
System . out . println( " Numero 2 : " + n[l) ) ;
System . out . println( " Numero 3 : " + n[2) ) ;
System . out . print ln( " Numero 4 : " + n[3)) ;
//Método Ordenar
private static void Ordenar (in t num[)) {
//Variables
}
int tmp, i , j , LI , LS ;
//Arreglos
int n () = num ;
//Proceso
LI = O;
LS - n . length - 1 ;
for(i = LI ; i <= LS - 1 ; i++) {
for(j = LI ; j <= LS- 1 ; j++ ) {
}
if(n[ j ) > n ( j + 1 )) {
tmp = n [ j] ;
}
}
//Salida
num = n ;
n [j) = n[j + 1) ;
n [j + 1 ) = tmp;
.............................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-285-2048.jpg)
![Capítulo 9: SubAigoritmos (procedimientos y funciones)
Problema n.2 103
-
Enunciado: Ingrese 6 números en una matriz de 3x2 y obtenga el numero mayor ingresado. Cree una
función para resolver el problema.
Mayor{E:num[] :Entero):Entero
Interfaz de usuario
'; C:ARCHIV-1XINOXS- 1.JC., I¡]EJ
Diagrama de flujo
( Inicio )
!
m : Entero
¡
n[3 ] [2] : Entero
+
~ Leer n[OJ (O J , n[OJ [1 ~~
n[l] [0],n[1] [1 ],
n [2 ] [O],n [2 ] [1]
¡
m - Mayor(n)
!
/ Escribir num /
!
( Fin )
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](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-286-2048.jpg)
![Algoritmos con java
Diagrama de flujo
Mayor
( Inicio }
l
m, i , j : Entero
!
num(JJ 121 . Entero
.
!
/ Leer num /
!
m . num(OJ 101
l
i - o F
i<a2
i. i+l
¡v
j. o
j<•l
F
j. j+1
l v
F
-num(il (ji >~
¡ v
m - num(il (j]
l
j Escribir m/
!
( Fin
SubAigoritmo
Pseudocódigo
Funcion Mayor(E:num[] []:Entero) :Entero
//Variables locales
m, i , j : Entero
//Arreglos (Matriz)
num[3] [2] : Entero
//Proceso
m ~ num[O] [0]
Para i-0 Hasta 2 Inc 1
Para j-0 Hasta 1 Inc 1
Si num[i] [j]>m Entonces
m - num[i] [j]
Fin Si
Fin Para
Fin Para
1/Salida
Escribir m
Fin Funcion](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-287-2048.jpg)
![Capítulo 9: SubAigoritmos (procedimientos y funciones)
Codificación:
..........................................................................................................................................................................................................··.
· import java . util . Scanner;
public class Problema103 {
//Principal
}
public static void main(String[) args) {
//Variables
}
int m;
//Arreglos
int n [] [) - new int [ 3) [ 2) ;
//Entrada
Scanne r teclado= new Scanner(System . in) ;
System . out .print( " Numero (0 , 0 ) : " ) ;
n [0 ) [0 ) = t eclado . nextint () ;
System . out . print (" Numero (0 , 1 ) : " ) ;
n (O J [1 ) = teclado . nextint () ;
System . out . print (" Numero (1 , 0) : ") ;
n[1) [0 ) = teclado . nex tint () ;
System . out . pri nt( " Numero (1 , 1) : " ) ;
n [1 ) [1) = t eclado . nextint () ;
System . o ut . print( " Numero (2 , 0) : '' ) ;
n [ 2) [0 ) = teclado . nextint () ;
System . out . print (" Numero (2 , 1 ) : " ) ;
n[2) [1) = teclado . nextint() ;
// Proceso
m = Mayo r (n) ;
1/Salida
System . out . println( "" ) ;
System . out . pri ntln( "Mayor : " +m) ;
//Método Mayor
private static int Mayor(int num [) [)) {
//Variables
}
in t m, i , j ;
//Proceso
m = num[O) [0 ) ;
for (i = O; i <=2 ; i++) 1
}
for (j = O; j<=l ; j ++) {
if(num [ i) [j ) >m)
m = num ( i )[j ] ;
}
//Sal ida
return m;](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-288-2048.jpg)
![Algoritmos con java
Problema n.2 104
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.
Mayor{E:num[] :Entero):Entero
Diagrama de flujo
Principal
( Inicio )
!
a[1) [1] : Entero
b[1) [1] . Entero
.
C(1) [ 1] . Entero
.
!
Leer a(O] (O),a(O] (1),
a[1) [0),a(1) (1),
1
b[O) [OJ,b[O] (1),
1 b[1] (OJ,b[1] [1] 1
!
e- SumaArreg1os (a , b , )
!
~~ Escribir :~
c(OJ (OJ,c(OJ ( 1 ]
c(1] [0J,c(1] ( 1 ]
!
( Fin )
Interfaz de usuario
Algoritmo
Pseudocódigo
Principal
Inicio
//Arreglos (Matriz)
a [ 11 [11 Entero
b[11 [11 Entero
c [ 11 [1 1 Entero
//Entrada
Lee r a [ O1 [ O11 a [ O1 [ 11 1
a[11 [01 ~ a[ 1 1 [ 1 11
b[0 1 [ 01 1 b[01 [11 1
b[1 1 [01 l b[ 1 1 ( 1 1
//Proceso
e- S umaA rreg l os < a ~ b >
//Salida
Esc r ibi r c[01 [OJ,c[OJ [ 1],
c(1] [0] 1 c [ 1] (1 ]
Fin](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-289-2048.jpg)
![Capítulo 9: SubAigoritmos (procedimientos y funciones)
Algoritmo
Diagrama de flujo
SumaArreglos
( Inicio )
l
i , j : Entero
!
ArrA[11 [1] . Entero
.
ArrB [ 1] [1] . Entero
.
s(1] [1] . Entero
.
l
/ Leer ArrA, ArrB/
l
i-0 F
i<-1
i-i+l
¡v
j-0
F
j<-1
j - j+l
F
s[i] [ j]-ArrA [i ) (j)+ArrB[i) (j )
l
l
l
/ Escribir s /
l
( Fin
Codificación:
import java . util . Scanner;
public class Problema104 {
//Pri.nci.pal
Funci.on
[]:Entero,
[l
Pseudocódigo
SumaArreglos (E :ArrA[]
E:ArrB[] []:Entero) :Entero[]
//Vari.ables locales
i , j : Entero
//Arreglos (Matri.z)
s [11 [11 : Entero
//Proceso
Para i-0 Hasta 1 Inc 1
Para j-0 Hasta 1 Inc 1
s [i) [ j 1-ArrA[i 1 [ j) +ArrB [i) [ j ]
Fin Para
Fin Para
//Sali.da
Retornar s
Fi.n Funci.on
public static void main{String[) args) {
//Arreglos
int a 1l [ l - new int [21 (2] ;
int b ( 1[) = new int [2 1 (2 ) ;
int e ( J [ J - new int [21 [2) ;
//Entrada
Scanner teclado= new Scanner{System . in) ;
System . out . println( " Arreglo A: " ) ;
System . out . println( " =========== : " ) ;
System . out . pri nt( " Numero (0 , 0) : " ) ;
... ..........................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-290-2048.jpg)
![)
)
Algoritmos con java
a[O] [0 ] = teclado . nextint () ;
System . out . print( " Numero (0 , 1) : " ) ;
a[O] [1] = teclado . nextint() ;
System . out . print( " Numero (1 , 0) : " ) ;
a[1] [0 ] = teclado . nextint() ;
System . out . print( " Numero (1 , 1) : " ) ;
a [1] [1] = teclado . next Int () ;
System . out . println( ''" ) ;
System . out . println( " Arreglo B : " ) ;
System . out . println( " =========== : '' ) ;
System . out . print( " Numero (0 , 0) : " ) ;
b [O] [0] = teclado . next!nt () ;
System . out . print (" Numero (0 , 1 ): " ) ;
b [OJ [1 ] = teclado . next!nt () ;
System . out . print (" Numero (1 , 0) : " ) ;
b [1] [0 ] = teclado . nextint () ;
System . out . print (" Numero (1 , 1 ) : " ) ;
b [1 ] [1 ] = teclado . nextint () ;
//Proceso
e= SumaArreglos(a, b) ;
11Salida
System . out . println( "'' J ;
System . out . println( " Arreglo C : " ) ;
System . out . println( " =========== : " ) ;
System . out . println( " Numero (0 , 0) : " + c[O ] [0] ) ;
System . out . println( " Numero (0 , 1) : " + c[O] [1] ) ;
System . out . println( " Numero (1 , 0) : " + c[1 ] [0 ] ) ;
System . out . println( " Numero (1 , 1) : " + c[1] [1] ) ;
//Método SumaArreglos
private static i nt [ ] [] SumaArreglos ( int ArrA [ ] [ ] , int ArrB [] [ ] ) {
//Variables
}
int i , j ;
//Arreglos
int s[] [] - new int[2] [2] ;
//Proceso
for (i = O; i<=1 ; i+ +) {
for ( j = O; j<=1 ; j++)
s[i] (j ] = ArrA(i] [ j] + ArrB [ i] [j] ;
)
//Salida
return s ;
•., ..........................................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-291-2048.jpg)
![Capítulo 9: SubAigoritmos (procedimientos y funciones)
Codificación:
· import java . util.Scanner ;
public class ProblemalOS {
//Principal
1
public static void main(String[] args) {
//Variables
1
String fl , f2 ;
//Entrada
Scanner teclado= new Scanner(System . in) ;
System . out . print( " Frase : " ) ;
fl = teclado . nextLine() ;
//Proceso
f2 = FraseSinEspacios ( fl) ;
1/Salida
System . out . println( "'' J ;
System . out . println("Frase sin espacios : " + f2) ;
//Método FraseS i nEspacios
private static String FraseSinEspacios(String Frase) (
//Variables
1
String f -
int i, p ;
//Proceso
p = O;
" " t ·
' '
Frase= Frase . trim( ) ;
for (i = O; i<Frase . length () ; i ++) {
}
if(Frase . substring(i , i+l) . equals( " " )) {
t = Frase . substring (p , i) ;
p - i + 1 ;
f - f + t ;
)
t - Frase . substring (p , i) ;
f - f + t ;
//Salida
return f ;
......................' .......................................................................................................................................................................................](https://image.slidesharecdn.com/00239fundamentosdeprogramacion-220323003043/75/00239_Fundamentos_de_programacion-pdf-294-2048.jpg)
Más contenido relacionado
Similar a 00239_Fundamentos_de_programacion.pdf
00239_Fundamentos_de_programacion.pdf
- 1. EDITORIAL MACRO" lng. RicardoMarcelo Villalobos Fundamentos de programación Más de 100 algoritmos codificados
- 2. Fundamentos de programación Másde 100 algoritmos codificados EDITORIAL MACRO~ España - México - Colombia - Chile - Ecuador - Perú - Bolivia - Uruguay - Guatemala - Costa Rica
- 3. EDITORIAL MACRO" Fundamentos de programaciónJava 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 Corrección de estilo: Milton A. Gonzales M. Coordinadora de edición: Cynthia Arestegui Baca Diseño de portada: Alejandro Marcas León Diagramación: Katia Valverde Espinoza Edición a cargo de: © Empresa Editora Macro EIRL Av. Paseo de la República N: 5613, Mirafiores, Lima, Perú t Teléfono: (511) 748 0560 i8! E-mail: proyecto@editorialmacro.com ® Página web: www.editorialmacro.com Primera edición e-book: agosto 2016 Disponible en: macro.bibliotecasenlinea.com ISBN N : 978-612-304-238-7 ISBN e-book N.· 978-612-304-454-1 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.
- 4. AUTOR Ricardo Marcelo Villalobos Profesionalde 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 t ransnacionales como Magna Rosseta Cerámica - MRC, en la cuales ha utilizado sus conocimientos de contabilidad y de ingeniería de software para realizar el análisis y 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-UN 1, Universidad Nacional de Trujillo, Universidad CésarVallejo 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 (Visual Bosic Nivel/l/ componentes, Orocle 10g, 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 stoffde escritores, y salen a la luz cuatro obras relacionadas a los primeros pasos de la ingeniería de software (libros de fundamentos y más de 100 algoritmos con Visual Basic, Java, C++ y Cll). En la actualidad, difunde su experiencia como docente en la Universidad Nacional de Ingeniería (UNI- 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.
- 5. Agradecim iento Es difícildejar 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 am igos en general.
- 6. / PROLOGO Prólogo Cómo no recordarlas 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 resueltos y 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 ent rada, proceso (secuencial) y salida de los cálculos realizados. El tercer capítulo presenta quince algoritmos con la estructura 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ítulo 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ítulo 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.
- 8. / INDICE / 1nd ice Capítulo 1 Fundamentosde programación ...................................................13 1.1 Introducción ................................................................................................................... 13 1.2 Computadora .................................................................................................................. 14 1.3 Arquitectura de una computadora ................................................................................ 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 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 Herramientas 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 fl ujo ........................................................................................................... 32
- 9. Capítulo 2 Estructura secuencial....................................................................33 2.1 Estructura secuencial .....................................................................................................33 Problema n.0 1 ......................................................................................................................33 Problema n.0 2 ......................................................................................................................35 Problema n.0 3 ......................................................................................................................36 Problema n.0 4 ......................................................................................................................38 Problema n.0 5 ......................................................................................................................39 Problema n.0 6 ......................................................................................................................41 Problema n.0 7 ......................................................................................................................43 Problema n-" 8 ......................................................................................................................44 Problema n.0 9 ......................................................................................................................46 Problema n.0 10 ...................................................................................................................48 2.2 Problemas propuestos ...................................................................................................50 Capítulo 3 Estructura selectiva simple y doble ...............................................51 3.1 1 ntroducción ...............................................,...................................................................51 3.2 Estructura selectiva simple ............................................................................................51 3.3 Estructura selectiva doble .............................................................................................52 3.4 Estructuras anidadas ......................................................................................................52 Problema n.0 11 ..................................................................................................,.................53 Problema n.0 12 ...................................................................................................................55 Problema n.0 13 ...................................................................................................................57 Problema n.0 14 ...................................................................................................................60 Problema n.0 15 ...................................................................................................................62 Problema n.0 16 ...................................................................................................................63 Problema n.0 17 ....................................................................................................................65 Problema n.0 18 ...................................................................................................................67 Problema n.0 19 ...... ............................. ......... ......... ......... ................... ................... ..... ..71 Problema n.0 20 ...................................................................................................................72 Problema n.0 21 ................................................................................................................... 75 Problema n.0 22 ...................................................................................................................77 Problema n.0 23 ....................................................................................................................81 Problema n.0 24 ...................................................................................................................82 Problema n.0 25 ....................................................................................................................84 3.5 Problemas propuestos ...................................................................................................87
- 10. Capítulo 4 Estructura selectivamúltiple .........................................................89 4.11ntroducción ...................................................................................................................89 4.2 Estructura selectiva múltiple .........................................................................................89 4.2.1 Estructura selectiva múltiple usando rangos ........................................................91 Problema n.0 26 ...................................................................................................................91 Problema n.0 27 ....................................................................................................................93 Problema n.0 28 ....................................................................................................................96 Problema n.0 29 ....................................................................................................................97 Problema n.0 30 ....................................................................................................................99 Problema n.0 31 .................................................................................................................. 101 Problema n.0 32 .................................................................................................................104 Problema n.0 33 ..................................................................................................................107 Problema n.0 34 .................................................................................................................109 Problema n.0 35 ................................................................................................................. 111 Problema n.0 36 ................................................................................................................. 115 Problema n.0 37 .................................................................................................................118 Problema n.0 38 .................................................................................................................120 Problema n.0 39 .................................................................................................................123 Problema n.0 40 .................................................................................................................126 4.3 Problemas propuestos ................................................................................................. 133 Capítulo S Estructura repetitiva «Mientras>> ................................................ 135 5.1 Introducción ................................................................................................................135 5.2 Contador ......................................................................................................................135 5.3 Acumulador ................................................................................................................. 136 5.4 Salir del bucle ...............................................................................................................136 5.5 Continuar al inicio del bucle ....................................................................................... 136 5.6 Estructura repetitiva «Mientras» ................................................................................. 137 5.7 Estructura repetitiva «Mientras» anidada ............ ............................................. ....... 137 Problema n.0 41 ..................................................................................................................138 Problema n.0 42 .................................................................................................................. 139 Problema n.0 43 ................................................................................................................. 141 Problema n.0 44 ..................................................................................................................142 Problema n.0 45 .................................................. .... .............. .... .............. .... .................144 Problema n.0 46 .................................................................................................................145 Problema n.0 47 ................................................................................................................. 147 Problema n.0 48 ................................................................................................................. 148
- 11. Problema n.0 49 .................................................................................................................150 Probleman.0 50 .................................................................................................................. 152 Problema n.0 51 ..................................................................................................................153 Problema n.0 52 .................................................................................................................. 155 Problema n.0 53 ................................................................................................................. 156 Problema n.0 54 .................................................................................................................158 Problema n.0 55 ................................................................................................................. 160 5.8 Problemas propuestos ................................................................................................. 163 Capítulo 6 Estructura repetitiva <<Para>> ........................................................ 165 6.llntroducción .................................................................................................................165 6.2 Estructu ra repetitiva «Para» ........................................................................................ 165 6.3 Estructura repetitiva «Para» anidada .......................................................................... 166 Problema n.0 56 ................................................................................................................. 166 Problema n.0 57 .................................................................................................................168 Problema n° 58 ... ..... ....................................... .... .... .............. .............. .... .................. 169 Problema n.0 59 ................................................................................................................. 171 Problema n.0 60 ................................................................................................................172 Problema n.0 61 ................................................................................................................. 174 Problema n.0 62 ................................................................................................................. 175 Problema n° 63 ......... ....................................... .... .... ......... .... .............. .... .................. 177 Problema n.0 64 ................................................................................................................. 180 Problema n.0 65 ................................................................................................................. 181 Problema n.0 66 ................................................................................................................. 183 Problema n.0 67 ................................................................................................................. 185 Problema n° 68 ................................................................................................................. 186 Problema n.0 69 .................................................................................................................188 Problema n.0 70 .................................................................................................................190 6.4 Problemas propuestos ................................................................................................. 193 Capítulo 7 Estructuras de datos. Arreglos (vectores y matrices) ................... 195 7.llntroducción ................................................................................................................. 195 7.2 Arroys (arreglos) .......................................................................................................... 196 7.3 Operaciones con orroys ............................................................................................... 196 7.4 Creación de orroys .......................................................................................................197 7.5 Recorrido por los elementos del orroy ........................................................................198 Problema n° 71 .......................................................................... .... ......... .... .................. 199
- 12. Problema n.0 72 .................................................................................................................200 Probleman.0 73 .................................................................................................................202 Problema n.0 74 .................................................................................................................203 Problema n.0 75 .................................................................................................................206 Problema n.0 76 ..............•...................•..............................................................................209 Problema n.0 77 .................................................................................................................212 Problema n.0 78 ................................................................................................................. 215 Problema n.0 79 .................................................................................................................217 Problema n.0 80 .................................................................................................................219 Problema n.0 81 .................................................................................................................222 Problema n.0 82 .................................................................................................................225 Problema n.0 83 ............... ...................................... .............. .... .... .... .... .... .................227 Problema n.0 84 .................................................................................................................230 Problema n.0 85 .................................................................................................................233 7.6 Problemas propuestos .................................................................................................238 Capítulo 8 Cadenas de caracteres ................................................................239 8.11ntroducción .................................................................................................................239 8.2 Juego de caracteres .....................................................................................................239 8.3 Carácter (char) .............................................................................................................240 8.4 Cadena de caracteres (string) . ... .... .... .............. ......................................... .... ....... 241 8.5 Operaciones con cadena ............................................................................................. 241 8.6 Concatenación .............................................................................................................241 8.7 Comparación ................................................................................................................ 242 8.8 Cálculo de longitud ......................................................................................................242 8.9 Extracción de cadenas (subcadenas) .... .... ......... .... ............................................. ...243 8.10 Búsqueda de cadenas ................................................................................................244 8.11 Conversiones ..............................................................................................................244 Problema n.• 86 ................................................................................................................. 246 Problema n.• 87 ................................................................................................................. 247 Problema n.• 88 .................................................................................................................248 Problema n.o89 ................................................................................................................. 249 Problema n.· 90 .................................................................................................................251 Problema n.• 91 ................................................................................................................. 253 Problema n.· 92 ................................................................................................................. 254 Problema n.• 93 .................................................................................................................256 Problema n.o94 ................................................................................................................. 257 Problema n.• 95 ..................................•.............................................................................. 260 8.12 Problemas propuestos ............................................................................................... 263
- 13. Capítulo 9 SubAigoritmos (procedimientosy funciones) ............................. 265 9.11ntroducción .................................................................................................................265 9.2 Procedimientos ............................................................................................................266 9.3 Funciones .....................................................................................................................266 9.4 Paso de parámetros ......................... .......................................................................... 267 9.5 Parámetros por valor (entrada) ...................................................................................267 9.6 Parámetros por referencia (salida) ................................................ ............................268 Problema n.• 96 .................................................................................................................269 Problema n.· 97 .................................................................................................................271 Problema n.• 98 .................................................................................................................273 Problema n.• 99 .................................................................................................................275 Problema n.• 100 ...............................................................................................................277 Problema n.• 101 ...............................................................................................................279 Problema n.· 102 ...............................................................................................................281 Problema n.• 103 ...............................................................................................................285 Problema n.• 104 ...............................................................................................................288 Problema n.· 105 ...............................................................................................................291 9.7 Problemas propuestos..................................................................................................294
- 14. Fundamentos de programación 1.11ntroducción Enlos 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 de Java, uno de los lenguajes de programación más utilizado en la actualidad. A continuación se describen los conceptos generales de los fundamentos de programación.
- 15. Algoritmos con java 1.2Computadora 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
- 16. Capítulo 1: Fundamentosde programación la siguiente figura muestra la arquitectura de la computadora y sus principales componentes en coordinación. Dispositivos de entrada (INPUT) Proceso CPU (Central Processing Unit) ALU (Arithmetic Logic Unit) t cu l (Control Unit) J Memoria interna . . .··- .~~ ___t__ Memoria externa 1.4 Unidades de medida de almacenamiento Dispositivos de salida (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
- 17. Algoritmos con java 1.5Sistemas 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 fórmula: 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 · 2 ' + 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 o 2 - 2 resto o 2 o 2 - 1 resto o 1 o 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.
- 18. Capítulo 1: Fundamentosde programación 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.
- 19. Algoritmos con java 1.11Lenguajes 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 ~
- 20. Capítulo 1: Fundamentosde programación 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 - - --
- 21. Algoritmos con java 1.14Algoritmo 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 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. Los 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 permitir su ejecución las veces que haga falta. No son válidos los que t ras ejecutarse una vez ya no pueden volver a hacerlo por la razón que sea.
- 22. Capítulo 1: Fundamentosde programación 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
- 23. Algoritmos con java r- " IMPAR" Inicio n Entero r Cadena Leer n Escribir r Fin r - "PAR" • Diagrama de Nassi Scheneiderman {N-S): Conocido también como el diagrama de Chapin, 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 - ''PAR11 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 .........................................................................................................................................................................................................
- 24. Capítulo 1: Fundamentosde programación 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 ~ Inicio Fin B. Instrucción de asignación: Representa la asignación de un valor a una variable, se puede representar usando una necha o el símbolo de igualdad, el cual es usado por muchos de los lenguajes de programación. Diagrama de flujo N <- lO N = 10 Pseudocódigo N <-lO 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. Diagrama de flujo Pseudocódigo / LeerN 7 Leer N [3D 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 ent rada/salida, por símbolo de pantalla o impresora. Diagrama de flujo / Escribir R 7 E? Escribir R Pseudocódigo Escribir R Escribir R Escribir R
- 25. Algoritmos con java E.Instrucción de bifurcación: Cambian el flujo del programa según el resultado de una expresión lógica (condición). Diagrama de flujo Pseudocódigo Si <Exp. Log> Entonces F V <Instrucción> Instruccion 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 : Entero .................................................................................................................................' .......................................................................... Java . ............................................................................................................................................................................................................ ... 'Variables i int N; .. ........................................................................................................................................................................................................... 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 Java short , int , .tloat, double , if, for , switch, this ...
- 26. Capítulo 1: Fundamentosde programación 1.17 Identificadores Son los nombres que asignamos a las variables, constantes, funciones, objetos, entre otros; y no pueden coincidir con las palabras reservadas porque ocasionaría ambiguedad, y el compilador no lo entendería. Por lo general, los identificadores deben de cumplir las siguientes reglas: • Deben comenzar por una let ra. Evite usar ñ y tilde. • No debe coincidir con palabras reservadas del lenguaje de programación que está utilizando. Error de compilación Java ............................................................................................................................................................................................................ ... 11 Identiñ cador de Vari able es if : // y esta es palabra reservada . ! int if; .............................................................................' ............................................................................................................................... 1.18 Variables Representa un espacio de memoria RAM, el cual guarda un valor que servirá para algún proceso en particular; dicho valor puede ser modificado en cualquier momento. Las variables tienen, por lo general, un identificador (nombre) y, asignado, el tipo de dato que se esta utilizando; es decir, si almacena un número (entero), si es texto o alfanumérico (cadena), si es un valor verdadero o falso (lógico) llamado también booleano. Eíemplo pseudocódigo ............................................................................................................................................................................................................ ; //Variabl es : N : Entero .. ........................................................................................................................................................................................................... Java ................................................................................................................'......................'. ................................................................. ... : //Var i abl es . : int N ..............................................................................................................................................................,..............................................· Para asignarle un valor, usamos el operador de asignación, para algoritmos usaremos(<-) o ( =); este último es el más usado por los lenguajes de programación. Eíemplo pseudocódigo .' .......................................................................................................................................................................................................... ... //Asignar un val or N - 10 //Cambiar su val or N -SO ... .......................................................................................................................................................................................................... .. Java .......................................................................................................................................................................................................... ··. //Asignar un val or N = 10 //Cambiar su val or N = SO ..............................................................................................................................................................................................................
- 27. Algoritmos con java 1.19Constantes 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. Ejemplo pseudocódigo .· .......................................................................................................................................................................................................... .. //Constantes P I - 3 . 1 4159 : Rea l //Error ya no puede modiñcarlo P I - 3. 1 4 ... .......................................................................................................................................................................................................... . Java : ............................................................................................................................................................................................'............. ... //Constantes F ina l float P I = 3 . 141 59F; //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). Ejemplo pseudocódigo . //Crear la variable //(identiñcador y tipo de dato) N : Enter o //Asignar un valor //(identiñcador, operador de asignación y valor) N - 15 •,, .......................................................................................................................................................................................................... En el lenguaje de Java el tipo entero se puede trabajar con short, int y long; la diferencia está en que uno almacenan rangos de números diferentes, llamados también <<entero corto» y <<entero largo». Ejemplo Java · //Entero corto short N; //Asignar un valor (error de desbordamiento) •,, ..........................................................................................................................................................................................................
- 28. //Sobrepaso su limite(rango) N = 45 000 ; //Entero largo int N; l ong N; //Asignar un valor N = 45 00099; Capítulo 1: Fundamentos de programación .............................................................................................................................................................................................................. B. Real: Representan los números reales (almacena decimales). Ejemplo pseudocódigo .. ............................................................' ...............................................................................................................................'............. .. //Crear la variable //(identiñcador y tipo de dato) N : Real //Asignar un valor //(identiñcador, operador de asignación y valor) N - 15. 75 En el lenguaje de C#, 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 iloat N; //Se redondea a 15.123457 N= 15 . 12345678 ; //Precisión doble doub 1e N; //Lo almacena sin redondear 15.12345678 N= 15 . 12345678 ; ' .............................................................................................................................................................................................................. C. Carácter: Representa un carácter de cualquier tipo: texto, número, símbolo, etc. El valor se coloca entre comillas simples. Ejemplo pseudocódigo .. ............................................................................................................................................................................................................ //Crear la variable R : Caracter //Asignar un valor R - ' A' R - ' 9 ' R - '*'
- 29. Algoritmos con java EjemploJava . ' Crear la variable char R; 'Asi gnar un val or R - ' A , . ' R - 9 , ; R - * 1 • ' •., ...................................································....................................................................................................................................... E. Lógico: Representan los valores <<verdadero>> o <<falso>>, conocidos también como boolean, no se colocan comillas simple ni dobles. Ejemplo pseudocódigo ............................................................................................................................................................................................................. · //Crear la variable L : Logico //Asignar un valor L - VERDADERO L - FALSO ............................................................................................................................................................................................................. . En Java se utiliza el tipo de dato llamado <<boolean», para almacenar valores lógicos. Ejemplo Java ............................................................................................................................................................................................................ ' Crear la variabl e boolean L; 'Asignar un valor L = True; L = Fal se; ............................................................................................................................................................................................................. ,• 1.21 Tipo de datos complejos (estructurados) Son aquellos que están constituidos por tipos de datos simples y definen una estructura de datos, un ejemplo claro es el tipo cadena, que está compuesto por un conjunto de caracteres (tipo de dato carácter). Existe una variedad de tipo de datos complejos, el enfoque de este libro es algorítmico y solo tocaremos dos tipos de datos complejos: 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. Ejemplo pseudocódigo .. .......................................................................................................................................................................................................... ... //Crear l a variable R : Cadena / /Asignar un val or R- " ricardomarcelo@hotmail . com"
- 30. Capítulo 1: Fundamentosde programación 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 del programación, los operadores varían o no implementan uno u otro operador; en el caso de Java, implementa los siguientes. Expresiones aritméticas Operador Descripción + Suma - Resta • Multiplicación 1 División % Módulo (resto de una división) Para elevar a una potencia se usa Math.pow{9.0, 2.0}, dentro de los parámetros se coloca números reales (double) y para división entera use 1pero con números enteros. División real N= 9.014.0 //retorna 2.2S División entera N= 914 //retorna 2
- 31. Algoritmos con java Expresiones aritméticas (algoritmo) 8x3 8 8+3o 3 J9 9~ (!)2 Equivale a Equivale a Equivale a Equivale a Equivale a 8*3 = 24 8/3 = 2.666666 83 = 2 9A(l/2) : 3 9 Mod 4 = 1 B. Operadores relacionales: Llamados también operadores de comparación, y permiten evaluar si dos valores guardan alguna relación entre sí Operador Descripción = Igualdad > Mayor que >= Menor o igual que < Menor que <= Menor o Igual que <> Diferente a Dependiendo del lenguaje de programación, los operadores varían o no, implementan uno u otro operador; en el caso de Java varía la simbología en algunos. Operador Descripción -- -- > >= < <= != Expresiones lógicas (condiciones)- (Algoritmo) 8=3 8>3 8 <= 3 8 <> 8 Igualdad Mayor que Menor o ígual que Menor que Menor o Igual que Diferente a Falso Verdadero Verdadero Falso
- 32. Capítulo 1: Fundamentosde programación C. Operadores lógicos: Son aquellos operadores que se utilizan en combinación con los operadores de relación. Operador Descripción y Y Lógico o O Lógico No No Lógico «Y» lógíco: Si p y q son valores lógicos, ambos deben ser verdaderos para que Y devuelva verdadero. Expresiones lógícas (condiciones) 8>4 7 <> 5 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) Para Java se utiliza la sigu iente simbología. Operador && 11 1 Falso Verdadero Descripción Y Lógico O Lógico No Lógico 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». Operador Descripción + Unir cadenas & Unir cadenas
- 33. Algoritmos con java Expresionesde cadena " Ri ca rdo~~ + " "+ "Marcelo" Ricardo Marcelo "ricardomarcelo" & "@" & "hotmail.com" ricardomarcelo@ hotmail.com En Java se utiliza solo el símbolo(+) para unir cadenas (concatenar). 1.23 Control de flujo Todos loslenguajes de programación implementan estruct uras para controlar la ejecución de un programa, estas son: • Estructura secuencial • Estructura selectiva simple y doble • Estructura selectiva múltiple • Estructura repetitiva mientras • Estructura repetitiva para En los siguientes capítulos se explicarán cada una de las estructuras mencionadas.
- 34. Estructura secuencial 2.1 Estructurasecuencial Son aquellos algoritmos que ejecutan instrucciones en forma consecutiva, es decir, uno detrás de otro, hasta finalizar el proceso. lnstruccion 1 lnstruccion 1 l lnstruccion 2 lnstruccion 2 l lnstruccion n tnstruccion n l Problema n.o 1 ·- - - - - - - - - - Enunciado: Dado 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=nl+n2 Expresión algorítmica s <- n1 + n2 Entrada • Dos números (nl y n2) Diseño: Interfaz de usuario Salida • La suma (s) , ; C:ARCHIV-1XINOXS-1.J(.;~ I¡]EJ
- 35. Algoritmos con java Algoritmo Diagramade flujo Pseudocódigo Inicio ! nl , n2 , S . . ! / Leer nl , L S - nl + ! / Escribir L Fin Codificación: ) Entero n2j n2 s / ) Inicio //Variables nl , n2 , s //Entrada Leer nl , n2 //Proceso s - nl + n2 //Salida Escribir s Fin Entero ......................................................................................., ............................................................., ........................................................ import java . util . Scanner; public class ProblemaOl { } public static void main(String[) args) { //Variables } int nl , n2 , s ; //Entrada Scanner teclado= new Scanner(System . i n) ; System . out . print( "Nume r o 1 : " ) ; nl = teclado . next!nt() ; System . out . print( "Nume r o 2 : " ) ; n2 = teclado . next!nt() ; // Proceso s = nl + n2 ; 1/Salida System . out . println ("'' ) ; System . out . println( " Suma : " + s) ;
- 36. Capítulo 2: Estructurasecuencial 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: Expresión algorítmica c<-nl /n2 r +- nl Mod n2 Entrada • Dos números (nl y n2) Diseño: Interfaz de usuario Salida • El cociente (e) • El residuo (r) , , C:ARCHIV-1XINOXS-1UC.:3J sea Hunct•o 1 : 11 'Nune l'O 2 : 4 Cocie nt e : 2 Rc~iduo: 3 J>l't::::: .,rty kt~y l.c• c:ltfltirlttt! •• Algoritmo Diagrama de flujo Pseudocódigo ( Inicio ) ¡ nl , n2 , e , r . Entero . l / Leer nl , n2j ! e - nl n2 r - nl Mod n2 ! /Escribir e , r/ ¡ ( Fin ) Inicio //Variables nl , n2 , e , r : Entero //Entrada Leer nl , n2 //Proceso e - nl n2 r - nl Mod n2 //Salida Esc rib i r e , r Fin
- 37. Algoritmos con java Codificación: importjava . util . Scanner; public class Problema02 { } public stati c void main(Stri ng[] args) { //Variables } int nl , n2 , c , r ; //Entrada Scanner teclado= new Scanner (System . in ) ; System . out . pr i nt( "Numero 1 : " ) ; nl = teclado . nex tint() ; System . out . pri nt ("Numero 2 : " ) ; n2 = teclado . nextint() ; //Proceso e = n l 1 n2 ; r = n l % n2 ; //Salida System . out . pr i ntln( "" ) ; System . out . pri ntln( "Coci ente : " +e ) ; System . out . println( " Residuo : " + r) ; Problema n.o3 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 respectívo para hallar el IGV y el precio de venta. Para esto use la siguiente expresión: Expresión algorítmica igv +- w * 0.19 pv <- w + igv Entrada • Valor de venta (vv) Salida • EIIGV (igv) • El precio de venta (pv)
- 38. Capítulo 2: Estructurasecuencial Diseño: Interfaz de usuario '' C:ARCHIV- 1XINOXS-1JCR}J IIr:l f:l Diagrama de flujo Inicio l vv , igv , pv . Real . ! 1 Leer vv 1 ! igv - vv * o.19 pv - vv + igv ! / Escribir igv , pv/ ! Fin Codificación: Algoritmo Pseudocódigo Inicio //Variables vv, igv , pv //Entrada Leer vv //Proceso Real i gv- vv * 0 . 19 pv - vv + igv //Salida Escribir igv , pv Fin ............'............................................................................................................................................................................................. ··. import java . util . Scanner; public class Problema03 { ) public static void main(String(] args) { //Variables 1 float vv , igv , pv; //Entrada Scanner teclado ; new Scanner(System . in ) ; System . out . print( "Valor de venta : " ) ; vv ; teclado . nextFloat() ; //Proceso igv ; V * Q. l9F; pv ; vv + igv; //Salida System . out . println( " " ) ; System . out . pr i ntln( " IGV : " + i gv) ; System . out . println( " Precio de Venta : " + pv ) ; ·............................................................................................................................................................................................................
- 39. Algoritmos con java 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». Expresión matemática p =a" =a x a x a x .. . x a n factores Expresión algorítmica p +- aA n Entrada • Dos números enteros (a, n) Diseño: Salida • La Potencia (p) Interfaz de usuario , ' C:ARCHIV- 1XINOXS-1U, ., II:JEJ ~ = ~~ a n: 1"' - Pot1~nc i.t: 'J'/ít!tít/.~, l'1·e~;s <tly key to t:ontitllle ••• _ a Algoritmo Diagrama de flujo Pseudocódigo Inicio a , n : Ente ro co rto p : Entero largo a , n p - a "' n Escribir p Fin Ini cio //Variables a , n : Entero corto p : Entero l a r go //Entrada Leer a , n //Proceso p - a " n //Salida Escribir p Fin
- 40. Capítulo 2: Estructurasecuencial Codificación: import java . util . Scanner; public class Problema04 { ) public stati c void main(Stri ng[] args) { //Variables ) short a , n ; int p ; //Entrada Scanne r teclado= new Scanner(System . i n) ; System . out . print( "a : "); a = tecl ado . nextShort() ; System . out . print ("n : "); n = tecl ado . nextShort() ; //Proceso p = (int ) Math . pow ((double) a , (double) n) ; //Salida System . out . println( "" l ; System . out . pri ntln( " Potencia : " + p ) ; ............................................................................................................................................................................................................. Enunciado: Hallar la radicación de !l[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 obtienga la radicación «r>>. Expresión matemática 1 r = !l[a = a~ Expresión algorítmica r+- a A (1/n) Entrada • Dos números enteros (a, n) Salida • La radicación (r)
- 41. Algoritmos con java Diseño:Interfaz de usuario n, " C:ARCHIV- 1XINOXS- 1J, , llr;]EJ ·"": 9?6S6?.S n: IJ.i Potenc in: ~ a - P1·e:::: ''"'J kt~y tn contillne . .. _ a Diagrama de flujo Inicio ) l r . Entero corto . a . Entero largo . l j Leer a , nj ! r.- a"' (1/n) l / Escribir rj ! ( Fin ) Algoritmo Pseudocódigo Inicio //Variables n , r : Entero corto a : Entero largo //Entrada Leer a , n //Proceso r - a A (1/n) //Salida Escribir r Fin Codificación: ............................................................................................................................................................................................................ import java . util . Scanner; pub1ic class ProblemaOS { ) public static void main(String[] args) { //Variables ) int a ; short n , r ; //Entrada Scanner teclado = new Scanner(System . in) ; System . out . print( • a : • ) ; a= teclado . nextint() ; System . out . print( • n : • ) ; n = teclado . nextShort() ; //Pr oceso r = (short)Math . pow((double)a, (1/(double)n)) ; //Salida System . out . println( "''l ; System . out . println( " Potencia : • + r) ; '
- 42. Capít ulo 2: Estructura secuencial 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 entre 10, para acumular el residuo y el último cociente. 12345110 ® 1234110 @) 123 110 ® 12 1 10 <Da:> Entrada Salida • Un número entero (n) • El número inverso (ni) Diseño: Interfaz de usuario e; C:ARCHIV-1XINOXS-1UC..~ II!:JE1 Nunet•o: 1?.34~ a - l n vel'~o: 54321 Pl't::::; .uty kt!y lo cont i11t11: . . __ Diagrama de flujo (r nicio 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 1 0 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
- 43. Algoritmos con java Codificación: ..........................................................................................................................................................................................................··. · import java . util . Scanner; public class Problema06 { } public static void main(String[J args) { //Variables ) int n, ni , r ; // Entrada Scanner teclado= new Scanner(System . in ) ; System . out . print( "Numero : " ) ; n = t eclado . nextint () ; // Proceso r = n % 10 ; n = n 1 10; ni = r * 10; r = n % 10 ; n = n 1 10; ni = (n i + r) * 10; r = n % 10 ; n = n 1 10 ; ni = (n i + r) * 10; r = n % 10; n = n 1 10 ; ni = (n i + r) * 10; ni = ni + n; //Sal ida System . out . println( "'' ) ; System . out . print ln("Inverso : " +ni ) ; .. ...........................................................................................................................................................................................................·
- 44. Capítulo 2: Estructurasecuencial Enunciado: Determinar la suma de los N primeros números enteros positivos (z•¡. Use la siguiente fórmula. S=N(N+l) 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». Expresión matemática Expresión algorítmica s +- (n • (n + 1)) 12 Entrada • Número entero (n). Diseño: Interfaz de usuario S = N(N+l) 2 Salida • Suma (s). ' ' C:ARCHIV-1XINOXS-1U... IIEIEJ Diagrama de flujo ( Inicio ) ~ n, S . Enter o corto . ! 1 Leer n 1 ! S - (n * (n + 1)) 1 ! / Escri bir s j ! ( Fin ) 2 Algoritmo Pseudocódigo Inicio //Variables n , s : Entero cor to //Entrada Lee r n //Proceso s - (n * ( n + 1 )) 1 2 //Salida Escribir s Fin
- 45. Algoritmos con java Codificación: ......................................'...............................................................................................................................' ....................................... import java. util . Scanner; public class Problema07 { } public stati c void main (Stri ng[] args ) { //Variables J i nt n, s ; //Entrada Scanner teclado= new Scanner (System . in ) ; System . out . pr i nt( "Numero : " ) ; n = t eclado . nex t int() ; //Proceso s = (n * (n + 1)) 1 2 ; 1/Salida System . out . print ln("'') ; System . out . pr i ntln( " Suma : " + s ) ; Problema n.o 8 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. Expresión matemática M = {1 + r"lo)'.C Expresión algorítmica m <- ({1 + r1100) A t) * e
- 46. Entrada • Capital (e) •Tasa de interés (r) • Tiempo (t) Diseño: Diagrama de flujo (rnicio ) ~ e , r , t , i , m . Real . ! / Leer e , r , t / ~ m- ((l +r/100 ) ~t ) *c i - m - e ! / Escribir i , m / ! ( Fin ) Codificación: Capítulo 2: Estructura secuencial Salida • Interés (i). • Monto (m). Interfaz de usuario Algoritmo Pseudocódigo Inicio //Variables e , r , t , i , m : Rea l //Entrada Leer e , r , t //Proceso m- ((l +r/ l OQ)A t)*c i - m - e //Salida Es crib i r i , m Fin ..........................................................................................................................................................................................................··. impo r t java . uti l . Scanner ; public c l ass Prob l ema08 { publ ic sta tic void main (St ring[) args ) { //Variabl es .tloat c , r , t , i , m; // Entrada Scanne r teclado= new Scanne r( System . i n) ; System . out . p r i nt ("Capital : " ) ; e= tecl ado . ne xtFl oat () ; ......................................................................................................................................................." .........................·~ .........................
- 47. } ) Algoritmos con java System. out . p rint ("Tasa de i nt eres : "); r = t e clado . ne xtFloat () ; System . out . p ri nt ("Ti empo : '' ) ; t = t eclado . ne xtFl oat () ; // Proceso m - (.tloat )(Math . pow((double )(l + r 1 100), (doub le ) t )) *e; i - m - e ; 1/Salida System . out . p ri nt l n ("" ) ; System . out . println ("I nteres : " + i) ; System . out . println ("Monto : " + m) ; ... .......................................................................................................................................................................................................... . Problema n.o 9 Enunciado:Crear un programa para encontrar el área de un círculo, use la 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 aritmética Expresión algoritmica A.- 3.14159 • r A 2 Entrada • Radio (r) Diseño: A= n.r2 Salida • Área (a). Interfaz de usuario " - C:ARCHIV-1XINOXS-1U.;~ I~EJ R<,dio: ~ a - Jh·e<': ?B.!.,]<;/'/~, P1•e:::~ <tny key to continue . .. _ a
- 48. Diagrama de flujo (Inicio ) ! PI - 3 . 14159 . Real . ! r , a : Real ~ / Leer r / l a - PI * r A 2 ! / Escribir a / ! ( Fin ) Capítulo 2: Estructura secuencial Algoritmo Pseudocódigo Inicio //Constantes PI = 3 . 14159 · Real //Variables r , a : Real //Entrada Leer r //Proceso a - PI * r A 2 //Salida Escrib i r a Fin Codificadón: import java . util . Scanner; public class Problema09 { ) public static void main(String[] args) { //Constantes ) ñ nal float PI- 3 . 14159F; //Variables float a , r ; //Entrada Scanner teclado = new Scanner (System . in) ; System . out . pri nt( "Radio : " ) ; r = teclado . nextFloat () ; //Proceso a= (float) (PI* (Math . pow (( double)r , 2 . 0))) ; 1/Salida System . out . println( "'' ) ; System . out . println( "Area : " +a) ; . .................'.........................................................................................................................................................................................
- 49. Algoritmos con java Probleman.o 10 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 las horas, minutos y segundos restantes. Entrada Salida • Tiempo en segundos (t ) • Horas (h) Diseño: • M inutos (m) • Segundos (s) Interfaz de usuario ". C:ARCHIV-1XINOXS-1UC.~ 1!5Ja lienpo en ~cgltllrlo~: 99999 HoPc:::;: 2? Minuto:~: 1(, .Segundo~:: ]9 Pt·t~~s .tny key to continttc ... D Algoritmo Diagrama de flujo Pseudocódigo Inicio ( Inicio ) ! //Constantes HORA = 360 . . Entero HORA = 360 : Entero MINUTO = 60 : En tero MINUTO = 60 . Entero . ! t , h , m, S . Entero . ! / Leer t / ! h - t HORA t - t Mod HORA m - t MINUTO S - t Mod MINUTO ! /Escribir h , m, s/ ! ( Fin ) //Variables t , h , m, s · Entero //Entrada Leer t //Proceso h ~ t HORA t - t Mod HORA m - t MINUTO S ~ t Mod MI NUTO //Salida Escribir h , m, s Fin
- 50. Capítulo 2: Estructurasecuencial Codificación: . ............................................................................................................................................................................................................. import java . util . Scanner; public class ProblemalO { } public static void main(String[J args) { //Constantes } ñ nal int HORA - 3600 ; ñ nal int MINUTO = 60 ; //Variables int t , h , m, s ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( "Tiempo en segundos : " ) ; t = teclado . nextint() ; //Proceso h - t 1 HORA; t - t % HORA; m - t 1 MINUTO; S - t % MINUTO; 1/Salida System . out . println( "" ) ; System . out . println( " Horas : " + h) ; System . out . println( "Minutos : " +m ) ; System . out . println( " Segundos : " + s) ; ............................................................................................................................................................................................................
- 51. Algoritmos con java 2.2 Problemas propuestos Los siguientes problemas le servirán para medir su aprendizaje, es importante que los resuelva. Propuesto n.o1 Enunciado: Dado dos números enteros (Z), a y b, hallar a + by a- b. Propuesto n.o2 Enunciado: Dado dos números enteros, determinar cuántos números enteros están incluidos en ellos. Propuesto n.o3 Enunciado: Dada una cantidad de milímet ros, expresarlo en la máxima cantidad de metros, el resto en decímetros, centímetros y milímetros. Propuesto n.o4 Enunciado: Obtener el valor de «e>> 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.
- 52. Estructura selectiva simpley 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 <Instruccion 1> Instruccion 1 <Instruccion n> Instruccion n Fin Si Sintaxis Java .···iJu~~ ···¡~-~t:-~~~-~ i 6~ ······················································································································································ if (<Exp . Log . >) <Instruccion 1>; //Varias instrucciones if (<Exp . Log . >) { <Instruccion 1>; <Instruccion n> ; } ..............................................................................................................................................................................................................
- 53. Algoritmos con java 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. 1 Si <Exp . Log . > Entonces F <I nstrucci on 1> V Exp . Log . <Instruccion n> SiNo Instruccion 1 Instruccion 1 <Instruccion 1> Instruccion n Instruccion n <Instrucc i on n> Fin Si Sintaxis Java .·............................................................................................................................................................................................................ if (<Exp . Log . >) { <Instruccion 1>; <I nstruccion n> · , } else { <I nstruccion 1>; <Instruccion n>¡ } ............................................................................................................................................................................................................. 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 I ns truccion n F V Instruccion 1 Instruccion n F V Inst r uccion 1 Instruccion n
- 54. Capítulo 3: Estructuraselectiva simple y doble .· ................................................' .........................................................................................................................................'............... .. Si <Exp . Log . > Entonces Si <Exp . Log . > Entonces <Instruccion 1> <Instruccion n> Fin Si SiNo Si <Exp . Log . > Entonces <Instrucci on 1> <Instruccion n> SiNo <Instrucci on 1> <Inst r ucci on n> Fin Si Fin Si Sintaxis Java if (<Exp . Log . >) { } else } if ( <Exp . Log . >) { <Instruccion 1>; <Instruccion n> ; } { if (<Exp . Log . >) { <Instrucc i on 1>; <Instrucci on n> ; } else { <Instrucci on 1>; <Instruccion n> ; } ............................................................................................................................................................................................................. Problema n.2 11 Enunciado: Dado dos números enteros diferentes, devolver el número mayor. . . ' ' Análisis: Para la solución de este problema, se requiere que el usuario ingrese dos números enteros 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 (nl y n2). Salida • Número mayor (m).
- 55. Diseño: Algoritmos con java Interfazde usuario '' C:ARCHIV-1XINOXS-1.JC.:~II:]J:I Diagrama de flujo Inicio n l , n2 , m Ent ero Leer nl , n2 F m - nl F m - n2 Escribir m Fin Algoritmo Pseudocódigo Inicio //Variables nl , n2 , m : Entero //Entrada Leer nl , n2 //Proceso Si nl > n2 Entonces m - nl Fin Si Si n2 > nl Entonces m - n2 Fin Si //Salida Escribir m Fin
- 56. Capítulo 3: Estructuraselectiva simple y doble Codificación: ........................................................................................................................................................................................................... ... ¡ impo r t java . uti l. Scanner ; ¡ public cla ss Problemall { public stati c void main(St ri ng[J args ) { //Variables l } int nl , n2 , m=O ; //Entrada Scanne r teclado= ne w Scanner (System . i n) ; System . out . p ri nt ("Nume r o 1 : " ) ; nl = teclado . nex t!nt () ; System . out . p ri nt ("Nume r o 2 : " ) ; n2 = teclado . nextint () ; //Pr oceso if (nl > n2) m = n l ; if (n2 > nl ) m = n2 ; 1/Salida System . out . p ri nt l n( "'' ) ; System . out . println ("Mayor : " + m) ; .............................................................................................................................................................................................................. 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 Si n< O=> NE GATIVO Sin= O=> NEUTRO Entrada • Número (n) Salida • Resultado (r ) - POSITIVO - NEGATIVO - NEUTRO
- 57. Diseño: Algoritmos con java F F F Interfazde usuario '; C:ARCHIV-1XINOXS-1UC.-:!) lliiEJ Nun•~ l'O : e Re::u l t.ulu : HF.GOT 1UO P1•e:;~; ~11y key L11 l:llJltirl~lt! ••• a Diagrama de flujo n r Ini cio 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" Fin Si Si n < O Entonces r - " NEGATIVO" Fin Si Si n = O Entonces r - " NEUTRO" Fin Si //Salida Escribir r Fin
- 58. Capítulo 3: Estructuraselectiva simple y doble Codificación: ............................................................................................................................................................................................................ import java . uti l . Scanner ; public c lass Pr ob l ema12 { public static void main (String[) args ) { //Variab les 1 } i nt n; Str i ng r = ""¡ //Entrada Scanne r teclado= new Scanne r( System . i n) ; System . out . print ("Nume ro : '' ) ; n = tecl ado . ne xtint () ; //Proceso if ( n > 0 ) { r = " POSITIVO"; } if ( n < 0 ) { r = " NEGATIVO"; } i f (n == O ) { r = " NEUTRO"; } 1/Salida System . out . println ("" J ; System . out . println (" Re sultado : " + r) ; ... ........................................................' ..........................................................................................................................' ....................... 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' ve = 'A'~ VOCAL Si e = 'e' v e = 'E' ~ VOCAL Si e = 'i' v e = T ~ VOCAL Si e= 'o' ve ='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 ,; C:ARCHIV- 1XINOXS- 1.JC... I!II:IEJ c(,,..,ctt~~·= u a ... l~c~ttlt,du: lS UOCAL }'I'C~~ dllY kcy tu CUIIlillliC ••• _ a
- 59. Algoritmos con java Diagramade flujo ( Inicio ) ~ e . Caracter . r . Cadena . ~ 1 Leer e 1 1. 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 , > V r - " ES VOCAL" F e ' o ' O e ' O' > Jv r - " ES VOCAL" F e ' u ' O e ' U > Jv 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
- 60. Capítulo 3: Estructuraselectiva simple y doble Codificación: ............................................................................................................................................................................................................... ; import java . util.Scanner; ¡ public class Problemal3 { public static void main(String[] //Variables args) { } } char e ; String r - //Entrada ""· ' Scanner teclado= new Scanner(System . in) ; System . out . print( "Caracter : " ) ; e= teclado . next() . charAt(OJ ; //Proceso r = " NO ES VOCAL"; if (C ' a ' 11 e == ' A' ) { r = " ES VOCAL"; } if (C ' e ' 1 1 e == ' E ' ) { r = " ES VOCAL"; } if (e ' i , 1 1 e == ' I ' ) { r = " ES VOCAL"; } if (e == ' o ' 1 1 e == ' O' l { r = " ES VOCAL"; } if (C ' u' 1 1 e == ' u' l { r = " ES VOCAL"; } 1/Salida System . out . println( "'' ) ; System . out . println( " Resultado : " + r) ; •.. ··········································································································································································································.
- 61. Algoritmos con java Probleman.º 14 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 Diseño: - NO ES MULTIPLO Interfaz de usuario '' C:ARCHIV-1XINOXS-1UCREAT-1 ~~ I!I¡]EJ Hunc ro: 1 ~ Hcoult.ulo: SI lOS Mlll.Tll'l.O DE :J Y'> P1·1~:;:; rlllY key t(J c:cJrltirlllt~ ... D Algoritmo Diagrama de flujo ( Inicio ) L n . Entero . r . Cadena . ¡ 1 Leer n 1 1 n Mod 3-0 Y n Mod 5- 0 r - " SI ES MULTIPLO DE 3 Y 5" r - " NO ES ¡ j Escribir r / L l Fin ) e MULTIPLO DE 3 Y 5"
- 62. Pse udocódigo Inicio //Variables n Entero r: Cadena //Entrada Leer n //Proceso Capítulo 3: Estructura selectiva simple y doble 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 Escri bir r Fin Codificación: import java . util . Scanner; public class Problemal4 { } public static void main(String[] args) { //Variables 1 int n; String r ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( " Numero : '' ) ; n = teclado . nextint() ; //Proceso if(n% 3 ==O && n% 5 == 0) { r = " SI ES MULTIPLO DE 3 Y 5"; }else{ r = " NO ES MULTIPLO DE 3 Y 5"; } 1/Salida System . out . println( "'' ) ; System . out . println( " Resultado : " + r) ;
- 63. Algoritmos con java Problema n.2 15 Enunciado: Determinar si un número entero es par o impar. Análisis: Para la solución de este problema se requiere que el usuario ingrese un número entero n; luego, que el sistema verifique si el número es par o impar. Expresión Sin Mod 2 =O=> PAR SiNo IMPAR Entrada • Número (n). Diseño: Salida • Resultado (r) -PAR - IMPAR Interfaz de usuario " - C:ARCHIV-1XINOXS- 1UC..,] I!I¡JEJ NLLncl'o:~ a - H1: ::u 1t .ulo: 111POH Pt•e:;~; rlllY key tc1 c:or1tir1ttf! .. a Algoritmo Diagrama de flujo Pseudocódigo n r r - " IMPAR" Inicio Entero Cade na Le er n E:scribir r Fin V r - " PAR" 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
- 64. Capítulo 3: Estructuraselectiva simple y doble Codificación: ........................'................................................................................................................................................................................... · import java . uti l. Scanner; public class ProblemalS { } public static void main (String[] args ) { //Variables } int n ; String r ; //Entrada Scanner teclado= new Scanner(System . i n) ; System . out . pri nt( "Numero : " ) ; n = tecl ado . nextint (); //Proceso i f ( n % 2 == O) { r = "PAR"; }else( r = " IMPAR" ; } 1/Salida System . out . println( "'') ; System . out . println( " Resultado : " + r) ; ............................................................................................................................................................................................................ Problema n.2 16 Enunciado: Dados 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) Diseño: • Número mayor (m) Interfaz de usuario " . C:ARCHIV-1XINOXS- 1JCd l!lilEJ Hun1: t•o Nunel'o Nun1: t•o 1 : 2?. 2: • " AC ] : •••• M<lyot•: 15 J,t'f!:::: ,,flY kt:y 1.1l C;IJillilltlf: ••• B
- 65. Algoritmos con java Algoritmo Diagramade flujo Inicio nl , n2 , n3, m : Entero Leer nl , n2 , n3 F V m - n3 m - n2 m - n3 Pseudocódigo Inicio //Variables n l , n2 , n3 Entero //Entrada Leer n l, n2 , n3 //Proceso Si nl > n2 Entonces Si nl > n3 Entonces m - nl SiNo m - n3 Fi n Si SiNo Si n2 > n3 Entonces m - n2 SiNo m - n3 Fin Si Fin Si //Salida Escribir m Fin Escribir m Fin V m - nl
- 66. Capítulo 3: Estructuraselectiva simple y doble Codificación: ...........................................................................................................................................................................................................•. · import java . ut i l. Scanner; public class Problema16 { ) public static void main(Stri ng[J args) { //Variables ) int nl , n2 , n3 , m; //Entrada Scanner teclado= new Scanner(System . in ) ; System . out . print( "Numero 1 : " ) ; nl = teclado . nex tint() ; System . out . print( "Numero 2 : '' ) ; n2 = tec lado . nextint() ; System . out . pr i nt( "Numero 3 : " ) ; n3 = teclado . nextint() ; //Proceso if(nl > n2){ if(nl > n3) { m - n l ; )e l se{ m = n3 ; } )else{ if (n2 > n3) { m - n2 ; )el se{ m = n3 ; ) ) 1/Salida System . out . println( "'' ) ; System . out . println( "Mayor : " +m) ; ........................................." ................................................................................................................................................................. Problema n.2 17 Enunciado: Dado un número, devolver el doble si el número no es par, caso contrario el triple. . Análisis:Para la solución de este problema, se requiere que el usuario ingrese un número entero n; 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) Salida • Resultado (r)
- 67. Diseño: Algoritmos con java F Interfaz de usuario ,, C:ARCHIV-1XINOXS- 1J:c, I~EJ NttniOI"IJ:7 a - Re:: ull<ttlu: 11 P1•e :::; ~tny kt~y lo cnnt inttt: ... _ Algoritmo Diagrama de flujo Pseudocódigo Inicio ! 1 n' r . Ent ero 1 . ~ 1 Leer n 1 1 o(n Mod 2 0) V Inicio //Variables n , r : Entero //Entrada Leer n //Proceso r ·- n *3 r - n *2 Si No(n Mod 2 =0 ) Entonces r - n * 2 l / Escribir ~ ( Fin r / SiNo r - n * 3 Fin Si //Salida Escribir r Fin
- 68. Capítulo 3: Estructuraselectiva simple y doble Codificación: ~· ·¡;;;·p·~·~;;..··j·~·~·~ :·~·;; ii . ...s·~·~·~·~·~·~·;·..···........·....··········........···..············.......···········..·····......···....···..···......···......·····..········ ¡public class Problema17 { ' } public stat i c void main (Stri ng[J args) { //Variables } int n, r ; //Entrada Scanner teclado= new Scanner(System . in ); System . out . pri nt( " Numero : " ) ; n = t eclado . nex tint (); //Proceso i f ( ! (n % 2 -- O) ) { r = n * 2 ; }else{ r = n * 3 ; } 1!Salida System . out . println( "" ) ; System . out . println( " Resultado : " + 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úmeros ordenados en forma ascendente. Primero se debe encontrar el número mayor, luego el número menor y al final el número Intermedio; el cual resulta de sumar los tres números para después restarle (mayor+ menor). Entrada Salida • Números (nl, n2, n3) Diseño: • Números ordenados (ma, int, me) Interfaz de usuario '; C:ARCHIV-1XINOXS-1JC. :fj l!!iJEJ Nune t•o 1 ; ~ Hunel'o 2: 22 Nunt~a·o J : 111 M.t')U .. : 111 lntel'nediu: 22 Mctyop: 5 Pl't:~::: .u1y kt!_y lo c:ont intw .. . a a -
- 69. Algoritmos con java Algoritmo Diagramade flujo ( Inicio ) ~ 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 inter - (nl +n2+n3 ) - (mayor+menor) ~ 1 Escribir mayor, ínter , menor 1 ( Fin )
- 70. Capítulo 3: Estructuraselectiva simple y doble Pseudocódigo Inicio //Variables nl , n2 , n3 , mayor , in ter , menor //Entrada Leer nl , n2 , n3 //Proceso Si nl > n2 Y nl > n3 Entonces mayor - nl SiNo Si n2 > nl Y n2 > n3 Entonces mayor - n2 SiNo mayor Si - n3 Fin Fin Si Si nl < n2 Y nl - nl < n3 Entonces menor SiNo Si n2 SiNo < nl menor Y n2 < - n2 menor - n3 Fin Si Fin Si n3 Entonces inter- (nl +n2 +n3)-(mayor+menor) //Salida Escribir mayor , inter, menor Fin Entero
- 71. Algoritmos con java Codificación: .............................................................................................................................................................................................................. import java . util . Scanner; public class Problema18 { } public static void main(Str i ng[J args) { //Variables } int nl , n2 , n3 , mayor, inter, menor; //Entrada Scanner teclado = new Scanner(System . in) ; System . out . print( "Numero 1 : " ) ; nl = teclado . nextint() ; System . out . pri nt( "Numero 2 : " ) ; n2 = teclado . next!nt() ; System . out . print( " Numero 3 : '') ; n3 = teclado . next!nt() ; //Proceso if(nl > n2 && nl > mayor - nl ; }el se{ if (n2 > nl && n2 }else{ mayor = n3 ; } } if (nl < n2 && nl < menor = n l ; }el se{ if (n2 < nl && n2 } menor = n2 ; }else { menor - n3 ; } n3 ) { > n3) { mayor - n2 ; n3 ) { < n3) { inter- (nl + n2 + n3 ) - (mayor+ me nor) ; 11Salida System . out . pri ntln( "'' }; System . out . println( "Mayor : " +mayor) ; System . out . println( " Intermedio : " + inter) ; System . out . println( "Mayor : " +menor) ; ............................................................................................................................................................................................................
- 72. Capítulo 3: Estructuraselectiva simple y doble Problema n.2 19 Enunciado: Un restaurante ofrece un descuento del 10 % para consumos de hasta S/.100.00 y un descuento de 20% para consumos mayores. Para ambos casos se aplica un impuesto del19 %. 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) Diseño: • Monto del descuento (m_d) • Impuesto (m_igv) • Importe a pagar (p) Interfaz de usuario '; C:ARCHIV- 1XINOXS-1J~,:~ l!l!iJEJ Con~:uno: I~HU Mu11tu th::.;cuctltu: 2~U.~ lnput:::to IGU: t!.2.H ln¡Jtlt'lt: d )1<9<1': 9~2.H P1·e~~ ~nt kc to cont inuc ... D Algoritmo E! Diagrama de flujo Pseudocódigo Inicio ) ¡ 01 - 0 . 1 . Real . D2 -0 . 2 . Real . IGV- 0 . 19 . Real . ! e , m_d , m_ igv, p . Real . ¡ 1 Leer e 1 1 F V c<=100 m_d - c *D2 m_d - c *D1 ·r m_igv - (e - m_d) * IGV P - e - m_d + m_ igv ! / Escribir m_d, m_igv , P/ l ( Fin ) Inicio //Constantes 01 = 0 . 1 : Real 02 = 0 . 2 : Real I GV = 0 . 19 Rea l //Variables e , m_d, m_igv , p //Entrada Leer e //Proceso Real Si e <= 100 Entonces m_d - e * 01 Si No m_d - e * 02 Fin Si m_ig v - (e - m_d) * IGV p - e - m_d + m_i gv //Salida Esc rib i r m_ d , m_igv , p Fin
- 73. Algoritmos con java Codificación: ............................................................"............................................................................................................................................ ... . import java . util . Scanner; publ i c class Problemal9 { l public static void main(St ring[J args) { //Cons t antes } ñ nal float Dl = O.lF; ñ nal float D2 = 0 .2F; ñ nal float IGV = 0 . 19F; //Variables float c , m_d , m_igv , p ; //Entrada Scanner teclado = new Scanner(Syst em . in) ; System . out . print( "Consumo : " ) ; e= t eclado . nextFloat () ; //Proceso if(c <= lOO l { m_d = e * Dl ; }else{ m_d - e * D2 ; } m_igv - (e - m_d) * IGV; p = e - m_d + m_ igv; 1/Salida System . out . println( " ") ; System . out . println( "Monto descuento : " + m_d) ; System . out . println( " Impuesto IGV : " + m_ igv); System . out . println("Importe a pagar : " + p) ; Problema n.2 20 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 (5/.) Descuento(%) Hasta 100 Mayor a 100 Mayor a 200 10 20 30
- 74. Capítulo 3: Estructuraselectiva simple y doble Análisis: Para la solución de este problema, se requiere que el usuario ingrese el consumo; luego, que elsistema verifique y calcule el monto del descuento, el impuesto y el importe a pagar. Entrada Salida • Consumo (e) • Monto del descuento (m_d) Diseño: • Impuesto (m_igv) • Importe a pagar (p) Interfaz de usuario " . C:ARCHIV- 1XINOXS-1Ud JIII:JEJ 'Con ~: 11no: 1m1H 11 .Muntu th::..;cucntu: J~l1.~ 1n lllW :; lo 1GU : 1] ] •n lnpol•tc d ll•9<1': o:JJ_,, P1•e :: :; •Hlt ke to continue . .. a Algoritmo - Diagrama de flujo l I nicio L 01 -0 . 1 . Real . 02 - 0 . 2 . Real . 03 - 0 . 3 . Real . I GV - 0 . 19 . Real . ¡ e , m_ d , m_ igv, p . Rea l . ! 1 Leer e 1 1 F e > 200 V F e > lOO V m_ d - e * 01 m_d - e * 02 m_d ¡ m_igv - (e - m_d) * I GV P - e - m_d + m_igv ! / Escribir m_d, m_i gv, P / l Fin ·- e * 03
- 75. Algoritmos con java Pseudocódigo Inicio //Constantes 01- 0 . 1 Real D2 = 0 . 2 : Real D3 = 0 . 3 : Real IGV = 0 . 19 : Real //Variables e , m_d, m_igv , p : Real //Entrada Leer e //Proceso Si e > 200 Entonces m_d - e * 03 SiNo Si e > 100 Entonces m_d - e * 02 SiNo m_d - e * 01 Fin Si Fin Si m_igv - (e - m_d) * IGV p - e - m_d + m_igv 1/Salida Escribir m_d, m_igv, p Fin Codificación: .. ............................................................................................................................................................................................................ import java . uti l . Scanner; public c las s Problema20 { public stati c void main (S tring [ J args) { //Constantes final float 01 - O. lF; final float 02 - 0 . 2F; final float 03 - 0 . 3F; final float IGV - 0 . 19F; //Variables float c , m_d , m_igv , p ; //Entrada Scanner teclado= new Scanner(System . in ) ; System . out . print( "Consumo : " ) ; e= teclado . nextFloat() ; ·............................................................................................................................................................................................................
- 76. } } Capítulo 3: Estructuraselectiva simple y doble //Proceso if(c > 200) ( m_d = e * 03 ; }else( if (c > 100 ) ( m_d - e * }else ( D2 · ' } m_d - e * Dl ; } m_igv - (e - m_d) * IGV; p = e m_d + m_igv ; //Salida System . out . println( "'' ) ; System . out . println( "Monto descuento : " + m_d) ; System . out . println( "Impuesto IGV : " + m_igv) ; System . out . println( "Importe a pagar : " + p) ; ... .......................................................................................................................................................................................................... . Problema n.2 21 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 Salida • Temperatura (t) • Clima (e) Diseño: Interfaz de usuario , ; C:ARCHIV-1XINOXS-1uc.::)I!I!5JI:J cnpet•cttut•ct: 28 a - Clinrt: CA!.OR P1·t~:;:: .uty k•~ Y tu e out iruu~ .. a
- 77. Algoritmos con java Algoritmo Diagramade flujo ( Inicio ) ¡ t : Entero e . Cadena . ¡ / Leer t / l F t < 10 V F "'>-u y t<=20 V e - ''FRIO" F -.?=21 y t<=30 V e - " NUBLADO" - e - "TROPICAL" e ·- "CALOR" ¡ / Escribir Pseudocódigo Inicio //Variables t Ent ero e : Cadena //Entrada Leer t //Proceso Si t < 10 Entonces e - "FRIO" SiNo ( Si t >= 11 Y t <=20 Entonces e - "NUBLADO" SiNo ¡ Fin e ) Si t >= 21 y t <=20 Entonces Fin Fi n Fi n Si //Salida Escribir e Si e -"CALOR" SiNo e -"TROPICAL" Fin Si /
- 78. Capítulo 3: Estructuraselectiva simple y doble Codificación: ............................................................................................................................................................................................................. ; impo rt java . uti l . Scanner ; ¡ public clas s Problema21 { publ i c stati c void main (Stri ng [] //Variabl es int t ; St ri ng e ; //Entrada args ) { Scanne r teclado= new Scanne r( System . i n) ; System . out . print ("Temperatura : " ) ; } } t = tecl ado . ne xtint () ; //Proceso if( t < 10) { e = "FRIO"; }else{ if ( t >= 10 && t <= 20 ) { e = " NUBLADO"; }else{ if (t >= 2 1 && t <= 30) { e = "CALOR"; )e 1se{ e = " TROPICAL"; } } } 1/Salida System . out . println ("") ; System . out . p ri nt l n( "Clima : " + C ) ; ... .......................................................................................................................................................................................................... .· Enunciado: Un negocio tiene dos tipos de cliente: cliente general (G) y cliente afiliado (A). 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. Tipo Contado (C) Plazos (P) descuento recargo Cliente general (G) 15 % 10% Cliente afiliado (A) 20% 5%
- 79. Algoritmos con java 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. Entrada • Monto de la compra (me) • Tipo de cliente (te) • Forma de pago (fp) Diseño: Salida • Monto de descuento o recargo (m) • Total a pagar (tp) Interfaz de usuario " C:ARCHIV-1XINOXS-1JC::~ I!I!:JEJ Monto de conp•·~: 100 1 ipo dt: el iente: O ]:oi·na d e pago: e DESCUENTO 2~%: 2H.H llt.l ., )ld~l·''": RA.H ]>¡·e~~ •''l ke lo corltirlttt: ••• D Algoritmo a - Diagrama de flujo ( Inicio ) ¡ DESC_ G ·- O. 15 . Real . DESC_A- 0 . 2 . Real . REC_G - 0 . 10 . Real . REC_ A - 0 . 05 . Real . ¡ me , m, t p . Rea l . te , fp , r . Cad ena . ¡ /Leer me , te, t¡y' .1 F tc="G" V 1 1 F fp="C" V F fp=" C" V ~ ~ m-mc*REC_A m-mc*DESC_A m-mc *REC_G m-mc*DESC_G t p-mc+m tp-mc-m t p -mc+m tp-mc-m r - " REC . 5%" r-" DESC . 20% " r-" REC. 10%" r-" DESC . 15%" ·r / Leer r , m, tp / ¡ ( FIN )
- 80. Pseudocódigo Inicio Capítulo 3: Estructuraselectiva simple y do ble //Constantes DESC_G = 0 . 15 : Real DESC_A = 0 . 2 Real REC_G = 0 . 10 Real REC_A = 0 . 05 Real //Variables me , m, tp te , fp, r Real Cadena //Entrada Leer me , te , fp //Proceso Si te = " G" Entonces Si fp = "C'' En t onces m - me * DESC_G tp - me - m SiNo r - "DESCUENTO 15%" 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 Fin Si Fin Si //Salida r - " DESCUENTO 20%" m - me * REC_A tp - me + m r - "RECARGA 5%" Escribir r , m, tp Fin
- 81. Algoritmos con java Codificación: importjava . uti l . Scanner; public class Problema22 { } public static void main (Stri ng[J args) { //Cons tantes } flnal float DESC_G = O. lSF; flnal float DESC_A = 0 . 2F ; ñ nal float REC G = O. lF; flnal float REC_A = O. OSF ; //Variables float mc , m, tp ; char te , fp; String r ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( ''Monto de compra : ") ; me= teclado . nextF l oat () ; System . out . print( " Tipo de cli ente : " ) ; te= teclado . next() . charAt(O) ; System . out . print( " Forma de pago : " ) ; fp = tec l ado . next() . charAt(O) ; //Proceso i f (te == •G' ) { }el se{ } if(fp== ' C' ){ m = me * DESC_G; tp = me - m; r = " DESCUENTO 15%u; }else{ m - me * REC G· - ' tp = me + m; r = " RECARGO 10%u; } if(fp== ' C' ){ m = me * DESC_A; tp = me - m; r = " DESCUENTO 20%u; }else{ m = me * REC_A ; tp = me + m; r = " RECARGO 5%u; } //Salida System . out . println( " 0 ) ; System . out . println( r + " : " +m) ; System . out . println( " Total a pagar : " + tp ) ; ..............................................................................................................................................................................................................
- 82. Capítulo 3 :Estructura selectiva simple y do ble Enunciado: Elabore un algoritmo que resuelva una ecuación de primer grado. ax + b = O -b x = - a Considerar, si a es diferente a Ono 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: Diagrama de flujo Inicio a , b , x Rea l Leer a , b • Raíz x (x) Interfaz de usuario 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 X - 0 E'i n Si //Salida Escrib i r r Fin
- 83. Algoritmos con java Codificación: . . .............................................'...............................................................................................................................................' ............... impo r t java . uti l . Scanner; public class Prob lema23 { } public static void main (String[) args) { //Variables } .tloat a , b ,x; //Entrada Scanner teclado= new Scanner(System . in ) ; System . out . print( "a : " ) ; a= tecl ado . nextFl oat () ; System . out . pri nt( "b : " ) ; b = tecl ado . next Fl oat () ; //Proceso if( a ! =O ){ x = - b 1 a ; )else{ X = O; ) //Sal ida System . out . println( "'') ; System . out . println( " x : '' + x) ; .............................................................................................................................................................................................................. 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. - b - .Jb2 - 4ac x2 = --:....___ 2a • 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, b y e; luego, que el sistema verifique y determine el valor de xl y x2. Entrada Salida • Coeficiente a (a) • Primera raíz x (xl) • Coeficiente b (b) • Segunda raíz x (x2) • Término independiente e (e)
- 84. Capítulo 3: Estructuraselectiva simple y doble Diseño: a , d F ! xl - x2 - Diagrama de flujo ( Inicio ) ! b, e , d , xl , x2 : Real ! / Leer a , b , e / ! - (b ~ 2) - 4 * a * e 1 a <> O y d > V u ! Interfaz de usuario Algoritmo Pseudocódigo I nicio //Variables a , b , e , x l , x2 //Entrada Leer a , b , e //Proceso Real d - (b A 2) - 4 * a * e o xl-(-b+dA (l/2))/2*a Si a <> O Y d >= O Entonces xl- (-b + d ~ (1 1 2)) 1 2 *a x2- (-b- d ~ (1 1 2)) 1 2 *a SiNo o x2- ( -b-d~(l/2))/2*a ¡ /Escribir xl , x2/ ! ( Fin ) xl - O x2 - O Fin Si //Salida Escribir xl , x2 Fin Codificación: ..........................................................................................................................................................................................................- ··. ' import java . util . Scanner; public class Problema24 { public static void main(String[) args) { //Variables double a , b , e , d , xl , x2 ; //Entrada Scanner teclado= new Scanner(System . i n) ; System . out . print( "a : " ) ; a= teclado . nextDouble() ; System . out . print( " b : " ) ; ......................................................................................,.......................................................................................................................
- 85. Algoritmos con java .............................................................................................................'......................................' ........................................................ } } b = teclado . nextDouble (} ; System . out . print( " c : " ) ; e= teclado . nextDouble(} ; //Proceso d = Math . pow(b , 2 . 0 } - 4 . 0 * a * e ; i f (a ! = O & & d >= O} { xl- (-b + Math . pow(d, (1. 0 1 2 . 0))) 1 2 *a; x 2 - (- b - Ma t h . pow (d , (l. O 1 2 . O}} } 1 2 * a ; }else{ l xl = O; x2 = O; 1/Salida System . out . println( " " }; System . out . pri ntln( " xl : " + xl} ; System . out . pri ntln( " x2 : " + x2} ; Problema n.2 25 Enunciado: Dado 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 • Hora (h) • Minuto (m) • Segundo (s) Diseño: Salida • Hora (h) • Minuto (m) • Segundo (s) Interfaz de usuario ,, C:ARCHIV-1XINOXS- 1U.,~ ~~EJ Hot•.,: ] .Minuto: ~)e¡ 'St~~flttiiiO: ~.'/ Hot•.,: 4 Minuto: 1:1 Sequndo: H Pl'e:;:; •'"' kt:' lo cont itllte . . _ a a -
- 86. Diagrama de flujo e Inicio) ¡ h, m , s : Entero ¡ ¡Leer h, m, o/ ¡ S - S + 1 J. f' S • 60 > V S ' o m. m + 1 1 f' m = 60 :::> Jv S ' o m - m + 1 j_V f' h - 24 l h . o /Escribir h, m, sj l Fin Capítulo 3: Estructura selectiva simple y doble Algoritmo Pseudocódigo Inicio //Variables h , m, s : Entero //Entrada Leer h , m, s //Proceso S - S + 1 Si s - 60 Entonces S - o m - m + 1 Si m = 60 Entonces m - o h - h + Si h h Fin Si Fin Si Fin Si 1/Salida Escribir h , m, s Fin 1 = 60 Entonces - o
- 87. Algoritmos con java Codificación: ............................................................................................................................................................................................................ . importjava . util . Scanner; public class Problema25 { } public s t atic void main(S t ring[] args) { //Vari ables } int h , m, s ; //Entrada Scanner tecl ado = new Scanner(System . i n) ; System . out . print( " Hora : " ) ; h = teclado . nextint() ; System . out . print( "Minuto : " ) ; m = teclado . nextint() ; System . out . print( " Segundo : " ) ; s = teclado . nextint() ; //Proceso S += 1 ; if (S == 60) { s = 0 ; ) m += 1 ; if(m == 60){ m = O; h += 1 ; ) if(h -- 24) { h = O; ) 1/Salida System . out . println( "" ) ; System . out . println( " Hora : " + h) ; System . out . println( "Minuto : " +m) ; System . out . println( " Segundo : " + s) ;
- 88. Capítulo 3: Estructuraselectiva simple y doble 3.5 Problemas propuestos Los siguientes problemas le servirán para medir su aprendizaje, es importante que los resuelva. Propuesto n.º 11 Enunciado: Dada la edad de una persona, determinar si es mayor o menor de edad. Considere que se considera a alguien como mayor de edad si tiene 18 años o más. Propuesto n.2 12 Enunciado: Dados dos números enteros, devolver el número menor. Propuesto n.º 13 Enunciado: Dados dos números, determinar si son iguales o son diferentes. Propuesto n.º 14 Enunciado: Dado un número entero, devolver el doble del número si el número es positivo; el triple del número si es negativo; y cero si el número es neutro. Propuesto n.2 15 Enunciado: Crear un programa que al ingresar tres números enteros devuelva los números ordenados en forma ascendente y en forma descendente. Propuesto n.º 16 Enunciado: Después de ingresar 4 notas, obtener el promedio de la tres mejores. Mostrar el mensaje «Aprobado>> si el promedio es mayor o igual a 11; caso contrario, mostrar «Desaprobado». Propuesto n.º 17 Enunciado: Dados los siguientes datos de entrada: saldo anterior, tipo de movimiento «R» (retiro) o «D» (deposito) y monto de la transacción, obtener como dato de salida el saldo actual. Propuesto n.2 18 Enunciado: Dados dos 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
- 89. Algoritmos con java Propueston.º 19 Enunciado: Dadas tres longitudes, diga si forman un t riángulo. TEOREMA: En todo triángulo cada lado es menor que la suma de los otros dos, pero mayor que su diferencia. Propuesto n.2 20 Enunciado: Dadas tres longitudes, si forman un triángulo, devolver el tipo de triángulo según sus lados. T. Equilátero: Sus tres lados son iguales T. Isósceles: Tiene dos lados iguales. T. Escaleno: Sus tres lados son diferentes.
- 90. Estructura selectiva múltiple 4.11ntroducción Sabemosque 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. F F F ¡ - - - - - ¡ V Valorl Instrucciones Valor2 Instrucciones .--------,V Valor3 Instrucciones En Caso que <Exp . > Sea Caso Valorl <Instrucciones> Cas o Valor2 <Instrucciones> Caso Valor3 <Instrucciones> Fin Caso
- 91. Algoritmos con java Sintaxis1 Java ........' ........................................................................'......................................................................................................................... ... switch (<Exp . >) { } case Valorl : <Instrucciones>; break; case Valor2 : <Instrucciones>; break; case Valor3 : <Instrucciones>; break; ............................................................................................................................................................................................................. Valor 1 F Instrucciones Valor 2 F Instrucciones SiNo Instrucciones Sintaxis 2 Java En Caso que <Ex p . > Sea Caso Valorl <Instrucc i ones> Caso Valor2 <Instrucc i ones> SiNo <Instrucc i ones> Fin Caso .· ......................................................................................................................., ............................,......................................................., . : } switch (<Exp . >) { case Valorl : <Instrucciones>; break; case Valor2 : <Instrucciones> ; break; default: <Instrucciones>; break; . ... .......................................................................................................................................................................................................... .
- 92. Capítulo 4: Estructuraselectiva múltiple 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. l V Si <Exp . Log . > Entonces Exp . Log . <Instrucc i ones> F 1 Instrucciones SiNoSi <Exp . Log . > Entonces V Exp . Log . <Instrucciones> F 1 Instrucciones SiNoSi <Exp . Log .> Entonces V <Ins trucc iones> Exp . Log . F 1 Instrucciones SiNo 1 Inst rucciones 1 <Ins trucciones> Fin Si Sintaxis Java .. .......................................................................................................................................................................................................... ... if ( <Exp . Log . > ) <Inst rucciones> ; else if (<Exp . Log . >) <Instrucciones> ; else if (<Exp. Log . >) <Instrucciones> ; else <Instrucciones> ; .. ........................................................................................................................................................................................................... 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
- 93. Algoritmos con java Análisis:Para la solución de este problema, se requiere que el usuario ingrese un número entero; luego, que el sistema realice el proceso para devolver la estación. Entrada Salida • Número (n) Diseño: • Estación (e) Interfaz de usuario ,, C:ARCHIV-1XINOXS-1Uc.:J I!:JEJ Nune Po: 3 a - b tnciun: IHUIERHO r.-.~:; ~; •lllt) k·~v lo cnut illttl~ •• · - a Algoritmo Diagrama de flujo Pseudocódigo Inicio ¡ n . Entero . e . Cadena . ! / Leer n l n -.J l V l F e-"VERANO " V ---+1 2 1 l F e-"OTOÑO " ---+1 3 1 V l F e-" INVIERNO" V ---+1 4 1 l F e-"PRIMAVERA" ¡ 1 Escribir e ! ( Fin / 1 Inicio //Variables n Entero e : Cadena //Entrada Leer n //Proceso En Caso que n Sea Caso 1 e - " VERANO" caso 2 e - " INVIERNO" Caso 3 e - "OTOÑO" Caso 4 e - "PRIMAVERA" Fin Caso //Salida Escribir e Fin
- 94. Capítulo 4: Estructuraselectiva múltiple Codificación: ;··¡;;;p·~·~ t....j ~~·~ :..~ú·i · ...s·~·~·~·~·e ·~ ;· ..............................................................................................................................··· ¡public class Problema26 { ! public s t atic void main (String[] args) { ! //Variables int n ; St ring e = ""; // Entrada Scanner teclado= new Scanner(System . in ) ; System . out . print( " Numero : '' ) ; n = teclado . nextint (); //Pr oceso . switch (n ) { } } } case 1 : case case e = "VERANO"; break; 2 : e = "OTOÑO"; break; 3 : e = " I NVIERNO"; break; case 4 : e = " PRI MAVERA"; break; 1/Sa lida System . out . pr i ntln( "'' ) ; System . out . pr i ntln( " Estac i on : " + e) ; .. .......................................................................................................................................................................................................... Enunciado: Dado un número entero de un dígito (O al 9), devolver el número en letras. . Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número entero; luego, que el sistema verifique y devuelva el número en letras. Entrada Salida • Número (n) • Resultado (r) Diseño: Interfaz de usuario '' C:ARCHIV-1XINOXS-1U~~!S]I:J
- 95. Algoritmos con java Diagramade flujo ( Inicio T n o Entero o 1 o Cadena o l / Leer n / 1 n H o V l F 1-"CERO" H 1 V '1 F 1-"UNO" f-.o 2 V '1 F 1·- "DOS '' H 3 V l F 1-"TRES " H 4 V l F 1-"CUATRO " H 5 V '1 F 1-"CI NCO" f--t 6 V 1 F 1-"SEIS " H 1 V l F 1-" SIETE " H 8 V l F 1-"0CHO" H 9 V '1 F 1-"NUEVE " r 1 Escribir r l ( Fin 1 Algoritmo Pseudocódigo Inicio //Variables n Entero 1 : Cadena //Entrada Lee r n //Proceso En Caso que n Sea Caso o l - "CERO" caso 1 l - "UNO" Caso 2 l - "DOS" Caso 3 l - "TRES" Caso 4 l - "CUATRO" Caso 5 l - "CINCO" Caso 6 l - "SE IS " Caso 7 l - " SIETE" Caso 8 l - "OCHO" Caso 7 l - "NUEVE" Fin Caso //Salida Escribir l Fin
- 96. Capítulo 4: Estructuraselectiva múltiple Codificación: '·i;;;·p·;·~ t····j a·~·a :·~úi . ...s·c·a·~·~·e·~·;-································································································································· public class Problema27 { } public static void main(String[J args) { //Variables } int n ; String 1 = JI ' ' //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( "Numero : ") ; n = t eclado . nextint() ; //Proceso switch(n) { case O: } l = "CERO"; break; case 1 : 1 = "UNO"; break; case 2 : 1 = "DOS"; break; case 3 : 1 = " TRES"; break; case 4 : 1 = "CUATRO"; break; case 5 : 1 = "CINCO"; break; case 6 : 1 = " SEIS"; break; case 7 : l = " SIETE"; break; case 8 : l = "OCHO"; break; case 9 : l = " NUEVE"; break; //Salida System . out . println( " '' ) ; System . out . println( " Letra : " + l ) ; .. ...........................................................................................................................................................................................................
- 97. Algoritmos con java ---- Problema n.2 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 que debe realizar y devuelva el resultado de la operación. Entrada Salida • Operador (op) • Resultado (r) • Número (nl y n2) Diseño: Interfaz de usuario Diagrama de flujo Inicio ! op . Caracter . nl , n2 , r . Entero . ! / Leer op, nl , n2/ l op --.¡ '+' : V ! F r - nl + n2 --+!·-': V + F r - nl - n2 V --.¡ ' * ' 1 + F r - nl * n2 -1 ' 1' V l F ~2<>0'- ! ! - r - o r- nl/n2 1 1 ! 1 Escribir r 1 J Fin Algoritmo Pseudocódigo Ini cio //Variables op : Caracter n l , n2 , r : En ter o //Entrada Leer op , n l , n2 //Proceso En Caso q ue op Sea Caso ' +' r - nl + n 2 Ca so ' - ' r - nl - n 2 Caso ' * ' r - nl * n 2 Caso ' / ' Si n2 <> O Enton ces r - nl + n 2 Si No r - O Fin Sin Fin Caso //Salida Escribir r Fin
- 98. Capítulo 4: Estructuraselectiva múltiple Codificación: .' .......................................................................................................................................................................................................... ; import java . util.Scanner; : public class Problema28 { } public static void main(String[J args) ( //Variables l int nl , n2 , r - O; char op; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( "Operacion : " ) ; op = teclado . next() . charAt(O) ; System . out . print( "Numero 1 : " ) ; nl = teclado . nextint() ; System . out . print( "Numero 2 : " ) ; n2 = teclado . nextint() ; //Proceso if(op == ' + ' ) { r = nl + n2 ; }else if(op == ' - ' ) { r = nl - n2 ; }else if(op == '*' ) { r = nl * n2 ; }else if(op == ' / ') { if(n2 ! = 0) } r = nl 1 n2 ; else r = O; //Salida System . out . println( " '' ) ; System . out . println( " Resultado : " + r) ; .. ........................................................................................................................................." ..............................................................' Problema n.2 29 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)
- 99. Algoritmos con java Diseño: Interfazde usuario e,- C:ARCHIV-1XINOXS-1U _S:] I!IGJEJ I.etl·<l: E 11 - Rt! Sllltddo: ES UOCAI. Pl't::::: .uty kt:y t. o c:onl i11111: .. __ Algoritmo Diagrama de flujo Pseudocódigo Inicio 1 . Caracter . r . Cadena . ¡ / Leer 1 / l_ < l-' a ' o 1-' A' V F 1 r-" ES - ' e ' o 1-' E' V F 1 r. " ES 1 i 1 o 1 , I , V F 1 r-"ES - ' o ' o 1-' 0 ' V F 1 r .- " ES ' u ' o 1 V , U ' F 1 r-" ES r - " NO ES VOCAL" 1 Escribir r 1 ~ Fin ) VOCAL" VOCAL" VOCAL" VOCAL" 1 1 VOCAL" 1 1 Ini cio //Variables 1 Caracter r : Cadena //Entrada Leer 1 //Proceso Si 1 = ' a ' O 1 = ' A' Entonces 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 Escrib i r r Fin
- 100. Capítulo 4: Estructuraselectiva múltiple Codificación: .......................................................................................................................................................................................................... ··. · import java . util . Scanner; public class Problema29 { } public stati c void main(St ri ng[] args ) { //Variables l char 1 ; Stri ng r - //Entrada ' ' 11 o ' Scanner teclado= new Scanner{System . in) ; System . out . print( "Letra : " ) ; l = teclado . next() . charAt (O) ; //Proceso if(l -- ' a ' 1 1 l -- r = " ES VOCAL"; else if (1 -- ' e ' 1 1 r - " ES VOCAL"; else if (1 == 'i f 1 1 r - " ES VOCAL"; else if (1 == ' o ' 1 1 r - "ES VOCAL"; else if (l -- ' u ' 1 1 r = " ES VOCAL"; else ' A' ) 1 -- l == l -- l -- r = " NO ES VOCAL"; //Salida ' E, ) ' I , ) ' O' ) ' u' ) System . out . println( " '' ) ; System . out . pr i ntln( " Resultado : " + r) ; ... ........................................................................................................'................' ................................................................................ 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
- 101. Algoritmos con java 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 • Mes (m) Diseño: Diagrama de flujo ( Inicio ) ¡ m . Entero . e . Cadena . ¡ / Leer m / l_ m r- 1 ' 2 ' 3 V F e·-"VERANO" H ¡ V 4 , 5 , 6 1 F e-"OTOÑO" H 7,s,9:v F e-" INVIERNO " H 1o, 11, 12fY F e-" PRIMAVERA " 1 Escribir e ¡ ( Fin ) 1 Salida • Estación (e) Interfaz de usuario Algoritmo Pseudocódigo Ini cio / / 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" E'in Caso / / Sal ida Esc ribir e Fin
- 102. Capítulo 4: Estructuraselectiva múltiple Codificación: .............................................................................·····........................................................................................................................... ; import java . util . Scanner; : public c lass Problema30 { : public static void main (String[] : //Variables int m; String e = //Entrada 11 • ' args) ( Scanner teclado = new Scanner(System . in) ; System . out . pr i nt( "Mes : '' ) ; } } m= teclado . ne xtint() ; //Proceso swi tch (m) { } case 1 : 2 : 3 : case case e = "VERANO"; break; case 4 : case 5 : case 6 : e = "OTOÑO"; break; case 7 : case 8 : case 9 : e = " INVIERNO"; break; case 10 : case 11: case 12 : e = " PRIMAVERA" ; break; 1/Salida System . out . println( "" ) ; System . out . println( " Estacion : " + e) ; ............................................................................................................................................' ............................................................... Problema n.2 31 Enunciado: Dado la nota promedio de un alumno, obtener la categoría, según la siguiente tabla. Promedio Categoría Entre OY S Pésimo Entre 6 Y 10 Malo Entre 11 Y 14 Regular Entre 15 Y 17 Bueno Entre 18 y 20 Excelente .
- 103. Algoritmos con java 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 • Promedio (p) Diseño: Salida • Categoría (e) Interfaz de usuario '' C:ARCHIV- 1XINOXS-1 uc.tUI!ilEJ Pt·oncdio : lJ a - C.ttt:!fot• i.t : BFGtJI.nR Pt•e:;s <lflY key l(l {;(JJltirlllt: •.• Algoritmo Diagrama de flujo Pseudocódigo ( I nicio ! p . Caracte r . e . Cadena . ¡ / Leer p / l. V < p> o y p< S F 1 c- " PESI MO" V < p > 6 y p< 10 F 1 c- "MALO" > 11 y p< 1q V F 1 e - " REGULAR" > 15 y p> 11 V F 1 e- "BUENO" > 18 y p< 2 V F 1 e - " EXCELENTE" 1 Escribir e 1 ! ( Fin 1 1 1 1 Ini cio / / 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 Escribir e Fin
- 104. Capítulo 4: Estructuraselectiva múltiple Codificación: ..........................................................................................................................................................................................................- .. import java . util . Scanner; public class Problema31 { ) public static void main(String[] args) { //Variables } int p ; String e - //Entrada 11, ' Scanner teclado= new Scanner(System . in) ; System . out . print ("Promedio : '' ) ; p = teclado . nextint() ; //Proceso if(p >= o && p <= 5) { e= " PESIMO"; }else if(p >= 6 && p <= 10) ( e = " MALO"; }else if (p >= 11 && p <= 14) { e = " REGULAR"; }else if(p >= 15 && p <= 17) { e = "BUENO"; }else if(p >= 18 && p <= 20) { e = " EXCELENTE"; } 1/Salida System . out . print1n( "" ) ; System . out . print1n( "Categoria : " +e) ; '.. .................................................................................................................' .........................................................................................
- 105. Algoritmos con java 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 ,, C:ARCHIV- 1XINOXS- 1UC... lr:JEJ
- 106. Diagrama de flujo Inicio) ! d , m . Entero . e . Cadena . l / Lee r d , m / 1 m H LV 1, 2, 3 l F e-"VERANO" 1 F m 3 Y d >2u T v e-"OTOÑO" J H I V 4 , 5 , 6 1 ! F e-"OTOÑO" l_ F m 6 Y d>2 ¡ v e•- " INVIERNO" H 7 , S, 9 J v l F e-" INVIERNO" F m-9 l_ y d>2 l v e-" PRIMAVERA" J H1o,11 , 1 1-l F e-" PRIMAVERA" 1 F m-12 Y d>2 Tv e-"VERANO" .~ l / Escribir e / ! ( Fin ) Capítulo 4: Estructura selectiva múltiple Algoritmo Pseudocódigo Ini cio //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" Fin Si Caso 4, 5, 6 e - "OTOÑO" Si m = 6 Y d > 21 Entonces e - " INVIERNO" Fin Si Caso 7, 8 , 9 e - " INVIERNO" Si m = 9 Y d > 22 Entonces e - " PRIMAVERA" Fin Si Caso 10 , 11, 12 e - " PRIMAVERA" Si m = 12 Y d > 20 Entonces e - " VERANO" Fi n Si Fin Caso //Salida Esc rib i r e Fin
- 107. Algoritmos con java Codificación: .·.......................................................................................................................................................................................................... ... import java . util . Scanner; public class Problema32 { 1 public static void main(String[) args) { //Variables 1 int d , m; String e = 11, ' //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( "Dia : " ) ; d = teclado . nextint() ; System . out . print( "Mes : '' ) ; m= teclado . nextint() ; //Proceso switch (m) { case 1 : case 2 : case 3 : 1 e = "VERANO"; if(m == 3 && d > 20) e = "OTOÑO"; break; case 4 : case 5 : case 6 : e = "OTOÑO"; if(m == 6 && d > 21) e = " INVIERNO"; break; case 7 : case 8 : case 9 : e = " INVIERNO"; i f(m == 9 && d > 22) e = "PRIMAVERA"; break; case 10 : case 1 1 : case 12 : e = " PRIMAVERA"; if(m == 12 && d > 20) e = "VERANO"; break; 1/Salida System . out . println( ''" ) ; System . out . println( " Estacion : " +e) ; ·.............................................................................................................................................................................................................
- 108. Capítulo 4: Estructuraselectiva múlt iple e - - Problema n.2 33 ' Enunciado: En una universidad se ha establecido los siguientes puntajes de ingreso para sus respectivas facultades: Facultad Puntaje mínimo Sistemas 100 Electrónica 90 Indust rial 80 Administración 70 De acuerdo al puntaje obtenido por un postulante, determinar la facultad a la cual ingresó o dar un mensaje correspondiente para el caso que 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 que ingreso. Entrada • Puntaje {p) Diseño: Salida • Facultad (f) Interfaz de usuario " - C:ARCHIV- 1XINOXS-1U... 1!1151EJ l'unl.tjc: 1211 f',,cult ,ul: SIST1'11AS Pt·e ~; :; dlllJ ke y to cnntinue . . . _ a a -
- 109. Algoritmos con java Diagramade flujo ( Inicio ! p . Entero . f : Cadena ! / Leer p / 1 p>- 70 y p<- 7 V < F 1 f-" CIENCIAS" < ~p> 80 y p< 8 V F 1 f-" INDUSTRIAL" V >-90 y p< 9 F l t - " ELECTRONICA": < p> lOO V F 1 f-" SISTEMAS" 1 1 r-" NINGUNA" / Escribir f / ! ( Fin Algoritmo Pseudocódigo Inicio //Variables p Entero f : Cadena //Entrada Leer p //Proceso Si p >= 70 Y p <= 79 Entonces f - " CIENCIAS" Si NoSi p >= 80 Y p <= 89 Entonces f - " INDUSTRIAL" Si NoSi p >= 90 Y p <= 99 Entonces f - " ELECTRONICA" SiNoSi p >= 100 Entonces f - " SISTEMAS" SiNo f - " NINGUNO" Fin Si //Salida Escribir f Fin
- 110. Capítulo 4: Estructuraselectiva múlt iple Codificación: ¡ import java . uti l. Scanner; 1 publi c class Problema33 { } public stati c void //Variables main (St ring[J args) { } int p ; String f - //Ent rada "" · ' Sc anner teclado= new Scanner{Syst em . in ) ; System . out . print ("Punt a j e : "); p = tecl ado . nextint() ; / /Proceso if ( p >= 70 && p <= 79) f = " CIENCIAS"; e l se if(p >= 80 && p <= f = " I NDUSTRIAL"; e l se if (p >= 90 && p <= f = " ELECTRONICA"; e l se if (p >= 1 00) f = " SI STEMAS"; else f = " NINGUNA"; 1/Salida 8 9 ) 99 ) System . out . print l n (''") ; System . out . pri ntln( " Facul tad : " + f) ; ..........................................................................................................................................................................." ..............................' Problema n.2 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 A B C 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) • Nível (n)
- 111. Diseño: Algoritmos con java Interfazde usuario '' C:IARCHIV- 1XINOXS-1U.,, 1!11:1EJ Diagrama de flujo ( Inicio ) ¡ e , n . Caracter . mp : Entero ! / Leer e , n / 1 e H ' N' V F -n ~ ' A' V ~ H mp- 300 f--o ~ ' B' V mp-200 f-t F rl 'C' V mp- 100 ~ H ' p ' V F -n 7 ' A' H mp-400 f--o 71 ' B' V mp-300 f-t F -::-1 ,e, V mp-200 ~ F I / Escribir mp/ ! ( Fin ) - - - Algoritmo Pseudocódigo Inicio //Variables e , n : Carácter mp : Entero //Entrada Leer e , n //Proceso En Caso que e Sea Caso ' N' En Caso que n Sea Caso ' A' mp - Caso ' B' mp - Caso ' C' mp - Fin Caso Caso ' P' En Caso que n Sea Caso ' A ' 300 200 l OO mp - 400 Caso ' B' mp - 300 Caso ' C' mp - 200 Fin Caso Fin Caso //Salida Escribir mp Fin
- 112. Capítulo 4: Estructuraselectiva múltiple Codificación: . ............................................' ..........................................................................................................................' .................................. ... import java . util . Scanner; public class Problema34 { public static void main(String[] args) { //Variables } } char c , n; int mp = O; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . pr i nt( " Col eg i o : "); e = teclado . next () . charAt (O) ; System . out . print( "Nivel : " ) ; n = teclado . next () . charAt (Ol ; //Proceso if ( c-- 'N'){ if(n -- ' A' ) mp = 300 ; else if (n == ' B' ) mp = 200; else if (n == ' C' ) mp = 100; }else if (e == ' P') { } //Salida i f (n = = ' A' ) mp = 400; else if (n == ' B' ) mp = 300; else if (n == ' C' ) mp = 200; System . out . println( "" ) ; System . out . pri ntln( "Monto a pagar : " + mp) ; ... .......................................................................................................................................................................... ............................... Enunciado: Dado el número del mes y el año (cuatro dígitos) de una fecha, determinar en letras qué mes es y cuántos 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 si de 400. Análisis: Para la solución de este problema, se requiere que el usuario ingrese el 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) • Días (d) • Año (a) • Mes letras (m1)
- 113. Algoritmos con java Diseño: Interfazde usuario ' ' C:ARCHIV-1XINOXS-1UCR:,':, IIiJ I:J Diagrama de flujo Algoritmo ( Inicio l A B ¡ m, a , d o Entero o 01 6 1 V í 1 ml o Cadena o 1 / Leer m, a / 1 m F d -30 ml- "JUNIO" r 7 1 V '1 1 ! F d - 31 o 1 1 1 V l F d - 31 ml-"ENERO" ml- "JULIO" r 8 1 V ! F d - 31 . 1 2 1 '1 1 ml- " AGOSTO" r 9 1 V ' 1 1 Mod 4 = O Y F d - 30 (a Mod 100 <> o ml - " SETIEMBRE" O a Mod 400 = 0) 1d-281 d-29 1 o 1 V 10 1 ' 1 l ml-" FEBRERO" F d - 31 mlo - "OCTUBRE" 3 V l 1 11 1 V í 1 F d - 30 F d - 31 ml - " NOVIEMBRE" ml- "MARZO" 4 V '1 1 r 12 1 V 1 ! F d o - 31 F d - 30 ml-" DICIEMBRE" ml - "ABRIL" .1 V 5 ' 1 1 1 F d - 31 / Escribir d, ml / ml - "MAYO" 1 ( Fin J A B
- 114. Pseudocódigo Inicio //Variables m, a ,d : Enter o ml : Cadena //Entrada Leer m, a //Proceso En Caso q ue m Sea Caso 1 d - 31 ml - "ENERO" Caso 2 Capítulo 4: Estructura selectiva múltiple 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 - 31 ml - "JULIO" Caso 8 d - 31 ml - "AGOSTO" Caso 9 d - 30 ml - ''SEPTIEMBRE" Caso 10 d - 31 ml - "OCTUBRE" caso 11 d - 30 m1 - "NOVI EMBRE" Caso 12 d - 3 1 ml - ''DICIEMBRE'' F i n Caso 1/Salida Escribir d , ml Fin a Mod 400 = 0) Entonces
- 115. Algoritmos con java Codificación: .......'..................................................................................................................................................................................................... · import java . util . Scanner; public class Problema35 { public static void main(String[] args) { //Variables int m, a , d = O; String ml = ""; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( " Mes : '' ) ; m= teclado . nextint() ; System . out . print( " Afto : " ) ; a= teclado . nextint() ; //Proceso switch(m) { case 1 : d = 31 ; ml = " ENERO"; break; case 2 : if (a % 4 == O && (a % 100 1 = O 1 1 a % 400 d - 29 ; else d - 28 ; ml = " FEBRERO"; break; case 3 : d = 31 ; ml = " MARZO"; break; case 4 : d = 30 ; ml = " ABRIL"; break; case 5 : d = 31 ; ml = " MAYO"; break; case 6 : d = 30 ; ml = " JUNIO"; break; case 7 : d = 31 ; ml = " JULIO"; break; case 8 : d = 31 ; ml = " AGOSTO"; break; case 9 : d = 30 ; ml = " SEPTIEMBRE''; break; 0))
- 116. Capítulo 4: Estructuraselectiva múltiple ............................................................................................................................................................................................................. } } } case 10 : d = 31 ; ml = "OCTUBRE"; break; case 1 1 : d = 30 ; ml = " NOV I EMBRE"; break; case 12 : d = 31 ; ml = " DICIEMBRE"; break; //Salida System . out . println( "'' ) ; System . out . println (" Mes : " + ml) ; System . out . println( " Dias : '' + d) ; .............................................................................................................................................................................................................. Enunciado: Una empresa ha establecido diferentes precios para sus productos, según la calidad. 5000 4500 4000 4500 4000 3500 4000 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 el sistema verifica y determina el precio. Entrada • Calidad (e) • Producto (p) Diseño: Salida • Precio (precio) Interfaz de usuario , ; C:ARCHIV- 1XINOXS-1JL~ lliJEJ C. 1 i tl.ul : /. P1•od.ucto: 3 'P1•ec io: ]~~HH I'J•t::::: •'''~ kt:~ L11 c;IJitlirll(c ••• !!!
- 117. Algoritmos con java Diagramade flujo Inicio e , p : Entero precio : Entero Leer e , p Algoritmo Pseudocódigo Inicio //Variables e , p : Entero precio : Entero //Entrada Leer e , p
- 118. Capítulo 4: Estructuraselectiva múltiple Codificación: ..........................................................................................................................................' .......................................................' .......... · import java . uti l . Scanner; public class Proble ma36 { ) public static void ma i n(String [ ) args) { //Variables ) int e , p , precio = O; // Entrada Scanner teclado; new Scanner(System . in ) ; System . out . print ( ''Calidad : " ) ; e • teclado . ne xtint () ; System . out . print( ''Producto : '' ) ; p ; teclado . ne xtint() ; //Proceso s~1itch (e) { } case 1 : switch(p) { case 1 : precio • 5000; break; case 2 : prec J.o = 4500 ; break; case 3 : precio - 4000 ; break; } break; case 2 : switch (p ) { case 1 : } precJ.o = 4500 ; break; case 2 : precio ; 4000 ; break; case 3 : precio = 3500; break; break; case 3 : switch(p) { c ase 1 : } precio = 4000 ; break; case 2 : precJ.o • 3500; break; case 3 : precJ.o = 3000; break; //Salida System . out .println (''" ) ; System . out .println (" Precio : '' +precio) ; ... ..............................................................................................................................' ....................................'...................................... .
- 119. Algoritmos con java 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 (d l ) • Premio (p) • Segundo dado (d2) • Tercer dado (d3) Diseño: Interfaz de usuario '' C:ARCHIV- 1XINOXS-1J:~:~U!~~EJ D,;rlo 1 : 3 a O.t<to ?. : L - Darlo 3: 6 P1•enio: BRONCE Pl'f! :: :: .nt) kf~'J to cnntintte .. . a
- 120. Diagrama de flujo Inicio dl, d2 , d3 : Entero p Cadena Leer dl , d2 , d3 dl=6 y d2=6 y d3=6 F (dl=6 y d2=6) o (d1=6 y d3=6) o (d2=6 y d3=6) F dl=6 o d 2=6 o d3= F p- " PERD IO" Escribir p Fin V p-, ORO" p-"PLATA" V p-" BRONCE" Capítulo 4: Estructura selectiva múltiple Algoritmo Pseudocódigo Inicio //Variables dl , d2 , d3 Entero p : Cadena //Entrada Leer dl , d2 , d3 //Proceso Si d1=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 d3=6) Entonces p - "PLATA" SiNoSi dl=6 O d2=6 O d3=6 Entonces p - " BRONCE" SiNo p - " PERDIO" Fin Si 1/Salida Escribir p Fin
- 121. Algoritmos con java Codificación: ............................................................................................................................................................................................................. ·import java. util . Scanner; public c lass Problema37 { } public static void main(String[] args) ( //Variables } int dl , d2 , d3 ; String p = ""; //Entrada Scanner teclado= new Scanner(System . in) ; System. out . print( "Dado 1 : " ) ; dl = tec lado . nextint() ; System . out . print( "Dado 2 : " ) ; d2 = tec lado . nextint() ; System . out . print( "Dado 3 : " ) ; d3 = teclado . nextint() ; //Proceso if (dl == 6 && d2 6 && d 3 == 6) p = " ORO"; else if((dl == 6 && d2 == 6) (d2 == 6 && d3 == 6)) p = " PLATA"; 11 (dl else if(dl == 6 11 d2 == 6 11 d3 - - 6) p = " BRONCE"; else p = " PERDIO"; 1/Salida System . out . println( "'' ) ; System . out . println( "Premio : " + p) ; 6 && d3 6) && ... ............·········································································......................................................, ..............................................., ·············· 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 " C:ARCHIV-1XINOXS-1U._11 1!19 E!
- 122. Diagrama de flujo Inicio d, m, a , dmax r : Cadena Entero Leer d , m, a 1 , 3, 5, 7, 8 , 10, 12 V 4' 6' 9' 11 f---'-----, 2 F dmax ·- 30 V a Mod 4 = O (a Mod 100 <> O a Mod 400 = 0) V Capítulo 4: Estructura selectiva múltiple Algoritmo Pseudocódigo Inicio //Variables 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 lOO <> O O a Mod 400 = 0) Entonces dmax ·- 29 SiNo dmax ·- 28 Fin Si Fin Caso dmax - 28 dmax - 29 Si d>O Y d<=dmax) Y (m>O Y m<l3) Y a>O Entonces F (d>O Y d<=dmax) Y (m>O Y m<l3) Y a>O r - " INCORRECIO" r - "CORRECIO" Escribir r Fin r - "CORRECTO" SiNo r - " INCORRECTO" Fin Si //Salida Escribir r Fin
- 123. Algoritmos con java Codificación: ......................................'...............................................................................................................................' ....................................... import java . util . Scanner; public class Probl ema38 { } public static void main(String[] args) { //Variables ) int d , m, a , dmax = O; String r = //Entrada "lf • 1 Scanner teclado= new Scanner(System . i n) ; System . out . pr i nt( " Dia : '' ) ; d = t eclado . nextint () ; System . out . print( " Mes : '' ) ; m= teclado . next int() ; System . out . print( " Afto : '' ) ; a= teclado . next int() ; //Proceso swi tch (m) { case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12 : dmax - break; case 4 : case 6 : case 9 : case 11 : dmax = break; case 2 : 31 ; 30 ; if (a % 4 == O && ( ! (a % 1OO == O) 11 a % 4OO == O) l dma x - 29; el se dma x - 28 ; } if ( (d > O && d <= dmax) && (m > O && m < 13) && a > 0 ) r = " CORRECTO"; e l se r = " INCORRECTO"; //Salida System . out . pri ntln( "'' ) ; System . out . println( " Respuesta : " + r) ; .............................................................................................................................................................................................................
- 124. Capítulo 4: Estructuraselectiva múltiple 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 devuelva 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 " . C:ARCHIV-1XINOXS-1 UCRE~ 11!5JEl
- 125. F F Algoritmos con java Diagramade flujo Inicio d , m, a , dmax r : Cadena Entero Leer d , m, a 1 , 3 , 5 , 7 , 8 , 10, 12 4 , 6 , 9 , 11 V 2 F F dmax - 30 V a Mod 4 = O Y (a Mod 100 <> O o a Mod 400 = 0) d - d + 1 V d - 1 m - m + 1 V m - 1 a - a + 1 Escribir d , m , a Fin Algoritmo V dmax - 29 Pseudocódigo Inicio //Variables d , m, a , dmax · Entero r : Cadena //Entrada Leer d , m, a //Proceso En Caso que m Sea Caso 1 , 3 , S , 7 , 8 , 10 , 12 dmax - 31 Caso 4 , 6 , 9 , 11 dmax - 30 Caso 2 Si a M:x:l 4 = O And (a M:x:l 100 <> O Or a Mod 400 = 0) Entonces dmax - 29 SiNo dmax - 28 Fin Si 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
- 126. Capítulo 4: Estructuraselectiva múltiple Codificación: · import java . util . Scanner; public class Problema39 { public static void main(String[J //Variables int d , m, a , dmax = O; //Entrada args) { Scanner teclado= new Scanner(System . in) ; System . out . print( " Dia : '' ) ; . . . . } } d = teclado . nextint() ; System . out . print( " Mes : " ) ; m= teclado . nextint() ; System . out . print( " Afto : " ) ; a= teclado . nextint () ; //Proceso swi tch (m) { case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12 : dmax - 31 ; break; case 4 : case 6 : case 9 : case 1 1 : dmax - break; case 2 : 30 ; if (a % 4 == O && ( ! (a % 1OO dmax - 29 ; else dmax = 28 ; } d = d + 1 ; if(d > dmax ) d = 1 ; { } m +=1 ; if(m == a ++ ; } 13) { m = 1; 1/Salida System . out . println( "" ) ; System . out . println( " Dia : System . out . println( " Mes : System . out . println( " Afto : " + " + " + d) ; m) ; a 1; -- 0) 1 1 a % 400 o) )
- 127. Algoritmos con java Probleman.2 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 a romano. Entrada Salida • Número decimal (n) • Número romano (r) Diseño: Interfaz de usuario
- 128. Capítulo 4: Estructuraselectiva múltiple Algoritmo Diagrama de flujo Inici o A B ¡ n , u, d , e , m . Enter o . d r . Ca dena . l / Leer n / J. F n< 399_2.-:> V ~ 1 r-r+" X" r V _, 2 r -r+" XX" _r. F V -t 3 f--o r-r+" XXX" 1-t ¡v 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 F V _, 4 1-+ r -r+" XL" ~ F V ~ 5 r-r+" L" ~ _, V ro 6 r -r+" LX" F V -t 7 f--.o r-r+" LXX" 1-t m __::> F V f-+ 8 1-+ r-r+ " LXXX" 1--< H 1 V r-"M" ~ F V __, 2 r-"MM" ro F V ;[ 9 r-r+" XC" ~ F ~ f-+ 3 r .- " MMM" ¡..... F d V H ~ 1 r -r+" X" -e_..> V - f-+ f-+ 1 t--"' r-r+ 11 C" F V H 2 r-r+ "CC" f-. F V H 3 r-r+"CCC" ~ F -+ 4 H r-r+ "CD11 ro F V f-+ 5 t-+ r-r+" D" f-+ F V H 6 r-r+ " DC" f-. F V H 7 r-r+ "DCC" ~ F V __, 8 r-r +" DCCC" ro F ~ -t 2 r·-r+" XX" 1-t F V -t 3 1-+ r-r+" XXX" 1-t F V H 4 r -r+" XL" f-. F V H 5 r-r+" L" ~ F _, V ro 6 r -r+" LX" F ~ -t 7 r-r+" LXX" 1-t F V H 8 r-r+ " LXXX" f-. F V -{ 9 r-r+" XC" ~ F F V f-+ 9 t-+ r-r+uCM'1 f-+ F / Es c r ibir r / ! A B ( Fin ) -
- 129. Algoritmos con java Pseudocódigo Inicio //Variables n,u, d , e , m : Entero r : Cadena //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
- 130. Capítulo 4: Estructuraselectiva múltiple 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 + . XC11 Fin Caso En Caso que u Sea Caso 1 r -r + " ! " 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
- 131. Algoritmos con java Codificación: .......'..................................................................................................................................................................................................... import java . util . Scanner; public class Problema40 { public static void main(String[J args) { //Variables int n, u , d , c , m; String r - "" · ' //Entrada Scanner teclado= new Scanner{System . in) ; System . out . print( "Numero : " ) ; n = teclado . nextint() ; //Proceso if (n <= 3999) { u - n % 10 ; n n 1 10 ; d - n % 10 ; n - n 1 10 ; e - n % 10 ; n - n 1 10 ; m - n % 10 ; switch (m) { case 1 : } r = "M "; break; case 2 : r = "MM"¡ break; case 3 : r = "MMM"; break; switch (e ) { case 1 : r = r + "C"; break; case 2 : r = r + "CC"; break; case 3 : r = r + 'CCC"; break; case 4 : r = r + "CD"; break; case 5 :
- 132. Capítulo 4: Estructuraselectiva múltiple ........................................................................................................................................................................................................... ... r = r + "D"; break; case 6 : r = r + '' DC"; break; case 7 : r = r + "DCC" ; break; case 8 : r = r + "DCCC"; break; } case 9 : r = r + "CM"; break; switch (d) { case 1 : r = r + break; case 2 : r = r + break; case 3 : r = r + break; case 4 : " Xu· ' "XX"· ' "XXX"¡ r = r + "XL"; break; case 5 : r = r + "L"; break; case 6 : r = r + "LX"; break; case 7 : r = r + break; case 8 : "LXX"· ' r = r + break; case 9 : "LXXX"· ' } r = r + "XC"; break; switch (u) { case 1 : r = r + " ! "; break; ..............................................................................................................................................................................................................
- 133. Algoritmos con java ............................................................................................................................................................................................................ ) ) ) ) 1/Salida case 2 : r = r + " II "; b r eak ; case 3 : r = r + " III "; break ; case 4 : r = r + break; case 5 : r = r + break ; case 6 : " IV"; r = r + "VI "; b r eak ; case 7 : r = r + "VII "; b r eak ; case 8 : r = r + " VII I "; b r eak ; case 9 : r = r + '' I X"; b r eak ; System . out . p ri nt l n( "'' ) ; System . out . println (" Romano : " + r ) ; .. .......................................................................................................................................................................................................... .
- 134. Capítulo 4: Estructuraselectiva múlt iple 4.3 Problemas propuestos Los siguientes problemas le servirán para medir su aprendizaje, es importante que los resuelva. Propuesto n.º 21 Enunciado: Dado el número de un mes, devolver el mes en letras. Propuesto n.º 22 Enunciado: Lea un número del 1 al 7 y devuelva el día de la semana, considere que 1 es domingo. Propuesto n.º 23 Enunciado: Dados los siguientes operadores aritméticos(+,-,* y/), devuelva el nombre del operador. Propuesto n.º 24 Enunciado: Dado el número de un canal de televisión, determine cual es el nombre del canal. Propuesto n.225 Enunciado: En una empresa se ha determinado la siguiente política de descuento. 20% 15% Determine mediante un programa, cuál será el monto del descuento al sueldo ingresado de un trabajador. Propuesto n.º 26 Enunciado: Una frutería ofrece las manzanas con descuento, según la siguiente tabla: Kilos %Descuento 0- 2 0% 2.01- 5 10% 5.01- 10 20% Mayor a 10 30% Determinar cuánto pagará una persona que compre manzanas en esa frutería.
- 135. Algoritmos con java Propueston.º 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.2 28 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 Saños 2500 2000 1500 Entre 6 y 8 años 3000 2500 2000 Mayor a 8 años 4000 3500 1500 Propuesto n.2 29 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 Femenino Entre 18 y 35 Arequipa Cuzco Entre 36 y 75 Cuzco lquitos Mayor a 75 lquitos Arequipa Propuesto n.º 30 Enunciado: Dada una fecha determine cuántos días faltan para que acabe el año.
- 136. Estructura repetitiva «Mientras» S.tlntroducción Muchasveces 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 (while) 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 j - j - 1 . .. .....·········................................................................................................................................................................................············ Java .......................................................................................................................................................................................................... ··. e = e + 1 ; i += 2 ; j-- ; .. .......................................................................................................................................................................................................... .
- 137. Algoritmos con java 5.3Acumulador 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>>. Ejemplo pseudocódigo ........................................................................................................................................................................................................... ... e -e + X i - i + e J -J - l. . Java .............................................., ............................................................................................................................................................... e = e + x ; i += e ; 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 Sal i r .. .......................................................................................................................................................................................................... . Java ............................................................................................................................................................................................................. break ; ... .......................................................................................................................................................................................................... .. 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 '•· .......................................................................................................................................................................................................... . Java .' .......................................................................................................................................................................................................... ... eontinue ;
- 138. Capítulo 5: Estructurare 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. 1 xp . Lógica ¡v Instrucción 1 Instrucción n + Sintaxis Java while (<E:xp . Log . >) { } <instrucción 1> ; <instrucción n> ; Mientras E:xp . F Instrucción Instrucción Fin Mientras 5.7 Estructura repetitiva «Mientras» anidada Lógica 1 n Dent ro de la estruct ura repetitiva es posible colocar una o más estructuras repetitivas, así como otras estructuras. Sintaxis Java Instrucción 1 Instrucción n F F Mientras E:xp . Lógica Mientras Exp . Lógica Instrucción 1 Instrucción n Fin Mientras Fin Mientras .......................................................................................................................................................................................................... ··. while (<Exp . Log . >) { while (<Exp . Log . >) { } } <instruccionl> ; <instruccionn> ; .. ...........................................................................................................................................................................................................
- 139. Algoritmos con java Probleman.2 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 ' ' C:ARCHIV- 1XINOXS-1UCR( '!I I!:JEJ Diagrama de flujo Inicio i , n, s : Entero Leer n i - 1 S - S + 1 i - i + 1 Escribir s Fin F Algoritmo Pseudocódigo Inicio //Variables i, n, s : Entero //Entrada Leer n //Proceso i - 1 Mientras i<=n S - S + 1 i - i + 1 Fin Mient ras //Salida Escribir s Fin
- 140. Capítulo 5: Estructurare petitiva «Mientras» Codificación: .. .......................................................................................................................................................................................................... ... import java . util . Scanner; public class Problema41 { } public stati c void main (Stri ng[J args) { //Variables ) int i , n , s; O; //Entrada Scanner teclado ; new Scanner(System . in ); System . out . print( "Numero : " ) ; n; t eclado . nex tint (); //Proceso i ; 1 ; while(i <; n) { ) 1/Salida S = S + i ; i - i + 1 ; System . out . println( "" ) ; System . out . println( " Suma : '' + s) ; .............................................................................................................................................................................................................. Problema n.2 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 e' C:ARCHIV-1XINOXS-1JCR.'~ IIri]I:J
- 141. Algoritmos con java Diagramade flujo i , e , ni , nf, Entero Leer ni , nf i - ni + 1 C •- C+l i ·-i +l Fin 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 Codificación: ............................................................................................................................................................................................................. · import java . uti1 . Scanner; pub1ic c1ass Prob1ema42 { public static void main(String[] args) { //Variables 1 int i , ni , nf , c =O ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( " Num . Incial : " ) ; ni= teclado . next!nt() ; System . out . print( " Num . Final : " ) ; nf = teclado . nextlnt() ; //Proceso i = ni + 1; while (i < nf) { e +=1 ; i++ ; ) //Salida System . out . println( "" ) ; System . out . println( "Cantidad : " +e) ; ..t........................................................................................................................................................................................................ .
- 142. Capítulo 5: Estructurarepetitiva «Mientras» Enunciado: Dado un rango de números enteros, obtener la cantidad de números pares 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 pares que contiene el rango. Entrada Salida • Número inicial (ni) • Cantidad de pares (cp) • Número final (nf) Diseño: Interfaz de usuario "- C:ARCHIV-1XINOXS-1UC.~ ~eEJ Algoritmo Diagrama de flujo Pseudocódigo ( I nicio ! i , cp, ni , nf, ~ / Leer ni , ! i - ni + l i<nf V F Mod 2 = V cp - cp + i - i + ! / Escribir ( Fi n ) . 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 J. < n f Si i M od 2 - O Entonces cp - cp + 1 Fin Si i - i + 1 Fin Mient r as //Salida Escrib i r cp Fin
- 143. Algoritmos con java Codificación: .............................................................." ............................................................................................................................................. . impo r t java . uti l . Scanner ; public cla ss Problema43 { public stati c void main(St ri ng[J args ) { //Variabl es } } int i , ni, nf, cp - O; //Entrada Scanne r teclado = ne w Scanner (System . i n) ; System . out . p ri nt ("Num . Inc i al : " ) ; ni = t eclado . nex t!nt () ; System . out . p ri nt ("Num . Fina l : " ) ; n f = t eclado . nextint () ; //Pr oceso i = ni + 1 ; while (i < n f ) 1 if(i % 2 o ) 1 c p += 1 ; } i++ ; } 1/Salida System . out . p ri nt l n (" '' ) ; System . out . pri ntln ("Cant . Pares : " + cp ) ; ... .......................................................................................................................................................................................................... . Enunciado: Obtener la cantidad de los primeros N números múltiplos de S. Análisis: Para la solución de este problema se requiere que el usuario ingrese un número; luego, que el sistema devuelva la cantidad de números múltiplos de S. Entrada • Número (n) Diseño: Salida • Cantidad (e) Interfaz de usuario e' C:ARCHIV-1XINOXS-1UCR!:l!) lr:J E1 Hune ro 1!J a - C,lflt ill,nl: J P1•e!;~; <lll'J kt~V to cont inue .. a
- 144. Diagrama de flujo Inicio ie , n : Entero Leer n i - 1 F F e - e + 1 i·- i+l Escribir e Fin Capítulo 5: Estructura re petitiva «Mientras» Algoritmo Pseudocódigo Ini cio //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 Codificación: import java . util . Scanner; public class Problema44 { } publie statie void main(String[) args) { //Variables } int i , n, e = O; //Entrada Scanner teclado = new Scanner(System . in) ; System . out . print( " Numero : " ) ; n = teelado . nextint() ; //Proceso i = 1 ; >lhile(i <= n) { if (i % 5 =- o) { e += 1 ; } i++ ; ) 1/Salida System . out . println( '' " ) ; System . out . println(" Cantidad : " +e) ; ..............................................................................................................................................................................................................
- 145. Algoritmos con java Probleman.2 45 Enunciado: Dado un número, determinar cunátos dígitos tiene. Análisis: Para la solución de este problema se requiere que el usuario ingrese un número entero; luego, 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 e; C:ARCHIV- 1XINOXS-1U... ~~El Nuncl'O : 12)4!.,(. a - C.wt. Diy i tu:; : (, Pt·e~;!; dny key to cnntinue ... _ a Algoritmo Diagrama de flujo Pseudocódigo Inicio i , e , n : Entero Leer n n - n 10 e - e + 1 Escr i bi r e Fin F Inicio //Variables i , n , e : Entero //Entrada Leer n //Proceso Mi e nt r as n>O n - n 10 e - e + 1 Fin Mient r as //Salida Escr ib i r e Fin
- 146. Capítulo 5: Estructurare petitiva «Mientras» Codificación: .. .......................................................................................................................................................................................................... ... import java . util . Scanner; public class Problema45 { } public static void main(String[J args) { //Variables } int i , n , c =O ; // Entrada Scanner teclado= new Scanner(System . in ) ; System . out . pr i nt( " Numero : " ) ; n = teclado . nextint () ; //Proceso while (n > 0 ) { n = n 1 10 ; e += 1 ; } 1/Salida System . out . pr i ntln( " '' l ; System . out . println( "Cant . Digitos : " +e ) ; ...........................................................................................................................................................................................................' Enunciado: Dado un número, determinar la cantidad de dígitos pares que contiene. . Análisis: Para la solución de este problema se requiere que el usuario ingrese un número entero; luego, que el sistema verifique y devuelva la cantidad de dígitos enteros que contiene el número. Entrada Salida • Números (n) Diseño: • Cantidad de dígitos pares (e) Interfaz de usuario '' C:ARCHIV- 1XINOXS-1JCR_!~~ ~IiJ El Num:t·o : 12J1~6 a - C.Uit _ Di~1 i tu:; ¡~ou•1::;: J P1·e~;:; ~ny key to cont inue .. __ a
- 147. Algoritmos con java Diagramade flujo ( Inicio ) l i , d , e, n . Entero . ! 1 Leer n 1 1 n>O F Tv d - n Mod 10 l v F d Mod 2 = o Tv e - e + 1 n - n 10 l / Escribir e / ! ( Fin ) Algoritmo Pseudocódigo Inicio //Variables i, d , e , n · Entero //Entrada Leer n //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 Escribir e Fin Codificación: .......................................................................................................................................................................................................... .. · import java . uti1 . Scanner; public class Problema46 { . J pub1ic static void main(String[J args) { //Variables J int i , d , c = O, n; //Entrada Scanner teclado= new Scanner(System . in ) ; System . out . print( "Numero : " ) ; n = teclado . nextint () ; //Proceso while (n > 0) { } d = n % 10 ; if(d%2== 0) { } n /= 10 ; 11Salida e += 1 ; System . out . println( "'' ) ; System . out . println( "Cant . Dígitos pares : " +e) ; ............................................................................................................................................................................................................
- 148. Capítulo 5: Estructurare petitiva «Mientras» Problema n.2 47 Enunciado: Dado un número, devolver el dígito mayor. Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número entero; luego, 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 " . C:ARCHIV-1XINOXS- 1UC:}1 II!:JEI Nunet•o: 12345(,7 a - Dig ito Mdyor: 7 Pt·t~:::: .tny kt~V lo cont iruu: ... a Algoritmo Diagrama de flujo Pseudocódigo Inicio d , m, n Enter o Lee r n F d - n 10 m - d n - n 10 Escribir m Fi n Inicio //Variables d , m, n : Entero //Entrada Lee r n //Proceso Mientras n > O d - n Mod 10 Si d > m Entonces m- d Fin Si n - n 10 Fin Mient ras //Salida Escribir m Fin
- 149. Algoritmos con java Codificación: .·..........................................................................................................' ................................................................................................. import java . util . Scanner; public c lass Problema47 { } public static void main(String[] args) { //Variables } int d , m = O,n; //Entrada Scanner teclado = new Scanner(System . in) ; System . out . pri nt ("Numero : " ) ; n = tecl ado . nextint() ; //Proceso while (n > 0 ) { d = n % 10 ; if (d > m) { m = d ; ) n / = 10 ; } 1/Salida System . out . pr i nt1n( "'' ) ; System . out . pri nt1n( " Digi to Mayor : " +m) ; ... .......................................................................................................................................................................................................... . Enunciado: Dados dos números, diga si son amigos. 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 {n1 y n2); luego, que el sistema verifique y devuelva si son o no números amigos. Entrada Salida • Números (n 1, n2) Diseño: • Respuesta (r) - SON AMIGOS - NO SON AMIGOS Interfaz de usuario " . C:ARCHIV- 1XINOXS- 1J.;~ 1151EJ Hune J•o 1 : ~/.H ,Nune1•o 2: 284 Reott ltado: SON AMIGOS I'J•t::;:; c'''V kt:v lll l:tlrttirtltc ••• _ a a -
- 150. Capítulo 5: Estructurarepetitiva «Mientras» Algoritmo Diagrama de flujo Pseudocódigo Inicio Inicio Fin r ·- " NO SON AMIGOS" r-" SON AMIGOS" Escribir r Fin
- 151. Algoritmos con java Codificación: ...........................................................................................................................................................................................................' ~import java . uti l. Scanner; ~ public class Problema48 { ~ public static void main(String[J 1 //Variables int i , n1 , n2 , s1 =O , String r = //Entrada s2 = O; lf , ' args) { Scanner teclado= new Scanner(System . in) ; System . out . print( " Numero 1 : " ) ; } } n1 = teclado . nextint() ; System . out . print( " Numero 2 : n2 = teclado . nextint() ; //Proceso i = 1 ; while (i <= nl 1 2) { if (n 1 % i == O) { s1 += i; } i++ ; } i = 1 ; whi le (i <= n2 1 2) { if (n 2 % i == O) { s2 += i ; } i ++ ; } if(nl == s2 && n2 == sl) r = else r = 1/Salida " SON AMIGOS "; " NO SON AMIGOS "; ) ; System . out . pri ntln( "'' l ; System . out . println( " Resultado : " + r) ; .. .......................................................................................................................................................................................................... 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)
- 152. Diseño: Capítulo 5: Estructurare petitiva «Mientras» Interfaz de usuario '' C:ARCHIV-1XINOXS-1UCR., II!:J f:l Diagrama de flujo ( Inicio } ¡ d , n, i . Entero . l 1 Leer n 1 l n>O 1 v d - n Mod 10 n - n 10 i - i * 10 + d 1 ¡ / Escribir i / l ( E"in } E" 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 l"in Mientras //Salida Escribir i Fin Codificación: , ·i;;;¡;·~-~ t····j·~·~·~·~-·~·t·i1·~··s·~~·~·~~·~·;-·································································································································· pub1ic c1ass Prob1ema49 { public static void main(String[J args) { //Variables } int d , n , i ~O ; //Entrada Scanner teclado~ new Scanner{System . in ) ; System . out . print( "Numero : "); n ~ teclado . nextint (); //Proceso whi le (n > 0) { } d - n % 10 ; n ~ n 1 10 ; i - i * 10 + d ; 1/Salida System . out . pri ntln( " '' ) ; System . out . println( " Inverso : " + i) ; ..}......................................................................................................................................................................................................... .
- 153. Algoritmos con java -Probleman.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, cubos de sus dígitos 13 + 53 + 33 = 153 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 y el sistema procesa y determina si es o no un cubo perfecto. Entrada Salida • Número (n) • Respuesta (r) - CUBO PERFECTO - NO ES CUBO PERFECTO Diseño: Interfaz de Usuario '' C:ARCHIV- 1XINOXS- 1UCR:?!JIII:J E'J Algoritmo Diagrama de Flujo t , d, s , n : Entero r Cadena Leer n t - n d - t Mod 10 t - t 10 S - S + d A 3 F r-" NO ES CUBO PERFECTO" r-"CUBO PERFECTO" Escribir r Fin Pseudocodigo Inicio //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 1/Salida Escribir r Fin
- 154. Capítulo 5: Estructurare petitiva «Mientras» Codificación: .......................................................................................................................................................................................................... ··. impo r t java . ut i l . Scan ner ; publi c class ProblemaSO { public stati c void mai n (St ri ng[J args ) { / /Variables l int t , d , s = O, n ; St ri ng r = ""; //En t rada Scanne r teclado = new Scanner (System . i n) ; System . out . pri nt ("Numero : "); n = t e clado . nex tint ( ) ; //Pr oceso t = n ; whi le (t > 0 ) { } d = t % 10 ; t / = 10 ; s = (i n t ) (s + Math . pow (( double ) d , 3 . 0 )) ; if ( n == s ) r = " CUBO PERFECTO"; e l se r = " NO ES CUBO PERFECTO"; 1/Salida System . out . print ln ("" ) ; System . out . p ri nt l n (" Resul tad o : " + r) ; .'.!......................................................................................................................................................................................................... . 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)
- 155. Algoritmos con java Diseño:Interfaz de usuario " C:ARCHIV- 1XINOXS-1JCREA... 1!15JI:J Diagrama de flujo Inicio n , d , e , r Entero Leer n , d n - n - d e - e + 1 r - n Escribir e , r Fin F Algoritmo Pseudocódigo Inic.io //Variables n , d , e , r · Entero //Entrada Leer n , d //Proceso Mientras n >= d n - n - d e - e + 1 Fin Mientras r - n //Sal.ida Escribir e , r Fin Codificación: ............................................................................................................................................................................................................ ' import j ava . util. Scanner; public class Problema51 { public static void main(String[] args) { //Variabl es } } int n , d , c = O, r ; //Entrada Scanner teclado • new Scanner(System . in) ; System .out . print( " Numerador : " ) ; n = teclado . nextlnt() ; System .out . print( " Denominador : " ) ; d • teclado . nextlnt( ) ; //Proceso while (n >= d) { n - = d ; e++ ; } r = n; 1!Salida System .out . println( ". ) ; System .out . print l n( "Cociente : '' +e) ; System .out . print l n( ''Residuo : " + r ) ; ...................................................................' ......................' ........................................................................."''..' ....." ......." ....' .." " ..' ....
- 156. Capítulo 5: Estructurarepetit iva «Mientras» Enunciado: Determine si un número es capicúa o no. Se dice que un número capicúa es aquel que al invertir sus cifras da el mismo número; por ejemplo, 12321 invertido es 12321. Entonces es un número capicúa. Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número; luego, que el sistema verifique y determine si es o no capicúa. Entrada Salida • Número (n) • Respuesta (r) - ES CAPICUA Diseño: l r-" NO ES - NO ES CAPICUA Interfaz de usuario ' ; C:ARCHIV- 1XINOXS-1U... l!ilEJ Algoritmo Diagrama de flujo Pseudocódigo Inicio Inic.i.o L //Variables n , i , d . Entero . n , i , d : Entero r : Cadena r . Cadena . ¡ 1 Leer n 1 ¡ t - n l t > o F 1V d - t Mod 10 t - t 10 i - i * 10 + d 1 l n i CAPICUA 1 1 r-"ES CAPI CUA" 1 l / Escribir ;/ L eFin //Entrada Lee r n //Proceso t - n Mientras t > O d - t Mod 10 t - t 10 i - i * 10 + d Fi n Mient r as Si n = i Entonces r - " ES CAPICUA" Si No r - " NO ES CAP I CUA" Fin Si //Sal.i.da Escribir r F.i.n
- 157. Algoritmos con java Codificación: importjava . util . Scanner; public c lass Problema52 { } public static void main (String(J args) ( //Variables } int n , i = O, d , t ; String r = //Entrada lf • ' Scanne r teclado= new Scanner(System . in) ; System . out . pr i nt( "Nume r o : " ) ; n = teclado . nextin t() ; //Pr oceso t = n ; whi le (t > 0 ) { } d - t % 10 ; t - t 1 10 ; l. - i * 10 + d ; if(n == i) r = " ES CAPICUA"; else r = " NO ES CAPICUA" ; 1/Salida System . out . println( "'') ; System . out . pr i ntln( " Resultado : " + r) ; Problema n.2 53 Enunciado: Dado un número, determine si es un número primo. Recuerde que un número primo es aquel que solo es divisible por 1 y por sí mismo. Análisis: Para la solución de este problema se requiere que el usuario ingrese un número; luego, que el sistema determine si es primo. Entrada • Número (n) Diseño: Salida • Respuesta (r) - ES PRIMO - NO ES PRIMO Interfaz de usuario "- C:ARCHIV- 1XINOXS- 1U _S3 11!:Jt1
- 158. Diagrama de flujo (Inicio ! n, i . En t ero . flag . Logico . r . Cadena . ¡ 1 Leer n 1 ¡ flag -Verdadero i - 2 i<=n2 F V F n M od i = o ¡v flag-Falso salir i - i + 1 1 F flag V ! ! 1 r- " NO ES PRIMO" 1 1 r-"ES PRIMO" ~ /Escribir r/ ¡ ( Fin ) Capítulo 5: Estructura repetitiva «Mientras» Algoritmo 1 Pseudocódigo Inicio //Variables n , i : Entero flag : Logico r : Cadena //Entrada Leer n //Proceso flag - Verdadero i - 2 Mientras i <= n2 Si n M od i = O flag - Fal so Sal i r Fin Si i - i + 1 Fin Mient r as Si flag Entonces r - "ES PRIMO" SiNo r - " NO ES PRIMO" Fin Si //Salida Escribir r Fin
- 159. Algoritmos con java Codificación: ............................................................................................................................................................................................................ . importjava . util . Scanner; public class Problema53 { } public stati c void main (Stri ng[J args) { //Variables } int n, i ; boo l ean flag ; String r = ""; //Entrada Scanner teclado= new Scanner(System . i n) ; System . out . pri nt( "Numero n = teclado . ne xtint () ; //Proceso flag = true ; i = 2; whi le(i <= n 1 2) { if (n % i == O) { flag = false ; break; } } i ++ ; if (flag) r = " ES PRIMO"; else r = " NO ES PRIMO"; 11Salida . " ) . . , System . out . println( "'') ; System . out . pri ntln( " Respuesta : " + r) ; .. ........................................................................................................................................................................................................... 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 una base si sus dígitos son menores a su base. Análisis: Para la solución de este problema se requiere que el usuario ingrese un número; luego, que el sistema verifique y determine si pertenece a la base. Entrada Salida • Número (n) • Respuesta (r) • Base (b) - BASECORRECTA - BASE INCORRECTA
- 160. Diseño: Capítulo 5: Estructurare petitiva «Mientras» Interfaz de usuario e' C:ARCHIV- 1XINOXS- 1UCR:~ 1115113 Hunt~t·o: 1/.]4!) l3 Rll~;e: () - ll""" 1t.ulo : nns..: COHili·:CTn P1·c~~ <llY kcy to c:(Jntilltle ... a Diagrama de flujo I nicio n, b, d : Ente ro flag : Logico r : Cadena Leer n, b flag - verdadero d - n Mod 10 n - n 10 F Algoritmo Pseudocódigo Inicio //Variables n , b , d : Entero flag : Logico r : Cadena //Entrada Leer n , b //Proceso flag - Verdadero Mientras n > O d - n Mod 10 n - n 10 F Si d >= b Entonces flag - Fal so Salir F flag - Falso f------+1 Sali r flag V Fin Si Fin Mientras Si flag Entonces r - "BASE CORRECTA" SiNo r - " BASE INCORRECTA" Fin Si r-" BASE INCORRECTA" r-" BASE CORRECTA" //Salida Escribir r Fin
- 161. Algoritmos con java Codificación: impor t java . uti l . Scan ner ; public class Problema54 { } public stat i c void main(St ri ng[J args) { //Variables } int n , b , d ; boolean flag ; String r = ""; //Entrada Scanner teclado= new Scanner (System . i n) ; System . out . print( " Numero : '' ) ; n = tecl ado . n e xtint (); System . out . print( " Base : " ) ; b = t eclado . nex t int() ; //Pr oceso flag = true ; wh i l e (n > 0) { } d = n % 10 ; n /= 10 ; if (d >= b ) { } flag = false ; break; if (flag) r = " BASE CORRECTA"; else r = " BASE INCORRECTA''; 1/Salida System . out . println( "" J ; System . out . pr i ntln( " Resul tado : " + r) ; '• ............................................................................................' .............................................................................................................. Problema n.2 55 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)
- 162. Diseño: n, Capítulo 5: Estructurare petitiva «Mientras» Interfaz de usuario '' C:ARCHIV- 1XINOXS-1JCR;~., ~¡] EJ Nttnt~t·o ll.t::t~ tl-1: t?.:-1 Corlvct•tit• d hrl::e: 2 Re:;u) t.ulo: 1111 "11 1 J•t·c~~ <~ltY kcy lo (;llrttirtttc ••• _ a Algoritmo a - Diagrama de flujo Pseudocódigo (Inicio ~ d , i , r . Ent ero . ~ 1 Leer n, b / l n>O F Tv d - n Mod b n - n b i - i * 10 + d l i >O F Jv d - i Mod 10 i ·- i 10 r - r * 10 + d ~ j Escribir r / ¡ ( Fin Inicio //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 E'in Mientras Mientras i > O d - i Mod 10 i - i 10 r = r * 10 + d E'in Mientras //Salida Escribir r Fin
- 163. Algoritmos con java Codificación: ......................................'...............................................................................................................................' ....................................... impo r t java . uti l . Scanner; public class Problema55 { } public static void main(String[J args) { //Variables ) int n, b , d , i =O , r=O ; //Entrada Scanner teclado = new Scanner(System . i n) ; System . out . print( " Nume r o Base 10 : " ) ; n = t eclado . nex tint () ; System . out . print( "Convertir a base : '' ) ; b = teclado . nextint () ; //Proceso while (n > 0) { d = n % b ; n /= b ; l. = i * 10 + d ; } whi le (i > 0) { d = i % 10 ; i /= 10; r = r * 10 + d ; } 1/Salida System . out . println( "" l ; System . out . println( " Resultado : " + r) ; .............................................................................................................................................................................................................
- 164. Capítulo 5: Estructurarepetitiva «Mientras» 5.8 Problemas propuestos Los siguientes problemas le servirán para medir su aprendizaje, es importante que los resuelva. Propuesto n.º 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.2 32 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.2 33 Enunciado: Calcular la suma y el producto de los N primeros números naturales múltiplos de 3. Propuesto n.2 34 Enunciado: Dado un número, determinar cuantos dígitos Ocontiene. Propuesto n.235 Enunciado: Se requiere saber si existe un determinado dígito en un número dado. Propuesto n.236 Enunciado: Dado un número, determinar cual es el porcentaje de números pares, impares y neutros (O). Propuesto n.2 37 Enunciado: Dado un rango de números determine cuántos números primos contiene. Propuesto n.2 38 Enunciado: Dado un rango de números, determine cuántos números capicúa hay. Propuesto n.º 39 Enunciado: Dados dos números, obtener el MCD (máximo común divisor), utilice el método Euclides (divisiones sucesivas). Propuesto n.2 40 Enunciado: Dados dos números, obtener el MCD (máximo común divisor), utilice el método de factorización simultánea. Recuerde: El máximo común divisor es el divisor mayor común de todos ellos.
- 166. Estructura repetitiva «Para» 6.11ntroducción Cadavez 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 Para i -vi Hasta vf Inc +1 ~V Instrucciones Instrucciones Fin Para 1 ! Sintaxis Java ............................................................................................................................................................................................................ .'• f o r (i =vi ; i<=vf ; i++) { <instrucciones>; } .. .......................................................................................'.................................................................................................................. ..
- 167. Algoritmos con java 6.3Estructura repetitiva «Para» anidada Dent ro de la estructura repetitiva es posible colocar una o más estructuras repetitivas, y también otras estructuras. ! i < vf i-v i F i - i +l !V j-vi F j<-vf j-j+l lV Instrucciones ~ l Sintaxis Java for ( i=v i ; i<=vf; i ++) { for (j=vi ; j<=vf ; j++) { <instrucciones>; } } Para i ~ v i Hasta vf Inc +1 Para j - vi Hasta vf Inc +1 Instruccione s Fin Para Fin Para ... ........................................................................................................................................................................................................... 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 1 Salida • Número (n) • Suma (s) Diseño: Interfaz de usuario
- 168. Diagrama de flujo Inicio l i, n, S o Entero o l 1 Leer n 1 l i-1 i< n i - i +l lV S - S + i J 1 Escribir S 1 l ( Fin F Capítulo 6: Estructura re petitiva «Para» Algoritmo Pseudocódigo Ini cio //Variables i , n , s : Entero //Entrada Leer n //Proceso Para i-1 Hasta n Inc 1 S - S + i Fin Para //Salida Escribir s Fin Codificación: ...........................................................................................................................................' .............................................................. ... o import java outil.Scanner ; public class Problema56 { ) public static void main(String[] args) { //Variables l int i , n , s = O; //Entrada Scanner teclado = new Scanner(System oi n) ; System oout oprint( " Nume r o : " ) ; n = teclado onextint() ; //Proceso for (i = 1 ; i<=n ; i++) S = S + i ; 1/Salida System oout oprintln( "'' ) ; System oout oprintln( " Suma : '' + s) ; ..................................................................................." .............................................................................." .......................................
- 169. Algoritmos con java Probleman.2 57 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: i , Interfaz de usuario ',· C:ARCHIV- 1XINOXS-1JCRE.~ I!:J1:1 Nun. Nun. lniciol: S Fin.tl : 9 (;,,nti<I,HI: ] Pt·t~~::; <llY key to (:on titlltt! ••• _ a Algoritmo a - Diagrama de flujo Pseudocódigo ( Inicio ¡ e , ni , nf . Ente ro . ~ /Leer ni, nf/ ¡ ni - ni + 1 nf - nf - 1 ¡ i< nf i -ni F i-i+l ¡v e - e + 1 l ¡ 1 Escribir e 1 ~ ( Fin Inicio //Variables i, e , ni , nf //Entrada Leer ni , nf //Proceso ni - ni + 1 nf - nf - 1 Entero Para i -n i Hasta nf I nc 1 e - e + 1 !"in Para //Salida Escribir e Fin
- 170. Capítulo 6: Estructurarepetitiva «Para» Codificación: • o• .............................................................................................................................. o. • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • .. • • • • • • • • • • • • • • • • • • • • • • • • • • • • •• . impo r t java . uti l . Scanner; public class ProblemaS? { } publ i c stati c void main(St ri ng[J args ) { //Variables l int i , ni , nf, c - O; //Entrada Scanner teclado = ne w Scanner (System . i n) ; System . out . pri nt ("Num . Inicial : " ) ; ni= teclado . nex t!nt () ; System . out . p ri nt ("Num . Final : " ) ; nf = teclado . nextint ( ) ; //Pr oceso ni = ni + 1; nf - nf 1 ; for (i = ni; i<=nf; i++) e += 1 ; //Salida System . out . println ("") ; System . out . p ri nt1n ("Cantidad : " +e ) ; . ............................................................................................................................................................................................................. . Problema n.2 58 Enunciado: Dado un rango de númerosenteros, obtener la cantidad de números pares 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 pares que contiene el rango. Entrada Salida • Número inicial (ni) • Número final (nf) Diseño: • Cantidad de pares (cp) Interfaz de usuario ". C:ARCHIV-1XINOXS-1UC~ I!ilEJ Nttn. lrt i(: i.tl: :J Nun. Fin<ll: 1] Crtnt . P<tPe:;: ~~ l'1·c~;~ •''•V kev t{) curtlirlttc ••• _ a E!
- 171. Algoritmos con java Diagramade flujo (Inicio 1 ¡ i , cp, ni , nf . Entero . ! jLeer ni , nfj ¡ ni - ni + 1 nf - nf - 1 ¡ i - ni i< nf F i-i+1 _lV F i Mod 2 o = ¡v cp - cp + 1 ! 1 Escribir cp / ¡ ( Fin l Algoritmo Pseudocódigo Inicio //Variables i , cp, ni , nf · Entero //Entrada Leer ni , nf //Proceso ni - ni + 1 n f - nf - 1 Para i-ni Hasta nf Inc 1 Si i Mod 2 = O Entonces cp - cp + 1 Fin Si Fin Para //Salida Escribir cp Fin Codificación: ............................................................................................................................................................................................................ · import java . ut il . Scanner; public class Probl ema58 { 1 public static void main(String[] args) ( //Variables } int i ,ni, nf , cp =O ; //Entrada Scanner teclado= new Scanner(System . i n) ; System . out . print (" Num . Inicial : " ) ; ni= teclado . nextint() ; System . out . pri nt( " Num . Final : " ) ; nf = teclado . nextint() ; //Proceso n i = ni + 1 ; n f = nf - 1 ; f o r(i - ni ; i <= nf ; i ++) { if (i % 2 == o ) cp += 1; 1 1/Salida System . out . pr i ntln( " '' ) ; System . out . println( "Cant . Pares : " + cp ) ; ... ..........................................................................................................................................................................................................
- 172. Capítulo 6: Estructurare petitiva «Para» Problema n.2 59 Enunciado: Obtener la cantidad de los primeros N números múltiplos de S. Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número; luego, que el sistema devuelva la cantidad de números múltiplos de S. Entrada Salida • Número (n) • Cantidad (e) Diseño: Interfaz de usuario , ' C:ARCHIV-1XINOXS-1UCR.~ ~I5J l:f Diagrama de flujo Inicio ! i , e , n . Entero . ! 1 Leer n 1 ! i-1 i< n i - i+S !V e - e + 1 l ! 1 Escribir e 1 ! Fin F Algoritmo Pseudocódigo Inicio //Variables i , e , n : Entero //Entrada Lee r n //Proceso Para i - 1 Hasta n Ine 5 e - e + 1 Fin Pa r a //Salida Escri b i r e Fin
- 173. Algoritmos con java Codificación: impor t java . uti l . Scanner; public class Problema59 { l public stati c void main(St ri ng[) args ) { //Variabl es 1 int i , n , c =O ; //Entrada Scanner teclado= ne w Scanner (System. i n) ; System . out . p ri nt ("Nume r o : " ) ; n = t eclado . nextint () ; //Proceso for (i = 1; i<=n ; i+=S ) e += 1; 1/Salida System . out . pri ntln ("" ) ; System . out . pri nt l n ("Cantidad : " +e ) ; Problema n.2 60 Enunciado: Obtener la suma de pares e impares de los primeros N números enteros positivos. Análisis: Para la solución de este problema se requiere que el usuario ingrese un número; luego, que el sistema devuelva la suma de pares e impares. Entrada Salida • Número (n) • Suma pares (sp) • Suma impares (si) Diseño: Interfaz de usuario e> C:ARCHIV- 1XINOXS- 1JC. ~ II!:JEJ - --
- 174. Diagrama de flujo (Inicio ~ i, sp, si , n . Entero . ! 1 Leer n 1 ~ i - 1 i< n F i-i+2 ~ V si - si + i ! i - 2 i< n F i - i+2 ~ V sp - sp + i ~ /Escribir sp, sy ~ eFin Codificación: Capítulo 6: Estructura re petitiva «Para» Algoritmo Pseudocódigo Inicio //Variables i , sp, si , n //Entrada Leer n //Proceso Entero Para i-1 Hasta n Inc 2 si - si + i Fin Para Para i-2 Hasta n Inc 2 sp - sp + i Fin Para //Salida Escribir sp , si Fin ...........................................................................................................................................................................................................·. import java . ut il . Scanner; public c l ass Problema60 { } public static void main(String [ ) args) { //Variables } int i , n, sp = O, si = O; //Entrada Scanner teclado a new Scanner(Syst em . i n) ; System . out . print( " Numero : " ) ; n = tecl ado . nextint () ; //Proceso for(i = 1 ; i <= n ; J.+= 2) { s i += i ; } for( i = 2 ; i <= n ; J.+= 2) { sp += i ; } 1/Salida System . out . println( ''" ) ; System . out . println( " Suma pares : " + sp) ; Syst em . o ut . println( '' Suma impares : '' + si) ; .............................................................................................................................................................................................................
- 175. Algoritmos con java Enunciado:Hallar el cuadrado de un número usando la siguiente relación N2 =1 + 3 + 5 + ... .. + 2N -1. Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número; luego, que el sistema devuelva el cuadrado del número. Entrada Salida • Número (n) • Cuadrado (e) Diseño: Interfaz de usuario e; C:ARCHIV-1XINOXS-1JC.~'J ll!iJEJ Diagrama de flujo Inicio ¡ i , n , e . Entero . L 1 Leer n 1 ¡ i-1 i< n F i-i+l ¡v e - e + (2 * i - 1 ) 1 ¡ 1 Escribir e 1 ¡ ( Fi n Algoritmo Pseudocódigo Ini cio / / Variables i , n , e : Entero //Entrada Leer n //Proceso Para i - 1 Hasta n Inc 1 e - e + (2 * i - 1 l Fin Para //Sal ida Escribir e Fin
- 176. Capítulo 6: Estructurarepetitiva «Para» Codificación: ....................................................................' ........................................................................................................................................ . impo r t java . uti l . Scanner; public class Problema61 { publ i c stati c void main(St ri ng[J args ) { //Variables } ) int i , n , c=O ; //Entrada Scanner teclado = ne w Scanner (System . i n) ; System . out . pri nt ("Numero : " ) ; n = t e clado . nextint () ; //Proceso for (i - 1; i<= n ; i ++ ) e = e + ( 2 * i - 1 ) ; 1/Salida System . out . println( "''); System . out . p ri nt1n( "Cuadrado : " +e) ; ·................................................·······.......................................·····......................................................................................................... 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, 3, entonces 1 + 3 =4, por lo tanto no es perfecto. Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número; luego, que el sistema devuelva si el número es o no perfecto. Entrada Salida • Número (n) • Respuesta (r) Diseño: Interfaz de usuario e; C:ARCHIV- 1XINOXS- 1UC::)) B!i!EJ NLinct•o:L a - Ht:::u lt.ulu: PFHFI·:CTO Pt·t~:;:; rlllY key te, l:l)fltirlltt! ... a
- 177. Algoritmos con java Diagramade flujo I nicio ~ n , s , i . Entero . r . Cadena . l 1 Leer n 1 ~ i-1 i < n2 i-i +l lV F n Mod i o = Tv S - S + i l F n = S F V Algoritmo Pseudocódigo Inicio //Variables n , s , i : Entero r : Cadena //Entrada Leer n //Proceso Para i-1 Hasta n 2 Inc 1 Si n Mod i = O Entonces S - S + i Fin Si Fin Para Si n = s Entonces r - " PERFECTO" SiNo r-" NO ES PERFECTO" r-" PERFECTO" r - " NO ES PERFECTO" Fin Si ¡ 1 Escribir ! ( Fin r 1 //Salida Escribir r Fin
- 178. Capítulo 6: Estructurarepetitiva «Para» Codificación: ..........................................................................................................................................................................................................··. · impo r t java . ut i l . Scanner ; pub lic c lass Prob l ema6 2 { } publ ic sta t i c void main( St ri ng [) args) { //Variable s } i nt n , s =O, i ; Stri ng r = ""; // Entrada Sc anner tec l ado = ne w Scanner(Sys tem . i n) ; System . out . print ("Nume ro : " ) ; n = teclado . ne xtint (); //Proceso fo r( i - 1 ; i <= n if (n % l. -- S += i ; } if ( n == s ) r = " PERFECTO"; e l se 1 0 ) 2; r = " NO ES PERFECTO"; //Sa lida i++ ) { System . out . p ri nt l n (" '' ) ; System . out .print l n (" Resul tado : " + r) ; .. .......................................................................................................................................................................................................... Problema n.2 63 . Enunciado: Dadoo dos 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 +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; luego, que el sistema devuelva el resultado, si los números son amigos o no. Entrada Salida • Números (n 1, n2) Diseño: • Resultado (r) Interfaz de usuario , ' C:ARCHIV- 1XINOXS-1J.Jt 11:11:1 .Nunel'o 1: ?.?.H 'Hunt~ r•o ?. : ?.B1 Re~L~ll<do: SON OMIC;Os Pr·e~::: .tnl} kel} to continue . .. _ a a -
- 179. Algoritmos con java Diagramade flujo Inicio i , nl , n2 , sl , s2 : Entero r : Cadena Leer nl , n2 .--+1 i<=nl2 F i-i+l F sl - sl + i .--+1 i<=nl2 F i-i+l F s2 - s2 + i F V Algoritmo Pseudocódigo Inicio //Variables i, n1 , n2 , s1 , s2 : Entero r : Cadena //Entrada Leer n1 , n2 //Proceso Para i-1 Hasta n2 Inc 1 Si n1 Mod i = O Entonces s1 - s1 + i Fin Si Fin Para Para i-1 Hasta n2 Inc 1 Si n2 Mod i = O Entonces s2 - s2 + i Fin Si Fin Para Si n1=s2 Y n2=s1 Entonces r - " SON AMIGOS" SiNo r - " NO SON AMIGOS " E'in Si //Salida r-" NO SON AMIGOS" r-" SON AMIGOS" Escribir r Escribir r Fin Fin
- 180. Capítulo 6: Estructurarepetitiva «Para» Codificación: ............................................................................................................................................................................................................ . import java . util . Scanner; public class Problema63 { ) public static void main(String[) args) { //Variables } int i , nl , n2 , sl=O , s2=0 ; String r = ""; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( " Numero 1 : '' ) ; nl = teclado . nextlnt() ; System.out . print( " Numero 2 : " ) ; n2 = teclado . nex tlnt() ; //Proceso for(i = 1 ; i <= nl/2 ; i ++) { if(n1 % i -- 0) sl += i ; } for(i = 1 ; i <= n2/2 ; i ++) { if(n2 % i == 0) s2 += i ; ) if(nl == s2 && n2 == sl) r = " SON AMIGOS "; else r = " NO SON AMIGOS "; //Salida System . out . println( "'' ) ; System.out . println( " Resultado : " + r) ; ., ...........................................................................................................................................................................................................
- 181. Algoritmos con java Probleman.2 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 ejemp o SI es entonces 2 3 4 N 1 2 7 - +-+- = 11666667 2 3 6 ' Análisis: Para la solución de este problema se requiere que el usuario ingrese un número; luego, que el sistema devuelva el resultado de la suma de quebrados. Entrada Salida • Número (n) • Suma (s) Diseño: Interfaz de usuario ,, C:ARCHIV-1XINOXS- 1U~~ ~IEEJ .Nune 1·u : J 1:1 - :Sun,,: 1.1 (,(¡(¡(¡(,'/ Pt·e~;:; -'"Y key to continue ... a Algoritmo Diagrama de flujo Pseudocódigo Inicio ) ¡ n, i , S . Entero . L / Leer n / ¡ i< n 1 i-1 F i-i+l ¡v S - S + (i 1 (i + 1) ) 1 ¡ / Escribir S / ¡ ( Fin Inicio //Variables i , n , s : Entero //Entrada Leer n //Proceso Para i-1 Hasta n-1 Inc 1 S - S + (i / (i + 1 )) Fin Para //Salida Escribir s Fin
- 182. Capítulo 6: Estructurarepetitiva «Para» Codificación: ..........................................................................................................................................................................................................··. impo r t java . uti l . Scanner ; public class Problema64 { publ i c stati c void main( St ri ng[J args ) { //Variables .tloat n , i , s - O; //Entrada Scanner teclado = new Scanner(System . i n) ; System . out . pri nt ("Numero : " ) ; ) ) n = teclado . nextint () ; //Proceso for (i - 1 ; l. <= n - 1 ; i++ ) S = S + (i / (i + 1 )); 1/Salida System . out . pri ntln ("" ) ; System . out . println( " Suma : '' + s) ; ............................................................................................................................................................................................................ Problema n.2 65 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) • Número final (nf) Diseño: • Cantidad positivos (cp) • Cantidad negativos (en) Interfaz de usuario e,- C:ARCHIV-1 XINOXS-1.~ l!ri]El Hun. lnici<l.l: -- I:J Hun. Fine:}: 9 ·Cñnt. PoS;itivo: 9 : C.mt. Ht:~f·'t ivo: B PPe:;:; ony key to cont inue ... a a -
- 183. Algoritmos con java Algoritmo Diagramade flujo Pseudocódigo ( Inicio ¡ I nicio ¡ ni , nf, cp, en, i . Entero . / /Variables ¡ ni , nf , cp, en, i Entero / Leer ni , nf/ ¡ i - ni i< nf ~-i+l F //Entrada Leer n i , n f //Proceso F J.V i <> o lv > Para i-ni Hasta nf Inc 1 Si i <> O Entonces Si i<O Entonces F i < o ¡ cp-cp+l 1 jÉscribir cp, ¡ ( Fin Codificación: V ¡ cn-cn+l 1 en / SiNo E'in Si E'in Si E'i n Par a //Salida Escrib i r cp, en Fin en - e n + 1 cp - cp + 1 : .......................................................................................................................................................................................................... ... import java . util . Scanner; pub1ic class Prob1ema65 { public static void main (String[] args) { //Variables int ni , nf , cp=O , cn=O, i ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( "Num . Inicial : " ) ; ni= teclado . nextint() ; System . out . print( "Num . E'inal : " ) ; nf = teclado . nextlnt() ; //Proceso for (i - ni ; i <= nf ; i ++) ( if (i ! = 0) { if ( i < 0) en += 1 ; . ' • ··········································································································································································································
- 184. Capítulo 6: Estructurarepetitiva «Para» .......................................................................................................................................................................................................... ... } } else cp += 1; } } 1/Salida System . out . println( "'' ) ; System . out . p ri ntln( "Cant . Pos i tivo : '' + cp) ; System . out . println ("Cant . Negativo : '' +en) ; ............................................................................................................................................................................................................ 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 (inicial, final y múltiplo}; luego, que el sistema devuelva la cantidad de múltiplos que hay en el rango. Entrada Salida • Número inicial (ni) • Cantidad (e) • Número final (nf) • Número múltiplo Diseño: Interfaz de usuario ,; C:ARCHIV-1XINOXS-1UC... 1!1!5JEJ
- 185. Algoritmos con java Diagramade flujo Inicio ! ni , nf, nm, e , i . Entero . ! / Leer ni , nf, no/ ! i -ni i<- nf F Í · i+l lV F i Mod nm~ Jv e - e + 1 ! 1 Escribir e 1 ! eFin Codificación: Algoritmo Pseudocódigo Inicio //Variables ni , nf , nm , e , i : Entero //Entrada Leer ni , nf , nm //Proceso Para i - ni Hasta nf Inc 1 Si i M od nm - O Entonces e - e + 1 Fin Si Fin Pa r a //Salida Escribir e Fin ............................................................................................................................................................................................................. import java . util . Scanner; public class Problema66 { l public static void main(String[] args) { //Variables } int ni , nf , nm, c=O, i ; //Entrada Scanner teclado= new Scanner(System . i n) ; System . out . print( "Num . Inicial : " ) ; ni= tec lado . nextint() ; System . out . pr i nt( "Num . Final : " ) ; nf = tec lado . nextint () ; System . out . pr i nt( "Num . Multip l o : " ) ; nm = tec lado . nextint() ; //Proceso for(i = ni ; i<=nf; i+ +) { if(i % nm == 0) e += 1 ; } 1/Salida System . out . p ri nt1n( "'' ) ; System . out . pri nt1n( "Cantidad : " +e) ; .. ....................................................................................................................................................' ......................................................
- 186. Capítulo 6: Estructurarepetitiva «Para» Problema n.2 67 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. Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número; luego, que el sistema devuelva el factorial del número. Entrada • Número (n) Diseño: Diagrama de flujo eInicio l n, f , i . Entero . ! 1 Leer n 1 l f - 1 ! i< nf i-ni F i - i +l !V f - f • i ! 1 Escribir f 1 ! F i n Salida • Factorial (f) Interfaz de usuario Algoritmo Pseudocódigo Inicio / / Variables n , f , i : Entero //Entrada Leer n //Proceso f - 1 Pa ra i -1 Hasta n I nc 1 f - f * i Fin Para //Salida Escribir f Fin
- 187. Algoritmos con java Codificación: ............................................................................................................................................................................................................. . impor t java . uti l . Scanner; public class Problema67 { l public static void main(String[] args ) { //Variables l int n, f , i ; //Entrada Scanner teclado= new Scanner(System . i n) ; System . out . print( "Numero : " ) ; n = teclado . nextint (); //Proceso f = 1 · 1 for(i = 1 ; i<=n; i ++) f *= 1 i 1/Salida System . out . println( "''); System . out . println( " Factorial : " + 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. Análisis: Para la solución de este problema, se requiere que el usuario ingrese un número; luego, que el sistema devuelva si el número es o no primo. Entrada Salida • Número (n) Diseño: • Respuesta (r) Interfaz de usuario e' C:ARCHIV-1XINOXS-1JCRf~ lrsJ I:J Hunt~ 1•o: '/ a - Rccp<<cctd: ES PRIMO P1·e~;~ iWl) Xev to cont inuc ...
- 188. Diagrama de flujo {Inicio ) n, i . Entero . flag . Logico . r . Cadena . ! 1 Leer n 1 ! flag - Verdadero ! i< n2 i-2 F i -i+l j_v n Mod i = o l flag - Falso Salir l F ag=Verdadero V r-"NO ES PRIMO" r- "ES 1 Escribir f 1 ! ( Fin ) Alg PRIMO" Capítulo 6: Estructura repetitiva «Para» oritmo Pseudocódigo Inicio //Variables n , i : Entero flag : Logico r : Cadena //Entrada Lee r n //Proceso flag - Verdadero Para i-1 Hasta n 2 Inc 1 Si n Mod i = O Entonces flag - Falso Salir Fin Si Fin Pa r a Si flag = Verdadero Entonces r - "ES PRIMO" SiNo r - " NO ES PRIMO" Fin Si //Salida Escribir r Fin
- 189. Algoritmos con java Codificación: ·import java. util . Scanner; public c lass Problema68 { } public static void main(String[] args) ( //Variables } int n , i ; boolean flag ; String r = ''"; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( " Numero : " ) ; n = teclado . nextint() ; //Proceso flag = t rue ; i = 2; f o r (i = 2 ; i<=n/2; i++) { } if ( n % i == O) { } flag = false ; break; if (flag) r = "ES PRIMO"; else r = " NO ES PRIMO"; 1/Salida System . out . println( "'' ) ; System . out .println( "Respuesta : " + r) ; Problema n.2 69 Enunciado: Determine cuántos números primos hay en los primeros N números enteros positivos. Análisis: Para la solución de este problema se requiere que el usuario ingrese un número; luego, que el sistema devuelva la cantidad de números primos; por ejemplo, si ingresa 7, hay 4 números primos 1, 3, S y 7. Entrada Salida • Número (n) • Cantidad (e) Diseño: Interfaz de usuario '' C:ARCHIV-1 XINOXS-1UCR(~ II¡JEJ
- 190. Diagrama de flujo (Inicio ) ~ n , e , i , j . Entero . naq : Loqico !. 1 Leer n 1 !. i - 2 F i<-n Í·- i +1 ¡ nag - Verdadero !. i -2 F j< i2 i-i+l l_v F i Mod j = o Tv flag - Falso Salir J. F nag Iv e - e + 1 !. 1 Escribir e 1 ! { Fin ) Capítulo 6: Estructura re petitiva «Para» Algoritmo Pseudocódigo Inicio //Variables n , e , i , j : Entero flag : Logico / / Entrada Leer n //Proceso Para i-2 Hasta n Inc 1 flag - Verdadero Para j-2 Hasta i2 Inc 1 Si i Mod j = O Entonces flag - Fal so Salir Fin Si Fin Para Si flag Entonces e - e + 1 Fin Si E'in Para //Salida Escribir e Fin
- 191. Algoritmos con java Codificación: .......'.................................................................................................................................................................................................... impo r t java . uti l . Scan ner ; public cla ss Problema69 { ) publ i c stati c void main( St ri ng[J args ) ( //Variables } int n, c = O, i , j ; bool ean flag; //Entrada Scanne r teclado= new Scanner (System . i n) ; System . out . print ("Nume ro : '' ) ; n = tecl ado . ne x tint () ; //Proceso f o r (i = 2 ; i<=n ; i ++) { flag = true ; ) for ( j = 2 ; j <= i 1 2 ; j ++) { i f ( i % j == o ) { flag = fa l se; b r eak ; } } if (flag) { } e += 1 ; flag - true ; //Salida System . out . p rintln (" '' ) ; System . out . p ri nt l n( "Cant i dad : " +e ) ; '•• ........................................,,................................................................................................................................................................ Problema n.2 70 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 D = 3, entonces R = 18 porque es el número múltiplo de 3 antecesor de 21. Análisis: Para la solución de este problema se requiere que el usuario ingrese un número; luego, que el sistema devuelva si el número es múltiplo antecesor. Entrada Salida • Número (n) • Respuesta (r) • Divisor (d)
- 192. Diseño: Capítulo 6: Estructurarepetitiva «Para» Interfaz de usuario '' C:ARCHIV-1XINOXS-1JCR;~., ~¡] EJ Nttnt~ t•o : /. t a Divio.ol': 3 - Re:; JHU: :: t ( : 1n J•t·c~~ <~llY kcy lo (:tlrltirltlc •• a Algoritmo Diagrama de flujo Pseudocódigo ( Ini cio ! n, d , i , r . Entero . ! 1 Leer n , d 1 ! i-n 1 F i> 1 i-i- 1 l_ V F i Mod d = o T v r - i Salir ! 1 Escribir r 1 ¡ ( Fin Inicio //Variables n , d , i, r //Entrada Leer n , d //Proceso Entero Para i-n-1 Hasta 1 Inc -1 Si i Mod d = O Entonces r - i Salir Fin Si Fin Para //Salida Escrib i r r Fin
- 193. Algoritmos con java Codificación: .............'.............................................................................................................................................................................................. . importjava . util . Scanner; public class Problema70 { } public static void main(String[] args) { //Variables } int n, d , i , r =O¡ //Entrada Scanner teclado= new Scanner(System . i n) ; System . out . print( "Numero : " ) ; n = teclado . nextint() ; System . out . print( "Divisor : " ) ; d = teclado . nextint() ; //Proceso for(i- n- 1; i >= 1; i-=1 ) { if(i%d 0){ r = i ; break; } ) //Salida System . out . println( "" l ; System . out . println( " Respuesta : " + r) ; •,, ...........................................................................................................................................................................................................
- 194. Capítulo 6: Estructurarepetitiva «Para» 6.4 Problemas propuestos Los siguientes problemas le servirán para medir su aprendizaje, es importante que los resuelva. Propuesto n.º 41 Enunciado: Calcule la suma de los cuadrados y cubos de los N primeros números naturales. Propuesto n.º 42 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.º 43 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.244 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 Oy 1, entonces si el número N ingresado es 30. Entonces la serie seria menor a 30, esto equivale a O 11 2 3 58 13 21, y lo que se pide es la suma y la cantidad de números de la serie. Propuesto n.º 45 Enunciado: Dado un rango de números determine cuántos números capicúa hay. Propuesto n.º 46 Enunciado: Dada la cantidad de cifras y un divisor, determine cuántos números múltiplos existen del divisor con dichas cifras. Propuesto n.º 47 Enunciado: Calcule la suma de la siguiente serie. 1 x x2 x3 x• x" s=- +-+-+-+-+...+- 0! 1! 2! 3! 4! n! Propuesto n.º 48 Enunciado: Calcule de cuántas formas se pueden ordenar n objetos. Propuesto n.º 49 Enunciado: Obtenga la cantidad de los números primos den cifras. Propuesto n.250 Enunciado: Obtenga la cantidad de los números capicúas de n cifras.
- 196. Estructuras de datos. Arreglos(vectores y matrices) 7.1 1 ntroducció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 Matriz o 1 2 3 4 o 1 2 3 1 15 1 12 1 18 1 14 1 12 1 o 25 10 15 32 1 52 10 4 18 2 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.
- 197. Algoritmos con java 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 5 ítems) (Matriz de 3X4) o 1 2 3 4 ll 2.• dimensión LS 15 12 18 14 12 l (columnas) l o 1 2 3 u - o 25 10 15 32 u - o 15 1• dimensión (filas) 1 52 10 4 18 i 1 12 LS- 2 18 22 3 9 N o 2 18 Selementos 1 (ítems) e 3 14 E L S- 4 12 7.3 Operaciones con arrays Las operaciones son el procesamiento y el t ratamiento individual de los elementos del array, los cuales son los siguientes: • Asignación • Lectura/ escrit ura • Recorrido • Actualización (insertar, borrar, modificar) • Ordenación • Búsqueda
- 198. Capítulo 7: Estructurasde 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 d e una dimensi ó n (Vector) 11 5 elementos LI = O y LS = 4 N[5) : Ente r o //Ar r ay d e dos dime ns i o nes (Mat r i z) 11 3X4 elementos /1 l e r a Di m. LI = O y LS = 2 // 2da Dim . LI = O y LS = 3 N[ 3) [4) : Ente r o Visual Java ............................................................................................................................................................................................................. //Array d e una dimensión (Vector ) /1 5 elementos LI = O y LS = 4 i nt N[ ) = new int[ 5) ; //Array d e dos dimens i o nes (Matriz ) 11 3X4 e l ementos /1 lera Dim . LI = O y LS = 2 // 2da Di m. LI = 0 y LS = 3 i n t N[ )[) = new i nt [3 ] [ 4 ) ; ... .......................................................................................................................................................................................................... ,•
- 199. Algoritmos con java 7.5Recorrido 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. L i-0 Para ~- o Hasta 4 Inc +1 i<-4 F i-i+1 ¡v N [i ) - 10 N [ i ] - 10 1 Fin Para ¡ Sintaxis Java for (i=O ; i<=4 ; i++) { N[i) = 10 ; } ... ..............' ........................................................................................................' ................................................................................... En el siguiente diagrama se tiene la matriz N de 3x4 elementos y se asigna el valor 10 a cada elemento. L i -0 i<-2 F i-i+l .¡.v j-0 F j<-3 j-j+1 ¡v N[i ] [j ] - 10 + ¡ Sintaxis Java for (i=O ; i<=2 ; i++ ) { for (j=O ; j<=3; j++ ) { N[i] [ j) - 10; } } Para i - O Hasta 2 Inc +1 Para j- O Hasta 3 Inc +1 N[i) [j ) - 10 Fin Para Fin Para '·· .......................................................................................................................................................................................................... .
- 200. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Enunciado: Dado Snú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 el proceso para devolver la suma. Entrada Salida • SNúmeros n[S] • Suma (s) Diseño: Interfaz de usuario '' C:ARCHIV-1XINOXS-1UCR(:1 1!!1!5JE1 HuneI'O HuneI'O Nune I'O Hunt! I'O Nune l'O Sun<l: Pt·e~;!"; a Diagrama de flujo ( I nicio ! i , S . Entero . ~ n [ 51 . Entero . ! ~Leer n[O] , n(1 1,~ n(21 , n(31 , n(4] ~ i-1 i<-4 F i -i+l ~V S - S + n [i 1 l ! 1 Escribir S 1 ! ( Fin 1 : 2: 3: 1: S: Hl <ln y 2 a 2 - 2 2 2 ~e y to r.ont inuc ... _ Algoritmo Pseudocódigo Inicio //Variables i , s : Ent e r o //Arreglos (Vector) n [ 5 ] : Ent e ro //Entrada Leer n[ OJ,n [ l ],n[ 2J,n [ 3 J,n[ 4] //Proceso Pa r a i-0 Hasta 4 I nc 1 S - S + n[i ] Fin Par a //Salida Esc r ib i r s Fin
- 201. Algoritmos con java Codificación: .........................................................................................................................................".................................................................. ·import java. util . Scanner; public c lass Problema71 { } public static void main(String[] args) { //Variables J int s = O, i ; //Arreglos int n [ ] - new int [ 5] ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( " Numero 1 : " ) ; n [O J = teclado . nextint () ; System . out . pri nt( " Nume r o 2 : " ) ; n [l ] - teclado . nextin t () ; System . out . print( " Numero 3 : " ) ; n[2] - teclado . nextin t () ; System . out . pri nt( " Nume r o 4 : " ) ; n [3 ] = teclado . nextin t () ; System . out . pr i nt( " Numero 5 : " ) ; n [4] = teclado . nextin t () ; //Proceso for ( i = O; i <= 4 ; i++) s += n[i] ; 1/Salida System . out . pr i ntln( "'' ) ; System . out .println( " Suma : " + s) ; ............................................................................................................................................................................................................. Problema n.2 72 Enunciado: Dado S números obtener el número mayor. 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 el mayor. Entrada Salida • 5 Números n[S) • Mayor (m) Diseño: Interfaz de usuario , ; C:ARCHIV- 1XINOXS- 1UCR(;.,1!5]EJ Hune I'O 1 : ' a •• Hnne I'O 2: 2 - NuneI'O ) : 31 Nunel'o 1: ' ' J -· Nune I'O S: ) Mayo1•: SS Pt'e:::: d(l y kt: y to cnnt irnu: ... a
- 202. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Diagrama de flujo ( Inicio l ¡ i , m : Entero ¡ n[S J . Entero . ! ~ Leer n[ O) , n [l) , ~ n[2 J,n [3 J,n[4) ¡ i - 0 i<-4 F i-i+l J.V F n [i J > m ¡v 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[OJ,n[l),n[2 ) , n[3J,n[4) //Proceso Para i-0 Hasta 4 Inc 1 Si n[i) >m Entonces m- n[i) Fin Si Fin Para //Salida Escribir m Fin ........................................................................................................................................................................................................... ... ' i mport java . util . Scanner; public class Problema72 { public static void main{String [ ) args ) { //Variabl es } int m= O, i ; //Arreglos int n[) = new int [S) ; //Entrad a Scanner teclado= new Scanner{System. in) ; System . out . print( • Numero 1 : '' ) ; n [ O] = teclado . nextlnt{) ; System . out . print (• Numero 2 : • 1; n ( l) = teclado . nextlnt{l ; System . out . print (• Numero 3 : • ) ; n [2) = teclado . nextlnt{) ; System . out . print (• Nume r o 4 : • ) ; n [ 3 J = t eclado . nextlnt{l ; System . out . print{ • Numero 5 : • 1 ; n [ 4) = t eclado . nextlnt{) ; //Proceso for{i = O; i <= 4 ; i ++ ) { if {n[i) > m) m=n [i ) ; } 1/Salida System . out . print l n( •• J ; System . out . print l n( • Mayor : • +m) ; ...l..........................................................................................................................................................................................................
- 203. Algoritmos con java Probleman.2 73 Enunciado: Dado 5 números y un divisor, determinar cuantos números múltiplos hay del divisor en los 5 números ingresados. Análisis: Para la solución de este problema se requiere que el usuario ingrese 5 números; luego, que el sistema procese y devuelva la cantidad de números múltiplos que hay. Entrada Salida • 5 Números (n[S]) • Cantidad (e) • Divisor (d) Diseño: Interfaz de usuario , ; C:ARCHIV-1XINOXS-1UC... l!lliJEJ Diagrama de flujo (Inicio ~ d , i , e : Ente ro ! n[S) . Entero . ~ ~ 1 Leer n[O] , n[l] , 1 ~ n(2 ],n[3],n[4],d ~ i-0 i<-4 F i. i+l l V F n(i ) Mod d= ¡v e - e + 1 ~ 1 Escribir e 1 ! Fin Algoritmo Pseudocódigo Inicio //Variables d , i , e : Entero //Arreglos (Vector) n[S] : Entero //Entrada Leer n [O), n [1), n [2), n [3), n [4), d //Proceso Para i - 0 Hasta 4 Inc 1 Si n[i] Mod d =O Entonces e - e + 1 Fin Si Fin Para //Salida Escribir e Fin
- 204. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Codificación: ..........................................................................................................................................................................................................··. · import java . ut il. Scanner; public class Problema73 1 } public static void main(String[] args) { //Variables } int d , i , c=O ; //Arreglos int n [ ] = new int [5] ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . pr i nt( " Numero 1 : "); n[O] = teclado . nextint() ; System . out . print( " Numero 2 : '' ) ; n[l] = teclado . nextint() ; System . out . print( " Numero 3 : " ) ; n[2] = teclado . nextint() ; System . out . print( " Numero 4 : " ) ; n[3] = teclado . next int() ; System . out . print( " Numero 5 : " ) ; n[4] = teclado . nextint() ; System . out . print( " Divisor : "); d = teclado . nextint(); //Proceso for ( i - O; i <= n . l ength - 1 ; i++) { i f ( n [ i ] % d == O) e += 1 ; } //Salida System . out . println( "''); System . out . pri ntln( "Cantidad : " +e) ; Problema n.o74 Enunciado: Dado S números, obtener la cantidad de números primos ingresados. Análisis: Para la solución de este problema se requiere que el usuario ingrese S números; luego, que el sistema procesa y devuelve la cantidad números primos. Entrada Salida • S Números (n[S]) • Cantidad (e) Diseño: Interfaz de usuario '' C:ARCHIV- 1XINOXS- 1UCR... l!lilf3 Nune t•o 1 : "1 Nune t•o 2 : ] a - Nunet•o ] : 1 Nu ncro 1: 6 Huru~ t'o ' . .' . 1 1 c.,ntict.Ht: 3 Pl'e:::: <HIY kt-:y to cnnt lnue .. . _ a
- 205. Algoritmos con java Diagramade flujo Inicio ) e , i , j . Entero . flag . Logico . n[S] . Entero . ¡ ~~eer n[O] , n[l] , / n[2J. n [3 J. n[4] ¡ i-0 i<-4 F ~ -i+l ¡ F flag ·- Verdadero ¡ )-¿ j< n ( i ] 2 F j-j+l lV F n (i ] Mod j=O Tv flag - 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 //Arreglos (Vector) n [S] : Entero //Entrada Lee r n[ OJ,n[ l),n[2 J,n[3 J,n[ 4] //Proceso Para i-0 Hasta 4 Inc 1 .flag - Verdad e r o Para j -2 Hasta n[i]2 Inc 1 Si n[i ] Mod j=O Entonces flag - Falso Salir Fin Si Fin Para Si .flag Entonces e - e + 1 Fin Si Fin Para //Salida Esc rib i r e Fin
- 206. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Codificación: import java . util . Scanner; public class Problema74 { l public static void main(String[J args) { //Variables } int c=O , i , j ; boolean flag ; //Arreglos int n [] = new int [5] ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . pri nt( "Numero 1 : " ) ; n[O] = teclado . nextint() ; System . out . print( "Numero 2 : " ) ; n[l] = teclado . nextint() ; System . out . print( "Numero 3 : '' ) ; n[2] = teclado . nextint() ; System . out . pri nt( "Numero 4 : " ) ; n[3] = teclado . nextint() ; System . out . print( "Numero 5 : " ) ; n[4] = teclado . nextin t () ; //Proceso for(i = O; i<= 4 ; i+ +) { flag = true ; } for(j = 2; j<=n[i]/2 ; j++){ l } if (n [ i J % j == O) { flag = false ; break; if (flag) e += 1 ; 1/Salida System . out . pri ntln( "'' ); System . out . println( "Cantidad : " +e ) ; ......................................................................................................................................................................." .....................................
- 207. Algoritmos con java -~-~~- Problema n.2 75 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. Análisis: Para la solución de este problema se requiere que el usuario ingrese 7 números; luego, que el sistema devuelva la respuesta, si existe o no el número y la posición del número encontrado. Entrada Salida o 7 Números (n[7)) o Respuesta (r) o Numero a buscar (nb) o Posición (p) Diseño: Interfaz de usuario
- 208. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Diagrama de flujo ( rnicio ~ nb, p , i . Entero . r . Cadena . ! n(7) . Entero . ~ ~Leer n(O) , n(11 , n(21 , .~ (31, n (41, n (5 1, n [61, nb l r - "NO EXISTE" p - - 1 ! i-0 F i< 6 i - i +l 1V F n [i 1 bn > Tv r - "EXISTE" p - i Salir l j Escribir r , P/ l ( Fin Algoritmo Pseudocódigo Ini cio //Vari ables 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 Para i-0 Hasta 6 Inc 1 Si n[i] = nb Entonces r - "EXISTE" Fin Si Fin Par a p - i Salir //Salida Escribir r , p Fin
- 209. Algoritmos con java Codificación: .......'..................................................................................................................................................................................................... · import java . uti l . Scanner; public class Problema75 { } public static void main(Stri ng[J args) { //Variables } int nb, p , i ; St ring r = //Arreglos ' ' 11 • ' int n[ ] = new int[7] ; //Entrada Scanne r teclado= new Scanner(System . in) ; System . out .print( "Numero 1 : " ) ; n[O] = teclado . nextint() ; System . out . print( "Numero 2 : " ) ; n [1 ] - teclado . ne xtin t () ; System . out . print( " Numero 3 : ") ; n[2] - teclado . nextint () ; System . out . pri nt( "Numero 4 : " ) ; n[3] = teclado . nextint() ; System . out . print( "Numero 5 : " ) ; n [ 4] = teclado . nextin t () ; System . out . print ("Numero 6 : " ) ; n[S] = teclado . nextint () ; System . out . pr i nt( "Numero 7 : " ) ; n [6 ] = teclado . nextin t () ; System . out . print( " Numero a buscar : " ) ; nb = teclado . nextint() ; //Proceso r = " NO EXISTE"; p = -1 ; fo r (i = O ; i <= n . length - 1 ; i++) { if(n[i] ==nb ){ } } 1/Salida r = " EXISTE"; p = l. ; break; System . out . println( "'') ; System . out . println( " Respuesta : " + r) ; System . out . pri ntln( " Pos i cion : " + p) ; .............................................................................................................................................................................................................
- 210. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Problema n.2 76 Enunciado: Lea 4 números y almacénelos en un vector de llamado A, y otros 4 números en un vector llamado B, y determine cuántos números de A se encuentran en B. Análisis: Para la solución de este problema se requiere que el usuario ingrese 8 números; luego, que el sistema devuelva la cantidad. Entrada Salida • 4 Números (a(4)) • Cantidad (e) • 4 Números (b[4]) Diseño: Interfaz de usuario
- 211. Algoritmos con java Diagramade flujo l Inicio ) ~ 1 e , i , j . Entero 1 . ! a [4] . Entero . b [4] : Entero ~ /a Leer a[O] , a(l],a[2J, ~ ~ [31 , b[OJ , b[l] , b[2J,b(3 ! i-0 i< 4 F i-i+l ! V j-0 F j<-4 j-j+l ~V F a[il - b ( j l l e - e + 1 l ! 1 Escribir e 1 ! ( Fin ) Algoritmo Pseudocódigo Ini c i o //Variables e , i , j : Entero //Arregl os (Vector) a[4], b[4] : Entero //Entrada Leer a[O],a[l],a[2],a[3], b(O] , b[1] , b(2] , b (3 ] //Proceso Para i-0 Hasta 4 Inc 1 Para j-0 Hasta 4 Inc 1 Si a[i]=b[j] Entonces e - e + 1 Fin Si Fin Para Fin Para //Salida Escrib i r e Fin
- 212. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Codificación: .. ............................................................................................................................................................................................................ import java . uti l . Scanner; public class Problema76 { ) public static void main(Stri ng[J args) { //Variables } int c=O , i , j ; //Arreglos int a(] - new int[4] ; int b (] = new int [ 4] ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . pr i ntln( "Arreglo A: " ) ; System . out . println( " ==========" ) ; System . out . print( " Numero 1 : " ) ; a(OJ = teclado . nextint() ; System . out . print( " Numero 2 : '' ) ; a(1] = teclado . nextint() ; System . out . pri nt( " Numero 3 : " ) ; a(2] = teclado . nextint() ; System . out . print( " Numero 4 : " ) ; a(3] = teclado . nexti nt() ; System . out . println( "" ) ; System . out . pri ntln( "Arreglo B : " ) ; System . out . println( " ==========") ; System . out . print( " Numero 1 : " ) ; b(OJ = teclado . nex tint() ; System . out . print( " Numero 2 : " ) ; b(l] = teclado . nextint() ; System . out . pri nt( " Numero 3 : " ) ; b (2] = teclado . nextint() ; System . out . print( " Numero 4: " ) ; b(3] = teclado . next int() ; //Proceso for ( i = O; i <=a . length - 1 ; i ++) { for(j = O; j <= b . length-1 ; j++) { if (a [ i J == b [ j J ) e += 1 ; } ) 1/Salida System . out . println( "'') ; System . out . println( "Cantidad : " +el ; ... ..................................................................................................................... ....................................................................................
- 213. Algoritmos con java Probleman.2 77 Enunciado: Ordene 4 números usando el método de ordenación por intercambio (burbuja). Análisis: Para la solución de este problema se requiere que el usuario ingrese 4 números; luego, que el sistema devuelva los números ordenados. Entrada Salida • 4 Números (n[4)) • 4 Números ordenados (n[4)) Diseño: Interfaz de usuario " - C:ARCHIV-1XINOXS-1JCRL.-, lli]EJ
- 214. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Diagrama de flujo ( Inicio ) ¡ tmp, i , j , LI , LS : Entero l n [4 1 : Entero l /Leer n[OI , n[ll , n[21 , n[31 / l Ll · o LS · 3 ¡ i. LI i<..LS 1 F i· i+1 ¡v j. LI F j<-LS-1 j-j+1 J.V F n[jl>n[j+1¡ 1 ::> tmp- n[jl n [ j 1 · n[j+1) n[j+ll · tmp L Algoritmo Pseudocódigo Inicio //Variables tmp , i , j , LI , LS : Entero //Arreglos (Vector) n[4) : Entero //Entrada Leer n [O],n[l ], n[2],n[3) //Proceso LI - O LS - 3 Para i-LI Hasta LS-1 Inc 1 Para j-LI Hasta LS-1 Inc 1 Si n[j]>n[j+1) Entonces tmp- n[j) n[j) - n[j+1) n [ j+1) - tmp Fin Si Fin Para Fin Para //Salida Escribir n[O] , n[1) , n[2) , n[3) / Escribir n[O) , n[1) , n[2) , n[3J/ Fin ¡ ( Fin )
- 215. Algoritmos con java Codificación: .......................................................................................................'...................................................................................................... import java . util . Scanner; public class Problema77 { 1 public static void main(String[J args) ( //Variables ) int tmp , i , j , LI , LS ; //Arreglos int n () = new int [ 4) ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( " Numero 1 : " ) ; n(O] = teclado . nextint() ; System . out . print( " Numero 2 : " ) ; n[l) = teclado . nextint() ; System . out . print( " Numero 3 : " ) ; n[2] - teclado . nextint() ; System . out . print( " Numero 4 : " ) ; n[3] = teclado . nextint() ; //Proceso LI - O; LS = n . length-1 ; f or (i = LI ; ~ <= LS - 1 ; i++) { for(j = LI ; j <= LS - 1 ; j++) { ) ) if(n[j] > n[j + 1 ]){ tmp = n(j) ¡ ) n (j) = n[j + 1) ; n (j + 1 ] = tmp; //Salida System . out . println( "" l ; System . out . println( "Ordenado" ) ; System . out . println( " Numero 1 : " + n[O)l ; System . out . println("Numero 2 : " + n[l)) ; System . out . println( " Numero 3 : " + n[2]) ; System.out . println( " Numero 4 : " + n[3)) ; ...................................................................................................................................................................................' .........................
- 216. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Problema n.2 78 Enunciado: Ingrese 6 números en un arreglo de dos dimensiones (matriz) de 3x2 y obtenga la suma de los números ingresados. Análisis: Para la solución de este problema se requiere que el usuario ingrese 6 números; luego, que el sistema devuelva la suma de los números. Entrada • 6 Números (n[3][2]). Diseño: Diagrama de flujo ( Inicio ) ~ s , i , j . Entero . ~ n[31 [2 ) . Entero . l 1 Leer n [ O1 [ O1, n [ O1 [1 1, n[l] [0] , n[l] [1] , n[21 (0),n[21 11 1 ~ i-0 i< 2 F i-i+l ~V j-0 F j< 1 j-j+l ~V S •- S + n[i] [j] * * ! 1 Escribir s 1 ! ( Fin ) Salida • Suma (s) Interfaz de usuario 1 Algoritmo Pseudocódigo 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],n[OJ [1] , //Proceso Para i-0 Hasta 2 Inc 1 Para j-0 Hasta 1 Inc 1 S - S + n (i] ( j] Fin Para Fin Para //Salida Escribir s Fin
- 217. Algoritmos con java Codificación: ..............................................................................................................................................................................................'...........- ... · impo r t java . uti l . Scanner; public class Problema78 { ) public static void main (Stri ng[J args) ( //Variables ) int s = O, i , j ; //Arreglos int n () [) = n ew int [ 3) ( 2) ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( " Numero (0 , 0 ): " ) ; n(O] [0 ) = teclado . nextint () ; System . out . pri nt( " Numero (0 , 1 ): " ) ; n(O] [1) = t eclado . nextint() ; System . out . pr i nt (" Nume ro (1, 0 ): " ) ; n[1] [0) = tec l ado . nex tint () ; System . out . print( " Numero (1 , 1 ) : " ) ; n [1 ] [1) = tec l ado . nextint () ; System . o ut . print( " Numero (2 , 0 ) : " ) ; n [2 ) [0 ) = teclado . nextint ( ) ; System . out . pri nt (" Nume r o (2 , 1 ) : " ) ; n [2 ) [ 1) = t eclado . nextint () ; //Proceso for ( i = O; i <= 2 ; i++) f or(j = O; j <= 1 ; j ++) s += n [ i) [ j) ; 1/Sa lida System . out . println( "'' ) ; System . out . pri ntln( " Suma : " + s) ; ... .......................................................................................................................................................................................................... .
- 218. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Enunciado: Ingrese 12 números en un arreglo bidimensional (matriz) de 4x3, y obtenga la suma de cada columna. Análisis: Para la solución de este problema, se requiere que el usuario ingrese 12 números; luego, que el sistema devuelva la suma de cada columna. Entrada • 12 números (n[4](3]) Diseño: Salida • Suma columna 1 (sO) • Suma columna 2 (sl) • Suma columna 3 (s2) Interfaz de usuario '' C:ARCHIV- 1XINOXS- 1UCRE... lf¡E'J Nunel'o <1-1. {j) : 2 Hunc••o 01.1): 3 Hunt:••o 01.?.): 1 Nune ••o <LID: 2 Nune t•o (1.1): 3 Hu n•~ •·n (1,2): 1 Nune I'O <2.0): 2 Nune I'O <2,1): ] Nune l'o (2,2): 4 Nune I'O U.H): 2 Nune l'O <3,1): 3 'Hune•·o 0 , 2): 1 Sunn Col. {!: 8 Sun•• Col . 1: 1?. Sun~ Col. ?.: t(, Pt•t!ss dny kt!y to continttc ••• _ a a •
- 219. Algoritmos con java Diagramade flujo ( Inicio ) T s0 , sl , s2 , i , j . Entero . 1 n[4] [3) . Entero . 1 Leer n[O] [O],n[O] [l] , n[O] [2], n[l] [ OJ, n[l] [ l],n[l] [ 2], n [2] [ 0] , n [2] [l] , n[2] [ 2] , n [3] [ 0), n [3] [1), n [3] [2] 1 i·- 0 F i<-4 i-i+l 1v sO - sO + n[i] [0] sl - sl + n[i] [1] s2 - s2 + n(i] [2] -¡ 1 / Escribir sO, sl , sz/ 1 1 E'in Algoritmo Pseudocódigo Inicio //Variables sO , sl , s2 , i , j : Entero //Arreglos (Matriz) n [ 4] [ 3] : Entero //Entrada Lee r n [O) [O J, n [0) [1), n [O) [2 ), n[l) [OJ,n[ l ) [ lJ, n[l) [2), n[2) [0 J,n [2) [1 J, n[2) [2), n[3) [O J, n[3) [1 J, n[3) [2), //Proceso Para i-0 Hasta 4 Ine 1 sO - sO + n [i) [0) sl - sl + n[i) [1) s2 - s2 + n[i) [2) Fin Para //Salida Escribir sO , sl , s2 Fin
- 220. Capítulo 7: Estructurasde datos. Arreglos (vectores y matr ices) Codificación: ...................................." .............................." ......." ......." ............................" .............' ................................" ............................" ......... ~ impo r t java . ut i l . Scanner ; : publi c cla ss Problema79 { : public static void main(St ri ng[J : //Vari ables ¡ i nt sO=O , s 1=0 , s2=0, i, j ; //Ar regl os i nt n [ J [] = //Entrad a ne w i nt[4 )[ 3] ; args ) { Scanne r tecl ado = new Scanner (Sys t em . i n ) ; System . out . p ri nt (" Nume r o (0 , 0 ) : " ) ; n [0 ) [ 0 ) = t e clado . nex t! nt () ; } ) System . out . p rint (" Nume r o (0 , 1 ) : " ) ; n [OJ [1 ) = tec l ado . nex ti nt () ; System . out . pr i nt (" Nume ro (0 , 2 ) : " ) ; n [O) [ 2 ) = tecl ado . nex t int () ; System . out . pri nt (" Nume ro (1 , 0 ) : "); n [1 ) [O ) = tec l ado . ne x tint () ; System . out . print (" Numero (1 , 1 ) : " ) ; n [1) [1 ] = tec1ado . ne x tint () ; System . out . print (" Numero (1 , 2 ) : " ) ; n [1) [2 ] = tecl ado . ne x t !nt () ; System . out . pri nt (" Numero (2 , 0 ) : " ) ; n [2 ) [ 0 ] = tecl ado . nex t !nt () ; System . out . p ri nt (" Nume r o (2 , 1 ) : " ) ; n [2 ) [1 ] = t e c l ado . nex t !nt () ; System . out . p ri nt (" Nume r o (2 , 2 ) : " ) ; n [2 ) [ 2 ) = teclado . nex t! n t () ; System . out . p rint (" Nume r o (3 , 0 ) : " ) ; n [ 3 ) [ 0 ) = teclado . nexti nt () ; System . out . pri nt (''Nume ro (3 , 1 ) : "); n [3) [1 ) = tecl ado . ne x tint () ; System . out . print (" Nume ro (3 , 2 ) : ") ; n [3 ) [ 2 ] = tecl ado . ne x tint () ; //Pr oceso f or (i = O; i <=3; i ++) sO+= n [ i) [O] ; s1 += n [ i 1[ 1 1; s2+ = n[i ] [ 2 ] ; } 1/Salida System . out . print1n ("" ) ; System . out . pri ntln (" Suma System . out . print 1n (" Suma System . out . pr i ntln (" Suma { Col. O: Col . 1 : Col . 2 : " + " + " + sO ) ; S 1 ) i s2 ) ; .............................................................................................................................................................................................................. Enunciado: Almacene en una matriz de 3x2, 6 números y obtenga la cantidad de pares e impares. Análisis: Para la solución de este problema se requiere que el usuario ingrese 6 números; luego, que el sistema devuelva la cantidad de pares e impares. Entrada Salida • 6 Número (n[3)[2)) • Cantidad de pares (cp) • Cantidad de impares (ci)
- 221. Diseño: 1 Algoritmos con java F Interfazde usuario ' ' C:ARCHIV- 1XINOXS- 1JCR.:~ ~I:l El Nune l'O Nune t•o Nun1~ t•n Hunero Huru~ t•o Nune t•o <11.11) : ?. (¡l_¡): f, ( 1 .11) : :1 (1.1): 8 <?..Ji): '1 (2.1): 4 C.:u1t. Pctt•es: 4 C.ut t . 1rll)• t·t: :; : ?. a - f•l•t::;~ dllY kcy tu (;ontirlttt: ••• a Diagrama de flujo ( Inicio ) ~ cp, ci , i , j . Entero . ~ n [3 ] [2] : Entero Leer n(O][O],n[O][l] , n(l) [O],n[l) [1], n[2] [0],n[2) [1] ~ i - 0 i<- 2 F i -i+l ~V J- 0 F j<- 1 j-j+l J.V n[i] [j i Mod 2=0 - 1 V Algoritmo Pseudocódigo Inicio //Variables cp, ci, i , j : Entero //Arreglos (Matriz) n [3) [2 ) : Entero //Entrada Leer n [ O] [O],n[O ] [ 1], n[l ) [O J,n[ l) [1], n[2 ) [0 ],n[2) [1) //Proceso Para i-0 Hasta 2 I nc 1 Para j-0 Hasta 1 Inc 1 Si n[i) [j] Mod 2 =0 Entonces cp - cp + 1 SiNo ci-ci+l cp-cp+l ci - ci + 1 Fi n Si 1 ~ / Escribir ! ( Fin 1 cp, ci j ) Fin Para Fin Para 1/Salida Escribir cp, ci Fin
- 222. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Codificación: .· ................................................................................................................................., ..........................................................................• · import java . util.Scanner ; public class Problema80 { ) public static void main(String[J args) ( //Variables ) int cp=O , ci=O , i , j ; //Arreglos int n 1) [) = new int [ 3) 12) ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( " Numero (0 , 0) : " ) ; niOJ [0 ) = teclado . nextint () ; System . out . print ( " Numero (0 , 1) : " ) ; n[O] [1) = teclado . nextint () ; System . out . print( " Numero (1 , 0) : " ) ; n[1] [0) = teclado . nextint () ; System . out . print( " Numero (1 , 1) : " ) ; n [1 ] [1 ) = teclado . nextint () ; System . out . print ( " Numero (2 , 0) : " ) ; n[2) [0) = teclado . nextint () ; System . out . print ( " Numero (2 , 1) : " ) ; n [2 ) [1) = teclado . nextint () ; //Proceso for (i = O; i<=2 ; i++) ( for (j = O; j<=1 ; j++) { ) ) i f (n [ i) [ j) % 2 == O) cp += 1; else ci += 1 ; 1/Salida System . out . println( "" ) ; System . out . println( " Cant . Pares : '' + cp) ; System . out . println( " Cant . Impares : " + ci ) ; .. ......................................................' .............' ........' ...............................' .............................................................................' .............' .
- 223. Algoritmos con java Enunciado:Busque un número dentro de una matriz de 4x3, 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 • Matriz (n[4)(3)) • Número a buscar (nb) Diseño: Salida • Respuesta (r) • Posición lera dim. (pl ) • Posición 2da dim. (p2) Interfaz de Usuario '' C:ARCHIV- 1XINOXS-1UCRL':!il l!i]EJ Nune t•o <H.H>: 1 Nune t•o (1-1.1): /. 'Nune l'O <H.2): S Nune J•o ( l.ll>: (, Nune t•o (1,1): ~ Nune l'O (1,2): 2 Nune t·o <?. . H>: 7 'Nune t•o (2.1): 3 Nune ••o <2.2): S Hune t•o <J.H>: 1 Nunt: ••o O.!): 1 Nune l'O <3.2): 8 Hun. •• hu:;c,tt•: R Re!;pue::;tn: S 1 EX 1S TI:: Po::iciorl lt!l"ct Din . : ] Pn!:icion /.ct,, Din.:?. P1•ess dny key to continlte ... _ a a •
- 224. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Diagrama de flujo ( Inicio } ! nb, i , j , pl , p2 . Entero . r . Cadena . ! n [ 4) [3) . Entero . ! Leer n [ OJ [ O], n [O J [ 1 1, n [O 1 [ 2 ], n[l l [O] , n[l l [1] , n[l l [2] , n[2 1 [O] , n[2 1 [l] , n[2 1 [2] , n [3] [0) , n [3] [1) , n [3] [21 ! r - "NO EXISTE" pl - -1 p2 - -1 J i< 3 i - 0 F i-i+l ! j-0 F j < 2 j ·- j +1 1V F [i l [j] no > T v r - "SI EXISTE" pl - i p2 - j Salir J. F " SI EXISTE' ¡v Salir ! 1 Escribir r , pl , p2 1 ! ( Fi n ) Algoritmo Pseudocódigo Inicio //Variables nb, i , j , p1 , p2 r : Cadena //Arreglos (Matriz) n[ 4 ] [3] : Entero //Entrada Entero Leer n [0] [0 ], n [0] [1], n [0] [2 ], n [l ] [O ], n[1] [l ], n[l] [2], n[2] [O ], n[2] [l ], n[2 ] [2], n[3] [O ], n[3] [l ], n[3] [2] //Proceso r - " NO EXISTE" p1 - - 1 p2 - - 1 Para i-0 Hasta 3 Inc 1 Para j-0 Hasta 2 Inc 1 Si n[i] [j]=nb Entonces r - " SI EXISTE" pl - i p2 - j Sali r Fi n Si Fin Para Si r =" SI EXISTE" Entonces Salir Fin Si Fin Para //Salida Escribir r , p1 , p2 Fin
- 225. Algoritmos con java Codificación: .·.......................................................................................................................................................................................................... ... import java . util . Scanner; public class Problema81 { public static void main(St ring[J args) { //Variables int nb, i , j , pl , p2 ; St ring r = ""; //Arreglos int n (] [] - new int [ 4) ( 3 ] ; //Entrada Scanner teclado= new Scanner(System . i n) ; System . out . print (" Numero (0 , 0) : " ) ; n (O J [0 ) = tec l ado . nex tint () ; System . out . print (" Numero (0 , 1 ) : " ) ; n (O ) [1 ) = teclado . nexti n t () ; System . out . print( " Numero (0 , 2) : " ) ; n [0 ) [2 ) = t eclado . nextint () ; System . out . pri nt( " Numero (1, 0) : " ) ; n (1 ) [0 ) = teclado . nextint () ; System . out . print ( " Numero (1 , 1) : " ) ; n (1 ) [1 ) = tecl ado . nex tint () ; System . out . print (" Numero (1 , 2) : " ) ; n [1) [2 ] = teclado . nextint () ; System . out . print( " Numero (2 , 0 ): " ) ; n [2 ] [0 ] = t eclado . nextint () ; System . out . pr i nt (" Numero (2 , 1 ): " ) ; n[2) [1) = t eclado . nextint () ; System . out . print ( " Numero (2, 2) : " ) ; n (2 ) [2 ) = teclado . nex tint () ; System . out . print (" Numero (3 , 0) : " ) ; n [3) [0 ] = teclado . nextint () ; System . out . print (" Numero ( 3 , 1 ): " ) ; n[3) [1 ] = teclado . nextint () ; System . out . pr i nt( " Numero ( 3 , 2) : " ) ; n[3) [2 ) = teclado . nextlnt() ; System . out . print (" Num . a buscar : '' ) ; nb = tec lado . nextint() ; //Proceso r = " NO EXISTE"; p1 - - 1; p2 - -1 ; for (i = O; i<=3; i ++ ) { f or (j = O; j<=2; j ++){ if (n [ i ] [j] == nb) { r = " SI EXISTE"; •., ................. ········································..............................................................................··································································
- 226. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) ........................................................................................................................................................................................................... .. . } } } } } p l = i ; p2 = j ; break; if(r == " SI EXISTE") break; 1/Salida System . out . println( "''); System . out . pri ntln( " Respuesta : " + r) ; System . out . println( " Posicion lera Dim . : " + pl ) ; Sys tem . out . println( " Pos icion 2da Dim . : " + p2) ; ............................................................................................................................................................................................................. Problema n.2 82 Enunciado: Dado la matriz A de 2x2, la matriz B de 2x2, obtenga la suma de dichas matriz. Análisis: Para la solución de este problema se requiere que el usuario ingrese 8 números; luego, que el sistema devuelva la suma de matrices. Entrada Salida • 4 Números matrizA (a[2](2)) • 4 Números matriz C(c(2](2]) • 4 Números matriz B (b[2](2)) Diseño: Interfaz de usuario e; C:ARCHIV- 1XINOXS- 1JC..~ 11151EJ Al'l'e~¡lo A: Hune t•o <ll.ll): 2 Nune t•o <ll.l): ?. Nunr~ 1'0 (1.11) : ?. Nune.-o <1.1): ?. Ot•J'e!Jln B: - -- - . Nune r•o <ll.ll): 1 Hune t•o <ll.l): 1 Nune t•o <t.ll>: 4 Nunr~ t•o (1.1> : 1 At•••eylo C: Nune t•o OL l1): IJ Nune.-o <n~1): (, 'Hunct•o ( 1 ~ 11): L Nunel'o (1 ~ 1): 6 .PI't!:::; •llV kt~y te) c:C)Ittirttlt: ... _ a 1
- 227. Algoritmos con java Algoritmo Diagramade flujo ( Inicio ! i , j . Entero . ¡ a [11 [11 . Entero . b[1] [1 ] . Entero . c[l] [1] . Entero . ! Leer a(O] [OJ,a(O] (1), a[11 IOLal 1 1 111, b(O] (OJ,b[O] l lL b[1] (O],b[ 1 ] ( 1 ] ! i-0 i< 1 F i-i+1 ¡v j< 1 j-0 F J-j+l !V e [i 1 [ j ]-a [ i] [ j ] +b [ i] [ j ] +v :1: ¡ A Escnna 1 e 101 101 , e 101 [11 c[1] [OJ,c[ 1] [1 ] ¡ ( Fin Codificación: import java . util . Scanner; pub1ic c1ass Problema82 { Pseudocódigo Inicio //Variables i, j : Entero //Arreglos (Matriz) a [1] [1] Entero b[1] [ 1 ] Entero c[1] [1] Entero //Entrada Leer a[O] [O J,a [O ] [1], a[1] [OJ,a[1 ] [1 ], b [O] [OJ,b[O ] [ 1], b [1 ] [0] , b[1] ( 1] //Proceso Para i -0 Hasta 1 Inc 1 Para j-0 Hasta 1 Inc 1 c[i] [j ]-a[ i ] [j ]+b[i] [j ] Fin Para Fin Para //Salida Escribir c[O] [OJ,c[O] [1], c[1] [0],c[1] [1 ] Fin public static void main(String[] args) { //Variables int i , j ; //Arreglos in t a [ ] [ ) - new int [ 2) [ 2] ; int b[) [] = new int[2) [2] ; int e[][] - new int [2) [2] ; //Entrada
- 228. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) ......................................................................................................................'....................................................................................'. ) ) Scanner teclado= new Scanner (System . in ) ; System . out . pr i ntln( " Arreglo A: " ) ; System . out . println( " =========== : " ) ; System . out . pri nt (" Numero (0 , 0 ) : " ) ; a[O] [0] = teclado . nextint () ; System . out . print( " Numero (0 , 1) : " ) ; a[O] [1] = teclado . nextint() ; System . out . pr i nt (" Numero (1 , 0 ) : " ) ; a [ 1] [O ] = teclado . next Int () ; System . out . print( " Numero (1 , 1 ) : " ) ; a[1] [1] = tecl ado . nex tint () ; System . out . println( "" ) ; System . out . pri ntln( " Arreglo B : " ) ; System . out . print1n( " =========== : '' ) ; System . out . print (" Numero (0 , 0 ) : " ) ; b [O] [0] = tec l ado . nex tint () ; System . out . print( " Numero (0 , 1) : " ) ; b[O] [1] = teclado . nextint () ; System . out . print( " Numero (1 , 0 ) : " ) ; b [1] [0] = teclado . nextint () ; System . out . print (" Numero (1 , 1) : " ) ; b[1] [1 ] = tecl ado . nextint () ; //Proceso f or ( i = O; i<=l ; i ++) { for ( j = O; j<=1; j++) c[i] [j ] = a[i] [j ] + b[i] [j ]; ) //Salida System . out . println( "" ) ; System . out . pri ntln( " Arreglo C : " ) ; System . out . print1n( " =========== : '' ) ; System . out . print1n (" Numero (0 , 0) " + e [0] [0] ) ; System . out . pr i ntln( " Numero (0 , 1) " + c[O] [1]) ; System . out . print1n( "Numero (1 , 0) " + c[1] [0] ) ; System . out . println( " Numero (1 , 1) " + c[1][1] ) ; Enunciado: Ingrese 6 números en una matriz de 3x2 y obtenga el numero mayor ingresado. Análisis: Para la solución de este problema se requiere que el usuario ingrese 6 números; luego, que el sistema devuelva el número mayor. Entrada Salida • 6 Números (n[3][2]) • Mayor (m)
- 229. Algoritmos con java Diseño: Interfazde usuario , ; C:ARCHIV-1XINOXS-1JCRE. .. l!ilEI Diagrama de flujo ( Inicio ) ! m, i , j . Entero . ! n(3) (2] . Entero . ! ~ Leer n[O] [O) , n[O] [1] , ~ n[l) [0 ) , n[l) [1) , n (2) (0 ) , n [2) (1 ) ! m - n[OJ [0) ! i-0 i< 2 F i-i+1 !V j-0 F j<-1 j-j+l l V F n[i) [j i > m > T v m- n(i) (j) l l 1 Escribir m 1 l ( Fin ) Algoritmo Pseudocódigo Inicio //Variables m, i , j : Entero //Arreglos (Matriz) n[3] [2] : Entero //Entrada Leer n[O) [OJ,n[OJ (1), n[1) [0 ),n[1 ) [1), n[2) [O),n(2) [1) //Proceso m- n[O) [0) Para i-0 Hasta 2 Inc 1 Para j-0 Hasta 1 Inc 1 Si n[i) [j)>m Entonces m- n[i) [j) Fin Si Fin Para Fin Para //Salida Escribir m Fin
- 230. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Codificación: ........................................................................................................................................................................................................... ... import java . util . Scanner; public class Problema83 { l public static void main(String[J args) { //Variables } int m, i , j ; //Arreglos int n 1] [] - new int [ 3] 12] ; //Entrada Scanner teclado= new Scanner(System . in) ; System.out . print( " Numero (0 , 0) : " ) ; niOJ [0] = teclado . nextint () ; System . out . print (" Numero (0 , 1) : " ) ; n 10 ] [1] = teclado . nextint () ; System . out . print (" Numero (1 , O) : " ) ; n[1] [0] = teclado . nextlnt () ; System . out . print (" Numero (1 , 1 ) : " ) ; n [1 ] [1 ] = teclado . nextint () ; System . out . print( " Numero (2 , 0) : " ) ; ni2J [0] = teclado . nextint () ; System . out . print (" Numero (2 , 1) : " ) ; n [2 ] [1] = teclado . nextint () ; //Proceso m = n[O ) [0 ) ; for(i = O; i<=2; i++) { } } 1/Salida for ( j = O; j<=1 ; j++) { if (n [ i J [ j 1 > m) m = n[i ) [j ) ; System . out . println( "'' ) ; System . out . println( "Mayor : " +m) ; •,, ..........................................................................................................................................................................................................
- 231. Algoritmos con java Probleman.2 84 Enunciado: Ingrese 6 números en una matriz de 3x2 y ordene los números de cada columna. Análisis: Para la solución de este problema, se requiere que el usuario ingrese 6 números; luego, que el sistema devuelva las columnas ordenadas. Entrada • 6 números (n[3)[2]) Diseño: Salida • Cada columna ordenada (n[3)[2)) Interfaz de usuario e' C:ARCHIV- 1XINOXS- 1JCREA 2J1'1 1!1liJEl Nune t•o 01. ¡j): ] Hunt: t•o <H.I): ] Hunero <1.0): 2 Huru: t•o (1.1): ?. Httnt~ t•n (/. • ¡1) : 1 Nune I'O <?..1): 1 Ot•<lt:n.(lo pot• coll~nrld~ Hunt:I'O 01,(.1): 1 Nunct•o <H .. 1): 1 Nune1•o ( 1 , ~D: ?. Nune l'o ( 1 , 1 ) : 2 Hunero (2 .. ~D: 3 Hum:Po (2, 1): ] Pl'e~:; <ny key to continue ... _ a -
- 232. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Diagrama de flujo ( Inicio ) ¡ tmp, i , j , LS : Entero ! n[3] [2] . Entero . l / Leer n[O][O],n[0][ 1 ],/ n[1) [0],n[1) [1], n[2 ) [O J, n[2 ) [1) ! LS - 2 ! i-0 F i< LS 1 i-i+1 !V j-0 F j< LS-1 j-j+1 l V F n(j] (0)>n[j+1) [0] Tv tmp - n[j) [ O] n(j] [0]- n[ j+1] [0) n(j+l ] (0 ] - tmp F n [j) [1)>n (j+1 ) (1) T tmp - n [ j l [ 1] n(j) 111- n[ j+ l l [1) n 1j+l 1[1 ) - tmp ! ~Leer n[OI (O) , n[O) ( 1 ~~ n[l ) (0 ) , n[1 ) (1 ) , n [2 ) [O ) , n [2 ) (1) l ( Fin ) Algoritmo Pseudocódigo Inicio //Variables tmp, i , j , LS · Ent e ro //Arreglos (Matriz) n [ 3] [2] : Entero //Entrada Lee r n [ O] [ O] , n [ O] [ 1] , n[1] [ 0] , n[1 ) [1] , n[2) [ 0) , 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 ] [O] Entonces tmp - n [ j 1 [O J n [j ) [01- 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) - t mp Fin Si Fin Para Fin Para //Salida Escribir n[ OJ [O),n[O] [1), n[l) [0),n[1 ) [1] , n[2) [ 0) , n[2 ) [ 1] Fin
- 233. Algoritmos con java Codificación: ............................................................................................................................................................................................................ · import java . uti l . Scanner; public class Problema84 { } public static void main(Stri ng[J args) { //Variables } int tmp , i , j , LS ; //Arreglos int n(] [] = new int[3] (2] ; //Entrada Scanner teclado= new Scanner(System . in ) ; System . out . print (" Numero (0 , O) : " ) ; n(OJ [0] = teclado . nextint () ; System . out . print( " Numero (0 , 1) : " ) ; n(OJ [1 ] = teclado . nextint () ; System . out . pri nt (" Numero (1, 0 ): " ) ; n(1] [0 ] = teclado . nextint () ; System . out . print (" Numero (1 , 1 ): " ) ; n (1] [1 ] = tec1ado . nextint () ; System . out . print( " Numero (2 , 0) : " ) ; n(2] [0 ] = teclado . nex tint () ; System . out . pri nt( " Numero (2 , 1 ): " ) ; n (2 ] [1 ] = tec1ado . nextint ( ) ; //Proceso LS = 2 ; for( i = O; i<=LS - 1 ; i ++) { ) //Salida f or (j = O; j<=LS - 1 ; j ++) { } } } if(n ( j] [01 > n(j + 1 1 (0 1) ( tmp = n [ j 1 [ O1; n ( j] [0 ] = n ( j + 1 ] (0 ] ; n(j + 1 1 (0 1 = tmp ; if(n ( j] [1] > n ( j + 1 ] (1] ) { tmp = n [ j 1 [11 ; n(j1 [11 = n(j + 11 (1 ]; n ( j + 1] ( 1 1 = t mp ; System . out . println( "" l ; System . out . pri nt1n( "Ordenado por columnas" ) ; System . out . println ("Numero (0 , 0) : " + n [0 1 (01 l ; System . out . println (" Numero (0 , 1) : " + n [0 ] (1] l ; System . out . println( " Numero (1 , 0) : " + n[1 ] [0] ) ; System . out . print1n( " Numero (1 , 1) : " + n[1 ][ 11J ; System . out . println (" Numero (2 , 0) : " + n [2 1 (01 l ; System . out . pri ntln (" Numero (2 , 1) : " + n [2 ] (1]) ; ..............................................................................................................................................................................................................
- 234. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Enunciado: Almacene 9 números en una matriz de 3x3 y obtenga los números ordenados. Análisis: Para la solución de este problema se requiere que el usuario ingrese 9 números; luego, que el 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 " . C:ARCHIV- 1XINOXS- 1UCRL.. I!:II:J Nune1•o <1-l,¡l): 9 a Hune I'O <H.!): H • Htllli!I'O <H,/.): '/ Nune1·o (1 ,¡j): 6 Hune t•o (!,!): 'J Hune I'O (1 ,/.): 1 Hunc1·o (2,11): J Nune¡•o <2,1): 2 Hu ru: I'O <2,/.): 1 Ot•denddo Huru:l'tl <H.H): 1 Nune I'O <H.!): /. Hune t•o <H.2): ] Htlllf'I'C) (1 ,H): 1 Nune t•o (1 ,1 ): ~ Hune I'O (1 ,2): 6 Hunt~ l'n <?.,H): '/ Nune t•o (2,1): 8 Nune t•o <2.2): 9 Pt·t~:::: dlll kt~ 1 lo conl in tu: .. .
- 235. Algoritmos con java Algoritmo Diagramade 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 ¡ ~
- 236. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) Pseudocódigo Inicio //Variables tmp, i , j , x , LS Entero flag : Logico //Arreglos (Matriz y Vector) n [3 ] [3] : Entero 0[9 ] : Entero //Entrada Leer n[O] [OJ,n[OJ [1J,n[0] [2], n[1] [OJ,n[1] [ 1J,n[1] [2], n[2] [0J,n[2] [ 1J,n[2] [2 ] //Proceso X - 0 Para i-0 Hasta 2 Inc 1 Para j - 0 Hasta 2 Inc 1 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+1] Entonces tmp - o ( j + 1) o(j + 1) - o(j) o(j) - tmp Fin Si Fin Para Fin Para X - 0 Para i-0 Hasta 2 Inc 1 Para j-0 Hasta 2 Inc 1 n[i] [j ] - o[x] X - X + 1 Fin Para Fin Para //Salida Escribir n[O] [ OJ,n[O] [1J,n[O] [ 2], n[1] [0J,n[1] [ l],n(l] [2], n[2] [OJ,n[2] [ l],n[2] [2 ] Fin
- 237. Algoritmos con java Codificación: ............................................................................................................................................................................................................. . import java . util . Scanner; public class Problema85 { public static void main(String[J args) { //Variables int tmp , i , j , x , LS ; //Arreglos int n () [) = new int ( 3) ( 3) ; int o () = new int [ 9] ; //Entrada Scanner teclado= new Scanner{System . in ) ; System . out . print( " Numero (0 , 0) : " ) ; n[O] [0] = teclado . nextint () ; System . out . print( " Numero (0 , 1 ) : " ) ; n(O] (1] = teclado . nextint () ; System . out . print ( " Numero (0 , 2) : " ) ; n [0 ] [2 ] = teclado . nextint () ; System . out . print( " Numero (1 , 0) : " ) ; n[1] [0] = teclado . nextint() ; System . out . print ( " Numero (1 , 1) : " ) ; n[1] [1] = teclado . nextint() ; System . out . print (" Numero (1 , 2) : " ) ; n[1] [2) = tec1ado . nextint () ; System . out . print( " Numero {2, 0) : '' ) ; n [2] [0 ) = teclado . nextint () ; System . out . print ( " Numero (2 , 1) : " ) ; n[2] [1] = tec1ado . nextlnt () ; System . out . print ( " Numero (2 , 2) : " ) ; n[2] [2] = teclado . nextint () ; //Proceso X = O; for (i = O; i<=2 ; i++ ) { for ( j = O; j<=2 ; j++) { o(x] = n[i](j] ; x++ ; } ) LS = o . length - 1 ; f o r ( i = O; i <=LS - 1 ; i ++ ) { for(j = O; j <= LS - 1 ; j++) { if(o[j] > o(j + 1)) { tmp = o[j + 1) ; o[j + 1] = o[j] ; o(j) = tmp ; } •., ...........................................................................................................................................................................................................
- 238. Capítulo 7: Estructurasde datos. Arreglos (vectores y matrices) .......................................................................................................................................................................................................... .. } } } } X = O; for (i = O; i<=2 ; i++) { for(j = O; j<=2 ; j++) { n[i) [j ) = o[x) ; x++ ; } } //Sal ida System . out . println( "'' ) ; System . out . println( "Ordenado" ) ; System . out . println( " Numero (o ' o) System . out . println( " Numero (o ' 1) System . out . println( "Numero (o ' 2) System . out . println( "Numero (1 ' o) System . out . println( " Numero (1 ' 1) System . out . println( "Numero (1 ' 2) System . out . println( " Numero (2' o) System . out . println( " Numero (2 ' 1) System . out . println( "Numero (2' 2) n + n[O )[O) ) ; n + n[O )[ l)) ; n + n[0)[2)) ; n + n[1 )[0) ) ; n + n[l )[ l)) ; n + n[1)[2)) ; n + n[2 )[0) ) ; n + n[2 )[1) ) ; n + n[2 )[2) ) ; .. .......................................................................................................................................................................................................... '
- 239. Algoritmos con java 7.6Problemas propuestos Los siguientes problemas le servirán para medir su aprendizaje, es importante que los resuelva. Propuesto n.º 51 Enunciado: Dado 4 números, almacénelos en un vector; luego obtenga la suma y el promedio de los valores almacenados. Propuesto n.2 52 Enunciado: Dado 4 números, y almacene en un vector el número mayor y el menor. Propuesto n.º 53 Enunciado: Dado 6 números, almacénelos en un vector; luego obtenga cuántos números múltiplos de n ha ingresado. Propuesto n.2 54 Enunciado: Ordene 5 números según la forma que se indique: A (ascendente) o D (descendente). Propuesto n.2 55 Enunciado: Ingrese 6 números y determine cuántos números repetidos existen. Propuesto n.2 56 Enunciado: Ingrese 6 números en una matriz de 3x2 y obtenga la suma de cada fila. Propuesto n.2 57 Enunciado: Ingrese 6 números en una matriz de 3x2 y obtenga el promedio aritmético. Propuesto n.2 58 Enunciado: En una matriz de 2x3 ingrese 6 números y múltiple su contenido por un valor K, y obtenga la suma de los números de la matriz. Propuesto n.2 59 Enunciado: Cree una matriz de A de 2x2 y otra B de 2x2 y obtenga una matriz C =A • B Propuesto n.2 60 Enunciado: Cree una matriz de 4x3 y obtenga los números mayores de cada columna.
- 240. 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 para comunicarse con las computadoras, 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
- 241. Algoritmos con java Caracteres extendidos de ASCII 128 € 144 • 160 176 o 193 ' A 209 N 225 á " o ' 129 145 . 161 177 + 194 A 210 226 • 1 a - ó 130 146 ' 162 <t 178 2 195 A 211 227 ¡¡ ' 131 f 147 " 163 t 179 3 196 A 212 ó 228 a 132 148 " 164 ll 180 ' 197 Á 213 6 229 • " a 133 149 • 165 y 181 ~ 198 fE 214 6 230 re ... 134 j· 150 166 ' 182 11 199 <; 215 X 231 r; - ' 135 :¡: 151 - 167 § 183 . 200 E 216 0 232 ' e 136 ' 152 - 168 .. 184 • 201 É 217 ¡) 233 ' e 137 %o 153 ·n.t 169 © 185 1 202 ~ 218 ú 234 " e 138 s 154 V S 170 • 186 V 203 E 219 o 235 e 139 ( 156 ce 171 << 187 >> 204 l 220 ü 236 '1 140 (E 157 • 172 .., 188 1,4 205 f 221 ' y 237 ' 1 141 • 158 z 173 189 V2 206 í 222 ]:> 238 '1 142 V z 159 y 174 ® 190 * 207 1 223 B 239 1 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 earaet er e : Caraete r //Asigna r un valo r e - 'A' 241 ñ 242 ' o 243 ' o 244 ' o 245 o 246 o 247 . 248 ~ 249 ' u 250 ' u 251 ' u 252 ü 253 ' y 254 p 255 y '•• .......................................................................................................................................................................................................... Java .......................................................................................................................................................................................................... ... //Crear una va r iab l e e araet e r ehar e ; / /As i gna r um va lor e = ' A ';
- 242. Capítulo 8: Cadenasde 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" .............................................................................................................................................................................................................. Java ........................................................................................................................................................................................................... ... //Uno o más caracteres String e ; //Asignar um valor e = ABC"; . •., .......................................................................................................................................................................................................... 8.5 Operaciones con cadena Para la manipulación de las cadenas, loslenguajes 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 : ............................................................................................................................................................................................................. . //Unir cadenas ~ e ·- ABC'' + ''XYZ '' Java .......................................................................................................................................................................................................... ··. //Unir cadenas e = ''ABC'' + ''XYZ ''; ............................................................................'.................................................................................................................................
- 243. Algoritmos con java 8.7Comparación Igualdad y desigualdad de cadenas. Pseudocódigo . ............................................................................................................................................................................................................. // I g ua l dad (Falso ) "AAA" = "aaa" //Des i gual dad (Ve r dader o ) " LUISA" > " LUIS" Java ' Igua l dad (Falso ) ''AAA" == "aaa " ' Desigualdad (Verdade r o ) " LUISA" > " LUIS" ... .......................................................................................................................................................................................................... . 8.8 Cálculo de longitud Obtener la cantidad de caracteres de una cadena. Pseudocódigo .......................................................................................................................................................................................................... ... //Retorna 3 ! 1 - Longitud ("aaa" ) .. ........................................................................................................................................................................................................... Java ......................................................................................................................................................................................................... ··. · //Retorna 3 1 = "aaa''. lengt h () ; .............................................................................................................................................................................................................·
- 244. Capítulo 8: Cadenasde caracteres 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» el segundo carácter y de posición 1, así sucesivamente. En Clllas posiciones de los caracteres de una cadena inician con 1. Pseudocódigo .· .......................................................................................................................................................................................................... .. //Extraer e l primer ca r acter A 11 1 cantidad a extraer e- I zquie r da( "ABe", 1 ) //También s e usa 11 O pos i cion 11 1 c antidad a extraer e- s ubcadena ("ABe", 0 , 1 ) //Ext rae r e l ú ltimo cara cter e 11 1 cant i dad a e xtrae r e- De r e cha i " ABe", l ) / /También se usa 11 2 pos icion 11 1 cant i dad a e xtraer e - subcade na ("ABe", 2 , 1 ) // Ext r aer e l segundo ca r acter B 11 2 pos icion 11 1 cantidad a e xtraer e- Ext r ae r( "ABe", 1, 1 ) e- s ubcadena ("ABe'', 1 , 1 ) .............................................................................................................................................................................................................. Java .............................................................................." .......""..................................................................................................." ...........·. //Extraer e l primer carac ter A e = "ABe". substring (O, l ) ; //Extrae r e l ú ltimo cara cter e e= "ABe''. sub s tr i ng (2 , 3) ; //Extraer e l segundo ca r act e r B e= "ABe'' . substri ng (1 , 2) ; .. .......................................................................................................................................................................................................... .
- 245. Algoritmos con java 8.10 Búsqueda de cadenas Buscar si una cadena se encuentra dentro de otra cadena más grande; si fuera así, la función devuelve la posición de la cadena encontrada; caso contrario, retorna-l . En C# la función que cumple la tarea de buscar, si no encuent ra la otra cadena, retorna O porque las cadenas inician con posición 1. Pseudocódigo ............................................................................................................................................................................................................··. //Retorna 1 p- I ndice (''ABC", • B" ) . ............................................................................................................................................................................................................. Java ............................................................................................................................................................................................................. ' Retorna 1 p = • ABC" . indexOf( . 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 .............................................................................................................................................................................................................. //Converti r a cadena un número , de 32 a • 32 " e- Cade na (32 ) //Convertir una cadena de números a dato numérico, de • 32" a 32 n - Va l or (" 32" 1 //Converti r a mayúscul a (ABC ) e- Mayus (''abc''l //Conve r ti r a mi núscu l a (abe ) e- Mi nus (''ABC''l //Obtener e l val or ASCII (A = 65) e - Codi go (" A" l //Obtener e l carácte r de un códi go ASCII (65 -Al e- Caracter (65 ) .. ...........................................................................................................................................................................................................·
- 246. Capítulo 8: Cadenasde caracteres Java ............................................................................................................................................................................................................. //Convertir a cadena un número , de 32 a " 32" e= String . value0f(32) ; //Convertir una cadena de números a dato numérico, de " 32" a 32 n = Integer . parseint( ''32" ) ; //Convertir a mayúscula (ABC) e= "abc". toUpperCase() ; //Convertir a minúscula (abe ) e= "ABC'' . toLoweCase() ; //Obtener el valor ASCII (A- 65) e= "A". codePointAt(O) ; //Obtener el carácter de un código ASCII (65 =A) e = (char) 65 ; ..........................................................................................................................................................................,................................. .
- 247. Algoritmos con java 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 '' C:ARCHIV-1XINOXS-1JCR[A... 111511:1 Diagrama de flujo nom can Inicio Cadena Cant i dad Leer nom can - Longitud(nom) E:scribir can Fin Algoritmo Pseudocódigo Inicio //Variables nom : Cadena can : Enter o //Entrada Lee r nom //Proceso can - Longi tud (nom ) //Salida Escrib i r can Fin Codificación: · import java . ut i l. Scanner; public class Problema86 { } public static void main (String[) args ) { //Variabl es } String nom; i nt can; //Entrada Scanne r teclado= new Scanner(System . i n) ; System . out . print (•Nombre : '' ) ; nom = tec l ado . nex t Line() ; //Proceso can = nom . l e ngth () ; 1/Salida System . out . println(•'') ; System . out . pri nt l n (• cantidad : • +can ) ; ·............................................................................................................................................................................................................
- 248. Capítulo 8: Cadenasde caracteres Problema n.2 87 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) • Nombre y Apellido (nom_ape) • Apellido (ape) Diseño: Interfaz de usuario ". C:ARCHIV-1XINOXS-1JCREAT-1GE20¡ ··11:1rJ Diagrama de flujo ( Inicio ! nom, ape , nom_ape . Cadena . l / Leer nom, apej ! nom_ape- Mayus(nom + " " + a pe) ' l ~Escribir nom_apej ! ( Fin Algoritmo Pseudocódigo Inicio //Variables nom, ape , nom_ape : Cadena //Entrada Lee r nom, ape //Proceso nom_ ape-Mayus (nom + ", " + ape ) //Salida Escribir nom_ape Fin
- 249. Algoritmos con java Codificación: ..................................................'....................................................................................................................................................... ' . · import java . ut il . Scanner; public class Problema87 { } public static void main(String[J args) { //Variables } String nom, ape , nomape ; //Entrada Scanner teclado= new Scanner(System . in ) ; System . out . print( " Nombre : " ) ; nom = teclado . nextLine() ; System . out . print( "Apellido : '' ) ; ape = teclado . nextLine() ; //Proceso nomape = (nom + ", " + apel . toUpperCase () ; //Salida System . out . println( "" J ; System . out . pri ntln( " Nombre y Apellido : " + nomape) ; Problema n.2 88 Enunciado: Dado un carácter, devolver su código ASCII. Análisis: Para la solución de este problema se requiere que el usuario ingrese un carácter; luego, que el sistema devuelva el ASCII . Entrada Salida • Carácter (e) • ASCII (a) Diseño: Interfaz de usuario , , · C:ARCHIV- 1XINOXS- 1UCR(~, ~~~EJ
- 250. Diagrama de flujo (Inicio ) ¡ e . Caracter . a . Entero . ¡ / Leer e / ¡ a - Codigo(c) ¡ / Escribir a / ¡ Fin ) Capítulo 8: Cadenas de caracteres Algoritmo Pseudocódigo Inicio //Variables e Caracater a : Entero //Entrada Leer e //Proceso a - Codigo(c) //Salida Escribir a Fin Codificación: ............................................................................................................................................................................................................. import java . util . Scanner; public class Problema88 { public static void main(String[] args) { //Variables } } String e ; int a ; //Entrada Scanner teclado = new Scanner(System . in ) ; System . out . pri nt( "Caracter : " ) ; e= teclado . nextLine() ; //Proceso a = c . codePointAt(O) ; 1/Salida System . out . println( "''J ; System . out . println( "ASCII : " +a) ; •,, .......................................................................................................................................................................................................... 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 Salida • letra (1 ) • Respuesta (r)
- 251. Diseño: / < <: <: < Algoritmos con java 1. . r . . 1 ·- Interfaz de usuario e,- C:ARCHIV- 1XINOXS- 1Uc.}:J 1151El l.e t l't : 1: a - Re~:pue:;ttt: FS UOCAL f>l't::;:; •'''Y kt:y lct c:cJIJlirJttt: ••• a Algoritmo Diagrama de flujo Pseudocódigo Inicio ! Caracter Cadena t Leer 1 / ¡ Mayus(1) j_ 1 , A' V F 1 r-" ES VOCAL" 1 , E' V F 1 r-" ES VOCAL" 1 , I , V F 1 r-" ES VOCAL" 1- ' O' V F 1 r-" ES VOCAL" V 1 ' U' F 1 r-" ES VOCAL" Inicio //Variables 1 Caracter r Cadena //Entrada Leer 1 //Proceso 1 - Mayus (1) Si 1=' A' Entonces R - " ES VOCAL" SiNoSi 1=' E' Entonces R - " ES VOCAL" SiNoSi 1=' 1 ' Entonces R - " ES VOCAL" SiNoSi 1=' 0 ' Entonces R - " ES VOCAL" SiNoSi 1=' U' Ent onces R - " ES VOCAL" SiNo R - " NO ES VOCAL" E'in Si r - " NO ES VOCAL" //Salida Escribir r 1 Escribir r 1 Fin ! Fin
- 252. Capítulo 8: Cadenasde caracteres Codificación: .·.............................................' .........' .................................................................................................................................................... · i mpor t java .ut i l . Scanne r ; public class Problema89 { } public static vo id main( St ring [ J args) { //Variables } String l , r ; //Ent r ada Scan ner teclado= new Scanner (System . i n); System . o ut . p rint (" Let r a : " ); 1 = teclado . ne x tLine( ) ; //Proceso 1 = l . toUpperCase () ; if (l . equals( ''A"ll r = " ES VOCAL"; else if(l. equals( " E")) r = " ES VOCAL"; else i f(l. equals( " I " ll r = " ES VOCAL"; else if (l. equals( ''O")) r = " ES VOCAL"; else i f (l. equals ("U")) r = "ES VOCAL" ; else r = " NO ES VOCAL"; //Salida System . o ut . print l n ("" ) ; System . o ut . pri nt l n (" Respuesta : " + r); ............................................................................................................................................................................................................. . Enunciado: Dado un carácter, determine si es una letra, número o símbolo. Análisis: Para la solución de este problema se requiere que el usuario ingrese un carácter; luego, que el sistema devuelva si es letra, número o símbolo. Entrada • Carácter (e) Diseño: Salida • Respuesta (r) Interfaz de usuario , ' C:ARCHIV-1XINOXS-1UCRr?l llliJI:I C,1'(Clt:J•:% a - Rt: ::u l t .ulo: FS S1HROI.O Pl'e:;~; ~ny key lo c:ont inue ... a
- 253. Algoritmos con java Diagramade flujo ( rnicio ) ¡ e . Caracter . r . Cadena . a . Entero . / Leer e / ¡ a-Codigo(Mayus(c)) l_ 48 y 5 V < a> a< F 1 r- "ES NUMERO" <a> 65 y a< 90 V F 1 r-"ES LETRA" r-" ES SIMBOLO" 1 Escribir r 1 ¡ eFin Codificación: Algoritmo Pseudocódigo Inicio //Variables e Caracter r Cadena a Entero //Entrada Leer e //Proceso a~ Codigo(Mayus(c)) Si a>=48 Y a<=57 Entonces r - " ES NUMERO" SiNoSi a>=65 Y a<=90 Entonces r - " ES LETRA" SiNo r - " ES SIMBOLO" E'in Si //Salida Escribir r Fin ............................................................................................................................................................................................................. import java . util . Scanner; public class Problema90 { } public static void main(String[] args) { //Variables } String c , r ; int a ; //Entrada Scanner teclado= new Scanner(System . in ) ; System . out . print( "Caracter : " ); e= teclado . nextLine() ; //Proceso a= c . toUpperCase (J . codePointAt(OJ ; if(a >= 48 && a <= 57 ) r = " ES NUMERO"; else if(a >= 65 && a<= 90) r = "ES LETRA"; else r = "ES SIMBOLO"; 1/Salida System . out . println( "'' ) ; System . out . println( " Resultado : " + r) ; .............................................................................................................................................................................................................
- 254. Capítulo 8: Cadenasde caracteres Problema n.2 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 e,- C:ARCHIV-1 XINOXS-1 .JCREAT;~~ lit!]El -- - Hnnh1•e: Ric<H'Itn a C.mt iddd: ] - Respuestd: Hic PI'e:;:; •Hll/ ke y t o (;011 t i IHU: _ • • a Algoritmo Diagrama de flujo Pseudocódigo ( Inicio ) ~ n , r . Cadena . e . Entero . ! / Leer n , e / ! r - Izquierda (n , c) ! 1 Escribir r 1 ! ( Fin Inicio //Variables n , r : Cadena e : Entero //Entrada Lee r n , e / / Proceso r - Izquierda(n , c) //Salida Escribir r Fin
- 255. Algoritmos con java Codificación: impo r t java . uti l . Scanner ; public cla ss Problema91 { publ i c stati c void main( St ri ng[J args ) ( //Variables Stri ng n, r ; i nt e ; // Entrada Scanne r teclado= new Scanne r( System . i n) ; System . out . print ("Nombre : ''); } } n = tecl ado . nex t Line () ; System . out . print ("Cantidad : " ) ; e= tecl ado . nex t i nt () ; //Proceso r = n . subst ri ng( O, c ) ; //Sal ida System . out . p ri nt l n ("'' ); Sys tem . out . println (" Re spuesta : " + r) ; ............................................................................................................................................................................................................. Problema n.2 92 Enunciado: Según las siguientes especificaciones, genere un código basado en el nombre ingresado. Especificaciones para generar el código 1.0 ' carácter del código: Primer carácter del nombre. 2.• 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 " . C:ARCHIV- 1XINOXS- 1U;:-~ 11151EJ Hunh,•t! : Pe~J~IIJ 11 - Cott i !IU : PGYS P1•e:;:; •l ty key ltl r:tlltliftlte ... _ a
- 256. 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) l / Escribir rj ! ( Fin Capítulo 8: Cadenas de caracteres Algoritmo Inicio Fin Pseudocódigo //Variables p , t , u , l , n , c //Entrada Leer n //Proceso Cadena p- Izquierda(n, 1) t- Extraer(n , 2, 1) u- Derecha (n , 1) 1- Cadena(Longitud(n)) e- Mayus(p + t +u+ 1) //Salida Escribir e Codificación: import java . util . Scanner; public class Problema92 { } public static void main(String[] args) ( //Variables } String p , t , u, l , n , c ; //Entrada Scanner teclado = new Scanner(System . in) ; System . out . print( "Nombre : '' ) ; n = teclado . next Line() ; //Proceso p- n . substring(0, 1) ; t- n . substring(2, 3) ; u = n . substring(n . length ()-1) ; 1- String . valueOf(n . trim() . length() ) ; e = (p + t +u + 1) . toUpperCase() ; //Salida System . out . println( "'' ) ; System . out . println( "Codigo : " +e) ; ., ........................................................................................................................................................................................................... .
- 257. Algoritmos con java -Probleman.2 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 Salida • Frase (f) • Cantidad (e) • Letra (1) Diseño: Interfaz de usuario , ; C:ARCHIV-1 XINOXS-1JCREAT-1 ~ llliii:J Diagrama de flujo ( Inicio ) ¡ f ' 1 . Cadena . c , i . Entero . ¡ 1 Leer f , 1 1 ! v i -0 i< Longitud (f)-1 i - i +l J. F ~us(Extraer (n,i, l)) Mayus(l ¡ v e - e + 1 ~ 1 Escribir e 1 ! ( Fin ) Algoritmo Pseudocódigo Inicio //Variables f , l Cadena c , i : Entero //Entrada Leer f, 1 //Proceso Para i-0 Hasta Longitud(f) -1 Inc 1 Si Mayus (Extraer (n , i , l )) =Mayus (l) Entonces e - e + 1 F in Si Fin Para //Salida Escribir e Fin
- 258. Capítulo 8: Cadenasde caracteres Codificación: .................." .............................................." ....................................................." ......................................................................." ........ ~ import java . util . Scanner; ¡public class Problema93 { public stati c void //Variables String f, 1 ; i nt c=O , i ; // Entrada main (Stri ng[J args) { Scanner teclado= new Scanner{System . in) ; System . out . print( " Frase : " ) ; f = teclado . nextLine() ; System . out . print( "Letra : 1 = teclado . nex t Line() ; //Proceso " ) ; for (i - O; i<=f . length() -l ; i++) 1 if (f . toUpperCase () . substring (i , toUpperCase())) } } e++; l 1/Salida System . out . println( "" ) ; System . out . pri ntln( "Cantidad : " + C) i i+l) . equals (l . .............................................................................................................................................................................................................. Problema n.2 94 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 '; C:ARCHIV-1XINOXS- 1JCRfAT-1Gf2001.exe. lli!EJ
- 259. Algoritmos con java Diagramade 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
- 260. Capítulo 8: Cadenasde caracteres Codificación: import java . util . Scanner; public class Problema94 { J public static void main(String[J args) ( //Variables J String fl , f2=''", t ; int i , p ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( "Frase : " ) ; fl = teclado . nextLine() ; //Proceso p = O; fl = fl . trim() ; for(i =O ; i<fl.length() ; i++){ } ) if(fl . substring(i, i+l) . equals( " " )) { t = fl . substring(p, i) ; p = i + 1 ; f2 = f2 + t ; t = fl . substring (p , i) ; f2 = f2 + t ; 1/Salida System . out . println( "" ) ; System . out . println( " Frase sin espacios : " + f2) ; ........." .............................." .......·········································...................................................................................................................
- 261. Algoritmos con java Probleman.2 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) • Frase encriptada (f2) Diseño: Interfaz de usuario ,..."- - _e_: A -R_,.,.c.,..H_I v_-1 .,..X~I N_o_ xs _-.,.... 1_u.,.,.cR_E_ A..,.T-_ 1 _ G ..,.E_2o_o_ 1_.e....,. x...,e,.,..--...,..,------·-1151EJ fp.-:;e: R i(;.-t·do M.ti'Ct! lo u- 1' ic<tl•don.tt•ce lof.IIJ¡otn.t i l.con a Fa-.t:;e ::111 e:;¡~<tc io:;: Sjdh::elJ Hh::ttfnp U/ :;j(th:;epnh::tlfnpA ipuuhjn/dpn P1·t~:;:; c:tny Kt:y t.o t: ont irnn~ ••• a -
- 262. Diagrama de flujo (Inicio ) ! fl , f2 , c . Cadena . i : Entero ! 1 Leer fl 1 ! f1 - Recortar (fl) l i · o i<-Longitud( fl) -1 i· i+l !v e . Extraer (fl , i , 1 ) 1 F e <> " " V e - Caracter(Codigo(c) + f2 - f2 + e ! 1 Escribir f2 1 ! ( Fin ) 1) Capítulo 8: Cadenas de caracteres Algoritmo F Pseudocódigo Inicio //Variables fl , f2 , c : Cadena i : Entero //Entrada Leer f1 //Proceso fl - Recortar(f1) Para i-0 Hasta Longitud (f1)-1 Inc 1 e- Extraer(f1 , i , 1) Si e <> " " Entonces e- Caracter(Codigo(c) + 1) Fin Si f2 - f2 + e Fin Para //Salida Escribir f2 Fin
- 263. Algoritmos con java Codificación: ......................................'...............................................................................................................................' ....................................... · import java . util . Scanner; public class Problema95 { } public static void main(String[) args) { //Variables } String fl , f2="", c ; in t i , p ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print ("Frase : " ) ; fl = tec lado . nextLine () ; //Proceso p = O; fl = fl . t r im () ; for (i =O; i<fl . lengt h() ; i++){ e= fl.substr i ng(i , i+l) ; if(!c . equals( " " )) { e= String . valueOf((char) (c . codePointAt (O) + 1 )) ; ) f2 += e ; ) //Salida System . out . println( "" ) ; System . out . println( " Frase sin espacios : " + f2) ; .. ...........................................................................................................................................................................................................
- 264. Capítulo 8: Cadenasde caracteres 8.12 Problemas propuestos Los siguientes problemas le servirán para medir su aprendizaje, es importante que los resuelva. Propuesto n.º 61 Enunciado: Dado el nombre de una persona, obtenga el mensaje: «Bienvenido, Sr(a) Gustavo, a su tienda de preferencia>>. Propuesto n.262 Enunciado: Dado un nombre, obtenga el nombre en forma invertido; por ejemplo, Julio invertido oiluJ. Propuesto n.º 63 Enunciado: Dada un frase, devuelva la frase con asteriscos en lugar de espacios en blancos. Propuesto n.º 64 Enunciado: Dada una let ra, determine si está en minúscula o mayúscula. Propuesto n.º 65 Enunciado: Lea una frase y una palabra, y determine si existe o no la palabra en la frase. Propuesto n.º 66 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.267 Enunciado: Dada una frase, determine cuántas palabras palíndromos ha ingresado. Propuesto n.268 Enunciado: Dada una frase, determine cuántas palabras se repiten. Propuesto n.º 69 Enunciado:Cree el algorit mo para encriptar una frase con el valor del carácter ASCII, sumando 2 posiciones. Propuesto n.º 70 Enunciado: Cree el algoritmo para desencriptar la frase generada por el algoritmo anterior.
- 266. 9.1 1 ntroducción SubAigoritmos (procedimientos yfunciones) 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 ! ! SubProblema 1 1 SubProblema 1 SubProblema 1 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
- 267. Algoritmos con java 9.2Procedimientos 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 procedimiento Procedimiento Procl(E : Paraml : Entero) <Instrucc i ones> Fin Procedimiento // I nvocar el procedimiento Llamar Procl (10) .............................................................................................................................................................................................................. Java //Método que no retorna ningun valor private static void Procl( i nt Paraml) <Instrucciones>; } ' Invocar al método Procl( l O) ; (voi d) { ... ..........................................................................................." ............................................................................................................. 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 función Funcion Fu ncl (E: Paraml : Entero) :Cadena <Instrucciones> Retorna <Valor> Fin Funcion //Invocar la función e - Funcl (10) .. ...........................................................................................................................................................................................................
- 268. Capítulo 9: SubAigoritmos(procedimientos y funciones) Java .........................................., .......................................................................................................................·········.......................········... //Crear una método que retorna un valor private static String Funcl (i nt Paraml) { <Instrucc i ones>; return <Valor> ; } //Invocar e l método e = Funcl(10) ; ............................................................................................................................................................................................................ 9.4 Paso de parámetros . Muchas 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 (entrada) 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 función Funcion Incrementar( E: N: Entero) : Entero N- N + 1 //Modi ñca el valor de N Retorna N Fin 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 val or es 6 .............................................................................................................................................................................................................
- 269. Algoritmos con java Java ............................................................................"............................................................................................................................... //Crear un método private static int I ncrementar (int N) { N =N + 1 ; //Modiñ ca el valor de N return N· ' } //Invocar el método Num = 5 ; Res= Incrementar(Num) ; //El valor de Num se copi a en N System . out . println(N um) ; //su valor s i gue siendo 5 System . out . println(Res) ; //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 .......................................................................................................................................................................................................... ··. · //Crear una función Funcion Incrementar(S : N: Entero) : Entero N- N + 1 //Modiñ ca el valor de N Retorna N Fin Funcion // Invocar la función Num - 5 Res- I ncrementar (Num) //El parámetro N hace referencia a Num Imprimir Num //su valor ahora es 6 Imprimir Res //su valor es 6 Java .......................................................................................................................................................................................................... ... //Crear una función private static int Incrementar(int N[ ] ) { N[O] = N( O] + 1 ; //Modiñ ca el valor de N return N( O] ; }
- 270. Capítulo 9: SubAigoritmos(procedimientos y funciones) .......................................................................................................................................................................................................... .. · // ' I nvocar la func i ó n Num [O] = 5 ; Res= Incrementar (Num) ; //El parámetro N hace referencia a Num System . o ut . print l n (Num[ O] ) ; //su valor ahora es 6 System . out . pri nt l n (Res ) ; //su valor es 6 ............................................................................................................................................................................................................ Problema n.2 96 Enunciado: Dados dos números enteros, hallar la suma. Cree una función para resolver el problema. Sumar(E:Numl :Entero, E:Num2:Entero):Entero Interfaz de usuario , ' C:ARCHIV- 1XINOXS-1UCR~.:;'. l!:li:J Algoritmo Diagrama de flujo Pseudocódigo Principal Principal Inicio //Variables nl , n2 , S . Entero nl , n2 , S Entero . Leer nl , n2 //Entrada Leer n l , n2 s ·- Sumar (nl , n2) //Proceso Esc r ibir S ·- Sumar (nl + n2) S //Salida Fin Esc rib i r S Fin
- 271. Algoritmos con java Diagramade flujo SubAigoritmo Pseudocódigo Sumar ( Inicio ) ~ Numl , Num2 , s . Entero . ~ ~Leer Numl , Num~ ~ S - Numl + Num2 ~ / Escribir S / ~ ( Fin ) Funcion Sumar(E:Numl:Entero, E:Num2:Entero) :Entero //Variables locales s : Entero //Proceso s - Numl + Num2 //Salida Retornar s Fin Funcion Codificación: .......................................................................................................................................................................................................... .. · import java . util . Scanner; public class Problema96 { //Principal } public static void main(String[] args) { //Variables } int nl , n2 , s ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print(" Numero 1 : " ) ; nl = teclado . next!nt() ; System . out . print( "Numero 2 : " ) ; n2 = teclado . next!nt() ¡ //Proceso s = Sumar(nl , n2) ; //Salida System . out . println( "" ) ; System . out . println( " Suma : " + s) ; //Método Sumar private static int Sumar(int Numl , int Num2) { //Variables int s ; //Proceso s = Numl + Num2 ; //Salida return s ; } ................................................................................................................'.............................................................................................
- 272. Capítulo 9: SubAigoritmos(procedimientos y funciones) Enunciado: Dado dos números enteros diferentes, devolver el número mayor. Cree una función para resolver el problema. Diagrama de flujo Principal ( Inicio ! nl , n2 , m . . ! / Leer nl , ! Mayor(E:n1:Entero, E:n2:Entero):Entero Interfaz de usuario , ' C:ARCHIV- 1XINOXS-1UCRE.:;~ I!II:JEJ ) Ente ro n2/ Algoritmo Pseudocódigo Principal Inicio //Variables nl , n2 , m / /Entrada Leer nl , n2 Entero m- Mayor(nl ,n2) ! 1 Escribir ! ( Fin m 1 ) / / Proceso m- Mayor(nl , n2) //Salida Escribir m Fin
- 273. Algoritmos con java Diagramade flujo Mayor Inicio nl , n2 , m Entero F m - nl F m - n2 Escribir m Fin Codificación: 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 ........................................................................................................................................................................................................... ... import java . util . Scanner; public c lass Problema97 { //Principal public static void main(String[] args) { //Variables ) int nl , n2 , m=O ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print ("Nume ro 1 : " ) ; nl = teclado . next!nt() ; System . out . print( " Numero 2 : " ) ; n2 = tec lado . nextint() ; //P r oceso m = Mayor(n l , n2) ; //Salida System . out . println( "" ) ; System . out . pri ntln( "Mayor : " + m) ; '·· ...........................................................................................................................................................................................................
- 274. Capítulo 9: SubAigoritmos(procedimientos y funciones) ........................................................................................................................................................................................................... .. o l //Método Mayor prívate static i nt M ayo r( i nt nl , i nt n2) ( //Variables l int m = O; //Proceso if(n l > n2) m - nl · ' if(n2 > nl) m - n2 · ' //Salida return m; ... .......................................................................................................................................................................................................... . Problema n.2 98 Enunciado: Determinar si un número entero es par o impar. Cree un procedimiento para resolver el problema. Principal Parlmpar(E:num:Entero, S:res:Entero) Interfaz de usuario , ' C:ARCHIV- 1XINOXS-1UCRf:~ l!lli]f!1 Diagrama de flujo Inicio nl, n2 , m : Entero Leer nl , n2 m - Mayor(nl , n2) Escribir m Fin Algoritmo Pseudocódigo Principal Inicio //Variables n Entero r : Cadena //Entrada Lee r n //Proceso Parimpar (n , r) //Salida Escrib i r r Fin
- 275. Algoritmos con java SubAigoritmo Diagramade flujo Pseudocódigo Parlmpar ( Inicio ) Procedimiento Parimpar(E:num:Entero, S:res:Cadena) ! num . Entero . res , r . Cadena . ! 1 Leer num 1 1 F ~Mod 2= V ! ! r - " IMPAR" r - "PAR" 1 1 / Escribir res -r / ! ( Fin ) Codificación principal: //Variables locales r : Cadena //Proceso Si num Mod 2 = O Entonces r - "PAR" SiNo r - " IMPAR" Fin Si //Salida res - r Fin Procedimiento .........................................................,,,,...................................,,,,.......................................................................................' .............. ... import java . util . Scanner; public class Problema98 { //Principal publ i c stati c void main (Stri ng[) args) { //Variables 1 int n; Stri ng r[] - new String[l] ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( "Numero : '' ) ; n = tecl ado . ne xtint () ; //Proceso Parimpar (n , r) ; 1/Salida System . out . println( "" ) ; System . out . println( " Resultado : " + r[O]) ; .. .......................................................................................................................................................................................................... .
- 276. Capítulo 9: SubAigoritmos(procedimientos y funciones) .........................................................................................................o ••••••••••••••••••'..• • • • • • • • • • • • .. • • • • • • • • • • • • • • • • • • • • • • • • • ..• • • • • • • • • • • • • • • • ..• • • • • • • • .. • • • • • • • •• //Método Parimpar private static void Par l mpar (int num, String res[]) 1 //Variabl es ) String r = //Proceso if (num % 2 ""· ' == o) 1 r - "PAR"; )else{ r = " IMPAR" · ' } //Sal i da res[O] = r ; } . ... ........................................................................................................................................................................................................... Problema n.2 99 Enunciado: Dado un número, determinar cuántos dígitos tiene. Cree una función para resolver el problema. Principal CantidadDigitos(E:num Entero):Entero Interfaz de usuario , ' C:ARC HIV- 1XINOXS- 1UCREAT. :t)lt:Jf:l Algoritmo Diagrama de flujo Pseudocódigo ( n, 1 Inicio ) ¡ e . Entero . l Leer n 1 ¡ Principal Inicio //Variables n , e : Entero //Entrada Leer n e - CantidadDigitos(n) //Proceso l 1 Escribir ¡ ( Fin e 1 ) e- CantidadDigitos (n) //Salida Escrib i r e Fin
- 277. Algoritmos con java Diagramade flujo CantidadDigitos Inicio num, e Entero Leer num num- num 10 C·- C+l Escribir e Fin F SubAigoritmo Pseudocódigo Funcion CantidadDigitos (E:num:Entero) :Entero //Variables locales e : Entero //Proceso Mientras num>O num - num 10 e - e + 1 Fin Mientras //Salida Retornar e Fin Funcion Codificación: . import java . util . Seanner; public class Problema99 1 //Principal public static void main(String[] args) { //Variables ) int n, e =O ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( "Numero n = t eclado . nextint() ; //Proceso e= CantidadDigitos(n) ; //Salida . " ) . • 1 System . out . println( "'' ) ; System . out . println( "Cant . Digitos : " + e ) ; ............................................................................................................................................................................................................
- 278. } Capítulo 9: SubAigoritmos(procedimientos y funciones) //Método CantidadDi gi tos private static i n t CantidadDigitos(int num) { //Variabl es } int c=O ; //Proceso while(num > 0) { num = num 1 10 ; e += 1; } //Sal ida return e ; '•· ........................................................................, ......................................................, .......................................................................... • · 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. Principal Factoriai(E:num:Entero):Entero Interfaz de usuario e' C:ARCHIV- 1XINOXS- 1UCR:~, ~til El Hu net•o: J 11 - F.u;lu¡• i.t) : (. Pl'e:; s rlny key to cont inue ... _ a Algoritmo Diagrama de flujo Pseudocódigo ( Inicio ) l n, f . Entero . ~ 1 Leer n 1 l f - Factorial (n) l 1 Escribir f 1 ~ ( Fin ) Principal Inicio //Variables n , f : Entero / /Entrada Leer n //Proceso f- Factorial(n) //Salida Escribir f Fin
- 279. Algoritmos con java Diagramade flujo Factorial ( Inicio ) l num, f , i . Entero . ! / Leer num / l f - 1 ! i-1 F i< n i-i+l ¡v f - f * i ! 1 Escribir f 1 l ( Fin ) Codificación: Algoritmo Pseudocódigo Func ion Factorial(E:num:Entero) :Entero //Variables locales f , i : Entero / / Proc eso f - 1 Para i-1 Hasta num Inc 1 f - f * i Fin Para //Sal ida Retornar f Fin Funcio n .· .......................................................................................................................................................................................................... ... import java . util . Scanner; public class ProblemalOO { //Principal public static void main(String[J args) { //Variables ) int n, f , i ; // Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( "Numero : " ) ; n = teclado . nextint() ; //Proceso f = Factorial(n) ; 1/Salida System . out . println( " '' ) ; System . out . println( "Factoria l : " + f) ; .. ......................................................................................................................' ................................................................................... .
- 280. Capítulo 9: SubAigoritmos(procedimientos y funciones) ............................................................................................................................................................................................................ . } //Método Factorial pr í vate static i nt Factorial(i nt num) { //Variables } int i , f ; //Proceso f = 1; f or (i = 1 ; i<=num; i++ ) f *= i ; //Salida return f ; ... .......................................................................................................................................................................................................... . Problema n.2 101 Enunciado: Dado 5 números obtener la suma. Cree una función para resolver el problema. Principal Sumar(E :num [):Entero):Entero Interfaz de usuario '; C:ARCHIV- 1XINOXS-1UCR(;!J I!I¡]E3 Diagrama de flujo ( Inicio } ¡ S . Entero . ~ n[S] : Entero ¡ Algoritmo Principal Inicio Pseudocódigo //Variables s : Entero //Arreglos (Vector) n[5] : Entero ¡ Leer n[O ] , n [l/ n[2 ], n[3 ], n [4 ) //Entrada Leer n [O] , n [ l ], n [ 2) , n[3 J, n [ 4) ! s- Sumar(n) ! 1 Escribir s 1 ¡ ( Fin ) //Proceso s- Sumar (n ) //Salida Escribir s Fin
- 281. Algoritmos con java Diagramade flujo Sumar Inicio J i , S . Entero . l num [ ] . Entero . ~ 1 Leer num 1 l i - 0 i< 4 i - i+l lV S ·- S + num[i ] 1 ~ 1 Escribir S 1 l ( E'in F SubAigoritmo Pseudocódigo Funcion Sumar(E:num[] :Entero) :Entero //Variables locales i , s : Entero //Proceso Para i-0 Hasta 4 Inc 1 s - s + num[i1 Fin Para //Salida Retornar s Fin Funcion Codificación: .· .......................................................................................................................................................................................................... ... import java . util . Scanner; public c lass ProblemalOl { //Principal public static void main(String[1 args) { //Variables int S= O, i ; //Arreglos int n ( 1 = new int [51 ; //Entrada Scanner teclado= new Scanner(System . in ) ; System . out . pri nt( "Numero 1 : " ) ; n(01 = t eclado . nextint() ; System . out . print( "Numero 2 : " ) ; n(11 = teclado . nextint() ; System . out . print( "Numero 3 : " ) ; n[21 = teclado . nextint() ; System . out . print( "Numero 4 : " ) ; n[31 = teclado . nextint () ; System . out . print( "Numero 5 : " ) ; n[41 = teclado . nextint() ;
- 282. Capítulo 9: SubAigoritmos(procedimientos y funciones) .·········································································································································································································· .., } } //Proceso s = Sumar (n) ; //Salida System . out . println( "'') ; System . out . pr i ntln( " Suma : " + s )¡ //Método Sumar private static i nt Sumar(int num[]) { //Variabl es } int s = O, i ; //Proceso for (i = O; i <= 4 ; i ++) s += num[i ]; //Sal ida return s ; .' .......·····.........................................································..................................................................................................................... Problema n.2 102 . Enunciado: Ordene 4 números usando el método de ordenación por intercambio (burbuja). Cree un procedimiento para resolver el problema. Ordenar (S:num(]:Entero) Interfaz de usuario '' C:ARCHIV-1XINOXS-1 ucR!JIIIiJf:l
- 283. Algoritmos con java Diagramade flujo Principal ( Inicio ) ¡ ln[4] : Entero! ! j Leer n[O] , n[l] , n[2] , n[3 v ! Ordenar(n) ! / Escribir n[O] , n[l] , n(2] , nl3y/ ! l E'in ) Algoritmo Pseudocódigo Principal Inicio //Arreglos (Vector) n[4] : Entero //Entrada Leer n[O),n[l),n[2J,n[3] //Proceso Ordenar( n ) //Salida Escrib i r n [O J, n( l],n [2],n(3] Fin
- 284. Capítulo 9: SubAigoritmos(procedimientos y funciones) Diagrama de flujo Ordenar ( rnicio ! tmp, i , j , LI , LS . Entero . ! num (4] . Entero . ! 1 Leer num j ! LI - o LS - 3 ! i-LI F i< LS 1 i-i+1 ¡v j-LI F j<-LS 1 j-j+l l_v F num(j]>num(j+1...,_ V tmp - num [ j l num ( j J ·- num[ j+1) num[j+1) - tmp ! /Escribir num/ ! ( Fin ) SubAigoritmo Pseudocódigo Procedimiento Ordenar(S:num[ ] :Entero) //Variables locales tmp, i , j , LI , LS : Entero //Proceso LI O LS - 3 Para i-LI Hasta LS-1 Inc 1 Para j-LI Hasta LS-1 Inc 1 Si num[j ]>num[j+l] Entonces tmp- num[j] num(j] - num[j+ l ] num[j+l] - tmp Fin Si Fin Para Fin Para //Salida Escribir num Fin Procedimiento
- 285. Algoritmos con java Codificación: ............................................................................................................................................................................................................ ·import java . util . Scanner; public class Problema102 { //Principal } public static void main (Stri ng[) args) { //Variables } int tmp , i , j , LI , LS ; //Arreglos int n () = new int ( 4) ; //Entrada Scanner teclado = new Scanner(System . in) ; System . out . print(" Numero 1 : " ) ; n(O] = teclado . nextint() ; System . out . print( " Numero 2 : " ) ; n[l) = teclado . nextint() ; System . out . prin t( " Numero 3 : " ) ; n [2 ) = teclado . nextin t () ; System . out . pri nt( " Numero 4 : " ) ; n [3 ] = teclado . nextin t () ; //Proceso Ordenar (n) ; //Salida System . out . pri ntln( "'' ) ; System . out . pri ntln( "Ordenado" ) ; System . out . println( " Numero 1 : " + n[O) ) ; System . out . println( " Numero 2 : " + n[l) ) ; System . out . println( " Numero 3 : " + n[2) ) ; System . out . print ln( " Numero 4 : " + n[3)) ; //Método Ordenar private static void Ordenar (in t num[)) { //Variables } int tmp, i , j , LI , LS ; //Arreglos int n () = num ; //Proceso LI = O; LS - n . length - 1 ; for(i = LI ; i <= LS - 1 ; i++) { for(j = LI ; j <= LS- 1 ; j++ ) { } if(n[ j ) > n ( j + 1 )) { tmp = n [ j] ; } } //Salida num = n ; n [j) = n[j + 1) ; n [j + 1 ) = tmp; .............................................................................................................................................................................................................
- 286. Capítulo 9: SubAigoritmos(procedimientos y funciones) Problema n.2 103 - Enunciado: Ingrese 6 números en una matriz de 3x2 y obtenga el numero mayor ingresado. Cree una función para resolver el problema. Mayor{E:num[] :Entero):Entero Interfaz de usuario '; C:ARCHIV-1XINOXS- 1.JC., I¡]EJ Diagrama de flujo ( Inicio ) ! m : Entero ¡ n[3 ] [2] : Entero + ~ Leer n[OJ (O J , n[OJ [1 ~~ n[l] [0],n[1] [1 ], n [2 ] [O],n [2 ] [1] ¡ m - Mayor(n) ! / Escribir num / ! ( Fin ) 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
- 287. Algoritmos con java Diagramade flujo Mayor ( Inicio } l m, i , j : Entero ! num(JJ 121 . Entero . ! / Leer num / ! m . num(OJ 101 l i - o F i<a2 i. i+l ¡v j. o j<•l F j. j+1 l v F -num(il (ji >~ ¡ v m - num(il (j] l j Escribir m/ ! ( Fin SubAigoritmo Pseudocódigo Funcion Mayor(E:num[] []:Entero) :Entero //Variables locales m, i , j : Entero //Arreglos (Matriz) num[3] [2] : Entero //Proceso m ~ num[O] [0] Para i-0 Hasta 2 Inc 1 Para j-0 Hasta 1 Inc 1 Si num[i] [j]>m Entonces m - num[i] [j] Fin Si Fin Para Fin Para 1/Salida Escribir m Fin Funcion
- 288. Capítulo 9: SubAigoritmos(procedimientos y funciones) Codificación: ..........................................................................................................................................................................................................··. · import java . util . Scanner; public class Problema103 { //Principal } public static void main(String[) args) { //Variables } int m; //Arreglos int n [] [) - new int [ 3) [ 2) ; //Entrada Scanne r teclado= new Scanner(System . in) ; System . out .print( " Numero (0 , 0 ) : " ) ; n [0 ) [0 ) = t eclado . nextint () ; System . out . print (" Numero (0 , 1 ) : " ) ; n (O J [1 ) = teclado . nextint () ; System . out . print (" Numero (1 , 0) : ") ; n[1) [0 ) = teclado . nex tint () ; System . out . pri nt( " Numero (1 , 1) : " ) ; n [1 ) [1) = t eclado . nextint () ; System . o ut . print( " Numero (2 , 0) : '' ) ; n [ 2) [0 ) = teclado . nextint () ; System . out . print (" Numero (2 , 1 ) : " ) ; n[2) [1) = teclado . nextint() ; // Proceso m = Mayo r (n) ; 1/Salida System . out . println( "" ) ; System . out . pri ntln( "Mayor : " +m) ; //Método Mayor private static int Mayor(int num [) [)) { //Variables } in t m, i , j ; //Proceso m = num[O) [0 ) ; for (i = O; i <=2 ; i++) 1 } for (j = O; j<=l ; j ++) { if(num [ i) [j ) >m) m = num ( i )[j ] ; } //Sal ida return m;
- 289. Algoritmos con java Probleman.2 104 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. Mayor{E:num[] :Entero):Entero Diagrama de flujo Principal ( Inicio ) ! a[1) [1] : Entero b[1) [1] . Entero . C(1) [ 1] . Entero . ! Leer a(O] (O),a(O] (1), a[1) [0),a(1) (1), 1 b[O) [OJ,b[O] (1), 1 b[1] (OJ,b[1] [1] 1 ! e- SumaArreg1os (a , b , ) ! ~~ Escribir :~ c(OJ (OJ,c(OJ ( 1 ] c(1] [0J,c(1] ( 1 ] ! ( Fin ) Interfaz de usuario Algoritmo Pseudocódigo Principal Inicio //Arreglos (Matriz) a [ 11 [11 Entero b[11 [11 Entero c [ 11 [1 1 Entero //Entrada Lee r a [ O1 [ O11 a [ O1 [ 11 1 a[11 [01 ~ a[ 1 1 [ 1 11 b[0 1 [ 01 1 b[01 [11 1 b[1 1 [01 l b[ 1 1 ( 1 1 //Proceso e- S umaA rreg l os < a ~ b > //Salida Esc r ibi r c[01 [OJ,c[OJ [ 1], c(1] [0] 1 c [ 1] (1 ] Fin
- 290. Capítulo 9: SubAigoritmos(procedimientos y funciones) Algoritmo Diagrama de flujo SumaArreglos ( Inicio ) l i , j : Entero ! ArrA[11 [1] . Entero . ArrB [ 1] [1] . Entero . s(1] [1] . Entero . l / Leer ArrA, ArrB/ l i-0 F i<-1 i-i+l ¡v j-0 F j<-1 j - j+l F s[i] [ j]-ArrA [i ) (j)+ArrB[i) (j ) l l l / Escribir s / l ( Fin Codificación: import java . util . Scanner; public class Problema104 { //Pri.nci.pal Funci.on []:Entero, [l Pseudocódigo SumaArreglos (E :ArrA[] E:ArrB[] []:Entero) :Entero[] //Vari.ables locales i , j : Entero //Arreglos (Matri.z) s [11 [11 : Entero //Proceso Para i-0 Hasta 1 Inc 1 Para j-0 Hasta 1 Inc 1 s [i) [ j 1-ArrA[i 1 [ j) +ArrB [i) [ j ] Fin Para Fin Para //Sali.da Retornar s Fi.n Funci.on public static void main{String[) args) { //Arreglos int a 1l [ l - new int [21 (2] ; int b ( 1[) = new int [2 1 (2 ) ; int e ( J [ J - new int [21 [2) ; //Entrada Scanner teclado= new Scanner{System . in) ; System . out . println( " Arreglo A: " ) ; System . out . println( " =========== : " ) ; System . out . pri nt( " Numero (0 , 0) : " ) ; ... ..........................................................................................................................................................................................................
- 291. ) ) Algoritmos con java a[O][0 ] = teclado . nextint () ; System . out . print( " Numero (0 , 1) : " ) ; a[O] [1] = teclado . nextint() ; System . out . print( " Numero (1 , 0) : " ) ; a[1] [0 ] = teclado . nextint() ; System . out . print( " Numero (1 , 1) : " ) ; a [1] [1] = teclado . next Int () ; System . out . println( ''" ) ; System . out . println( " Arreglo B : " ) ; System . out . println( " =========== : '' ) ; System . out . print( " Numero (0 , 0) : " ) ; b [O] [0] = teclado . next!nt () ; System . out . print (" Numero (0 , 1 ): " ) ; b [OJ [1 ] = teclado . next!nt () ; System . out . print (" Numero (1 , 0) : " ) ; b [1] [0 ] = teclado . nextint () ; System . out . print (" Numero (1 , 1 ) : " ) ; b [1 ] [1 ] = teclado . nextint () ; //Proceso e= SumaArreglos(a, b) ; 11Salida System . out . println( "'' J ; System . out . println( " Arreglo C : " ) ; System . out . println( " =========== : " ) ; System . out . println( " Numero (0 , 0) : " + c[O ] [0] ) ; System . out . println( " Numero (0 , 1) : " + c[O] [1] ) ; System . out . println( " Numero (1 , 0) : " + c[1 ] [0 ] ) ; System . out . println( " Numero (1 , 1) : " + c[1] [1] ) ; //Método SumaArreglos private static i nt [ ] [] SumaArreglos ( int ArrA [ ] [ ] , int ArrB [] [ ] ) { //Variables } int i , j ; //Arreglos int s[] [] - new int[2] [2] ; //Proceso for (i = O; i<=1 ; i+ +) { for ( j = O; j<=1 ; j++) s[i] (j ] = ArrA(i] [ j] + ArrB [ i] [j] ; ) //Salida return s ; •., ..........................................................................................................................................................................................................
- 292. Capítulo 9: SubAigoritmos(procedimientos y funciones) Enunciado: Dado una frase devolver la frase sin espacio en blancos. Cree una función para resolver el problema. Principal FraseSinEspacios(E:Frase:Cadena):Cadena Interfaz de usuario ". C:ARCHIV-1XINOXS-1UCREAT-1GE2001 .... 111aEJ Diagrama de flujo Inicio fl , f2 : Cadena Algoritmo Pseudocódigo Principal Inicio //Variables fl , f2 : Cadena //Entrada Leer f l f2-FraseSinEspacios(fl ) //Proceso Escribir f2 Fin f2- Fr aseSinEspacios (f l) //Salida Esc rib i r f2 Fin
- 293. Algoritmos con java Diagramade flujo FrasesSinEspacios ( Inicio ) Frase, f , t . Cadena . i , p . Entero . l / Leer Frase / l p - o Frase -Recortar(Frase) l i-0 i< Longitud(Frase)-1 i-i+l 1 Extraer(Frase, i , l) " " t -Extraer(Frase , p , i-p) p -i + 1 f -f + t l t - Extraer(Frase , p , i-p) f -f + t l 1 Escribir f 1 + Fin J Algoritmo Pseudocódigo Funcion FraseSinEspacios (E:Frase:Cadena) :Cadena //Variables f2 , t : Cadena i , p : Entero //Proceso p - o 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 - l. + 1 f - f + t Fin Si Fin Para t - Extraer{Frase , p , i-p) f - f + t //Salida Retornar f Fin Funcion
- 294. Capítulo 9: SubAigoritmos(procedimientos y funciones) Codificación: · import java . util.Scanner ; public class ProblemalOS { //Principal 1 public static void main(String[] args) { //Variables 1 String fl , f2 ; //Entrada Scanner teclado= new Scanner(System . in) ; System . out . print( " Frase : " ) ; fl = teclado . nextLine() ; //Proceso f2 = FraseSinEspacios ( fl) ; 1/Salida System . out . println( "'' J ; System . out . println("Frase sin espacios : " + f2) ; //Método FraseS i nEspacios private static String FraseSinEspacios(String Frase) ( //Variables 1 String f - int i, p ; //Proceso p = O; " " t · ' ' Frase= Frase . trim( ) ; for (i = O; i<Frase . length () ; i ++) { } if(Frase . substring(i , i+l) . equals( " " )) { t = Frase . substring (p , i) ; p - i + 1 ; f - f + t ; ) t - Frase . substring (p , i) ; f - f + t ; //Salida return f ; ......................' .......................................................................................................................................................................................
- 295. Algoritmos con java 9.7Problemas propuestos Los siguientes problemas le servirán para medir su aprendizaje, es importante que los resuelva. Propuesto n.º 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.º 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.273 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 5 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.274 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.º 75 Enunciado: Dado un carácter, determinar si es vocal, let ra mayúscula, letra minúscula, número o símbolo. Recuerde: Crear un procedimiento que realice la tarea. Propuesto n.º 76 Enunciado: Hallar el área de un rectángulo, cree una función para realizar dicha tarea. AreaRectangulo(E:Base:Rea1 , E:Altura :Rea1):Real
- 296. Capítulo 9: SubAigoritmos(procedimientos y funciones) Propuesto n.º 77 Enunciado: Un negocio tiene dos tipos de cliente: público en general (G) y cliente afiliado (A). Acepta dos formas de pago: al contador (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. 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.º 78 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 321; si ingresa 12345, número invertido 54321. Recuerde: Crear una función que realice la tarea . Propuesto n.279 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. Recuerde: Crear una función que realice la tarea. Propuesto n.280 Enunciado: Cree una matriz de A de 2x2 y otra B de 2x2, y obtenga una matriz C =A • B. Recuerde: Crear una función que realice la tarea.
- 297.