52 Ejercicios en Pseudocódigo

Ejercicios en Pseudocódigo

52 Ejercicios en Pseudocódigo


Aquí les dejo 52 ejercicios en Pseudo-código, para reforzar los conocimientos dados en el la saga de posts Cómo aprender a programar y no morir en el intento, estos ejercicios son muy buenos para desarrollar la lógica y están enfocados para los estudiantes en Ingeniería de Sistemas y a fines.
Al final de cada consigna esta el ejercicio resuelto, trata de resolverlo sin mirar el resultado.

Que es el Pseudocódigo
El Pseudo-Código sirve para orientar a los programadores, pero sin la sintaxis ni la estructura propia de ningún lenguaje (C#, VisaualBasic, etc.). En vez de escribir el programa directamente en un lenguaje de programación determinado (C, Basic, etc.), crearemos un borrador entendible para todos los lenguajes, para luego de tener bien en claro lo que se debe hacer, para pasar a la programación propiamente dicha. En pocas palabras lo que se hace es marcar la estructura de cómo sería hacer un "Programa" con cualquier lenguaje. No importa donde lo hagas en tu mano, bloc de notas, papel higiénico, etc. ya que es solo para comprender la estructura o lógica de cómo se programaría en un lenguaje real.


Los ejercicios están divididos en 9 temas:

-Bucles y tomas de decision
-Bucles anidados y subprogramas
-Presentación en pantalla y cabeceras
-Números aleatorios y menus
-Arrays unidimensionales
-Arrays bidimensionales
-Arrays multidimensionales
-Ficheros
-Informes y rupturas de control
-Organización aleatoria y secuencial

Programacion


Bucles y tomas de decisión

1.-Hacer un pseudocodigo que imprima los numeros del 1 al 100.


 PROGRAMA contador1
ENTORNO:
   c <- 0
ALGORITMO:
   Borrar_pantalla( )
   MIENTRAS c < 101 HACER
      ESCRIBIR c
      c <- c + 1
   FINMIENTRAS
FINPROGRAMA


2.-Hacer un pseudocodigo que imprima los numeros del 100 al 0, en orden decreciente.

 PROGRAMA contador2
ENTORNO:
   c <- 100
ALGORITMO:
   Borrar_pantalla( )
   MIENTRAS c <= 0 HACER
      ESCRIBIR c
      c <- c - 1
   FINMIENTRAS
FINPROGRAMA


3.-Hacer un pseudocodigo que imprima los numeros pares entre 0 y 100.

 PROGRAMA pares
ENTORNO:
   c <- 2
ALGORITMO:
   Borrar_pantalla( )
   MIENTRAS c < 101 HACER
      ESCRIBIR c
      c <- c + 2
   FINMIENTRAS
FINPROGRAMA


4.-Hacer un programa que imprima la suma de los 100 primeros numeros.

 PROGRAMA suma
ENTORNO:
   c <- 1
   suma <- 0
ALGORITMO:
   Borrar_pantalla( )
   MIENTRAS c <= 100 HACER
      suma <- suma + c
      c <- c + 1
   FINMIENTRAS
   ESCRIBIR "La suma de los 100 primeros n£meros es: "
   ESCRIBIR suma
FINPROGRAMA


5.-Hacer un pseudocódigo que imprima los numeros impares hasta el 100 y que imprima cuantos impares hay.

 PROGRAMA impares
ENTORNO:
   c <- 1
   son <- 0
ALGORITMO:
   Borrar_pantalla( )
   MIENTRAS c < 100
      ESCRIBIR c
      c <- c + 2
      son <- son + 1
   FINMIENTRAS
   ESCRIBIR "El n£mero de impares: "
   ESCRIBIR son
FINPROGRAMA


6.-Hacer un pseudocodigo que imprima todos los numeros naturales que hay desde- la unidad hasta un numero que introducimos por teclado.

 PROGRAMA natural
ENTORNO:
   i <- 0
   n <- 0
ALGORITMO:
   Borrar_pantalla( )
   ESCRIBIR "Introduce un n£mero: "
   LEER n
   MIENTRAS i < n HACER
      i <- i + 1
      ESCRIBIR i
   FINMIENTRAS
FINPROGRAMA


7.-Introducir tantas frases como queramos y contarlas.

 PROGRAMA frases
ENTORNO:
   res <- "S"
   frase <- Espacios( 30 )
   c <- 0
ALGORITMO:
   Borrar_pantalla( )
   MIENTRAS res = "S" HACER
      ESCRIBIR "Frase: "
      LEER frase
      c <- c + 1
      ESCRIBIR "Deseas introducir m s frases (S/N): "
      LEER res
   FINMIENTRAS
   ESCRIBIR "El n£mero de frases introducidas son: "
   ESCRIBIR c
FINPROGRAMA


8.-Hacer un pseudocodigo que solo nos permita introducir S o N.

 PROGRAMA sn
ENTORNO:
   res <- " "
ALGORITMO:
   Borrar_pantalla( )
   MIENTRAS res <> "S" Y res <> "N" HACER
      ESCRIBIR "Introduce S o N"
      LEER res
      res <- Convertir_may£sculas( res )
   FINMIENTRAS
FINPROGRAMA


9.-Introducir un numero por teclado. Que nos diga si es positivo o negativo.

 PROGRAMA signo
ENTORNO:
   num <- 0
ALGORITMO:
   Borrar_pantalla( )
   ESCRIBIR "Introduce un n£mero: "
   LEER num
   SI num >= 0 ENTONCES
      ESCRIBIR "es positivo"
   SINO
      ESCRIBIR "es negativo"
   FINSI
FINPROGRAMA


10.-Introducir un numero por teclado. Que nos diga si es par o impar.

 PROGRAMA paridad
ENTORNO:
   num <- 0
ALGORITMO:
   Borrar_pantalla( )
   ESCRIBIR "Introduce un n£mero: "
   LEER num
   SI num = int( num / 2 ) * 2 ENTONCES
      ESCRIBIR "es par"
   SINO
      ESCRIBIR "es impar"
   FINSI
FINPROGRAMA


11.-Imprimir y contar los multiplos de 3 desde la unidad hasta un numero que introducimos por teclado.

 PROGRAMA multiplo3
ENTORNO:
   i <- 3
   n <- 0
   c <- 0
ALGORITMO:
   Borrar_pantalla( )
   ESCRIBIR "N£mero: "
   LEER n
   MIENTRAS i <= n HACER
      SI i = int( i / 3 ) * 3 ENTONCES
         ESCRIBIR i
         c <- c + 1
      FINSI
      i <- i + 1
   FINMIENTRAS
   ESCRIBIR "El n£mero de m£ltiplos de 3 son: "
   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( )
   MIENTRAS i < 101 HACER
      SI i = int( i / 2 ) * 2 ENTONCES
         sumapar <- sumapar + i
      SINO
         sumaimp <- sumaimp + i
      FINSI
      i <- i + 1
   FINMIENTRAS
   ESCRIBIR "La suma de los pares es: "
   ESCRIBIR sumapar
   ESCRIBIR "La suma de los impares es: "
   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( )
   MIENTRAS i < 101 HACER
      SI i = int( i / 2 ) * 2 O i = int( i / 3 ) * 3 ENTONCES
         c <- c + 1
         ESCRIBIR i
      FINSI
      i <- i + 1
   FINMIENTRAS
   ESCRIBIR "El n£mero de m£ltiplos es de: "
   ESCRIBIR c
FINPROGRAMA


14.-Hacer un pseudocodigo que imprima el mayor y el menor de una serie de cinco numeros que vamos introduciendo por teclado.

 PROGRAMA mayor_menor
ENTORNO:
   con <- 0
   n <- 0
   maximo <- 0
   minimo <- 99999
ALGORITMO:
   Borrar_pantalla( )
   MIENTRAS con <= 5 HACER
      ESCRIBIR "N£mero: "
      LEER n
      SI n > maximo ENTONCES
         maximo = n
      FINSI
      SI n < minimo ENTONCES
         minimo <- n
      FINSI
      con <- con + 1
   FINMIENTRAS
   ESCRIBIR "El mayor de los n£meros es: "
   ESCRIBIR maximo
   ESCRIBIR "El menor de los n£meros es: "
   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 cuantos de ellos son pares. Calcular la suma de los impares.

 PROGRAMA par_impar
ENTORNO:
   num1 <- 0
   num2 <- 0
   aux <- 0
   son <- 0
   pares <- 0
   sumaimpa <- 0
ALGORITMO:
   Borrar_pantalla( )
   ESCRIBIR "N£mero: "
   LEER num1
   ESCRIBIR "N£mero: "
   LEER num2
   SI num1 > num2 ENTONCES
      aux <- num1
      num1 <- num2
      num2 <- aux
   FINSI
   MIENTRAS num1 >= num2 HACER
      ESCRIBIR num1
      son <- son + 1
      SI num1 = int( num1 / 2 ) * 2 ENTONCES
         pares <- pares + 1
      SINO
         sumaimpa <- sumaimpa + num1
      FINSI
      num1 <- num1 + 1
   FINMIENTRAS
   ESCRIBIR "N£meros visualizados: "
   ESCRIBIR son
   ESCRIBIR "Pares hay: "
   ESCRIBIR pares
   ESCRIBIR "La suma de los impares es: "
   ESCRIBIR sumaimpa
FINPROGRAMA


Bucles anidados y subprogramas

16.-Imprimir diez veces la serie de numeros del 1 al 10.

 PROGRAMA diez
ENTORNO:
   serie <- 0
ALGORITMO:
   Borrar_pantalla( )
   MIENTRAS serie <= 10 HACER
      numero <- 1
      MIENTRAS numero <= 10 HACER
         ESCRIBIR numero
         numero <- numero + 1
      FINMIENTRAS
      serie <- serie + 1
   FINMIENTRAS
FINPROGRAMA


17.-Imprimir, contar y sumar los multiplos de 2 que hay entre una serie de numeros, tal que el segundo sea mayor o igual que el primero.

 PROGRAMA multiplo2
ENTORNO:
   res <- "S"
ALGORITMO:
   Borrar_pantalla( )
   MIENTRAS res = "S" HACER
      c <- 0
      sum <- 0
      num1 <- 0
      num2 <- -999
      ESCRIBIR "N£mero: "
      LEER num1
      ESCRIBIR "N£mero mayor que el anterior"
      MIENTRAS num1 >= num2 HACER
         LEER num2
      FINMIENTRAS
      num1 <- num1 + 1
      MIENTRAS num1 <= num2 - 1 HACER
         SI num1 = int( num1 / 2 ) * 2 ENTONCES
            ESCRIBIR num1
            c <- c + 1
            sum <- sum + num1
         FINSI
         num1 <- num1 + 1
      FINMIENTRAS
      ESCRIBIR "N£mero de m£ltiplos de 2: "
      ESCRIBIR c
      ESCRIBIR "Su suma es: "
      ESCRIBIR sum
      res <- Espacios( 1 )
      MIENTRAS res <> "S" Y res <> "N" HACER
         ESCRIBIR "Otra serie de n£meros (S/N): "
         LEER res
         res <- Convertir_may£sculas( res )
      FINMIENTRAS
   FINMIENTRAS
FINPROGRAMA


18.-Hacer un pseudocodigo que cuente las veces que aparece una determinada letra en una frase que introduciremos por teclado.

 PROGRAMA letra
ENTORNO:
   frase <- Espacios( 30 )
   letra <- Espacios( 1 )
   longitud <- 0
   a <- 0
   res <- "S"
ALGORITMO:
   MIENTRAS res = "S" HACER
      Borrar_pantalla( )
      ESCRIBIR "Introduce una frase: "
      LEER frase
      longitud <- Hallar_longitud( frase )
      i <- 1
      ESCRIBIR "Letra a buscar: "
      LEER letra
      MIENTRAS i <= longitud HACER
         SI letra = Caracter( frase, i, 1 ) ENTONCES
            a <- a + 1
         FINSI
         i <- i + 1
      FINMIENTRAS
      Borrar_pantalla( )
      ESCRIBIR "El n£mero de veces que aparece la letra "
      ESCRIBIR letra
      ESCRIBIR " en la frase "
      ESCRIBIR frase
      ESCRIBIR " es de "
      ESCRIBIR a
      res <- Espacios( 1 )
      MIENTRAS res <> "S" Y res <> "N" HACER
         ESCRIBIR "Desea introducir m&aacute;s frases (S/N): "
         LEER res
         res <- Convertir_may£sculas( res )
      FINMIENTRAS
   FINMIENTRAS
FINPROGRAMA


19.-Hacer un pseudocodigo que simule el funcionamiento de un reloj digital y que permita ponerlo en hora.

 PROGRAMA reloj
ENTORNO:
   horas <- 0
   minutos <- 0
   segundos <- 0
   res <- "S"
ALGORITMO:
   Borrar_pantalla( )
   ESCRIBIR "Horas: "
   LEER horas
   ESCRIBIR "Minutos: "
   LEER minutos
   ESCRIBIR "Segundos: "
   LEER segundos
   MIENTRAS res = "S" HACER
      MIENTRAS horas < 24 HACER
         MIENTRAS minutos < 60 HACER
            MIENTRAS segundos < 60 HACER
               ESCRIBIR horas
               ESCRIBIR minutos
               ESCRIBIR segundos
               segundos <- segundos + 1
            FINMIENTRAS
            minutos <- minutos + 1
            segundos <- 0
         FINMIENTRAS
         horas <- horas + 1
         minutos <- 0
      FINMIENTRAS
      horas <- 0
   FINMIENTRAS
FINPROGRAMA


20.-Calcular el factorial de un numero, mediante subprogramas.

 PROGRAMA factorial
ENTORNO:
   res <- "S"
ALGORITMO:
   MIENTRAS res = "S" HACER
      Borrar_pantalla( )
      factorial <- 1
      ESCRIBIR "N£mero: "
      LEER numero
      SI numero < 0 ENTONCES
         ESCRIBIR "No tiene factorial"
      SINO
         HACER Calculos
      FINSI
      HACER Mas
   FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Calculos
   MIENTRAS numero > 1 HACER
      factorial <- factorial * numero
      numero <- numero - 1
   FINMIENTRAS
   HACER Imprimir
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Mas
   res <- " "
   MIENTRAS res <> "S" Y res <> "N" HACER
      ESCRIBIR "Desea calcular m&aacute;s factoriales (S/N): "
      LEER res
      res <- Convertir_may£sculas( res )
   FINMIENTRAS
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Imprimir
   ESCRIBIR "Su factorial es: "
   ESCRIBIR factorial
FINSUBPROGRAMA


21.-Hacer un programa que calcule independientemente la suma de los pares y los impares de los numeros entre 1 y 1000, utilizando un switch.

 PROGRAMA suma
ENTORNO:
   par <- 0
   impar <- 0
   sw <- 0
   i <- 1
ALGORITMO:
   Borrar_pantalla( )
   MIENTRAS i <= 1000 HACER
      SI sw = 0 ENTONCES
         impar <- impar + i
         sw <- 1
      SINO
         par <- par + i
         sw <- 0
      FINSI
      i <- i + 1
   FINMIENTRAS
   ESCRIBIR "La suma de los pares es: "
   ESCRIBIR par
   ESCRIBIR "La suma de los impares es: "
   ESCRIBIR impar
FINPROGRAMA


Presentacion en pantalla y cabeceras

22.-Introducir una frase por teclado. Imprimirla cinco veces en filas consecutivas, pero cada impresion ir desplazada cuatro columnas hacia la derecha.

 PROGRAMA frase
ENTORNO:
   frase <- Espacios( 30 )
ALGORITMO:
   Borrar_pantalla( )
   EN 5,15 ESCRIBIR "Frase: "
   EN 5,22 LEER frase
   fi <- 8
   co <- 15
   veces <- 0
   MIENTRAS veces <= 5 HACER
      EN fi,co ESCRIBIR frase
      veces <- veces + 1
      co <- co + 4
      fi <- fi + 1
   FINMIENTRAS
FINPROGRAMA


23.-Hacer un pseudocodigo que imprima los n£meros del 0 al 100, controlando las filas y las columnas.

 PROGRAMA numeros
ENTORNO:
   c <- 0
ALGORITMO:
   Borrar_pantalla( )
   EN 5,20 ESCRIBIR "Los n£meros del 0 al 100 son: "
   fi <- 7
   col <- 5
   MIENTRAS c < 101 HACER
      EN fi,col ESCRIBIR c
      c <- c + 1
      col <- col + 4
      SI col > 75 ENTONCES
         fi <- fi + 2
         col <- 5
      FINSI
   FINMIENTRAS
FINPROGRAMA


24.-Comprobar si un numero mayor o igual que la unidad es primo.

 PROGRAMA primo
ENTORNO:
   res <- "S"
ALGORITMO:
   MIENTRAS res = "S" HACER
      Borrar_pantalla( )
      numero <- 0
      sw <- 0
      MIENTRAS numero < 1 HACER
         EN 8,10 ESCRIBIR "N£mero: "
         EN 8,18 LEER numero
      FINMIENTRAS
      i <- numero - 1
      MIENTRAS i > 1 Y sw <> 1 HACER
         SI numero = Int( numero / i ) * i ENTONCES
            sw = 1
         SINO
            i <- i - 1
         FINSI
      FINMIENTRAS
      SI sw = 1 ENTONCES
         EN 10,10 ESCRIBIR "no es primo"
      SINO
         EN 10,10 ESCRIBIR "s¡ es primo"
      FINSI
      HACER Mas
   FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Mas
   res <- " "
   MIENTRAS res <> "S" Y res <> "N" HACER
      ESCRIBIR "Desea introducir m s n£meros (S/N): "
      LEER res
      res <- Convertir_mayusculas( res )
   FINMIENTRAS
FINSUBPROGRAMA


25.-Introducir un numero menor de 5000 y pasarlo a numero romano.

 PROGRAMA romano
ENTORNO:
   res <- "S"
ALGORITMO:
   MIENTRAS res = "S" HACER
      Borrar_pantalla( )
      num <- 0
      MIENTRAS num < 1 O num > 5000 HACER
         EN 8,10 ESCRIBIR "N£mero: "
         EN 8,18 ESCRIBIR num
      FINMIENTRAS
      col <- 15
      MIENTRAS num >= 1000 HACER
         EN 15,col ESCRIBIR "M"
         num <- num - 1000
         col <- col + 1
      FINMIENTRAS
      SI num >= 900 ENTONCES
         EN 15,col ESCRIBIR "CM"
         num <- num - 900
         col <- col + 2
      FINSI
      SI num >= 500 ENTONCES
         EN 15,col ESCRIBIR "D"
         num <- num - 500
         col <- col + 1
      FINSI
      MIENTRAS num >= 100 HACER
         EN 15,col ESCRIBIR "C"
         num <- num - 100
         col <- col + 1
      FINMIENTRAS
      SI num >= 90 ENTONCES
         EN 15,col ESCRIBIR "XC"
         num <- num - 90
         col <- col + 2
      FINSI
      SI num >= 50 ENTONCES
         EN 15,col ESCRIBIR "L"
         num <- num - 50
         col <- col + 1
      FINSI
      SI num >= 40 ENTONCES
         EN 15,col ESCRIBIR "XL"
         num <- num - 40
         col <- col + 2
      FINSI
      MIENTRAS num >= 10 HACER
         EN 15,col ESCRIBIR "X"
         num <- num - 10
         col <- col + 1
      FINMIENTRAS
      SI num = 9 ENTONCES
         EN 15,col ESCRIBIR "IX"
         num <- num - 9
         col <- col + 2
      FINSI
      SI num >= 5 ENTONCES
         EN 15,col ESCRIBIR "V"
         num <- num - 5
         col <- col + 1
      FINSI
      SI num >= 4 ENTONCES
         EN 15,col ESCRIBIR "IV"
         num <- num - 4
         col <- col + 2
      FINSI
      MIENTRAS num > 0 HACER
         EN 15,col ESCRIBIR "I"
         num <- num - 1
         col <- col + 1
      FINMIENTRAS
      HACER Mas
   FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Mas
   res <- " "
   MIENTRAS res <> "S" Y res <> "N" HACER
      ESCRIBIR "Desea introducir m s n£meros (S/N): "
      LEER res
      res <- Convertir_mayusculas( res )
   FINMIENTRAS
FINSUBPROGRAMA


26.-Introducir una frase por teclado. Imprimirla en el centro de la pantalla.

 PROGRAMA centro
ENTORNO:
   res <- "S"
   frase <- Espacios( 40 )
ALGORITMO:
   MIENTRAS res = "S" HACER
      Borrar_pantalla( )
      EN 5,15 ESCRIBIR "Frase: "
      EN 5,22 LEER frase
      EN 12,40 - Int( Longitud( frase ) / 2 ) ESCRIBIR frase
      HACER Mas
   FINMIENTRAS
FINPROGRAMA


27.-Realizar la tabla de multiplicar de un numero entre 0 y 10.

 PROGRAMA tabla
ENTORNO:
   num <- -1
ALGORITMO:
   HACER Numero
   Borrar_pantalla( )
   EN 5,10 ESCRIBIR "Tabla de multiplicar del n£mero: "
   EN 5,40 LEER num
   i <- 0
   fi <- 8
   MIENTRAS i <= 10 HACER
      EN fi,15 ESCRIBIR num
      EN fi,19 ESCRIBIR " * "
      EN fi,23 ESCRIBIR i
      EN fi,25 ESCRIBIR " = "
      EN fi,29 ESCRIBIR num * i
      fi <- fi + 1
      i <- i + 1
   FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Numero
   MIENTRAS num < 0 HACER
      Borrar_pantalla( )
      EN 10,25 ESCRIBIR "N£mero: "
      EN 10,33 LEER num
   FINMIENTRAS
FINSUBPROGRAMA


Numeros aleatorios y menus

28.-Simular el lanzamiento de una moneda al aire e imprimir si ha salido cara o cruz.

 PROGRAMA moneda
ENTORNO:
   res <- "S"
ALGORITMO:
   MIENTRAS res = "S" HACER
      Borrar_pantalla( )
      SI Rnd( ) <= 0.5 ENTONCES
         EN 10,35 ESCRIBIR "Cara"
      SINO
         EN 10,35 ESCRIBIR "Cruz"
      FINSI
      HACER Mas
   FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Mas
   res <- Espacios( 1 )
   MIENTRAS res <> "S" Y res <> "N" HACER
      EN 20,30 ESCRIBIR "M s lanzamientos (S/N): "
      EN 20,57 LEER res
      res <- Convertir_mayusculas( res )
   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( )
   MIENTRAS i < 101 HACER
      SI Int( Rnd( ) * 6 ) + Int( Rnd( ) * 6 ) + 2 = 10 ENTONCES
         c <- c + 1
      FINSI
      i <- i + 1
   FINMIENTRAS
   EN 10,20 ESCRIBIR "Las veces que suman 10 son: "
   EN 10,48 ESCRIBIR c
FINPROGRAMA


30.-Simular una carrera de dos caballos si cada uno tiene igual probabilidad de ganar.

 PROGRAMA caballos
ENTORNO:
   dibujo <- "****"
   col1 <- 4
   col2 <- 4
ALGORITMO:
   Borrar_pantalla( )
   EN 10,col1 ESCRIBIR dibujo
   EN 10,col2 ESCRIBIR dibujo
   MIENTRAS col1 <= 75 Y col2 <= 75 HACER
      SI Rnd( ) <= 0.5 ENTONCES
         EN 10,col1 ESCRIBIR Espacios( 4 )
         col1 <- col1 + 4
         EN 10,col1 ESCRIBIR dibujo
      SINO
         EN 12,col2 ESCRIBIR Espacios( 4 )
         col2 <- col2 + 4
         EN 12,col2 ESCRIBIR dibujo
      FINSI
   FINMIENTRAS
   EN 16,20 ESCRIBIR "El ganador es el caballo n£mero: "
   SI col1 >= 75 ENTONCES
      EN 16,54 ESCRIBIR "1"
   SINO
      EN 16,54 ESCRIBIR "2"
   FINSI
FINPROGRAMA


31.-Introducir dos nymeros por teclado y mediante un menu, calcule su suma, su resta, su multiplicacion o su division.

 PROGRAMA menu1
ENTORNO:
   op <- 0
ALGORITMO:
   EN 10,20 ESCRIBIR "N£mero: "
   EN 10,29 LEER n1
   EN 12,20 ESCRIBIR "N£mero: "
   EN 12,29 LEER n2
   MIENTRAS op <> 5 HACER
      op <- 0
      Borrar_pantalla( )
      EN 6,20 ESCRIBIR "Men£ de opciones"
      EN 10,25 ESCRIBIR "1.- Suma"
      EN 12,25 ESCRIBIR "2.- Resta"
      EN 14,25 ESCRIBIR "3.- Multiplicaci¢n"
      EN 16,25 ESCRIBIR "4.- Divisi¢n"
      EN 18,25 ESCRIBIR "5.- Salir del programa"
      EN 22,25 ESCRIBIR "Elija opci¢n: "
      EN 22,39 LEER op
      Borrar_pantalla( )
      HACER CASO
         CASO op = 1
            EN 10,20 ESCRIBIR "Su suma es: "
            EN 10,33 ESCRIBIR n1 + n2
            Pausa( )
         CASO op = 2
            EN 10,20 ESCRIBIR "Su resta es: "
            EN 10,33 ESCRIBIR n1 - n2
            Pausa( )
         CASO op = 3
            EN 10,20 ESCRIBIR "Su multiplicaci¢n es: "
            EN 10,33 ESCRIBIR n1 * n2
            Pausa( )
         CASO op = 4
            EN 10,20 ESCRIBIR "Su divisi¢n es: "
            EN 10,33 ESCRIBIR n1 / n2
            Pausa( )
      FINCASO
   FINMIENTRAS
FINPROGRAMA


32.-Hacer un programa que nos permita introducir un numero por teclado y sobre el se realicen las siguientes operaciones: comprobar si es primo, hallar su factorial o imprimir su tabla de multiplicar.

 PROGRAMA menu2
ENTORNO:
   op <- 0
ALGORITMO:
   EN 10,20 ESCRIBIR "N£mero: "
   EN 10,29 LEER n
   MIENTRAS op <> 4 HACER
      op <- 0
      Borrar_pantalla( )
      EN 6,30 ESCRIBIR "Men£ de opciones"
      EN 10,25 ESCRIBIR "1.- Comprobar si es primo"
      EN 12,25 ESCRIBIR "2.- Hallar su factorial"
      EN 14,25 ESCRIBIR "3.- Tabla de multiplicar"
      EN 16,25 ESCRIBIR "4.- Salir del programa"
      EN 22,25 ESCRIBIR "Elija opci¢n: "
      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
   MIENTRAS i > 1 Y sw <> 1 HACER
      SI n = Int( n / i ) * i ENTONCES
         sw <- 1
      SINO
         i <- i - 1
      FINSI
   FINMIENTRAS
   Borrar_pantalla( )
   SI sw = 1 ENTONCES
      EN 10,10 ESCRIBIR "no es primo"
   SINO
      EN 10,10 ESCRIBIR "s¡ es primo"
   FINSI
   Pausa( )
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Factorial
   fac <- 1
   Borrar_pantalla( )
   SI n < 0 ENTONCES
      EN 10,10 ESCRIBIR "No tiene factorial"
   SINO
      MIENTRAS n > 1 HACER
         fac <- fac * n
         n <- n - 1
      FINMIENTRAS
      EN 10,10 ESCRIBIR "Su factorial es: "
      EN 10,27 ESCRIBIR fac
   FINSI
   Pausa( )
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Tabla
   i <- 0
   fi <- 10
   Borrar_pantalla( )
   MIENTRAS i <= 10 HACER
      EN 8,10 ESCRIBIR "Tabla de multiplicar"
      EN fi,10 ESCRIBIR n
      EN fi,15 ESCRIBIR "*"
      EN fi,20 ESCRIBIR i
      EN fi,25 ESCRIBIR "="
      EN fi,30 ESCRIBIR n * i
      i <- i + 1
   FINMIENTRAS
   Pausa( )
FINSUBPROGRAMA


Arrays unidimensionales

33.-Crear un array unidimensional de 20 elementos con nombres de personas. Visualizar los elementos de la lista debiendo ir cada uno en una fila distinta.


 PROGRAMA nombres
ENTORNO:
   DIMENSIONA datos[ 20 ]
   i <- 1
ALGORITMO:
   Borrar_pantalla( )
   fi <- 10
   MIENTRAS i < 21 HACER
      EN fi,10 ESCRIBIR "Nombre: "
      EN fi, 18 LEER datos[ i ]
      i <- i + 1
   FINMIENTRAS
   Borrar_pantalla( )
   i <- 1
   fi <- 3
   EN 1,20 ESCRIBIR "Elementos de la lista"
   MIENTRAS i < 21 HACER
      EN fi,28 ESCRIBIR datos[ i ]
      fi <- fi + 1
      i <- i + 1
   FINMIENTRAS
FINPROGRAMA


34.-Hacer un programa que lea las calificaciones de un alumno en 10 asignaturas, las almacene en un vector y calcule e imprima su media.

 PROGRAMA notamedia
ENTORNO:
   DIMENSIONA notas[ 10 ]
   suma <- 0
   media <- 0
ALGORITMO:
   Borrar_pantalla( )
   fi <- 7
   PARA i DESDE 1 HASTA 10 HACER
      EN fi,15 ESCRIBIR "Nota "
      EN fi,20 ESCRIBIR i
      EN fi,21 ESCRIBIR ": "
      EN fi,23 LEER notas[ i ]
      fi <- fi + 1
   FINPARA
   PARA i DESDE 1 HASTA 10 HACER
      suma <- suma + notas[ i ]
   FINPARA
   media <- suma / 10
   EN 20,20 ESCRIBIR "Nota media: "
   EN 20,32 ESCRIBIR media
FINPROGRAMA


35.-Usando el segundo ejemplo, hacer un programa que busque una nota en el vector.

 PROGRAMA buscar
ENTORNO:
   i <- 0
   num <- 0
ALGORITMO:
   Borrar_pantalla( )
   ESCRIBIR "Nota a buscar: "
   LEER num
   ITERAR
      i <- i + 1
      SI notas[ i ] = num O i = 10 ENTONCES
         SALIR
      FINSI
   FINITERAR
   SI notas[ i ] = num ENTONCES
      ESCRIBIR "Encontrado en posici&oacute;n: "
      ESCRIBIR i
   SINO
      ESCRIBIR "No existe esa nota"
   FINSI
FINPROGRAMA


Arrays bidimensionales

36.-Generar una matriz de 4 filas y 5 columnas con numeros aleatorios entre 1 y 100, e imprimirla.

 PROGRAMA matriz
ENTORNO:
   DIMENSIONAR A[ 4, 5 ]
   i <- 1
   fi <- 10
   co <- 15
ALGORITMO:
   Borrar_pantalla( )
   EN 6,25 ESCRIBIR "Elementos de la matriz"
   MIENTRAS i <= 4 HACER
      j <- 1
      MIENTRAS j <= 5 HACER
         A[ i, j ] <- Int( Rnd( ) * 100 ) + 1
         EN fi,co ESCRIBIR A[ i, j ]
         co <- co + 5
         j <- j + 1
      FINMIENTRAS
      co <- 15
      fi <- fi + 2
      i <- i + 1
   FINMIENTRAS
FINPROGRAMA


37.-Generar una matriz de 4 filas y 5 columnas con n£meros aleatorios entre 1y 100, y hacer su matriz transpuesta.

 PROGRAMA transpuesta
ENTORNO:
   DIMENSIONAR A[ 4, 5 ]
   DIMENSIONAR B[ 5, 4 ]
   fi <- 8
   co <- 10
   fit <- 8
   cot <- 40
   i <- 1
ALGORITMO:
   Borrar_pantalla( )
   EN 6,15 ESCRIBIR "Matriz uno"
   EN 6,45 ESCRIBIR "Transpuesta"
   MIENTRAS i <= 4 HACER
      j <- 1
      MIENTRAS j <= 5 HACER
         A[ i, j ] <- Int( Rnd( ) * 100 ) + 1
         B[ j, i ] <- A[ i, j ]
         EN fi,co ESCRIBIR A[ i, j ]
         EN fit,cot ESCRIBIR B[ j, i ]
         co <- co + 4
         fit <- fit + 2
         j <- j + 1
      FINMIENTRAS
      fi <- fi + 2
      co <- 10
      fit <- 8
      cot <- cot + 4
      i <- i + 1
   FINMIENTRAS
FINPROGRAMA


38.-Cargar en una matriz las notas de los alumnos de un colegio en funcion del numero de cursos (filas) y del n£mero de alumnos por curso (columnas).

 PROGRAMA notas
ENTORNO:
   i <- 1
   j <- 1
ALGORITMO:
   Borrar_pantalla( )
   EN 10,20 ESCRIBIR "N£mero de cursos: "
   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 2,25 ESCRIBIR "Introducci¢n de las notas"
   MIENTRAS i <= M HACER
      EN 10,25 ESCRIBIR "Curso: "
      EN 10,32 ESCRIBIR i
      MIENTRAS j <= N HACER
         EN 14,25 ESCRIBIR "Alumno: "
         EN 14,33 ESCRIBIR j
         EN 16,25 ESCRIBIR "Nota: "
         EN 16,32 LEER A[ i, j ]
         j <- j + 1
      FINMIENTRAS
      i <- i + 1
   FINMIENTRAS
FINPROGRAMA


39.-Ordenar una matriz de M filas y N columnas por la primera columna utilizando el m‚todo SHELL (por insercion).

 PROGRAMA ordenar
ENTORNO:
   i <- 1
   j <- 1
   fi <- 10
   co <- 15
   M <- 0
   N <- 0
ALGORITMO:
   Borrar_pantalla( )
   EN 10,20 ESCRIBIR "Filas: "
   EN 10,27 LEER M
   EN 12,20 ESCRIBIR "Columnas: "
   EN 12,30 LEER N
   DIMENSIONAR A[ M, N ]
   Borrar_pantalla( )
   MIENTRAS i <= M HACER
      MIENTRAS j <= N HACER
         A[ i, j ] = Int( Rnd( ) * 100 ) + 1
         EN fi,co ESCRIBIR A[ i, j ]
         co <- co + 5
         j <- j + 1
      FINMIENTRAS
      co <- 15
      fi <- fi + 2
      i <- i + 1
   FINMIENTRAS
   salto <- Int( M / 2 )
   MIENTRAS salto >= 1 HACER
      sw <- 1
      MIENTRAS sw <> 0 HACER
         sw <- 0
         i <- 1
         MIENTRAS i <= M - salto HACER
            SI A[ i, 1 ] > A[ i + salto, 1 ] ENTONCES
               HACER Cambios
            FINSI
            i <- i + 1
         FINMIENTRAS
      FINMIENTRAS
      salto <- Int( salto / 2 )
   FINMIENTRAS
FINPROGRAMA
------------------------------
SUBPROGRAMA Cambios
   j <- 1
   MIENTRAS j <= N HACER
      aux <- A[ i + salto, j ]
      A[ i + salto, j ] <- A[ i, j ]
      A[ i, j ] <- aux
      j <- j + 1
   FINMIENTRAS
   sw <- 1
FINSUBPROGRAMA


Arrays multidimensionales

40.-Crear una tabla de 3 paginas, 4 filas y 5 columnas donde el primer elemento valga 1, el segundo 2, el tercero 3 y as¡ sucesivamente, e imprimirla.

 PROGRAMA tabla
ENTORNO:
   DIMENSIONAR A[ 3, 4, 5 ]
   i <- 1
   j <- 1
   k <- 1
   b <- 0
   fi <- 8
   co <- 12
ALGORITMO:
   MIENTRAS i <= 3 HACER
      Borrar_pantalla( )
      EN fi,co ESCRIBIR "Elementos de la p gina: "
      EN fi,co + 24 ESCRIBIR i
      fi <- fi + 2
      MIENTRAS j <= 4 HACER
         MIENTRAS k <= 5 HACER
            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
      EN fi + 2,20 ESCRIBIR "Pulse INTRO para continuar ..."
      Pausa( )
      i <- i + 1
   FINMIENTRAS
FINPROGRAMA


41.-Se dispone de una tabla de 5 p ginas, 10 filas y 20 columnas, que se refieren al centro, al curso y al numero de alumnos de un colegio respectivamente. Imprimir la nota media por curso y la nota media maxima y su centro de pertenencia.

 PROGRAMA notas
ENTORNO:
   max <- -1
   sum <- 0
   centro <- 0
   i <- 1
   j <- 1
   k <- 1
   fi <- 10
ALGORITMO:
   Borrar_pantalla( )
   EN 8,18 ESCRIBIR "Centro"
   EN 8,38 ESCRIBIR "Nota media"
   MIENTRAS i <= 5 HACER
      MIENTRAS j <= 10 HACER
         MIENTRAS k <= 20 HACER
            sum <- sum + A[ i, j, k ]
            k <- k + 1
         FINMIENTRAS
         j <- j + 1
      FINMIENTRAS
      EN fi,20 ESCRIBIR i
      EN fi,40 ESCRIBIR sum / 20
      fi <- fi + 2
      SI sum / 20 > max ENTONCES
         max <- sum / 20
         centro <- i
      FINSI
      i <- i + 1
   FINMIENTRAS
   EN fi + 2,20 ESCRIBIR "Nota media m xima: "
   EN fi + 2,39 ESCRIBIR max
   EN fi + 4, 20 ESCRIBIR "pertenece al centro: "
   EN fi + 4,41 ESCRIBIR centro
FINPROGRAMA


42.-Una empresa guarda en una tabla de 3x12x4 las ventas realizadas por sus tres representantes a lo largo de doce meses de sus cuatro productos, VENTAS[ representante, mes, producto ]. Queremos proyectar el array tridimensional sobre uno de dos dimensiones que represente el total de ventas, TOTAL[ mes, producto ], para lo cual sumamos las ventas de cada producto de cada mes de todos los representantes. Imprimir ambos arrays.

 PROGRAMA ventas
ENTORNO:
   ** Las variables est n definidas en cada subprograma
ALGORITMO:
   HACER Volcar
   HACER Imp_Tres
   HACER Imp_Dos
FINPROGRAMA
------------------------------
SUBPROGRAMA Volcar
   DIMENSIONAR TOTAL[ 12, 4 ]
   j <- 1
   MIENTRAS j <= 12 HACER
      k <- 1
      MIENTRAS k <= 4 HACER
         i <- 1
         suma <- 0
         MIENTRAS i <= 3 HACER
            suma <- suma + VENTAS[ i, j, k ]
            i <- i + 1
         FINMIENTRAS
         TOTAL[ j, k ] <- suma
         k <- k + 1
      FINMIENTRAS
      j <- j + 1
   FINMIENTRAS
FINSUBPROGRAMA
------------------------------
SUBPROGRAMA Imp_Tres
   i <- 1
   MIENTRAS i <= 3 HACER
      Borrar_pantalla( )
      fi <- 8
      co <- 12
      EN fi,co ESCRIBIR "Ventas del representante: "
      EN fi,co + 26 ESCRIBIR i
      fi <- fi + 2
      j <- 1
      MIENTRAS j <= 12 HACER
         k <- 1
         MIENTRAS k <= 4 HACER
            EN fi,co ESCRIBIR VENTAS[ i, j, k ]
            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
   EN 8,20 ESCRIBIR "Ventas totales"
   fi <- 10
   co <- 16
   MIENTRAS j <= 12 HACER
      k <- 1
      MIENTRAS k <= 4 HACER
         EN fi,co ESCRIBIR TOTAL[ j, k ]
         co <- co + 4
         k <- k + 1
      FINMIENTRAS
      fi <- fi + 2
      co <- 12
      j <- j + 1
   FINMIENTRAS
FINSUBPROGRAMA


Ficheros

43.-
Hacer un programa que nos permita dar altas en el fichero secuencial DATOS.DAT, cuyos campos son: DNI, NOMBRE, APELLIDOS, DIRECCION y PROVINCIA.


[code] PROGRAMA altas 
ENTORNO: 
   res <- "S" 
ALGORITMO: 
   MIENTRAS res = "S" HACER 
      ABRIR "DATOS.DAT" 
      sw <- 0 
      num <- 0 
      Borrar_pantalla( ) 
      EN 5,10 ESCRIBIR "D.N.I.: " 
      EN 5,18 LEER num 
      MIENTRAS NO Eof( ) Y sw = 0 HACER 
         SI dni = num ENTONCES 
            EN 10,10 ESCRIBIR "Alta duplicada" 
            EN 15,10 ESCRIBIR "Pulse INTRO para continuar" 
            Pausa( ) 
            sw <- 1 
         SINO 
            Siguiente_registro( ) 
         FINSI 
      FINMIENTRAS 
      SI sw = 0 ENTONCES 
         EN 7,5 ESCRIBIR "Nombre: " 
         EN 9,5 ESCRIBIR "Apellidos: " 
         EN 11,5 ESCRIBIR "Direcci&oacute;n: " 
         EN 13,5 ESCRIBIR "Provincia: " 
         EN 7,16 LEER nombre 
         EN 9,16 LEER apellidos 
         EN 11,16 LEER direccion 
         EN 13,16 LEER provincia 
         dni <- num 
         Final_fichero( ) 
         Escribir_registro( ) 
      FINSI 
      CERRAR "DATOS.DAT" 
      res <- Espacios( 1 ) 
      HACER Mas 
   FINMIENTRAS 
FINPROGRAMA 
------------------------------ 
SUBPROGRAMA Mas 
   MIENTRAS res <> "S" Y res <> "N" HACER 
      ESCRIBIR "Desea m s altas (S/N): " 
      LEER res 
      res <- Convertir_mayusculas( res ) 
   

16 comentarios - 52 Ejercicios en Pseudocódigo

@lpg09 +2
muy bueno! gracias man, me alegro que te haya servido la idea . van 10
@jafetsacha +1
hace cuento que no te veo amigo! te dejo mis ultimo punto!
@daniisss +2
no entiendo nada, ni ahi, pero te felicito por compartir estas cosas que deben ser re útiles para los que estan en el tema
@Luzbelito_88
Como futuro programador agradezco tu aporte
@Onehit77
No consigo entender el pseudocódigo y tengo que escribir un programa en el que tenés que adivinar un número que está entre 1-100 y tenés 10 intentos
@wndr94
es con random
@jshares
se agradece! igual fijate que en el ej.2 parece está mal condicion. deberia ser MIENTRAS c >= 0 HACER
@woldkeeper
muy bueno gracias, lastima que ya paso la entrega de mis trabajos.
@Alejandro_Caro
Error en el ejercicio 15, hay un signo invertido. 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 cuantos de ellos son pares. Calcular la suma de los impares.

PROGRAMA par_impar
ENTORNO:
num1 <- 0
num2 <- 0
aux <- 0
son <- 0
pares <- 0
sumaimpa <- 0
ALGORITMO:
Borrar_pantalla( )
ESCRIBIR "N£mero: "
LEER num1
ESCRIBIR "N£mero: "
LEER num2
SI num1 < num2 ENTONCES
aux <- num1
num1 <- num2
num2 <- aux
FINSI
MIENTRAS num1 <= num2 HACER ///<----- en el original está el signo invertido
ESCRIBIR num1
son <- son + 1
SI num1 = int( num1 / 2 ) * 2 ENTONCES
pares <- pares + 1
SINO
sumaimpa <- sumaimpa + num1
FINSI
num1 <- num1 + 1
FINMIENTRAS
ESCRIBIR "N£meros visualizados: "
ESCRIBIR son
ESCRIBIR "Pares hay: "
ESCRIBIR pares
ESCRIBIR "La suma de los impares es: "
ESCRIBIR sumaimpa
FINPROGRAMA
@Alejandro_Caro
Nueva corrección en la respuesta
Otro signo mal
PROGRAMA par_impar
ENTORNO:
num1 <- 0
num2 <- 0
aux <- 0
son <- 0
pares <- 0
sumaimpa <- 0
ALGORITMO:
Borrar_pantalla( )
ESCRIBIR "N£mero: "
LEER num1
ESCRIBIR "N£mero: "
LEER num2
SI num1 > num2 ENTONCES /// otro signo mal, corregido
aux <- num1
num1 <- num2
num2 <- aux
FINSI
MIENTRAS num1 <= num2 HACER ///<----- en el original está el signo invertido
ESCRIBIR num1
son <- son + 1
SI num1 = int( num1 / 2 ) * 2 ENTONCES
pares <- pares + 1
SINO
sumaimpa <- sumaimpa + num1
FINSI
num1 <- num1 + 1
FINMIENTRAS
ESCRIBIR "N£meros visualizados: "
ESCRIBIR son
ESCRIBIR "Pares hay: "
ESCRIBIR pares
ESCRIBIR "La suma de los impares es: "
ESCRIBIR sumaimpa
FINPROGRAMA
@gamerandres
como soluciono este en lpp?
algoritmo que lea una fecha cualquiera (dd,mm,aaaa) y muestre la fecha del dia siguiente???