Está en la página 1de 11

Ejercicios propuestos y resueltos arreglos o

arrays en pseudocódigo
Hola a todos, hoy os dejo una serie de ejercicios propuestos y resueltos sobre arreglos o
arrays en pseudocódigo.

Los ejercicios no tienen una única solución, el objetivo es que haga lo que pide y si se pide
que se haga de una forma especifica hacerlo.

Esta vez, están hechos en PseInt, pero os recomiendo que los penséis un poco antes de
poneros a programar. Los indices de los arrays o arreglos que usaremos sera el
predeterminado por PseInt, es decir, que empezaran en 1. Puedes hacerlos como te
convengan

Aquí os dejo algunos posts anteriores para recordar algunos puntos por si lo necesitáis:

 Variables y constantes.
 Operadores.
 Asignación.
 Operaciones de entrada y de salida.
 Funciones internas.
 Instrucciones de control.
 Instrucciones repetitivas o bucles.
 Seguimiento.
 Declaración.
 Análisis de un problema.
 Descarga de PSeInt.
 Arreglos o arrays.
 Arreglos o arrays multidimensionales.
 Arreglos o arrays en funciones.

Si tienes alguna duda o quieres proponer alguna solución alternativa, deja un comentario en


este post o mándanos un mensaje a administrador@discoduroderoer.es También dejare
algunos comentarios para explicar que hace cada paso. Puedes ponerlos con //

ATENCIÓN: si copias el código y te salta algún tipo de error, revisar el tipo de lenguaje
que usas. Puedes cambiarlo en Configurar-Opciones del lenguaje-personalizado

1) Crea un array o arreglo unidimensional con un tamaño de 5, asignale los valores


numéricos manualmente (los que tu quieras) y muestralos por pantalla.

Esconder «

Proceso Ejercicio1
//Declaramos variables
Definir num como entero;
Definir TAMANIO como entero;
TAMANIO<-5
//Definimos el array
Dimension num[TAMANIO]

//Asignamos valores
num[1]<-1
num[2]<-2
num[3]<-3
num[4]<-4
num[5]<-5

//Recorremos el array y mostramos su contenido


Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
escribir num[i]
Fin Para

FinProceso

2) Modifica el ejercicio anterior para que insertes los valores numéricos con leer mediante
un bucle y los muestre por pantalla.

Esconder «

Proceso Ejercicio2

//Declaramos variables
Definir num como entero

Definir TAMANIO como entero;


TAMANIO<-5;

//Definimos el array
Dimension num[TAMANIO]

//Introducimos valores
Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
Escribir "Introduce un valor para la posición ",i
leer num[i]
Fin Para

//Recorremos el array y mostramos su contenido


Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
escribir num[i]
FinPara

FinProceso
3) Crea un array o arreglo unidimensional con un tamaño de 10, inserta los valores
numéricos que desees de la manera que quieras y muestra por pantalla la media de valores
del array.

Esconder «

Proceso Ejercicio3

//Declaramos variables
Definir num como entero
Definir TAMANIO como entero
Definir suma Como Entero
TAMANIO<-10

//Definimos el array
Dimension num[TAMANIO]

//Introducimos valores
Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
Escribir "Introduce un valor para la posición ",i
leer num[i]
Fin Para

//Recorremos el array, sumando su contenido


Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
suma<-suma+num[i]
FinPara

FinProceso

4) Crea un array o arreglo unidimensional donde tu le indiques el tamaño por teclado y


crear una función que rellene el array o arreglo con los múltiplos de un numero pedido por
teclado. Por ejemplo, si defino un array de tamaño 5 y eligo un 3 en la función, el array
contendrá 3, 6, 9, 12, 15. Muestralos por pantalla usando otra función distinta.

Esconder «

SubProceso asignaValores ( num, TAMANIO, num_multiplo )

Para i<-1 Hasta TAMANIO Con Paso 1 Hacer


num[i]<-num_multiplo*i
Fin Para
Fin SubProceso

SubProceso mostrarArray ( num, TAMANIO )


Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
escribir num[i]
Fin Para
Fin SubProceso

Proceso Ejercicio4

//La creacion de subprocesos es totalmente opcional

//Declaramos variables
Definir num como entero
Definir TAMANIO como entero
Definir suma Como Entero
definir num_multiplo como entero

//Definimos el tamaño del array por teclado


escribir "Introduce el tamaño del array"
leer TAMANIO

//Definimos el array
Dimension num[TAMANIO]

//Definimos el numero con el que rellenaremos el array con sus


multiplos
escribir "Introduce el numero con el que rellenar"
leer num_multiplo

//invocamos a las funciones


asignaValores(num, TAMANIO, num_multiplo)
mostrarArray(num, TAMANIO)

FinProceso

5) Crea dos arrays o arreglos unidimensionales que tengan el mismo tamaño (lo pedirá por
teclado), en uno de ellos almacenaras nombres de personas como cadenas, en el otro array o
arreglo ira almacenando la longitud de los nombres, para ello puedes usar la función
LONGITUD(cadena) que viene en PseInt. Muestra por pantalla el nombre y la longitud
que tiene. Puedes usar funciones si lo deseas.

Esconder «

SubProceso mostrarArrays ( longitud_nombres, nombres, TAMANIO )

Para i<-1 Hasta TAMANIO Con Paso 1 Hacer


escribir "La longitud del nombre ",nombres[i]," es de
",longitud_nombres[i]
Fin Para

Fin SubProceso

Proceso Ejercicio5

//Declaramos variables
Definir longitud_nombres como entero
Definir nombres como cadena
Definir TAMANIO como entero
//Definimos el tamaño del array por teclado
escribir "Introduce el tamaño de los arrays"
leer TAMANIO

//Definimos el array
Dimension longitud_nombres[TAMANIO]
Dimension nombres[TAMANIO]

//Introducimos los nombres y la longitud de los mismos


Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
escribir "Introduce un nombre para la posicion ",i
leer nombres[i]
longitud_nombres[i]<-Longitud(nombres[i])
Fin Para

//Invocamos la función
mostrarArrays(longitud_nombres, nombres, TAMANIO)

FinProceso

6) Haz lo mismo que el ejercicio anterior pero con un arreglo o array multidimensional. Ten
en cuenta que no podemos tener una columna con cadena y otra con números, así que usa la
función convertiratexto(numero) que viene en PseInt. Piensa cuantas columnas y filas
debera tener el array o arreglo, también de que forma deberemos recorrer el array o arreglo
según lo que nos pide.

Esconder «

SubProceso mostrarArrays ( nombres, FILAS )


Para i<-1 Hasta FILAS Con Paso 1 Hacer
//Usamos un bucle ya que seria mas complicado(no es
imposible)
//mostrar dos valores en una misma instruccion
escribir "La longitud del nombre ",nombres[i,1]," es de
",nombres[i, 2]
Fin Para
Fin SubProceso

Proceso Ejercicio6

//Declaramos variables
Definir longitud_nombres como entero
Definir nombres como cadena
Definir FILAS como entero
definir num_nombre como cadena

//Definimos las filas del array por teclado


escribir "Introduce las filas del array multidimensional"
leer FILAS

//Definimos el array
Dimension nombres[FILAS, 2]
//Introducimos los nombres y la longitud de los mismos
Para i<-1 Hasta FILAS Con Paso 1 Hacer
escribir "Introduce un nombre en la fila ",i
leer nombres[i, 1]
num_nombre<-convertiratexto(Longitud(nombres[i, 1]))
nombres[i, 2]<-num_nombre
Fin Para

//Invocamos la función
mostrarArrays( nombres, FILAS)

FinProceso

7) Crea un arreglo o array multidimensional con un tamaño que nosotros le indiquemos por
teclado (puede ser 6×4, 7×2, etc.), recorre el array o arreglo e introduce número aleatorios
(función azar(x) donde x es el limite donde generara), crea una función llamada
rellenaArray. Por último, muestralos por pantalla tal como quedarían en el array o arreglo,
es decir, si el array es de 5×5 tendremos que hace que cada 5 números baje una línea, por
ejemplo:

52684

54321

98742

98752

23542

Para escribir sin que salte de linea, usamos Sin Saltar

Esconder «

SubProceso rellenaArray ( num, FILAS, COLUMNAS )

Para i<-1 Hasta FILAS Con Paso 1 Hacer


Para j<-1 Hasta COLUMNAS Con Paso 1 Hacer
//Genera numeros entre 0 y 9
num[i,j]<-azar(10)
Fin Para
Fin Para
Fin SubProceso

SubProceso mostrarArray ( num, FILAS, COLUMNAS)


Para i<-1 Hasta FILAS Con Paso 1 Hacer
Para j<-1 Hasta COLUMNAS Con Paso 1 Hacer
escribir num[i,j]," " Sin Saltar
Fin Para
//Salto de linea
escribir ""
Fin Para
Fin SubProceso

Proceso Ejercicio7

//Declaramos variables
Definir num como entero
Definir FILAS como entero
Definir COLUMNAS Como Entero

//Definimos las filas y columnas del array por teclado


escribir "Introduce las filas del array"
leer FILAS

escribir "Introduce las columnas del array"


leer COLUMNAS

//Definimos el array
Dimension num[FILAS, COLUMNAS]

//Invocamos la función
rellenaArray(num, FILAS, COLUMNAS)
mostrarArray( num, FILAS, COLUMNAS)

FinProceso

8) Crea un arreglo o array multidimanesional que contenga 3 columnas y las filas que tu
quieras, las dos primeras columnas tendrán números y en la 3 columna sera el resultado de
sumar el número de la primera y segunda columna. Muestra el array o arreglo de la
siguiente forma:

3+5=8
4+4=7

Piensa de que forma puedes mostrar con un solo bucle.

Esconder «

SubProceso mostrarArray ( num, FILAS )

Para i<-1 Hasta FILAS Con Paso 1 Hacer


escribir num[i,1]," + ",num[i,2]," = ",num[i, 3]
Fin Para
Fin SubProceso

Proceso Ejercicio8

//Declaramos variables
Definir num como entero
Definir FILAS como entero
Definir COLUMNAS Como Entero

//Definimos las fila del array por teclado, las columnas


//ya sabemos que siempre seran 3
escribir "Introduce las filas del array multidimensional"
leer FILAS
COLUMNAS<-3

//Definimos el array
Dimension num[FILAS, COLUMNAS]

//Introducimos los nombres y la longitud de los mismos

Para i<-1 Hasta FILAS Con Paso 1 Hacer


Para j<-1 Hasta COLUMNAS Con Paso 1 Hacer
//Cuando j llegue a 3 (donde debemos sumar),
sumara los valores anteriores,
//esto permite que nos ahorremos despues un bucle
si (j=COLUMNAS) Entonces
num[i,j]<-num[i,1]+num[i,2]
Sino
Escribir "Introduce un numero para la FILA
",i," COLUMNA ",j
leer num[i,j]
FinSi
Fin Para
Fin Para

//Invocamos la función
mostrarArray( num, FILAS)

FinProceso

9) Crea un arreglo o array multidimensional con un tamaño que definiremos nosotros por
teclado,  contendrá números aleatorios usando la función anterior y crearemos un array o
arreglo unidimensional donde se copiaran los números que contiene el array
multidimensional. Piensa que tamaño debe tener el array o arreglo unimensional.

Esconder «

SubProceso copiaArray ( num_multidimensional,num_unidimensional, FILAS,


COLUMNAS )

//Esta variable la usaremos para controlar


definir saltador como entero
saltador<-0

Para i<-1 Hasta FILAS Con Paso 1 Hacer


Para j<-1 Hasta COLUMNAS Con Paso 1 Hacer
num_unidimensional[j+saltador]<-
num_multidimensional[i,j]
Fin Para
saltador<-saltador+COLUMNAS
Fin Para

Fin SubProceso

SubProceso rellenaArray ( num, FILAS, COLUMNAS )

Para i<-1 Hasta FILAS Con Paso 1 Hacer


Para j<-1 Hasta COLUMNAS Con Paso 1 Hacer
//Genera numeros entre 0 y 9
num[i,j]<-azar(10)
Fin Para
Fin Para
Fin SubProceso

SubProceso mostrarArray ( num_unidimensional, FILAS, COLUMNAS)

Para i<-1 Hasta FILAS*COLUMNAS Con Paso 1 Hacer


escribir num_unidimensional[i]
Fin Para

Fin SubProceso

Proceso Ejercicio9

//Declaramos variables
Definir num_multidimensional como entero;
Definir num_unidimensional como entero;
Definir FILAS como entero
Definir COLUMNAS Como Entero

//Definimos las filas y columnas del array por teclado


escribir "Introduce las filas del array"
leer FILAS
escribir "Introduce las columnas del array"
leer COLUMNAS

//Definimos el array
Dimension num_multidimensional[FILAS, COLUMNAS]
Dimension num_unidimensional[FILAS*COLUMNAS]

//Invocamos laa funciones


rellenaArray(num_multidimensional, FILAS, COLUMNAS)
copiaArray(num_multidimensional,num_unidimensional, FILAS,
COLUMNAS)
mostrarArray( num_unidimensional, FILAS, COLUMNAS)

FinProceso
10) 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. Algo
así:

El resto de números deberemos calcularlo, usando los numeros 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. Así debe quedar al final:

No os preocupéis por la apariencia ya que es por el número de dígitos.

Esconder «

SubProceso calculaTabla ( tabla_multiplicar, FILAS, COLUMNAS )

Para i<-2 Hasta FILAS Con Paso 1 Hacer


Para j<-2 Hasta COLUMNAS Con Paso 1 Hacer
//Empezamos desde la posicion 2,2
//Lo único que varia es la fila o la columna en
cada caso
tabla_multiplicar[i,j]<-
tabla_multiplicar[i,1]*tabla_multiplicar[1,j]
Fin Para
Fin Para

Fin SubProceso

SubProceso rellenaColumnasPrinc ( tabla_multiplicar, FILAS)

definir contador como entero


contador<-0

Para i<-1 Hasta FILAS Con Paso 1 Hacer


tabla_multiplicar[1,i]<-contador
tabla_multiplicar[i,1]<-contador
contador<-contador+1
Fin Para

Fin SubProceso

SubProceso mostrarArray ( tabla_multiplicar, FILAS, COLUMNAS)

Para i<-1 Hasta FILAS Con Paso 1 Hacer


Para j<-1 Hasta COLUMNAS Con Paso 1 Hacer
escribir tabla_multiplicar[i,j]," " Sin Saltar
Fin Para
//Salto de linea
escribir ""
Fin Para

Fin SubProceso

Proceso Ejercicio10

//Definimos las variables


definir FILAS como entero
definir COLUMNAS como entero
FILAS<-10
COLUMNAS<-10
dimension tabla_multiplicar[FILAS,COLUMNAS]

//Funciones
rellenaColumnasPrinc(tabla_multiplicar, FILAS)
calculaTabla(tabla_multiplicar, FILAS, COLUMNAS )
mostrarArray(tabla_multiplicar, FILAS, COLUMNAS)

FinProceso

Espero que os sea de ayuda. Si teneis dudas, preguntad. Estamos para ayudarte.

También podría gustarte