Categoría: PSeInt

Hasta ahora vimos los principales conceptos de PSeInt por separado: condicionales, ciclos, vectores, matrices, búsquedas, ordenamiento, funciones y subprocesos. En este proyecto final vamos a combinar gran parte de todo eso en un programa completo y bastante más cercano a un sistema real.

La idea es construir un sistema de reservas de cine que permita visualizar una sala, reservar y cancelar asientos, consultar estadísticas de ocupación y calcular la recaudación. El programa estará dividido en subprocesos para mantener cada responsabilidad separada y reducir la complejidad del algoritmo principal.

¿Qué vamos a practicar?

• Matrices para representar los asientos de la sala.
• Condicionales para validar reservas y cancelaciones.
• Ciclos para recorrer filas y columnas.
• Funciones y subprocesos para dividir el programa.
• Acumuladores y contadores para obtener estadísticas.
• Menús interactivos.
• Validaciones para evitar operaciones incorrectas.

Como en los demás ejemplos del sitio, vamos a trabajar con posiciones que comienzan en 1.

Cómo representaremos la sala

Usaremos una matriz de 5 filas por 6 columnas. El valor 0 indicará que un asiento está libre y el valor 1 que está reservado.

Dimension sala[5,6]

Visualmente queremos mostrar algo parecido a esto:

========================================
          CLUB PROGRAMADOR CINE
========================================

Película: Interestelar
Función: 21:30

       1   2   3   4   5   6
Fila 1 L   L   X   L   L   L
Fila 2 X   X   L   L   L   X
Fila 3 L   L   L   X   L   L
Fila 4 L   X   L   L   L   L
Fila 5 L   L   L   L   L   L

L = Libre
X = Reservado

Funciones principales del sistema

1. Inicializar la sala.
2. Mostrar los asientos.
3. Reservar un asiento.
4. Cancelar una reserva.
5. Contar asientos ocupados.
6. Calcular porcentaje de ocupación.
7. Calcular recaudación.
8. Detectar la fila con más reservas.
9. Mostrar estadísticas.
10. Salir del sistema.

Código completo

SubProceso InicializarSala(sala, filas, columnas)
    Definir f, c Como Entero

    Para f <- 1 Hasta filas Hacer
        Para c <- 1 Hasta columnas Hacer
            sala[f,c] <- 0
        FinPara
    FinPara
FinSubProceso


SubProceso MostrarSala(sala, filas, columnas)
    Definir f, c Como Entero

    Escribir ""
    Escribir "       1   2   3   4   5   6"

    Para f <- 1 Hasta filas Hacer
        Escribir Sin Saltar "Fila ", f, " "

        Para c <- 1 Hasta columnas Hacer
            Si sala[f,c] = 0 Entonces
                Escribir Sin Saltar " L  "
            Sino
                Escribir Sin Saltar " X  "
            FinSi
        FinPara

        Escribir ""
    FinPara

    Escribir ""
    Escribir "L = Libre"
    Escribir "X = Reservado"
FinSubProceso


SubProceso ReservarAsiento(sala, filas, columnas)
    Definir fila, columna Como Entero

    Escribir "Ingrese fila:"
    Leer fila

    Escribir "Ingrese columna:"
    Leer columna

    Si fila >= 1 Y fila <= filas Y columna >= 1 Y columna <= columnas Entonces
        Si sala[fila,columna] = 0 Entonces
            sala[fila,columna] <- 1
            Escribir "Reserva realizada correctamente."
        Sino
            Escribir "Ese asiento ya se encuentra reservado."
        FinSi
    Sino
        Escribir "Fila o columna fuera de rango."
    FinSi
FinSubProceso


SubProceso CancelarReserva(sala, filas, columnas)
    Definir fila, columna Como Entero

    Escribir "Ingrese fila:"
    Leer fila

    Escribir "Ingrese columna:"
    Leer columna

    Si fila >= 1 Y fila <= filas Y columna >= 1 Y columna <= columnas Entonces
        Si sala[fila,columna] = 1 Entonces
            sala[fila,columna] <- 0
            Escribir "Reserva cancelada correctamente."
        Sino
            Escribir "Ese asiento ya se encuentra libre."
        FinSi
    Sino
        Escribir "Fila o columna fuera de rango."
    FinSi
FinSubProceso


SubProceso cantidad <- ContarReservados(sala, filas, columnas)
    Definir f, c Como Entero

    cantidad <- 0

    Para f <- 1 Hasta filas Hacer
        Para c <- 1 Hasta columnas Hacer
            Si sala[f,c] = 1 Entonces
                cantidad <- cantidad + 1
            FinSi
        FinPara
    FinPara
FinSubProceso


SubProceso filaMayor <- FilaMasOcupada(sala, filas, columnas)
    Definir f, c, cantidadFila, maximo Como Entero

    maximo <- -1
    filaMayor <- 1

    Para f <- 1 Hasta filas Hacer
        cantidadFila <- 0

        Para c <- 1 Hasta columnas Hacer
            Si sala[f,c] = 1 Entonces
                cantidadFila <- cantidadFila + 1
            FinSi
        FinPara

        Si cantidadFila > maximo Entonces
            maximo <- cantidadFila
            filaMayor <- f
        FinSi
    FinPara
FinSubProceso


SubProceso MostrarEstadisticas(sala, filas, columnas, precioEntrada)
    Definir reservados, totalAsientos, filaMayor Como Entero
    Definir porcentaje, recaudacion Como Real

    reservados <- ContarReservados(sala, filas, columnas)
    totalAsientos <- filas * columnas
    porcentaje <- reservados * 100 / totalAsientos
    recaudacion <- reservados * precioEntrada
    filaMayor <- FilaMasOcupada(sala, filas, columnas)

    Escribir ""
    Escribir "========== ESTADISTICAS =========="
    Escribir "Asientos reservados: ", reservados
    Escribir "Asientos libres: ", totalAsientos - reservados
    Escribir "Ocupacion: ", porcentaje, "%"
    Escribir "Recaudacion: $", recaudacion
    Escribir "Fila con mayor ocupacion: ", filaMayor
    Escribir "=================================="
FinSubProceso


Algoritmo SistemaReservasCine
    Definir sala, opcion Como Entero
    Definir filas, columnas Como Entero
    Definir precioEntrada Como Real
    Dimension sala[5,6]

    filas <- 5
    columnas <- 6
    precioEntrada <- 5000

    InicializarSala(sala, filas, columnas)

    Repetir
        Escribir ""
        Escribir "========================================"
        Escribir "          CLUB PROGRAMADOR CINE"
        Escribir "========================================"
        Escribir "Pelicula: Interestelar"
        Escribir "Funcion: 21:30"
        Escribir ""
        Escribir "1. Ver sala"
        Escribir "2. Reservar asiento"
        Escribir "3. Cancelar reserva"
        Escribir "4. Ver estadisticas"
        Escribir "5. Salir"
        Escribir ""
        Escribir "Seleccione una opcion:"
        Leer opcion

        Segun opcion Hacer
            1:
                MostrarSala(sala, filas, columnas)

            2:
                MostrarSala(sala, filas, columnas)
                ReservarAsiento(sala, filas, columnas)

            3:
                MostrarSala(sala, filas, columnas)
                CancelarReserva(sala, filas, columnas)

            4:
                MostrarEstadisticas(sala, filas, columnas, precioEntrada)

            5:
                Escribir "Gracias por utilizar Club Programador Cine."

            De Otro Modo:
                Escribir "Opcion invalida."
        FinSegun

    Hasta Que opcion = 5
FinAlgoritmo

1. Inicialización de la sala

Al comenzar el programa necesitamos asegurarnos de que todos los asientos estén libres. Para eso recorremos toda la matriz y colocamos 0 en cada posición.

Para f <- 1 Hasta filas Hacer
    Para c <- 1 Hasta columnas Hacer
        sala[f,c] <- 0
    FinPara
FinPara

Separar esta tarea en InicializarSala evita que el algoritmo principal tenga que conocer cómo se prepara internamente la matriz.

2. Mostrar la sala

El procedimiento MostrarSala recorre la matriz y transforma los valores internos en una representación más amigable:

• 0 → asiento libre: L
• 1 → asiento reservado: X

Así conseguimos una interfaz sencilla sin cambiar la forma en la que almacenamos los datos.

3. Reservar un asiento

Antes de modificar la matriz hacemos dos validaciones:

1. que la fila y columna estén dentro del rango válido;
2. que el asiento se encuentre libre.

Si sala[fila,columna] = 0 Entonces
    sala[fila,columna] <- 1
    Escribir "Reserva realizada correctamente."
Sino
    Escribir "Ese asiento ya se encuentra reservado."
FinSi

Esto impide que una misma butaca se reserve dos veces.

4. Cancelar una reserva

La cancelación realiza el proceso inverso. Si el asiento está reservado, vuelve a asignarse el valor 0.

Si sala[fila,columna] = 1 Entonces
    sala[fila,columna] <- 0
    Escribir "Reserva cancelada correctamente."
Sino
    Escribir "Ese asiento ya se encuentra libre."
FinSi

5. Contar asientos ocupados

La función ContarReservados recorre toda la sala y cuenta cuántos valores son iguales a 1.

Si sala[f,c] = 1 Entonces
    cantidad <- cantidad + 1
FinSi

Este único resultado luego nos permite calcular otros datos sin repetir el recorrido.

6. Porcentaje de ocupación

Conociendo la cantidad de reservas y el total de asientos:

porcentaje <- reservados * 100 / totalAsientos

En una sala de 30 lugares, si hay 15 reservas, la ocupación será del 50%.

7. Recaudación

En este ejemplo usamos un precio fijo de entrada:

precioEntrada <- 5000

La recaudación se obtiene multiplicando la cantidad de reservas por el precio:

recaudacion <- reservados * precioEntrada

Podés cambiar ese valor para probar distintos escenarios.

8. Fila con mayor ocupación

Para encontrar la fila con más reservas contamos los asientos ocupados de cada fila y conservamos el mayor valor encontrado.

Este patrón aparece constantemente en programación: recorrer un conjunto, calcular un valor parcial y comparar contra un máximo anterior.

9. Un algoritmo principal mucho más simple

Una de las partes más importantes del proyecto es observar cómo queda el algoritmo principal. En vez de contener cientos de instrucciones mezcladas, se limita a coordinar operaciones:

MostrarSala(sala, filas, columnas)
ReservarAsiento(sala, filas, columnas)
CancelarReserva(sala, filas, columnas)
MostrarEstadisticas(sala, filas, columnas, precioEntrada)

Esta es justamente la utilidad de separar complejidades: cada subproceso resuelve una parte concreta y el programa principal se ocupa del flujo general.

Ideas para ampliar el proyecto

Si querés convertir este ejercicio en un desafío todavía mayor, podés agregar:

• varias películas;
• varios horarios por película;
• diferentes precios según el tipo de entrada;
• nombres de clientes;
• número de reserva;
• asientos VIP;
• descuentos para estudiantes;
• una matriz diferente para cada función;
• recaudación por película;
• ranking de funciones con mayor ocupación;
• impresión de un comprobante al finalizar la reserva.

Qué conceptos reúne este proyecto

Este sistema combina prácticamente todo el recorrido de PSeInt que desarrollamos en Club Programador:

• variables y operadores;
• condicionales;
• ciclos;
• matrices;
• contadores y acumuladores;
• búsqueda de máximos;
• funciones y subprocesos;
• validaciones;
• menús interactivos;
• modularización.

Seguí practicando PSeInt

Si todavía querés practicar algún tema antes de encarar este proyecto completo, podés recorrer nuestro hub de PSeInt, donde reunimos los ejercicios y guías del sitio en un orden recomendado.

También podés repasar los ejercicios con vectores, los ejercicios con matrices y nuestra guía de funciones y subprocesos.

---

¿Te sirvió este proyecto? ☕

Si este contenido te ayudó a estudiar, practicar o preparar un trabajo, podés apoyar a Club Programador. Tu aporte ayuda a mantener el sitio online y a seguir publicando ejercicios y proyectos gratuitos.

🇦🇷 Apoyar desde Argentina

☕ Invitame un café con Mercado Pago

🌎 Apoyar desde otro país

☕ Apoyar con PayPal

Las matrices en PSeInt permiten organizar datos en filas y columnas. Son una extensión natural de los vectores y resultan muy útiles para practicar recorridos anidados, búsquedas, acumuladores y operaciones con datos bidimensionales.

En estos ejemplos usamos posiciones desde 1, manteniendo el mismo criterio utilizado en nuestros ejercicios de vectores.

Índice de ejercicios

1. Cargar y mostrar una matriz 3×3
2. Sumar todos los elementos
3. Calcular el promedio de una matriz
4. Encontrar el valor mayor
5. Encontrar el valor menor
6. Sumar una fila
7. Sumar una columna
8. Mostrar la diagonal principal
9. Sumar la diagonal principal
10. Mostrar la diagonal secundaria
11. Contar números pares
12. Contar positivos, negativos y ceros
13. Buscar un valor en la matriz
14. Copiar una matriz
15. Multiplicar todos los elementos por un número
16. Sumar dos matrices
17. Comparar dos matrices
18. Obtener la matriz transpuesta
19. Encontrar la fila con mayor suma
20. Crear una matriz identidad

1. Cargar y mostrar una matriz 3×3

Este ejercicio recorre una matriz primero para cargar sus valores y luego para mostrarlos por filas.

Algoritmo CargarMostrarMatriz
    Definir matriz, i, j Como Entero
    Dimension matriz[3,3]

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Escribir "Ingrese el valor [", i, ",", j, "]:"
            Leer matriz[i,j]
        FinPara
    FinPara

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Escribir Sin Saltar matriz[i,j], " "
        FinPara
        Escribir ""
    FinPara
FinAlgoritmo

2. Sumar todos los elementos

Usamos un acumulador para sumar cada elemento mientras recorremos todas las filas y columnas.

Algoritmo SumarMatriz
    Definir matriz, i, j, suma Como Entero
    Dimension matriz[3,3]
    suma <- 0

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]
            suma <- suma + matriz[i,j]
        FinPara
    FinPara

    Escribir "La suma total es: ", suma
FinAlgoritmo

3. Calcular el promedio de una matriz

En una matriz 3×3 hay 9 elementos, por lo que dividimos la suma total por 9.

Algoritmo PromedioMatriz
    Definir matriz, i, j Como Entero
    Definir suma, promedio Como Real
    Dimension matriz[3,3]
    suma <- 0

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]
            suma <- suma + matriz[i,j]
        FinPara
    FinPara

    promedio <- suma / 9
    Escribir "Promedio: ", promedio
FinAlgoritmo

4. Encontrar el valor mayor

Tomamos el primer elemento como referencia y lo comparamos con el resto.

Algoritmo MayorMatriz
    Definir matriz, i, j, mayor Como Entero
    Dimension matriz[3,3]

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]
        FinPara
    FinPara

    mayor <- matriz[1,1]

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Si matriz[i,j] > mayor Entonces
                mayor <- matriz[i,j]
            FinSi
        FinPara
    FinPara

    Escribir "El mayor es: ", mayor
FinAlgoritmo

5. Encontrar el valor menor

El procedimiento es similar al anterior, pero conservando el menor valor encontrado.

Algoritmo MenorMatriz
    Definir matriz, i, j, menor Como Entero
    Dimension matriz[3,3]

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]
        FinPara
    FinPara

    menor <- matriz[1,1]

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Si matriz[i,j] < menor Entonces
                menor <- matriz[i,j]
            FinSi
        FinPara
    FinPara

    Escribir "El menor es: ", menor
FinAlgoritmo

6. Sumar una fila

En este ejemplo sumamos todos los elementos de la segunda fila.

Algoritmo SumarFila
    Definir matriz, i, j, suma Como Entero
    Dimension matriz[3,3]
    suma <- 0

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]
        FinPara
    FinPara

    Para j <- 1 Hasta 3 Hacer
        suma <- suma + matriz[2,j]
    FinPara

    Escribir "Suma de la fila 2: ", suma
FinAlgoritmo

7. Sumar una columna

Ahora recorremos una columna fija; en este caso, la columna 2.

Algoritmo SumarColumna
    Definir matriz, i, j, suma Como Entero
    Dimension matriz[3,3]
    suma <- 0

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]
        FinPara
    FinPara

    Para i <- 1 Hasta 3 Hacer
        suma <- suma + matriz[i,2]
    FinPara

    Escribir "Suma de la columna 2: ", suma
FinAlgoritmo

8. Mostrar la diagonal principal

En la diagonal principal coinciden el número de fila y el número de columna.

Algoritmo DiagonalPrincipal
    Definir matriz, i, j Como Entero
    Dimension matriz[3,3]

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]
        FinPara
    FinPara

    Para i <- 1 Hasta 3 Hacer
        Escribir matriz[i,i]
    FinPara
FinAlgoritmo

9. Sumar la diagonal principal

Sumamos los elementos ubicados en las posiciones [1,1], [2,2] y [3,3].

Algoritmo SumarDiagonalPrincipal
    Definir matriz, i, j, suma Como Entero
    Dimension matriz[3,3]
    suma <- 0

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]
        FinPara
    FinPara

    Para i <- 1 Hasta 3 Hacer
        suma <- suma + matriz[i,i]
    FinPara

    Escribir "Suma diagonal principal: ", suma
FinAlgoritmo

10. Mostrar la diagonal secundaria

Para una matriz 3×3, las posiciones de la diagonal secundaria cumplen que columna = 4 – fila.

Algoritmo DiagonalSecundaria
    Definir matriz, i, j Como Entero
    Dimension matriz[3,3]

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]
        FinPara
    FinPara

    Para i <- 1 Hasta 3 Hacer
        Escribir matriz[i,4-i]
    FinPara
FinAlgoritmo

11. Contar números pares

Usamos MOD para comprobar qué elementos son divisibles por 2.

Algoritmo ContarParesMatriz
    Definir matriz, i, j, pares Como Entero
    Dimension matriz[3,3]
    pares <- 0

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]

            Si matriz[i,j] MOD 2 = 0 Entonces
                pares <- pares + 1
            FinSi
        FinPara
    FinPara

    Escribir "Cantidad de pares: ", pares
FinAlgoritmo

12. Contar positivos, negativos y ceros

Clasificamos cada elemento según sea mayor, menor o igual a cero.

Algoritmo ContarSignosMatriz
    Definir matriz, i, j, positivos, negativos, ceros Como Entero
    Dimension matriz[3,3]
    positivos <- 0
    negativos <- 0
    ceros <- 0

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]

            Si matriz[i,j] > 0 Entonces
                positivos <- positivos + 1
            Sino
                Si matriz[i,j] < 0 Entonces
                    negativos <- negativos + 1
                Sino
                    ceros <- ceros + 1
                FinSi
            FinSi
        FinPara
    FinPara

    Escribir "Positivos: ", positivos
    Escribir "Negativos: ", negativos
    Escribir "Ceros: ", ceros
FinAlgoritmo

13. Buscar un valor en la matriz

Recorremos todos los elementos y usamos una variable lógica para indicar si el valor fue encontrado.

Algoritmo BuscarEnMatriz
    Definir matriz, i, j, buscado Como Entero
    Definir encontrado Como Logico
    Dimension matriz[3,3]
    encontrado <- Falso

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]
        FinPara
    FinPara

    Escribir "Valor a buscar:"
    Leer buscado

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Si matriz[i,j] = buscado Entonces
                encontrado <- Verdadero
            FinSi
        FinPara
    FinPara

    Si encontrado Entonces
        Escribir "El valor se encuentra en la matriz"
    Sino
        Escribir "El valor no se encuentra en la matriz"
    FinSi
FinAlgoritmo

14. Copiar una matriz

Cada elemento de la matriz original se asigna a la misma posición de la matriz copia.

Algoritmo CopiarMatriz
    Definir original, copia, i, j Como Entero
    Dimension original[3,3]
    Dimension copia[3,3]

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer original[i,j]
            copia[i,j] <- original[i,j]
        FinPara
    FinPara

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Escribir Sin Saltar copia[i,j], " "
        FinPara
        Escribir ""
    FinPara
FinAlgoritmo

15. Multiplicar todos los elementos por un número

Solicitamos un factor y lo aplicamos a cada posición de la matriz.

Algoritmo MultiplicarMatriz
    Definir matriz, i, j, factor Como Entero
    Dimension matriz[3,3]

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]
        FinPara
    FinPara

    Escribir "Ingrese el factor:"
    Leer factor

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            matriz[i,j] <- matriz[i,j] * factor
            Escribir Sin Saltar matriz[i,j], " "
        FinPara
        Escribir ""
    FinPara
FinAlgoritmo

16. Sumar dos matrices

La suma se realiza posición por posición.

Algoritmo SumarDosMatrices
    Definir a, b, c, i, j Como Entero
    Dimension a[3,3]
    Dimension b[3,3]
    Dimension c[3,3]

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Escribir "A[", i, ",", j, "]:"
            Leer a[i,j]
            Escribir "B[", i, ",", j, "]:"
            Leer b[i,j]
            c[i,j] <- a[i,j] + b[i,j]
        FinPara
    FinPara

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Escribir Sin Saltar c[i,j], " "
        FinPara
        Escribir ""
    FinPara
FinAlgoritmo

17. Comparar dos matrices

Dos matrices son iguales si todos sus elementos coinciden en las mismas posiciones.

Algoritmo CompararMatrices
    Definir a, b, i, j Como Entero
    Definir iguales Como Logico
    Dimension a[3,3]
    Dimension b[3,3]
    iguales <- Verdadero

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer a[i,j]
        FinPara
    FinPara

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer b[i,j]

            Si a[i,j] <> b[i,j] Entonces
                iguales <- Falso
            FinSi
        FinPara
    FinPara

    Si iguales Entonces
        Escribir "Las matrices son iguales"
    Sino
        Escribir "Las matrices son diferentes"
    FinSi
FinAlgoritmo

18. Obtener la matriz transpuesta

Para transponer una matriz intercambiamos filas por columnas.

Algoritmo MatrizTranspuesta
    Definir matriz, transpuesta, i, j Como Entero
    Dimension matriz[3,3]
    Dimension transpuesta[3,3]

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]
            transpuesta[j,i] <- matriz[i,j]
        FinPara
    FinPara

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Escribir Sin Saltar transpuesta[i,j], " "
        FinPara
        Escribir ""
    FinPara
FinAlgoritmo

19. Encontrar la fila con mayor suma

Calculamos la suma de cada fila y conservamos el número de la fila que tenga el total más alto.

Algoritmo FilaMayorSuma
    Definir matriz, i, j, sumaFila, mayorSuma, filaMayor Como Entero
    Dimension matriz[3,3]

    Para i <- 1 Hasta 3 Hacer
        Para j <- 1 Hasta 3 Hacer
            Leer matriz[i,j]
        FinPara
    FinPara

    mayorSuma <- 0
    filaMayor <- 1

    Para i <- 1 Hasta 3 Hacer
        sumaFila <- 0

        Para j <- 1 Hasta 3 Hacer
            sumaFila <- sumaFila + matriz[i,j]
        FinPara

        Si i = 1 O sumaFila > mayorSuma Entonces
            mayorSuma <- sumaFila
            filaMayor <- i
        FinSi
    FinPara

    Escribir "Fila con mayor suma: ", filaMayor
    Escribir "Suma: ", mayorSuma
FinAlgoritmo

20. Crear una matriz identidad

Una matriz identidad tiene 1 en la diagonal principal y 0 en todas las demás posiciones.

Algoritmo MatrizIdentidad
    Definir matriz, i, j Como Entero
    Dimension matriz[4,4]

    Para i <- 1 Hasta 4 Hacer
        Para j <- 1 Hasta 4 Hacer
            Si i = j Entonces
                matriz[i,j] <- 1
            Sino
                matriz[i,j] <- 0
            FinSi

            Escribir Sin Saltar matriz[i,j], " "
        FinPara
        Escribir ""
    FinPara
FinAlgoritmo

Seguí practicando PSeInt

Si todavía estás practicando estructuras básicas, podés continuar con PSeInt: ejemplos básicos resueltos, los 20 ejercicios de ciclos y condicionales o los 20 ejercicios resueltos con vectores.

---

¿Te sirvió este ejercicio? ☕

Si este contenido te ayudó, podés apoyar a Club Programador con el monto que quieras. Tu aporte ayuda a mantener estos ejercicios disponibles gratuitamente y a seguir publicando nuevos ejemplos.

🇦🇷 Apoyar desde Argentina

☕ Invitame un café con Mercado Pago

🌎 Apoyar desde otro país

☕ Apoyar con PayPal

Cuando un programa empieza a crecer, intentar resolver todo dentro de un único algoritmo hace que el código sea más difícil de leer, probar y corregir. Una de las ideas más importantes de la programación es separar un problema complejo en problemas más pequeños.

En PSeInt podemos hacerlo mediante subprocesos. Un subproceso encapsula una tarea concreta para poder ejecutarla cuando la necesitemos. Si además devuelve un valor, cumple el papel de una función.

Dividir un programa en partes permite reducir la complejidad, reutilizar código, evitar repeticiones y localizar errores con mayor facilidad. En lugar de pensar en todo el problema al mismo tiempo, podemos resolver pequeñas tareas independientes y luego combinarlas.

¿Para qué sirven las funciones y subprocesos?

• Separar responsabilidades: cada bloque resuelve una tarea concreta.
• Reutilizar código: una misma operación puede utilizarse varias veces.
• Evitar repeticiones: no necesitamos copiar las mismas instrucciones en distintos lugares.
• Facilitar las pruebas: podemos comprobar cada parte por separado.
• Mejorar la lectura: el algoritmo principal queda más corto y expresa mejor la lógica general.

Subproceso y función en PSeInt

Un subproceso puede recibir parámetros y ejecutar una serie de instrucciones. Cuando necesitamos obtener un resultado, podemos definir un valor de retorno:

SubProceso resultado <- NombreFuncion(parametros)
    // instrucciones
    resultado <- valor
FinSubProceso

También existen subprocesos que simplemente realizan una acción y no necesitan devolver ningún valor:

SubProceso MostrarMensaje()
    Escribir "Hola"
FinSubProceso

Índice de ejemplos

1. Subproceso que muestra un saludo
2. Función que suma dos números
3. Función que determina si un número es par
4. Función que devuelve el mayor de dos números
5. Función para calcular un factorial
6. Subproceso para cargar un vector
7. Función para buscar un valor en un vector
8. Programa dividido en varios subprocesos

1. Subproceso que muestra un saludo

Empezamos con el caso más simple: separar una acción que no necesita devolver ningún valor.

SubProceso Saludar()
    Escribir "Hola desde un subproceso"
FinSubProceso

Algoritmo EjemploSaludo
    Escribir "Inicio del programa"
    Saludar()
    Escribir "Fin del programa"
FinAlgoritmo

El algoritmo principal solamente indica qué quiere hacer. Los detalles de cómo se muestra el saludo quedan dentro de Saludar.

2. Función que suma dos números

Cuando necesitamos obtener un resultado, definimos una variable de retorno.

SubProceso resultado <- Sumar(a, b)
    resultado <- a + b
FinSubProceso

Algoritmo EjemploSuma
    Definir n1, n2, total Como Real

    Escribir "Ingrese el primer numero:"
    Leer n1

    Escribir "Ingrese el segundo numero:"
    Leer n2

    total <- Sumar(n1, n2)

    Escribir "Resultado: ", total
FinAlgoritmo

a y b son parámetros. La función recibe los valores, calcula la suma y devuelve el resultado al algoritmo principal.

3. Función que determina si un número es par

Una función también puede devolver un valor lógico.

SubProceso respuesta <- EsPar(numero)
    Si numero MOD 2 = 0 Entonces
        respuesta <- Verdadero
    Sino
        respuesta <- Falso
    FinSi
FinSubProceso

Algoritmo EjemploPar
    Definir numero Como Entero

    Escribir "Ingrese un numero:"
    Leer numero

    Si EsPar(numero) Entonces
        Escribir "El numero es par"
    Sino
        Escribir "El numero es impar"
    FinSi
FinAlgoritmo

El algoritmo principal ya no necesita conocer cómo se determina la paridad. Solo pregunta si EsPar(numero) devuelve verdadero o falso.

4. Función que devuelve el mayor de dos números

SubProceso mayor <- ObtenerMayor(a, b)
    Si a > b Entonces
        mayor <- a
    Sino
        mayor <- b
    FinSi
FinSubProceso

Algoritmo EjemploMayor
    Definir n1, n2 Como Real

    Escribir "Ingrese dos numeros:"
    Leer n1
    Leer n2

    Escribir "El mayor es: ", ObtenerMayor(n1, n2)
FinAlgoritmo

Una ventaja de esta separación es que ObtenerMayor puede utilizarse muchas veces sin repetir la comparación.

5. Función para calcular un factorial

SubProceso resultado <- Factorial(numero)
    Definir i Como Entero

    resultado <- 1

    Para i <- 1 Hasta numero Hacer
        resultado <- resultado * i
    FinPara
FinSubProceso

Algoritmo EjemploFactorial
    Definir numero, resultado Como Entero

    Escribir "Ingrese un numero entero no negativo:"
    Leer numero

    Si numero >= 0 Entonces
        resultado <- Factorial(numero)
        Escribir "Factorial: ", resultado
    Sino
        Escribir "El numero debe ser mayor o igual a cero"
    FinSi
FinAlgoritmo

La validación queda en el algoritmo principal y el cálculo específico se delega a la función Factorial.

6. Subproceso para cargar un vector

Los subprocesos son especialmente útiles cuando trabajamos con vectores. En este ejemplo separamos la carga de datos del resto del programa.

SubProceso CargarVector(numeros, cantidad)
    Definir i Como Entero

    Para i <- 1 Hasta cantidad Hacer
        Escribir "Ingrese el valor ", i, ":"
        Leer numeros[i]
    FinPara
FinSubProceso

Algoritmo EjemploCargaVector
    Definir numeros Como Entero
    Dimension numeros[5]

    CargarVector(numeros, 5)

    Escribir "Vector cargado correctamente"
FinAlgoritmo

Mantenemos la convención utilizada en los demás ejercicios del sitio: las posiciones del vector comienzan en 1.

7. Función para buscar un valor en un vector

Podemos aislar la lógica de búsqueda para que el algoritmo principal no tenga que recorrer el vector directamente.

SubProceso posicion <- BuscarValor(numeros, cantidad, buscado)
    Definir i Como Entero
    Definir encontrado Como Logico

    i <- 1
    encontrado <- Falso
    posicion <- -1

    Mientras i <= cantidad Y NO encontrado Hacer
        Si numeros[i] = buscado Entonces
            encontrado <- Verdadero
            posicion <- i
        Sino
            i <- i + 1
        FinSi
    FinMientras
FinSubProceso

Algoritmo EjemploBusqueda
    Definir numeros, buscado, posicion Como Entero
    Dimension numeros[5]

    numeros[1] <- 10
    numeros[2] <- 20
    numeros[3] <- 30
    numeros[4] <- 40
    numeros[5] <- 50

    Escribir "Ingrese el valor a buscar:"
    Leer buscado

    posicion <- BuscarValor(numeros, 5, buscado)

    Si posicion <> -1 Entonces
        Escribir "Encontrado en la posicion ", posicion
    Sino
        Escribir "El valor no se encuentra en el vector"
    FinSi
FinAlgoritmo

En este caso usamos -1 como valor de retorno para indicar que el elemento no fue encontrado. Como las posiciones válidas del vector van de 1 a 5, no existe ambigüedad con un índice real.

8. Programa dividido en varios subprocesos

La ventaja se vuelve más evidente cuando varias tareas se combinan. El algoritmo principal puede quedar reducido a una secuencia de operaciones de alto nivel.

SubProceso CargarVector(numeros, cantidad)
    Definir i Como Entero

    Para i <- 1 Hasta cantidad Hacer
        Escribir "Ingrese el valor ", i, ":"
        Leer numeros[i]
    FinPara
FinSubProceso

SubProceso MostrarVector(numeros, cantidad)
    Definir i Como Entero

    Para i <- 1 Hasta cantidad Hacer
        Escribir numeros[i]
    FinPara
FinSubProceso

SubProceso suma <- SumarVector(numeros, cantidad)
    Definir i Como Entero

    suma <- 0

    Para i <- 1 Hasta cantidad Hacer
        suma <- suma + numeros[i]
    FinPara
FinSubProceso

Algoritmo ProgramaModular
    Definir numeros Como Entero
    Dimension numeros[5]

    CargarVector(numeros, 5)

    Escribir "Valores cargados:"
    MostrarVector(numeros, 5)

    Escribir "Suma total: ", SumarVector(numeros, 5)
FinAlgoritmo

El algoritmo principal ahora expresa claramente tres operaciones: cargar, mostrar y sumar. Cada una tiene su propia implementación.

Variables locales y parámetros

Las variables declaradas dentro de un subproceso se utilizan para resolver esa tarea concreta. Esto ayuda a evitar que todos los datos del programa estén mezclados en un único lugar.

Los parámetros permiten enviar información desde el algoritmo principal hacia el subproceso. De esta manera una misma función puede trabajar con valores diferentes cada vez que se la invoca.

¿Cuándo conviene separar un problema?

No hace falta crear una función para cada línea de código. Conviene modularizar cuando una tarea:

• tiene una responsabilidad claramente identificable;
• se utiliza más de una vez;
• requiere varias instrucciones y complica el algoritmo principal;
• puede probarse de forma independiente;
• representa una operación con un nombre claro, como BuscarValor, CalcularPromedio o OrdenarVector.

La idea central es que el algoritmo principal muestre la estructura general del problema, mientras que cada subproceso se ocupa de los detalles de una parte específica.

Seguí practicando PSeInt

Para seguir practicando, podés consultar los 20 ejercicios resueltos de PSeInt con vectores, los 20 ejercicios de ciclos y condicionales y los ejercicios básicos resueltos en PSeInt.

---

¿Te sirvió este contenido? ☕

Si esta guía te ayudó, podés apoyar a Club Programador con el monto que quieras. Tu aporte ayuda a mantener el contenido gratuito y a seguir publicando nuevos ejercicios.

🇦🇷 Apoyar desde Argentina

☕ Invitame un café con Mercado Pago

🌎 Apoyar desde otro país

☕ Apoyar con PayPal

Los vectores y arreglos en PSeInt permiten guardar varios valores del mismo tipo dentro de una sola estructura. Son uno de los temas más importantes para avanzar desde los ejercicios básicos hacia problemas más reales.

En esta guía vas a encontrar 20 ejercicios resueltos de PSeInt con vectores, ordenados desde los más simples hasta otros que combinan búsquedas, conteos y ordenamientos. En los ejemplos usamos posiciones desde 1 hasta n, que es la configuración utilizada por PSeInt en estos ejercicios.

Índice de ejercicios

1. Cargar y mostrar un vector
2. Sumar todos los elementos
3. Calcular el promedio
4. Encontrar el mayor
5. Encontrar el menor
6. Contar números pares
7. Contar positivos, negativos y ceros
8. Buscar un número
9. Mostrar el vector en orden inverso
10. Copiar un vector
11. Duplicar todos los valores
12. Reemplazar números negativos por cero
13. Contar cuántas veces aparece un valor
14. Sumar elementos de posiciones pares
15. Intercambiar el primer y último elemento
16. Comparar dos vectores
17. Encontrar el segundo número mayor
18. Ordenar de menor a mayor
19. Eliminar lógicamente un elemento
20. Unir dos vectores

1. Cargar y mostrar un vector

Enunciado: cargar 5 números en un vector y mostrarlos en pantalla.

Algoritmo CargarMostrarVector
    Definir numeros, i Como Entero
    Dimension numeros[5]

    Para i <- 1 Hasta 5 Hacer
        Escribir "Ingrese el elemento ", i
        Leer numeros[i]
    FinPara

    Para i <- 1 Hasta 5 Hacer
        Escribir "numeros[", i, "] = ", numeros[i]
    FinPara
FinAlgoritmo

Este es el ejercicio básico para entender cómo se declara, carga y recorre un arreglo.

2. Sumar todos los elementos de un vector

Enunciado: cargar 5 números y calcular la suma total.

Algoritmo SumarVector
    Definir numeros, i, suma Como Entero
    Dimension numeros[5]
    suma <- 0

    Para i <- 1 Hasta 5 Hacer
        Leer numeros[i]
        suma <- suma + numeros[i]
    FinPara

    Escribir "Suma total: ", suma
FinAlgoritmo

La variable suma funciona como acumulador.

3. Calcular el promedio de los elementos

Enunciado: cargar 5 números reales y calcular su promedio.

Algoritmo PromedioVector
    Definir valores Como Real
    Definir i Como Entero
    Definir suma, promedio Como Real
    Dimension valores[5]

    suma <- 0

    Para i <- 1 Hasta 5 Hacer
        Leer valores[i]
        suma <- suma + valores[i]
    FinPara

    promedio <- suma / 5
    Escribir "Promedio: ", promedio
FinAlgoritmo

4. Encontrar el número mayor

Enunciado: cargar 5 números e indicar cuál es el mayor.

Algoritmo MayorDelVector
    Definir numeros, i, mayor Como Entero
    Dimension numeros[5]

    Para i <- 1 Hasta 5 Hacer
        Leer numeros[i]
    FinPara

    mayor <- numeros[1]

    Para i <- 2 Hasta 5 Hacer
        Si numeros[i] > mayor Entonces
            mayor <- numeros[i]
        FinSi
    FinPara

    Escribir "Mayor: ", mayor
FinAlgoritmo

El primer elemento se usa como valor inicial de referencia.

5. Encontrar el número menor

Enunciado: determinar el menor elemento almacenado.

Algoritmo MenorDelVector
    Definir numeros, i, menor Como Entero
    Dimension numeros[5]

    Para i <- 1 Hasta 5 Hacer
        Leer numeros[i]
    FinPara

    menor <- numeros[1]

    Para i <- 2 Hasta 5 Hacer
        Si numeros[i] < menor Entonces
            menor <- numeros[i]
        FinSi
    FinPara

    Escribir "Menor: ", menor
FinAlgoritmo

6. Contar cuántos números pares hay

Enunciado: cargar 10 números y contar cuántos son pares.

Algoritmo ContarPares
    Definir numeros, i, cantidadPares Como Entero
    Dimension numeros[10]

    cantidadPares <- 0

    Para i <- 1 Hasta 10 Hacer
        Leer numeros[i]

        Si numeros[i] MOD 2 = 0 Entonces
            cantidadPares <- cantidadPares + 1
        FinSi
    FinPara

    Escribir "Cantidad de pares: ", cantidadPares
FinAlgoritmo

7. Contar positivos, negativos y ceros

Enunciado: clasificar los valores de un vector según su signo.

Algoritmo ClasificarVector
    Definir numeros, i, positivos, negativos, ceros Como Entero
    Dimension numeros[8]

    positivos <- 0
    negativos <- 0
    ceros <- 0

    Para i <- 1 Hasta 8 Hacer
        Leer numeros[i]

        Si numeros[i] > 0 Entonces
            positivos <- positivos + 1
        Sino
            Si numeros[i] < 0 Entonces
                negativos <- negativos + 1
            Sino
                ceros <- ceros + 1
            FinSi
        FinSi
    FinPara

    Escribir "Positivos: ", positivos
    Escribir "Negativos: ", negativos
    Escribir "Ceros: ", ceros
FinAlgoritmo

8. Buscar un número dentro del vector

Enunciado: cargar 10 números y determinar si un valor buscado se encuentra en el arreglo.

Algoritmo BuscarEnVector
    Definir numeros, i, buscado Como Entero
    Definir encontrado Como Logico
    Dimension numeros[10]

    Para i <- 1 Hasta 10 Hacer
        Leer numeros[i]
    FinPara

    Escribir "Numero a buscar:"
    Leer buscado

    encontrado <- Falso

    Para i <- 1 Hasta 10 Hacer
        Si numeros[i] = buscado Entonces
            encontrado <- Verdadero
        FinSi
    FinPara

    Si encontrado Entonces
        Escribir "El numero esta en el vector"
    Sino
        Escribir "El numero no fue encontrado"
    FinSi
FinAlgoritmo

9. Mostrar el vector en orden inverso

Enunciado: cargar 5 valores y mostrarlos desde el último hasta el primero.

Algoritmo VectorInverso
    Definir numeros, i Como Entero
    Dimension numeros[5]

    Para i <- 1 Hasta 5 Hacer
        Leer numeros[i]
    FinPara

    Para i <- 5 Hasta 1 Con Paso -1 Hacer
        Escribir numeros[i]
    FinPara
FinAlgoritmo

10. Copiar un vector en otro

Enunciado: copiar todos los elementos de un arreglo en un segundo arreglo.

Algoritmo CopiarVector
    Definir origen, copia, i Como Entero
    Dimension origen[5]
    Dimension copia[5]

    Para i <- 1 Hasta 5 Hacer
        Leer origen[i]
        copia[i] <- origen[i]
    FinPara

    Para i <- 1 Hasta 5 Hacer
        Escribir copia[i]
    FinPara
FinAlgoritmo

11. Duplicar todos los valores

Enunciado: multiplicar por 2 cada elemento del vector.

Algoritmo DuplicarVector
    Definir numeros, i Como Entero
    Dimension numeros[5]

    Para i <- 1 Hasta 5 Hacer
        Leer numeros[i]
        numeros[i] <- numeros[i] * 2
    FinPara

    Para i <- 1 Hasta 5 Hacer
        Escribir numeros[i]
    FinPara
FinAlgoritmo

12. Reemplazar números negativos por cero

Enunciado: recorrer un vector y sustituir todos los valores negativos por 0.

Algoritmo ReemplazarNegativos
    Definir numeros, i Como Entero
    Dimension numeros[6]

    Para i <- 1 Hasta 6 Hacer
        Leer numeros[i]

        Si numeros[i] < 0 Entonces
            numeros[i] <- 0
        FinSi
    FinPara

    Para i <- 1 Hasta 6 Hacer
        Escribir numeros[i]
    FinPara
FinAlgoritmo

13. Contar cuántas veces aparece un número

Enunciado: indicar cuántas veces aparece un valor determinado dentro del vector.

Algoritmo ContarRepeticiones
    Definir numeros, i, buscado, cantidad Como Entero
    Dimension numeros[10]

    Para i <- 1 Hasta 10 Hacer
        Leer numeros[i]
    FinPara

    Escribir "Valor a contar:"
    Leer buscado

    cantidad <- 0

    Para i <- 1 Hasta 10 Hacer
        Si numeros[i] = buscado Entonces
            cantidad <- cantidad + 1
        FinSi
    FinPara

    Escribir "Aparece ", cantidad, " veces"
FinAlgoritmo

14. Sumar los elementos ubicados en posiciones pares

Enunciado: sumar los valores almacenados en las posiciones pares 2, 4, 6, 8 y 10.

Algoritmo SumarPosicionesPares
    Definir numeros, i, suma Como Entero
    Dimension numeros[10]

    Para i <- 1 Hasta 10 Hacer
        Leer numeros[i]
    FinPara

    suma <- 0

    Para i <- 2 Hasta 10 Con Paso 2 Hacer
        suma <- suma + numeros[i]
    FinPara

    Escribir "Suma: ", suma
FinAlgoritmo

En este caso hablamos de posiciones pares del vector (2, 4, 6, 8 y 10), no necesariamente de valores pares.

15. Intercambiar el primer y último elemento

Enunciado: intercambiar los extremos de un vector sin perder ninguno de los valores.

Algoritmo IntercambiarExtremos
    Definir numeros, i, auxiliar Como Entero
    Dimension numeros[5]

    Para i <- 1 Hasta 5 Hacer
        Leer numeros[i]
    FinPara

    auxiliar <- numeros[1]
    numeros[1] <- numeros[5]
    numeros[5] <- auxiliar

    Para i <- 1 Hasta 5 Hacer
        Escribir numeros[i]
    FinPara
FinAlgoritmo

16. Comparar dos vectores

Enunciado: determinar si dos vectores tienen exactamente los mismos elementos en las mismas posiciones.

Algoritmo CompararVectores
    Definir a, b, i Como Entero
    Definir iguales Como Logico
    Dimension a[5]
    Dimension b[5]

    Para i <- 1 Hasta 5 Hacer
        Leer a[i]
    FinPara

    Para i <- 1 Hasta 5 Hacer
        Leer b[i]
    FinPara

    iguales <- Verdadero

    Para i <- 1 Hasta 5 Hacer
        Si a[i] <> b[i] Entonces
            iguales <- Falso
        FinSi
    FinPara

    Si iguales Entonces
        Escribir "Los vectores son iguales"
    Sino
        Escribir "Los vectores son diferentes"
    FinSi
FinAlgoritmo

17. Encontrar el segundo número mayor

Enunciado: encontrar el segundo valor distinto más grande de un vector.

Algoritmo SegundoMayor
    Definir numeros, i, mayor, segundo Como Entero
    Definir haySegundo Como Logico
    Dimension numeros[6]

    Para i <- 1 Hasta 6 Hacer
        Leer numeros[i]
    FinPara

    mayor <- numeros[1]
    haySegundo <- Falso

    Para i <- 2 Hasta 6 Hacer
        Si numeros[i] > mayor Entonces
            segundo <- mayor
            mayor <- numeros[i]
            haySegundo <- Verdadero
        Sino
            Si numeros[i] < mayor Entonces
                Si NO haySegundo O numeros[i] > segundo Entonces
                    segundo <- numeros[i]
                    haySegundo <- Verdadero
                FinSi
            FinSi
        FinSi
    FinPara

    Si haySegundo Entonces
        Escribir "Segundo mayor: ", segundo
    Sino
        Escribir "No existe un segundo valor distinto"
    FinSi
FinAlgoritmo

La variable haySegundo permite controlar el caso en que todos los elementos tengan el mismo valor.

18. Ordenar un vector de menor a mayor

Enunciado: ordenar 5 números utilizando el método burbuja.

Algoritmo OrdenamientoBurbuja
    Definir numeros, i, j, auxiliar Como Entero
    Dimension numeros[5]

    Para i <- 1 Hasta 5 Hacer
        Leer numeros[i]
    FinPara

    Para i <- 1 Hasta 4 Hacer
        Para j <- 1 Hasta 5 - i Hacer
            Si numeros[j] > numeros[j + 1] Entonces
                auxiliar <- numeros[j]
                numeros[j] <- numeros[j + 1]
                numeros[j + 1] <- auxiliar
            FinSi
        FinPara
    FinPara

    Escribir "Vector ordenado:"
    Para i <- 1 Hasta 5 Hacer
        Escribir numeros[i]
    FinPara
FinAlgoritmo

El ordenamiento burbuja compara elementos vecinos e intercambia sus posiciones cuando están en el orden incorrecto.

19. Eliminar lógicamente un elemento

Enunciado: eliminar un elemento de una posición determinada desplazando hacia la izquierda los valores siguientes.

Algoritmo EliminarElemento
    Definir numeros, i, posicion, cantidad Como Entero
    Dimension numeros[5]

    cantidad <- 5

    Para i <- 1 Hasta cantidad Hacer
        Leer numeros[i]
    FinPara

    Escribir "Posicion a eliminar (1 a 5):"
    Leer posicion

    Si posicion >= 1 Y posicion <= cantidad Entonces
        Para i <- posicion Hasta cantidad - 1 Hacer
            numeros[i] <- numeros[i + 1]
        FinPara

        cantidad <- cantidad - 1

        Para i <- 1 Hasta cantidad Hacer
            Escribir numeros[i]
        FinPara
    Sino
        Escribir "Posicion invalida"
    FinSi
FinAlgoritmo

El arreglo mantiene su tamaño físico, pero la variable cantidad indica cuántas posiciones seguimos considerando válidas.

20. Unir dos vectores

Enunciado: cargar dos vectores de 3 elementos y generar un tercero con los 6 valores.

Algoritmo UnirVectores
    Definir a, b, c, i Como Entero
    Dimension a[3]
    Dimension b[3]
    Dimension c[6]

    Para i <- 1 Hasta 3 Hacer
        Leer a[i]
    FinPara

    Para i <- 1 Hasta 3 Hacer
        Leer b[i]
    FinPara

    Para i <- 1 Hasta 3 Hacer
        c[i] <- a[i]
        c[i + 3] <- b[i]
    FinPara

    Para i <- 1 Hasta 6 Hacer
        Escribir c[i]
    FinPara
FinAlgoritmo

---

¿Cómo practicar estos ejercicios?

La mejor forma de aprovecharlos es escribir cada algoritmo en PSeInt y modificarlo. Probá cambiar la cantidad de elementos, agregar validaciones, utilizar números reales o intentar resolver el mismo problema sin mirar la solución.

Si todavía estás empezando, te conviene pasar primero por PSeInt: ejemplos básicos resueltos. También podés continuar con 20 ejercicios resueltos de PSeInt con ciclos y condicionales y con nuestra guía de arreglos en PSeInt.

---

¿Te sirvieron estos ejercicios? ☕

Si este contenido te ayudó a estudiar, resolver una práctica o entender mejor los vectores, podés apoyar a Club Programador. Cada aporte ayuda a mantener el sitio y seguir publicando material gratuito.

🇦🇷 Apoyar desde Argentina

☕ Invitame un café con Mercado Pago

🌎 Apoyar desde otro país

☕ Apoyar con PayPal

También podés visitar la página Apoyar Club Programador.

Determinar si un número es par o impar en PSeInt es uno de los ejercicios más comunes para comenzar a practicar condicionales y el operador MOD.

Enunciado

Crear un algoritmo que solicite un número entero al usuario e indique si ese número es par o impar.

Solución en PSeInt

Algoritmo ParOImpar
    Escribir "Ingrese un numero entero"
    Leer nro

    Si nro MOD 2 = 0 Entonces
        Escribir "El numero es par"
    Sino
        Escribir "El numero es impar"
    FinSi
FinAlgoritmo

¿Cómo funciona?

El operador MOD devuelve el resto de una división. Si al dividir un número por 2 el resto es 0, entonces el número es par. Si el resto es distinto de 0, es impar.

Por ejemplo, 8 MOD 2 devuelve 0, mientras que 7 MOD 2 devuelve 1.

Ejemplo de ejecución

Ingrese un numero entero
15
El numero es impar

Ejercicios para practicar

• Modificar el algoritmo para indicar además si el número es positivo, negativo o cero.
• Ingresar 10 números y contar cuántos son pares y cuántos impares.
• Mostrar todos los números pares comprendidos entre 1 y 100.

Más ejercicios de PSeInt

Podés seguir practicando con nuestra guía de ejercicios básicos resueltos en PSeInt y con los ejemplos de arreglos y vectores en PSeInt.

Comprobar si un número es primo en PSeInt es un excelente ejercicio para practicar ciclos, condicionales y el operador MOD.

¿Qué es un número primo?

Un número primo es un entero mayor que 1 que tiene exactamente dos divisores positivos: 1 y él mismo. Por ejemplo, 2, 3, 5, 7 y 11 son primos.

Enunciado

Crear un algoritmo que solicite un número entero e indique si es primo o no.

Solución en PSeInt

Algoritmo NumeroPrimo
    Escribir "Ingrese un numero entero"
    Leer nro

    Si nro <= 1 Entonces
        Escribir "No es primo"
    Sino
        divisor <- 2
        esPrimo <- Verdadero

        Mientras divisor * divisor <= nro Y esPrimo Hacer
            Si nro MOD divisor = 0 Entonces
                esPrimo <- Falso
            FinSi
            divisor <- divisor + 1
        FinMientras

        Si esPrimo Entonces
            Escribir "Es primo"
        Sino
            Escribir "No es primo"
        FinSi
    FinSi
FinAlgoritmo

Explicación paso a paso

Primero se descartan todos los valores menores o iguales a 1. Después se prueban divisores comenzando por 2. Si alguno divide exactamente al número, la variable esPrimo pasa a falso.

No hace falta probar hasta el propio número. Basta con comprobar divisores mientras divisor * divisor <= nro, lo que equivale a verificar hasta la raíz cuadrada.

Ejemplo de ejecución

Ingrese un numero entero
29
Es primo

Ejercicios para practicar

• Mostrar todos los números primos entre 1 y 100.
• Contar cuántos números primos hay entre dos valores ingresados.
• Modificar el algoritmo para guardar los primos encontrados en un arreglo.

Más ejercicios de PSeInt

También podés consultar nuestra colección de ejercicios básicos resueltos en PSeInt y los ejercicios de arreglos y vectores.

Sumar los dígitos de un número en PSeInt es un ejercicio clásico para practicar ciclos y operaciones matemáticas como MOD y Trunc.

Enunciado

Crear un algoritmo que solicite un número entero positivo y calcule la suma de todos sus dígitos. Por ejemplo, si el usuario ingresa 123, el resultado debe ser 6.

Solución en PSeInt

Algoritmo SumaDigitos
    Escribir "Ingrese un numero positivo"
    Leer nro

    resultado <- 0

    Mientras nro <> 0 Hacer
        resultado <- resultado + nro MOD 10
        nro <- Trunc(nro / 10)
    FinMientras

    Escribir "La suma de los digitos es: ", resultado
FinAlgoritmo

¿Cómo funciona?

La expresión nro MOD 10 obtiene el último dígito del número. Luego, Trunc(nro / 10) elimina ese último dígito para continuar con el siguiente.

Si el número es 123, las iteraciones trabajan con 3, luego 2 y finalmente 1. El acumulador termina con 3 + 2 + 1 = 6.

Ejemplo de ejecución

Ingrese un numero positivo
583
La suma de los digitos es: 16

Versión que acepta números negativos

Si querés admitir números negativos, podés convertir primero el valor a positivo con Abs:

nro <- Abs(nro)

De esa manera, por ejemplo, -583 también devolverá 16.

Ejercicios para practicar

• Contar cuántos dígitos tiene un número.
• Calcular el producto de todos sus dígitos.
• Determinar cuál es el dígito mayor de un número.
• Invertir el orden de los dígitos.

Más ejercicios de PSeInt

Encontrá más ejemplos en nuestra guía de ejercicios básicos resueltos en PSeInt y en los ejercicios de arreglos y vectores en PSeInt.

A continación se muestra un algoritmo sencillo que representa una calculadora de las cuatro operaciones básicas:

Algoritmo Calculadora
	Repetir
		Escribir "Ingrese un número:"
		Leer n1
		Escribir "Ingrese otro número:"
		Leer n2
		Escribir "Ingrese el numero de operación: "
		Escribir " 1) Suma"
		Escribir " 2) Resta"
		Escribir " 3) División"
		Escribir " 4) Multiplicación"
		Escribir "Ingrese 0 para salir"
		Leer operacion
		Segun operacion Hacer
			1:
			  Escribir n1, " + ", n2, " = ", n1+n2
			2:
			  Escribir n1, " - ", n2, " = ", n1-n2
			3:
			  Escribir n1, " / ", n2, " = ", n1/n2
			4:  
		          Escribir n1, " * ", n2, " = ", n1*n2
                        De Otro Modo:
			SI operacion <> 0 Entonces
			  Escribir  "No es una opción válida"
		        FinSi
		Fin Segun
	Hasta Que operacion == 0
FinAlgoritmo