Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
--------------------------------------------------------------------------
T1.GIF TEMA 1
--------------------------------------------------------------------------
--------------------------------------------------------------------------
PROGRAMA contador1
ENTORNO:
c <- 0
ALGORITMO:
Borrar_pantalla( )
ESCRIBIR c
c <- c + 1
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
decreciente.
PROGRAMA contador2
ENTORNO:
c <- 100
ALGORITMO:
Borrar_pantalla( )
ESCRIBIR c
c <- c - 1
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA pares
ENTORNO:
c <- 2
ALGORITMO:
Borrar_pantalla( )
ESCRIBIR c
c <- c + 2
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA suma
ENTORNO:
c <- 1
suma <- 0
ALGORITMO:
Borrar_pantalla( )
c <- c + 1
FINMIENTRAS
ESCRIBIR suma
FINPROGRAMA
--------------------------------------------------------------------------
5.-Hacer un pseudocódigo que imprima los numeros impares hasta el 100 y que
PROGRAMA impares
ENTORNO:
c <- 1
son <- 0
ALGORITMO:
Borrar_pantalla( )
ESCRIBIR c
c <- c + 2
FINMIENTRAS
ESCRIBIR son
FINPROGRAMA
--------------------------------------------------------------------------
6.-Hacer un pseudocodigo que imprima todos los numeros naturales que hay
PROGRAMA natural
ENTORNO:
i <- 0
n <- 0
ALGORITMO:
Borrar_pantalla( )
LEER n
i <- i + 1
ESCRIBIR i
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA frases
ENTORNO:
c <- 0
ALGORITMO:
Borrar_pantalla( )
LEER frase
c <- c + 1
LEER res
FINMIENTRAS
ESCRIBIR c
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA sn
ENTORNO:
ALGORITMO:
Borrar_pantalla( )
LEER res
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA signo
ENTORNO:
num <- 0
ALGORITMO:
Borrar_pantalla( )
LEER num
SINO
FINSI
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA paridad
ENTORNO:
num <- 0
ALGORITMO:
Borrar_pantalla( )
LEER num
SI num = int( num / 2 ) * 2 ENTONCES
SINO
FINSI
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA multiplo3
ENTORNO:
i <- 3
n <- 0
c <- 0
ALGORITMO:
Borrar_pantalla( )
LEER n
SI i = int( i / 3 ) * 3 ENTONCES
ESCRIBIR i
c <- c + 1
FINSI
i <- i + 1
FINMIENTRAS
ESCRIBIR c
FINPROGRAMA
--------------------------------------------------------------------------
12.-Hacer un pseudocodigo que imprima los numeros del 1 al 100. Que calcule la
suma de todos los numeros pares por un lado, y por otro, la de todos los
impares.
PROGRAMA par_impar
ENTORNO:
i <- 1
sumapar <- 0
sumaimp <- 0
ALGORITMO:
Borrar_pantalla( )
SINO
FINSI
i <- i + 1
FINMIENTRAS
ESCRIBIR sumapar
ESCRIBIR sumaimp
FINPROGRAMA
--------------------------------------------------------------------------
13.-Imprimir y contar los numeros que son multiplos de 2 o de 3 que hay entre
1 y 100.
PROGRAMA multiplo_2_3
ENTORNO:
i <- 1
c <- 0
ALGORITMO:
Borrar_pantalla( )
c <- c + 1
ESCRIBIR i
FINSI
i <- i + 1
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA mayor_menor
ENTORNO:
con <- 0
n <- 0
maximo <- 0
ALGORITMO:
Borrar_pantalla( )
LEER n
maximo = n
FINSI
minimo <- n
FINSI
FINMIENTRAS
ESCRIBIR maximo
ESCRIBIR minimo
FINPROGRAMA
--------------------------------------------------------------------------
15.-Introducir dos numeros por teclado. Imprimir los numeros naturales que
hay entre ambos numeros empezando por el m s pequeño, contar cuantos hay y
PROGRAMA par_impar
ENTORNO:
num1 <- 0
num2 <- 0
aux <- 0
son <- 0
pares <- 0
sumaimpa <- 0
ALGORITMO:
Borrar_pantalla( )
LEER num1
LEER num2
FINSI
ESCRIBIR num1
FINSI
FINMIENTRAS
ESCRIBIR son
ESCRIBIR pares
ESCRIBIR sumaimpa
FINPROGRAMA
--------------------------------------------------------------------------
TEMA 2
--------------------------------------------------------------------------
--------------------------------------------------------------------------
PROGRAMA diez
ENTORNO:
serie <- 0
ALGORITMO:
Borrar_pantalla( )
numero <- 1
ESCRIBIR numero
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
17.-Imprimir, contar y sumar los multiplos de 2 que hay entre una serie de
PROGRAMA multiplo2
ENTORNO:
ALGORITMO:
Borrar_pantalla( )
c <- 0
sum <- 0
num1 <- 0
LEER num1
LEER num2
FINMIENTRAS
ESCRIBIR num1
c <- c + 1
sum <- sum + num1
FINSI
FINMIENTRAS
ESCRIBIR c
ESCRIBIR sum
LEER res
FINMIENTRAS
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
18.-Hacer un pseudocodigo que cuente las veces que aparece una determinada
PROGRAMA letra
ENTORNO:
longitud <- 0
a <- 0
ALGORITMO:
LEER frase
i <- 1
LEER letra
a <- a + 1
FINSI
i <- i + 1
FINMIENTRAS
Borrar_pantalla( )
ESCRIBIR letra
ESCRIBIR frase
ESCRIBIR a
LEER res
FINMIENTRAS
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
19.-Hacer un pseudocodigo que simule el funcionamiento de un reloj digital y
PROGRAMA reloj
ENTORNO:
horas <- 0
minutos <- 0
segundos <- 0
ALGORITMO:
Borrar_pantalla( )
LEER horas
LEER minutos
LEER segundos
ESCRIBIR horas
ESCRIBIR minutos
ESCRIBIR segundos
FINMIENTRAS
segundos <- 0
FINMIENTRAS
minutos <- 0
FINMIENTRAS
horas <- 0
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA factorial
ENTORNO:
ALGORITMO:
Borrar_pantalla( )
factorial <- 1
LEER numero
SINO
HACER Calculos
FINSI
HACER Mas
FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Calculos
HACER Imprimir
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Mas
LEER res
FINMIENTRAS
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Imprimir
ESCRIBIR factorial
FINSUBPROGRAMA
--------------------------------------------------------------------------
21.-Hacer un programa que calcule independientemente la suma de los pares y
PROGRAMA suma
ENTORNO:
par <- 0
impar <- 0
sw <- 0
i <- 1
ALGORITMO:
Borrar_pantalla( )
SI sw = 0 ENTONCES
sw <- 1
SINO
sw <- 0
FINSI
i <- i + 1
FINMIENTRAS
ESCRIBIR par
ESCRIBIR impar
FINPROGRAMA
--------------------------------------------------------------------------
TEMA 3
--------------------------------------------------------------------------
--------------------------------------------------------------------------
derecha.
PROGRAMA frase
ENTORNO:
ALGORITMO:
Borrar_pantalla( )
fi <- 8
co <- 15
veces <- 0
co <- co + 4
fi <- fi + 1
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
ENTORNO:
c <- 0
ALGORITMO:
Borrar_pantalla( )
fi <- 7
col <- 5
EN fi,col ESCRIBIR c
c <- c + 1
fi <- fi + 2
col <- 5
FINSI
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA primo
ENTORNO:
ALGORITMO:
Borrar_pantalla( )
numero <- 0
sw <- 0
FINMIENTRAS
i <- numero - 1
sw = 1
SINO
i <- i - 1
FINSI
FINMIENTRAS
SI sw = 1 ENTONCES
SINO
FINSI
HACER Mas
FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Mas
LEER res
FINMIENTRAS
FINSUBPROGRAMA
--------------------------------------------------------------------------
PROGRAMA romano
ENTORNO:
ALGORITMO:
Borrar_pantalla( )
num <- 0
FINMIENTRAS
col <- 15
FINMIENTRAS
FINSI
FINSI
MIENTRAS num >= 100 HACER
FINMIENTRAS
FINSI
FINSI
FINSI
FINMIENTRAS
SI num = 9 ENTONCES
FINSI
FINSI
FINSI
FINMIENTRAS
HACER Mas
FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Mas
LEER res
FINMIENTRAS
FINSUBPROGRAMA
--------------------------------------------------------------------------
ENTORNO:
ALGORITMO:
Borrar_pantalla( )
HACER Mas
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA tabla
ENTORNO:
num <- -1
ALGORITMO:
HACER Numero
Borrar_pantalla( )
i <- 0
fi <- 8
fi <- fi + 1
i <- i + 1
FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Numero
Borrar_pantalla( )
FINMIENTRAS
FINSUBPROGRAMA
--------------------------------------------------------------------------
TEMA 4
--------------------------------------------------------------------------
--------------------------------------------------------------------------
o cruz.
PROGRAMA moneda
ENTORNO:
ALGORITMO:
Borrar_pantalla( )
SI Rnd( ) <= 0.5 ENTONCES
SINO
FINSI
HACER Mas
FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Mas
FINMIENTRAS
FINSUBPROGRAMA
--------------------------------------------------------------------------
29.-Simular cien tiradas de dos dados y contar las veces que entre los dos
suman 10.
PROGRAMA dado
ENTORNO:
c <- 0
i <- 0
ALGORITMO:
Borrar_pantalla( )
FINSI
i <- i + 1
FINMIENTRAS
EN 10,48 ESCRIBIR c
FINPROGRAMA
--------------------------------------------------------------------------
30.-Simular una carrera de dos caballos si cada uno tiene igual probabilidad
de ganar.
PROGRAMA caballos
ENTORNO:
col1 <- 4
col2 <- 4
ALGORITMO:
Borrar_pantalla( )
SINO
FINMIENTRAS
SINO
FINSI
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA menu1
ENTORNO:
op <- 0
ALGORITMO:
EN 10,29 LEER n1
EN 12,29 LEER n2
op <- 0
Borrar_pantalla( )
EN 22,39 LEER op
Borrar_pantalla( )
HACER CASO
CASO op = 1
EN 10,33 ESCRIBIR n1 + n2
Pausa( )
CASO op = 2
EN 10,33 ESCRIBIR n1 - n2
Pausa( )
CASO op = 3
EN 10,33 ESCRIBIR n1 * n2
Pausa( )
CASO op = 4
EN 10,33 ESCRIBIR n1 / n2
Pausa( )
FINCASO
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
32.-Hacer un programa que nos permita introducir un numero por teclado y sobre
ENTORNO:
op <- 0
ALGORITMO:
EN 10,29 LEER n
op <- 0
Borrar_pantalla( )
EN 22,39 LEER op
HACER CASO
CASO op = 1
HACER Primo
CASO op = 2
HACER Factorial
CASO op = 3
HACER Tabla
FINCASO
FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Primo
sw <- 0
i <- n - 1
sw <- 1
SINO
i <- i - 1
FINSI
FINMIENTRAS
Borrar_pantalla( )
SI sw = 1 ENTONCES
SINO
FINSI
Pausa( )
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Factorial
fac <- 1
Borrar_pantalla( )
SI n < 0 ENTONCES
SINO
n <- n - 1
FINMIENTRAS
FINSI
Pausa( )
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Tabla
i <- 0
fi <- 10
Borrar_pantalla( )
EN fi,10 ESCRIBIR n
EN fi,20 ESCRIBIR i
EN fi,30 ESCRIBIR n * i
i <- i + 1
FINMIENTRAS
Pausa( )
FINSUBPROGRAMA
--------------------------------------------------------------------------
TEMA 4
--------------------------------------------------------------------------
Arrays unidimensionales
--------------------------------------------------------------------------
distinta.
PROGRAMA nombres
ENTORNO:
DIMENSIONA datos[ 20 ]
i <- 1
ALGORITMO:
Borrar_pantalla( )
fi <- 10
i <- i + 1
FINMIENTRAS
Borrar_pantalla( )
i <- 1
fi <- 3
fi <- fi + 1
i <- i + 1
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA notamedia
ENTORNO:
DIMENSIONA notas[ 10 ]
suma <- 0
media <- 0
ALGORITMO:
Borrar_pantalla( )
fi <- 7
PARA i DESDE 1 HASTA 10 HACER
EN fi,20 ESCRIBIR i
fi <- fi + 1
FINPARA
FINPARA
FINPROGRAMA
--------------------------------------------------------------------------
vector.
PROGRAMA buscar
ENTORNO:
i <- 0
num <- 0
ALGORITMO:
Borrar_pantalla( )
LEER num
ITERAR
i <- i + 1
FINSI
FINITERAR
ESCRIBIR i
SINO
FINSI
FINPROGRAMA
--------------------------------------------------------------------------
TEMA 5
--------------------------------------------------------------------------
Arrays bidimensionales
--------------------------------------------------------------------------
y 100, e imprimirla.
PROGRAMA matriz
ENTORNO:
DIMENSIONAR A[ 4, 5 ]
i <- 1
fi <- 10
co <- 15
ALGORITMO:
Borrar_pantalla( )
j <- 1
MIENTRAS j <= 5 HACER
EN fi,co ESCRIBIR A[ i, j ]
co <- co + 5
j <- j + 1
FINMIENTRAS
co <- 15
fi <- fi + 2
i <- i + 1
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA transpuesta
ENTORNO:
DIMENSIONAR A[ 4, 5 ]
DIMENSIONAR B[ 5, 4 ]
fi <- 8
co <- 10
fit <- 8
cot <- 40
i <- 1
ALGORITMO:
Borrar_pantalla( )
B[ j, i ] <- A[ i, j ]
EN fi,co ESCRIBIR A[ i, j ]
EN fit,cot ESCRIBIR B[ j, i ]
co <- co + 4
j <- j + 1
FINMIENTRAS
fi <- fi + 2
co <- 10
fit <- 8
i <- i + 1
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
38.-Cargar en una matriz las notas de los alumnos de un colegio en funcion del
PROGRAMA notas
ENTORNO:
i <- 1
j <- 1
ALGORITMO:
Borrar_pantalla( )
EN 10,39 LEER M
EN 12,20 ESCRIBIR "N£mero de alumnos: "
EN 12,40 LEER N
DIMENSIONAR A[ M, N ]
Borrar_pantalla( )
EN 10,32 ESCRIBIR i
EN 14,33 ESCRIBIR j
EN 16,32 LEER A[ i, j ]
j <- j + 1
FINMIENTRAS
i <- i + 1
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
PROGRAMA ordenar
ENTORNO:
i <- 1
j <- 1
fi <- 10
co <- 15
M <- 0
N <- 0
ALGORITMO:
Borrar_pantalla( )
EN 10,27 LEER M
EN 12,30 LEER N
DIMENSIONAR A[ M, N ]
Borrar_pantalla( )
EN fi,co ESCRIBIR A[ i, j ]
co <- co + 5
j <- j + 1
FINMIENTRAS
co <- 15
fi <- fi + 2
i <- i + 1
FINMIENTRAS
sw <- 1
sw <- 0
i <- 1
HACER Cambios
FINSI
i <- i + 1
FINMIENTRAS
FINMIENTRAS
FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Cambios
j <- 1
A[ i + salto, j ] <- A[ i, j ]
A[ i, j ] <- aux
j <- j + 1
FINMIENTRAS
sw <- 1
FINSUBPROGRAMA
--------------------------------------------------------------------------
TEMA 6
--------------------------------------------------------------------------
Arrays multidimensionales
--------------------------------------------------------------------------
imprimirla.
PROGRAMA tabla
ENTORNO:
DIMENSIONAR A[ 3, 4, 5 ]
i <- 1
j <- 1
k <- 1
b <- 0
fi <- 8
co <- 12
ALGORITMO:
Borrar_pantalla( )
EN fi,co + 24 ESCRIBIR i
fi <- fi + 2
b <- b + 1
A[ i, j, k ] <- b
EN fi,co ESCRIBIR A[ i, j, k ]
co <- co + 4
k <- k + 1
FINMIENTRAS
fi <- fi + 2
co <- 12
j <- j + 1
FINMIENTRAS
Pausa( )
i <- i + 1
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
41.-Se dispone de una tabla de 5 p ginas, 10 filas y 20 columnas, que se
su centro de pertenencia.
PROGRAMA notas
ENTORNO:
max <- -1
sum <- 0
centro <- 0
i <- 1
j <- 1
k <- 1
fi <- 10
ALGORITMO:
Borrar_pantalla( )
k <- k + 1
FINMIENTRAS
j <- j + 1
FINMIENTRAS
EN fi,20 ESCRIBIR i
fi <- fi + 2
FINSI
i <- i + 1
FINMIENTRAS
FINPROGRAMA
--------------------------------------------------------------------------
42.-Una empresa guarda en una tabla de 3x12x4 las ventas realizadas por sus
ventas, TOTAL[ mes, producto ], para lo cual sumamos las ventas de cada
PROGRAMA ventas
ENTORNO:
ALGORITMO:
HACER Volcar
HACER Imp_Tres
HACER Imp_Dos
FINPROGRAMA
------------------------------
SUBPROGRAMA Volcar
j <- 1
MIENTRAS j <= 12 HACER
k <- 1
i <- 1
suma <- 0
i <- i + 1
FINMIENTRAS
k <- k + 1
FINMIENTRAS
j <- j + 1
FINMIENTRAS
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Imp_Tres
i <- 1
Borrar_pantalla( )
fi <- 8
co <- 12
EN fi,co + 26 ESCRIBIR i
fi <- fi + 2
j <- 1
k <- 1
co <- co + 4
k <- k + 1
FINMIENTRAS
fi <- fi + 2
co <- 12
j <- j + 1
FINMIENTRAS
Pausa( )
i <- i + 1
FINMIENTRAS
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Imp_Dos
Borrar_pantalla( )
j <- 1
fi <- 10
co <- 16
k <- 1
co <- co + 4
k <- k + 1
FINMIENTRAS
fi <- fi + 2
co <- 12
j <- j + 1
FINMIENTRAS
FINSUBPROGRAMA
--------------------------------------------------------------------------
TEMA 7
--------------------------------------------------------------------------
Ficheros
--------------------------------------------------------------------------
PROVINCIA.
PROGRAMA altas
ENTORNO:
ALGORITMO:
ABRIR "DATOS.DAT"
sw <- 0
num <- 0
Borrar_pantalla( )
Pausa( )
sw <- 1
SINO
Siguiente_registro( )
FINSI
FINMIENTRAS
SI sw = 0 ENTONCES
EN 7,5 ESCRIBIR "Nombre: "
Final_fichero( )
Escribir_registro( )
FINSI
CERRAR "DATOS.DAT"
HACER Mas
FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Mas
LEER res
FINMIENTRAS
FINSUBPROGRAMA
--------------------------------------------------------------------------
PROGRAMA bajas
ENTORNO:
ALGORITMO:
ABRIR "DATOS.DAT"
sw <- 0
Borrar_pantalla( )
sw <- 1
SINO
ABRIR "AUX.DAT"
Final_fichero( )
Escribir_registro( )
FINSI
ABRIR "DATOS.DAT"
Siguiente_registro( )
FINMIENTRAS
CERRAR "DATOS.DAT"
CERRAR "AUX.DAT"
SI sw = 0 ENTONCES
BORRAR "AUX.DAT"
Pausa( )
SINO
BORRAR "DATOS.DAT"
FINSI
res = Espacios( 1 )
HACER Mas
FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Mas
LEER res
FINMIENTRAS
FINSUBPROGRAMA
--------------------------------------------------------------------------
PROGRAMA modifica
ENTORNO:
ALGORITMO:
ABRIR "DATOS.DAT"
sw <- 0
num <- 0
Borrar_pantalla( )
EN 5,10 ESCRIBIR "D.N.I.: "
HACER Imprimir
HACER Cambios
sw <- 1
SINO
Siguiente_registro( )
FINSI
FINMIENTRAS
SI sw = 0 ENTONCES
HACER Detener
FINSI
CERRAR "DATOS.DAT"
HACER Mas
FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Mas
LEER res
FINMIENTRAS
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Imprimir
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Cambios
Escribir_registro( )
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Detener
Pausa( )
FINSUBPROGRAMA
--------------------------------------------------------------------------
TEMA 8
--------------------------------------------------------------------------
--------------------------------------------------------------------------
PROGRAMA provincia
ENTORNO:
fi <- 55
c <- 0
pag <- 1
ALGORITMO:
Borrar_pantalla( )
ABRIR "DATOS.DAT"
Activar_impresora( )
SI fi = 55 ENTONCES
HACER Cabecera
FINSI
fi <- fi + 1
c <- c + 1
FINSI
Siguiente_registro( )
FINMIENTRAS
EN fi + 2,39 ESCRIBIR c
FINSI
Activar_pantalla( )
CERRAR "DATOS.DAT"
FINPROGRAMA
------------------------------
SUBPROGRAMA Cabecera
Salto_pagina( )
fi <- 9
FINSUBPROGRAMA
--------------------------------------------------------------------------
productos durante el d¡a, cuyos campos son: NART y VENTAS. Se desea hacer
un programa que liste por impresora todas las ventas realizadas durante el
d¡a.
PROGRAMA ventas
ENTORNO:
total <- 0
uno <- 0
fi <- 55
sw <- 0
aux <- 0
pag <- 1
ALGORITMO:
Borrar_pantalla( )
Activar_impresora( )
ABRIR "VENTAS.DAT"
SI fi = 55 ENTONCES
HACER Cabecera
FINSI
SI sw = 0 ENTONCES
sw <- 1
FINSI
SINO
HACER Imprimir
uno <- 0
FINSI
Siguiente_registro( )
FINMIENTRAS
HACER Imprimir
Activar_pantalla( )
CERRAR "VENTAS.DAT"
FINPROGRAMA
------------------------------
SUBPROGRAMA Imprimir
fi <- fi + 1
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Cabecera
Salto_pagina( )
fi <- 9
FINSUBPROGRAMA
--------------------------------------------------------------------------
48.-Dado el fichero secuencial ARTICULOS.DAT, cuyos campos son: NART,
campos son: NART2, VENTAS y TIPO. El campo TIPO puede tomar los valores 0
PROGRAMA modifica
ENTORNO:
entra <- 0
sale <- 0
total <- 0
fi <- 55
sw <- 0
aux <- 0
pag <- 1
ALGORITMO:
Borrar_pantalla( )
Activar_impresora( )
ABRIR "ARTICULOS.DAT"
Primer_registro( )
ABRIR "SALIDAS.DAT"
Primer_registro( )
ABRIR "VENTAS.DAT"
Primer_registro( )
SELECCIONAR "VENTAS.DAT"
SI fi = 55 ENTONCES
HACER Cabecompras
FINSI
SI sw = 0 ENTONCES
HACER Buscar
sw <- 1
FINSI
HACER Calculos
SINO
HACER Grabar
HACER Compra
entra <- 0
sale <- 0
HACER Buscar
HACER Calculos
FINSI
Siguiente_registro( )
FINMIENTRAS
HACER Grabar
HACER Compra
SELECCIONAR "SALIDAS.DAT"
fi <- 55
SI fi = 55 ENTONCES
HACER Cabesal
FINSI
SELECCIONAR "ARTICULOS.DAT"
Siguiente_registro( )
FINMIENTRAS
HACER Sale
SELECCIONAR "SALIDAS.DAT"
Siguiente_registro( )
FINMIENTRAS
Activar_pantalla( )
Cerrar_ficheros( )
BORRAR "SALIDAS.DAT"
FINPROGRAMA
------------------------------
SUBPROGRAMA Calculos
SI tipo = 0 ENTONCES
SINO
FINSI
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Grabar
SELECCIONAR "ARTICULOS.DAT"
Escribir_registro( )
SELECCIONAR "SALIDAS.DAT"
Final_fichero( )
Escribir_registro( )
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Cabecompras
Salto_pagina( )
fi <- 9
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Compra
fi <- fi + 1
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Cabesal
Salto_pagina( )
fi <- 9
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Sale
Salto_pagina( )
FINSI
fi <- fi + 1
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Buscar
SELECCIONAR "ARTICULOS.DAT"
Siguiente_registro( )
FINMIENTRAS
FINSUBPROGRAMA
--------------------------------------------------------------------------
TEMA 9
--------------------------------------------------------------------------
Algoritmo( dn ) =
cero.
de la informacion.
el archivo SINONIMOS.DAT.
------------------------------
PROGRAMA altas
ENTORNO:
ALGORITMO:
ABRIR "DATOS.DAT"
ABRIR "SINONIMOS.DAT"
dn <- 0
nom <- Espacios( 15 )
swh <- 0
sw <- 0
num <- 0
donde <- 0
i <- 0
Borrar_pantalla( )
EN 10,29 LEER dn
SELECCIONAR "DATOS.DAT"
LEER num
HACER Alta_duplicada
SINO
swh <- 1
FINSI
HACER Introducir
GRABAR num
SINO
HACER Buscar
SI sw = 0 ENTONCES
HACER Introducir
SI swh = 1 ENTONCES
GRABAR num
SINO
HACER Encontrar_sitio
SELECCIONAR "SINONIMOS.DAT"
GRABAR 1
SI i = 0 ENTONCES
SELECCIONAR "DATOS.DAT"
GRABAR num
SINO
SELECCIONAR "SINONIMOS.DAT"
FINSI
SELECCIONAR "SINONIMOS.DAT"
GRABAR donde
FINSI
SINO
HACER Alta_duplicada( )
FINSI
FINSI
FINSI
HACER Mas
FINMIENTRAS
Cerrar_ficheros( )
FINPROGRAMA
------------------------------
SUBPROGRAMA Introducir
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Encontrar_sitio
SELECCIONAR "SINONIMOS.DAT"
LEER 1
LEER donde
SINO
FINSI
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Buscar
i <- 0
SELECCIONAR "SINONIMOS.DAT"
Pausa( )
sw <- 1
SINO
FINSI
FINSI
FINMIENTRAS
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Alta_duplicada
Pausa( )
FINSUBPROGRAMA
--------------------------------------------------------------------------
programa que nos permita listar por pantalla todos los registros del
PROGRAMA listar
ENTORNO:
fi <- 22
ALGORITMO:
SI fi = 22 ENTONCES
HACER Cabecera
FINSI
fi <- fi + 1
SI fi = 20 ENTONCES
Pausa( )
fi <- 22
FINSI
Siguiente_registro( )
FINMIENTRAS
CERRAR "DATOS.DAT"
Cerrar_indices( )
FINPROGRAMA
------------------------------
SUBPROGRAMA Cabecera
Borrar_pantalla( )
fi <- 5
FINSUBPROGRAMA
--------------------------------------------------------------------------
indexado por el campo DNI. Crear un programa que nos permita consultar un
PROGRAMA consulta
ENTORNO:
ALGORITMO:
num <- 0
Borrar_pantalla( )
BUSCAR num
SI Encontrado( ) ENTONCES
SINO
Pausa( )
FINSI
HACER Mas
FINMIENTRAS
CERRAR "DATOS.DAT"
Cerrar_indices( )
FINPROGRAMA
Proceso Ejercicio1
Escribir "Lado1"
Leer lado1
Escribir "Lado2"
Leer lado2
Escribir lado1*2+lado2*2
Sino
Fin Si
Escribir lado1*lado2
Leer lado1
Leer lado2
Leer lado3
Si Lado1=lado2 y lado2=lado3
Entonces
Escribir 3*lado1
Escribir "Es un triangulo equilatero"
Sino
Escribir 2*lado1+lado3
Sino
Escribir lado1+lado2+lado3
Fin Si
Fin Si
//Una vez averiguado que clase de triangulo es y los datos de los lados habremos sacado la
base y la altura.
Leer base
Leer altura
Escribir (base*altura)/2
FinProceso
Proceso Ejercicio2
result<-(a*2+l*2);
Leer a
Leer l
Si a>0 y l>0 Entonces
Escribir (a*2+l*2)*3;
Sino
Fin Si
FinProceso
EJERCICIO 3. Diseñar un algoritmo según los siguientes datos: Un piso de xx metros por xx
metros se debe cubrir con baldosas de cerámicas. ¿Cuántas baldosas se necesitan si se sabe
que 16 baldosas cubren 1 m2?
Proceso Ejercicio3
Leer a
Leer b
Escribir a+b
Escribir (a+b)*16
Sino
Fin Si
FinProceso
Proceso Ejercicio4
Escribir "Escriba el primer valor"
Leer a
Leer b
Leer c
Sino
Sino
Fin Si
Fin Si
FinProceso
pseint
Proceso Ejercicio5
Sal<-"s"
Leer Sueldo;
Si Sueldo>500000 Entonces
Aumento=12;
Sino
Aumento=15;
Fin Si
NSueldo=Sueldo+(Sueldo/100)*Aumento
Leer Sal
Fin Mientras
FinProceso
Proceso Ejercicio6
Sal<-"s"
Leer N
Si N>0 Entonces
Fin Si
Si N<0 Entonces
Fin Si
Si N=0 Entonces
Fin Si
Leer Sal
Fin Mientras
FinProceso
(Con este programa podrás saber si el número en el que pensás está en el rango establecido o
no. Rango: 35 a 50 ó 65 a 90.)
Proceso Ejercicio1
Sal<-"s"
Escribir "Con este programa podrás saber si el número en el que pensás está en el rango
establecido o no. Rango: 35 a 50 ó 65 a 90. ";
leer a;
Sino
FinSi
Leer Sal
Fin Mientras
FinProceso
(Con este programa sabrás fácilmente si el número en el que pensás es par o impar.
Proceso Ejercicio2
Sal<-"s"
Escribir "Con este programa sabrás fácilmente si el número en el que pensás es par o impar.";
leer a;
Sino
FinSi
Leer Sal
Fin Mientras
FinProceso
Proceso Ejercicio3
leer nom;
leer snom;
leer ape;
leer edad;
Escribir "Tu nombre completo es:" nom," " snom," " ape," " edad
Fin Proceso
Proceso Ejercicio4
Sal<-"s"
Escribir "Con este programa sabrás si la letra que escribes es consonante o vocal. "
Leer letra
Si letra ="a" O letra="e" o letra= "i" o letra ="o" O letra="u" O letra="A" O letra="E" O letra="I"
O letra="O" O letra="U" o letra=" " Entonces
Sino
Fin Si
Leer Sal
Fin Mientras
FinProceso
Proceso Ejercicio5
num1 <-0
num2<-0
op<-0
result<-0
Sal<-"s"
Escribir "Calculadora"
Escribir "Ingrese primer número"
Leer num1
Leer num2
Leer op;
Si op=1 Entonces
result<-num1+num2
Sino
si op=2 Entonces
result<-num1-num2
Sino
si op=3 Entonces
sino
si op=4 Entonces
result<-num1/num2
Sino
FinSi
FinSi
FinSi
FinSi
Leer Sal
Fin Mientras
FinProceso
ACTUALIZADO 8/10/2014
EJERCICIO 1. En este ejercicio corregir el ingreso de las notas para que estas estén dentro de
los valores correspondientes (1 al 10). También indicar el nombre de la materia, y que se
pueda hacer el cálculo del promedio para 3 materias, y el ingreso de notas sean 3 (Trab-pract,
evaluación y concepto).
Proceso Ejercicio1
Sal<-"s"
Leer a;
Leer m1;
Leer n1;
Leer m2;
Leer n2;
Leer m3;
Leer n3;
Escribir (n1+n2+n3)/3;
Sino
Escribir "Reescriba las notas" ;
Leer m1;
Leer n1;
Leer m2;
Leer n2;
Leer m3;
Leer n3;
FinSi
Leer Sal
FinMientras
FinProceso
Proceso Pitágoras
resp<-'s'
Leer a;
Leer b;
c<-(rc(a^2+b^2))
Escribir 'la hipotenusa es:',c;
Leer resp
FinMientras
FinProceso
Proceso Ejercicio2
Sal<-"s"
Leer a;
Leer b;
c<-(rc(a^2+b^2))
Leer Sal
FinMientras
FinProceso
EJERCICIO 3. Corregir los errores, marcarlos en color. Luego condicionar para que el ingreso del
valores no sea = a cero
Proceso areaTriangulo
resp<-'s'
leer altura;
leer base;
si (altura=3) Entonces
a<-(base*altura)/2;
escribir 'resultado:',a;
r=a*b/2
sino
a<-(base*altura)/2;
escribir 'resultado:',a;
FinSi
Leer res
FinMientras
FinProceso
Proceso areaTriangulo
resp<-'s'
//le falta la comilla al terminar triangulo corrección: Escribir 'EL AREA DE UN TRIANGULO';
leer altura;
leer base;
si (altura=3) Entonces
a<-(base*altura)/2;
escribir 'resultado:',a;
r=a*b/2
sino
a<-(base*altura)/2;
escribir 'resultado:',a;
FinSi
// Tiene un error en Leer res tendría que ser: Leer resp para que funcione el comando: Escribir
'Desea calcular otro triangulo? (S/N)'
Leer res
FinMientras
FinProceso
Proceso areaTriangulo
resp<-'s'
leer altura;
leer base;
a<-(base*altura)/2;
escribir 'resultado:',a;
r=a*b/2
sino
a<-(base*altura)/2;
escribir 'resultado:',a;
FinSi
Leer resp
FinMientras
FinProceso
EJERCICIO 4. Uso de REPETIR. Hacer. RECORDAR EL USO DEL MENU PARA PROXIMOS
proceso Menu
c1<-0
c2<-0
c3<-0
max<-0
Repetir
Escribir '*******MENU*******'
Escribir '1........SUMATORIA'
Escribir '******************'
leer opcion
1 : c1<-c1+1
Repetir
Leer n
fact<-1
s<-0
para i<-1 hasta n Hacer
s<-s+1/(fact*i)
FinPara
max<-s
FinSi
2 : c2<-c2+1
Leer L
Sino
sino
Sino
FinSi
FinSi
FinSi
FinSegun
FinProceso
Proceso Ejercicio4
Repetir
Leer opc;
1:
Leer num1;
Leer num2;
suma<-num1+num2;
2:
Leer num1;
Leer num2;
resta<-num1-num2;
3:
Leer num1;
mult<-num1*num2;
4:
Leer num1;
Leer num2;
division<-num1/num2;
FinSegun
FinProceso
EJERCICIO 5. Diseñar un pseudocódigo que muestre las horas trabajadas de una persona y el
valor por hora. Calcular su salario e imprimirlo. Agregarle información como por ejemplo:
datos del empleado, Empresa, cant de horas trabajadas por día, cantidad de horas trabajador
por semana, cant de horas trabajadas por mes, etc
Proceso Ejercicio5
Sal<-"s"
dse<-0
dme<-0
Leer nom
Leer nomem
Leer tar
Leer hor
Escribir "Número de días trabajados por semana";
Leer dse
Leer dme
si 7>=dse entonces
hos<-(hor*dse);
Sino
Leer nom
Leer nomem
Leer tar
Leer hor
Leer dse
Leer dme
FinSi
Si 31>=dme Entonces
hom<-(hor*dme);
Sino
Leer nom
Leer nomem
Leer tar
Escribir "Número de horas trabajadas por día";
Leer hor
Leer dse
Leer dme
Fin Si
Leer Sal
FinMientras
FinProceso
ACTUALIZADO 16/10/2014
Trabajo Practico Nº 4
Conjunto ordenado que contiene un nº fijo de elementos (su dimension) de cualquier tipo
valido definido con la condición de que todos deben ser del mismo tipo. Son una forma de
almacenar datos que permiten contener una serie de valores del mismo tipo, cada uno de los
valores contenidos tienen una posición asociada que se usara para accederlos.
Vectores en PSeInt
En programación y/o algoritmos, un vector es una zona de almacenamiento continuo, que
almacena serie de elementos del mismo tipo, los elementos del vector. Desde el punto de vista
lógico un vector se puede ver como un conjunto de elementos ordenados en fila.
ejercicios PSeint
Ejemplo:
psint
Ejemplo:
Este ejemplo muestra que el algoritmo define un vector de 3 posiciones y solicita que se
ingrese un valor, el cual va a ser almacenado en el vector con nombre, datos y , posición 1.
Ejemplo:
pseint
Se hace el ciclo 3 veces, pidiendo los datos, como vemos en el anterior ejemplo.
ejercicios PSeint
Si les solicitan imprimir el contenido de la información que tiene el vector de manera inversa a
como fue ingresada, se debe tener en cuenta el siguiente procedimiento:
psint
2.Si solicitan imprimir la información al contrario de cómo fue ingresada al vector. Debemos
comenzar por la posición 3 y terminar en la posición 1.
Un vector no es más que un conjunto de variables consecutivas en memoria y del mismo tipo
guardadas dentro de un variable contenedor. Tipos de variables y vectores más comunes:
•Variables tipo Char: Estas variables contienen un único carácter, es decir, una letra, un signo o
un número.
•Variables tipo Int: Contienen un número entero.
•Variables tipo String: Contienen cadenas de texto, o lo que es lo mismo, es un vector con
varias variables del tipo Char.
•Variables del tipo Boolean: Solo pueden contener un 0 o un 1. El cero es considerado para
muchos lenguajes como el literal "False", mientras que el 1 se considera "True".
Formula:
Dim Nombre del Vactor o Matriz (primer valor To ultimo valor) As Tipo De Dato
Ejemplo:
Donde:
Primer Valor es 1
Ultimo Valor es 5
Ejercicio:
Escribir un programa en Visual Basic que lea N números, calcule la media aritmética de los
mismos y muestre los números leídos que son mayores que la media calculada.
Se debe crear:
1.Command Button
2.TextBox
3.Label
4.ListBox
Te quedaría así:
En Visual Basic 2010 la declaración de un array, arreglo o vector la hacemos de la misma forma
que en Visual Basic 6.
Vectores en C++
Ejemplo:
Los elementos de un array se pueden utilizar igual que cualquier otra variable y se puede hacer
con ellos las mismas operaciones que se pueden hacer con el resto de variables.
#include <iostream>
using namespace std;
int main ()
int n, m = 5;
n = a[0]; //n = 2
a[0]=a[1]+a[2]; //a[0]= 8 + 3 = 11
a[1]++; //a[1]= 9
a[n]=m+10; //a[2]= 15
a[n+1]=7; //a[3]= 7
a[4]=a[0]; // a[4]= 11
cout << a[0]<<" "<< a[1]<< " "<< a[2]<< " "<< a[3]<< " "<< a[4];
system("pause";
Una vez definido un array, es muy sencillo acceder a cada uno de sus elementos. Cada
elemento se accede indicando su posición dentro del array. La única complicación, que es
responsable de muchos errores cuando se empieza a programar, es que las posiciones de los
elementos empiezan a contarse en el 0 y no en el 1 ejemplo:
En el ejemplo, la primera instrucción quiere obtener el primer elemento del array. Por eso, se
indica el nombre del array y entre corchetes la posición del elemento dentro del array.
Las posiciones se empiezan a contar en el 0, por lo que el primer elemento ocupa la posición 0
y se accede a el mediante dias[0].
El valor dias[5] hace referencia al elemento que ocupa la sexta posición dentro del array dias.
Como las posiciones empiezan a contarse en 0, la posición 5 hace referencia al sexto elemento,
en este caso, el valor Sábado.
Ejercicio
Proceso vectorenorden
Dimension V[1000];
Leer n;
Leer v(i);
Fin Para
//4 1 3 2
//1 4 3 2
//1 3 4 2
//1 2 4 3
//1 2 3 4
t = v(i);
V(i) = V(j);
V(j) = t;
Fin Si
Fin Para
Fin Para
Fin Para
Fin Para
FinProceso
2) Se solicita que el usuario ingrese un número y el algoritmo verifique que el valor ingresado
existe en el vector. Dado el caso de existir se debe indicar la posición en el que se encuentra.
Proceso Vectorposicion
Dimension V[10];
n<-6
Leer V(i);
finpara
Leer j
si j=V(i) entonces
FinSi
FinPara
FinProceso
3) Desarrollar un algoritmo que permita almacenar los DNI y apellido de diez estudiantes. El
usuario debe ingresar un numero de DNI a buscar en el vector y el algoritmo debe mostrar el
apellido que corresponde al numero de DNI ingresado.
Proceso base1
Dimension A[10,2]
salida="S"
salida1="S"
escribir "Programa para cargar DNI y nombre de 10 alumnos y luego buscar por DNI"
a[i,1]=nombre
leer dni
a[i,2]=dni
FinPara
nop="true"
leer dnibusqueda
si dnibusqueda=a[i,2] entonces
nop="false"
FinSi
FinPara
si nop="true" entonces
FinSi
escribir "Desea buscar otro alumno? S/N?"
leer salida
finmientras
leer salida1
finmientras
FinProceso
ACTUALIZADO 09/11/2014
Trabajo Practico Nº 5
Ejercitación.
Practica1. Programa que pide n números, cada uno lo multiplica por 5 y el resultado lo guarda
en otro arreglo.
Proceso Ejercicio1
Leer a
Dimension Num(a)
Leer Num(x)
FinPara
FinPara
FinProceso
Practica2. Calcular el promedio de los elementos que se encuentren en las posiciones pares de
un arreglo de n números.
Proceso Ejercicio2
Leer a
Prom<-0
Dimension Num(a)
si (a MOD 2) <> 0
x<-a-1
Sino
x<-a
FinSi
Leer Num(n)
FinPara
Prom<-Prom+Num(n)
FinPara
Resul<-Prom/(x/2)
Escribir Num(n)
FinPara
FinProceso
Practica3. Utilice un vector con 10 elementos y devuelva la suma de los mismos.
Proceso Ejercicio3
a<-10
Sal<-"s"
Dimension Num(a)
Leer Num(i)
Resul<-Resul+Num(i)
FinPara
Leer Sal
Fin Mientras
FinProceso
Practica4. Lea las materias y las calificaciones de los alumnos de un grupo, almacénelas en 2
arreglos unidimensionales. Después debe imprimir el contenido de ambos arreglos.
Proceso Ejercicio4
Leer cant
Dimension Materia(cant)
Dimension nota(cant)
Leer nota(i)
escribir "Error"
FinSi
FinPara
FinPara
FinProceso
Practica5. Hacer un programa que solicite al usuario 20 números y los ordene de mayor a
menor.
Proceso Ejercicio5
n<-20;
Dimension num[n]
Leer num(i);
FinPara
si num(j)<num(j+1) entonces
aux<-num(j);
num(j)<-num(j+1);
num(j+1)<-aux;
FinSi
FinPara
FinPara
Escribir "";
FinPara
FinProceso
Practica6. Realizar una variante del programa anterior ordenado de menor a mayor.
Proceso Ejercicio6
n<-20;
Dimension num[n]
Leer num(i);
FinPara
si num(j)>num(j+1) entonces
aux<-num(j);
num(j)<-num(j+1);
num(j+1)<-aux;
FinSi
FinPara
FinPara
Escribir "";
FinPara
FinProceso
Practica7. Cargar un arreglo de m números enteros indicar cual es el mayor y donde esta.
Proceso Ejercicio7
Leer dim
b<-0
Dimension Num(dim)
Leer num(i);
si Num(i)>b
b<-Num(i)
a<-i
FinSi
FinPara
FinProceso
Practica8. Generar un vector de tamaño 20 con números entre -10 y 10. Deje en un arreglo Z
todos los números negativos y en un arreglo X todos los positivos o iguales a cero.
Proceso Ejercicio8
Leer dim
Dimension num(dim)
Para i<-1 Hasta dim Con Paso 1 Hacer
Leer num(i);
Sino
Sino
Si (a=0) Entonces
Sino
Escribir "Error"
Fin Si
FinSi
FinSi
FinPara
FinProceso
Practico9. Genere un vector de tamaño 10 con números enteros leídos desde teclado. Calcule
el promedio e indique cuantos elementos del vector son mayores que el promedio y cuantos
menores o iguales.
Proceso Ejercicio9
Leer x;
Sal<-"s"
Dimension Num(x)
j<-0;
j<-j+a
FinPara
k<-j/x;
si Num(x)>b
b<-Num(x)
u<-i
FinSi
FinPara
Leer Sal
Fin Mientras
FinProceso
Proceso Ejercicio10
i <- 3
n <- 0
c <- 0
LEER n
SI i = ( i / 3 ) * 3 ENTONCES
ESCRIBIR i
c <- c + 1
FINSI
i <- i + 1
FINMIENTRAS
ESCRIBIR c
FinProceso
ACTUALIZADO 11/11/2014
Trabajo Practico Nº 6
1. La sintanxis para que el usuario defina las posiciones del vector. Que los valores a guardar
dentro del vector sean entre 50 y 100 (validar).
Proceso ejercicio1
b<-0
j<-5
Dimension Num(j)
Leer Num(i)
Escribir 'Debe ingresar un valor que se encuentre emtre 50 y 100, vuelva a'
escribir ""
FinMientras
si Num(i)>b Entonces
b<-Num(i)
a<-i
FinSi
FinPara
FinProceso
2) Crea un array o arreglo multidimensional que contenga la tabla de multiplicar del 1 al 9 (10
filas y 10 columnas). La primera fila y la columna debe contener estos números. El resto de
números deberemos calcularlo, usando los números que disponemos, es decir, en la primera
fila de 0, calculara 1*1, 1*2, 1*3, etc. usando las posiciones del array o arreglo.
Fin Para
Fin Para
Fin SubProceso
cont<-0
tablamulti[1,i]<-cont
tablamulti[i,1]<-cont
cont<-cont+1
Fin Para
Fin SubProceso
Fin Para
escribir ""
Fin Para
Fin SubProceso
Proceso Ejercicio4
definir FILAS como entero
FILAS<-10
COLUMNAS<-10
dimension tablamulti[FILAS,COLUMNAS]
rellenaColumnas(tablamulti, FILAS)
FinProceso
ACTUALIZADO 3/12/2014
Trabajo Practico Nº 7
Crea un arreglo unidimensional donde tu le indiques el tamaño por teclado y crear una función
que rellene el arreglo con los múltiplos de un número pedido por teclado. Por ejemplo la sirve
para crear las tablas 9x1 y el resultado será 18, 27, 36.
Escribir "Crea un arreglo unidimensional donde tu le indiques el tamaño por teclado y crear
una función que rellene el arreglo con los múltiplos de un número pedido por teclado. Por
ejemplo la sirve para crear las tablas 9x1 y el resultado será 18, 27, 36."
FinSubProceso
escribir ""
leer opc;
leer n1;
leer n2;
Leer t;
var <- n * i
FinPara
FinSegun
Fin SubProceso
Proceso Ejercicio10
FILAS<-10
COLUMNAS<-10
n1<-0
n2<-0
menudeoperacion<-0
Sal<-"s"
dimension tabla_multiplicar[FILAS,COLUMNAS]
//Funciones
menu( tabla_multiplicar )
Leer Sal
Fin Mientras
FinProceso
Trabajo Practico Nº 8
Crear dos arrays unidimensionales y realizar las 4 operaciones básicas. Diseñar un Menu como
el siguiente ejemplo (si el ejercicio lo permitiera)
Escribir "Crear dos arrays unidimensionales y realizar las 4 operaciones básicas. Diseñar un
Menu como el siguiente ejemplo (si el ejercicio lo permitiera)"
Fin SubProceso
Leer opcion;
Segun opcion Hacer
1:
Leer num1;
Leer num2;
2:
Leer num1;
Leer num2;
3:
Leer num1;
Leer num2;
4:
Leer num1;
Leer num2;
5:
FinSegun
Fin SubProceso
Proceso final
Sal<-"s"
//Funciones
mostrarArray(tabla_multiplicar, FILA,COLUMNA )
menu( tabla_multiplicar )
Leer Sal
Fin Mientras
FinProceso