Aprendiendo a programar programando

    cabecera

terepebernal.com

Pseudocódigo Ejemplo. Hoja de Calendario en PSeInt

El objetivo de este ejercicio es programar un calendario en pseudocódigo con PSeInt. El algoritmo calendario mostrará por pantalla la hoja de calendario del mes y año que el usuario introduzca por teclado. Será un calendario entre el año 1601 y el año 3000. El único dato del que partir para iniciar el algoritmo es que el 1 de enero de 1601 fue lunes.

Si necesitas ver ejercicios básicos de pseudocódigo y saber como usar PSeInt, puede ayudarte Algoritmos en Pseudocódigo con PSeInt. Lo más básico

Si aún no tienes instalada esta aplicación, puedes descargar PSeInt de su página oficial.

Este mismo algoritmo lo puedes ver «traducido a Javascript» en Algoritmo Hoja de Calendario en JS

Si quieres estar al tanto de las novedades y publicaciones de esta página web

Suscríbete

Puedes ver el resultado de este ejemplo en pseudocódigo para febrero de 1969 en la siguiente imagen:

Resultado pseudocódigo ejemplo

Algoritmo calendario – Pseudocódigo Ejemplo

El algoritmo calendario será el programa principal, desde donde se llama al resto de instrucciones.

Primero se declaran las variables:

  • month, year, donde se guardarán los valores del mes y año, que se pedirán al usuario por teclado.
  • S, para manejar un bucle «mientras» en el que, primero se comprobará que el mes y el año sean correctos y después se preguntará al usuario si quiere salir del programa o continuar.
  • seguir, donde guardará la respuesta del usuario a la pregunta de si quiere continuar o no.

Y después se entra en una estructura de control mientras que se repetirá hasta que no cambie el valor de S a Falso, lo cual dependerá de si el usuario quiere seguir o no ejecutando el programa. Si el mes y el año son correctos se mostrará por pantalla la hoja de calendario con la función drawMonth(year, month).

// Mostrará por pantalla una hoja de calendario de un mes y año
// que se pedirá al usuario por teclado. 
// El valor del año estará entre 1601 y 3000

Algoritmo calendario
// Declaración de variables
   Definir year, month Como Entero;
   Definir S Como Logico;
   Definir seguir Como Caracter;

   S <- Verdadero;
   Mientras S Hacer
      // Pedir por teclado el mes
      Escribir '¿Mes (1..12)? ' Sin Saltar;
      Leer month;
      // Comprueba que el mes sea correcto
      Si (month>=1 Y month<=12)  Entonces
      // Pedir por teclado el año
         Escribir '¿Año (1601...3000)? '  Sin Saltar;
         Leer year;
         // Comprueba que el año sea correcto
         Si (year<1601 O year>3000) Entonces
            Escribir 'Año incorrecto';
         SiNo
            drawMonth(year,month);             // Dibuja la hoja de calendario
            Escribir ' ';
         FinSi
      SiNo
         Escribir 'Mes incorrecto';
      FinSi
      // Da la opción de seguir o salir del programa
      Escribir 'Para continuar pulse la tecla S ... ';
      Leer seguir;
      Si ((seguir=='S') O (seguir=='s')) Entonces
         S <- Verdadero;
      SiNo
         S <- Falso;
      FinSi
   FinMientras
FinAlgoritmo

Y el diagrama de flujo correspondiente:

Diagrama flujo programa principal

 

Pero antes de pintar la hoja de calendario hay que hacer varios cálculos, así que de momento en PSeInt voy a ir sustituyendo drawMonth(year, month) por los cálculos que hay que ir haciendo hasta conseguir pintarlo todo.

Lo primero que necesito saber es en que día de la semana cae el primer día del mes que introduce el usuario, y para saberlo tendré que averigüar en que cae el primer día del año que también ha introducido el usuario. El único dato que tengo para calcular ambas cosas es que el primer día de 1601 fue lunes. Vamos allá…

Función isLeapYear

Esta función (leap year = año bisiesto) me va a hacer falta para calcular en que día de la semana cae el primer día del año. Esta función recibe el año (year) y devuelve (lY) con un valor lógico (verdadero o falso) dependiendo de si el año es bisiesto o no. Si lo es febrero tendrá 29 días en vez de 28, y por tanto, el año bisiesto tendrá un día más que el año común, es decir, 366 días.

Un año es bisiesto si es múltiplo de 4, excepto los que son múltiplos de 100 y que no son también múltiplos de 400. Son bisiestos: 1604, 1992, 2000 o 2400, pero no lo son: 1900, 2100 o 2900.

La expresión lógica del algoritmo sería:

siendo

  • p = múltiplo de 4
  • q = múltiplo de 100
  • r = múltiplo de 400

Un número es múltiplo de otro si le contiene una o varias veces, exactamente; esto es si al dividirlo nos da de resto 0. Utilizamos el operador MOD (resto), si dividimos el año entre 4 y nos da de resto 0, entonces será bisiesto siempre que no acabe en 00, que entonces tendremos que comprobar si es múltiplo de 400, en cuyo caso, también será bisiesto.

El pseudocódigo correspondiente a esta función sería:

// Recibe el año (year) y devuelve (lY) si es bisiesto o no
Funcion lY <- isLeapYear(year)
   // Si el año es múltiplo de 4
   Si (year MOD 4==0) Entonces
      lY <- Verdadero;
      // Si además es múltiplo de 100 y de 400
      Si ((year MOD 100!=0) O (year MOD 400==0)) Entonces
         lY <- Verdadero;
      SiNo
         lY <- Falso;
      FinSi
   SiNo
      lY <- Falso;
   FinSi
FinFuncion

El diagrama de flujo para esta función será el siguiente:Diagrama flujo función isLeapYear
Una vez que puedo averigüar si un año es bisiesto o no, ya puedo encargarme de la siguiente función, que me permitirá calcular en qué día de la semana cae el primer día del año.

Función firstDayYear

Esta función recibe el año (year) correspondiente, y devuelve (dW) el día de la semana en el que empieza dicho año. Se sabe que el año 1601 comienza en lunes. De ahí partiremos para hacer los cálculos, teniendo en cuenta que cada año que pasa hay que añadir un día más del anterior, y si el anterior es bisiesto, se añadirán dos días. Por ejemplo, si el primer día del año 1601 fue lunes, el primer día de 1602 será martes, el de 1603 será miércoles y el de 1604 será jueves, y el de 1605, al ser el año anterior bisiesto, será sábado.

  • restaY, guardará el número de años a recorrer desde 1601 hasta el año del que vamos a calcular su primer día de la semana.
  • dW, guardará el número del día de la semana.
  • lY, guardará si el año anterior fue bisiesto o no.
// Recibe el año (year) correspondiente y
// devuelve el día de la semana (dW) en el que cae el primer día de dicho año
Funcion dW <- firstDayYear(year)
   Definir dW,i Como Entero;
   Definir lY Como Logico;

   Si year==1601 Entonces
   // Si es 1601, el primer día del año es Lunes
      dW <- 1;
   SiNo
   // Si el año es mayor que 1601
   // Buscar primer dia del año
      dW <- 1;                          // Se comienza en lunes
      Para i<-1602    Hasta year    Hacer
      // Si el año anterior fue bisiesto el día de la semana
      // habrá que sumarle dos más, y sino uno.
         lY <- isLeapYear(i-1);
         Si lY  Entonces
           dW <- dW+2;
         SiNo
           dW <- dW+1;
         FinSi
          // Si se llega a 8, es lunes
          Si dW==8  Entonces
            dW <- 1;
          FinSi
          // Si se llega a 9, es martes
          Si dW==9  Entonces
            dW <- 2;
          FinSi
      FinPara
   FinSi
FinFuncion

El diagrama de flujo para esta función será el siguiente:

Diagrama de flujo función firstDayYear

 

Bien, ahora que ya tengo el día de la semana en el que cae el primer día del año, ya tengo el primer día para el mes de enero, pero hay 12 meses. Eso se verá en el siguiente apartado.

Función firstDayMonth

Esta función recibe el año (year) y el mes (month) correspondientes, y devuelve (dW) el día de la semana en el que empieza el mes de dicho año. Aquí voy a utilizar una estructura de control «para» que me va ayudar a recorrer los meses del calendario hasta llegar al mes del que quiero, y al tiempo que recorro los meses, voy calculando el día de la semana que corresponde.

  • Empiezo en enero, con el contador i igual a 1, el día de la semana será el mismo que el primero del año, que lo obtenemos con fDY <- firstDayYear(year).
  • Para i igual a 2, febrero, como le precede un mes de 31 días, su primer día de la semana será el mismo que el del mes anterior más tres días (4 semanas + 3 días). Y lo mismo sucederá con abril, junio, agosto, septiembre y noviembre, para i igual a 4, 6, 8, 9 y 11.
  • Para i igual a 3, marzo, como le precede febrero, su primer día de la semana dependerá de si febrero tiene 28 ó 29 días, que se sabrá con lY <- isLeapYear(year). Si tiene 28 (4 semanas justas), el día de la semana será el mismo, y si tiene 29, habrá que sumarle un día.
  • Para i igual a 5, mayo, como le precede un mes de 30 días, su primer día de la semana será el mismo que el del mes anterior más dos días (4 semanas + 2 días). Y lo mismo sucederá con julio, octubre y diciembre, para i igual a 7, 10 y 12.
// Recibe el año (year) y mes (month) correspondientes y
// devuelve el día de la semana (dW) en el que cae el primer día del mes de ese año
Funcion dW <- firstDayMonth(year,month)
   // Declarar variables
   Definir fDY,dW,i Como Entero;
   Definir lY Como Logico;

   lY <- isLeapYear(year);                 // ¿Es un año bisiesto?
   fDY <- firstDayYear(year);            // Primer día de la semana del año
   Para i<-1  Hasta month  Hacer
      // Si es enero, el primer día será el primer día del año
      Si i==1  Entonces
         dW <- fDY;
      FinSi
      // Si es marzo, el primer día dependerá de si el año es bisiesto o no
      Si i==3  Entonces
         Si lY  Entonces
            dW <- dW+1;
         SiNo
            dW <- dW;
         FinSi
      FinSi
      // Si es un mes precedido de otro de 31 días, se le sumarán 3 días
      Si (i==2) O (i==4) O (i==6) O (i==8) O (i==9) O (i==11) Entonces
         dW <- dW+3;
      FinSi
      // Si es un mes precedido de otro de 30 días, se le sumarán 2 días
      Si (i==5) O (i==7) O (i==10) O (i==12) Entonces
          dW <- dW+2;
      FinSi
      // Si llega a 8, es lunes
      Si dW==8 Entonces
         dW <- 1;
      FinSi
      // Si llega a 9, es martes
      Si dW==9 Entonces
         dW <- 2;
      FinSi
      // Si llega a 10, es miércoles
      Si dW==10 Entonces
         dW <- 3;
      FinSi
   FinPara
FinFuncion

El diagrama de flujo para esta función será el siguiente:

Diagrama de flujo función firstDayMonth

Función drawMonth

La función drawMonth(year,month) recibe como parámetros el año (year) y el mes (month), que el usuario previamente ha introducido por teclado. Además, utilizando otras funciones, muestra por pantalla la hoja de calendario completa. Las funciones que utiliza se irán mostrando a continuación, cada una de ellas resuelve un problema más pequeño, como mostrar la cabecera de la hoja del calendario, mostrar la primera semana, mostrar las semanas centrales, etc...

A continuación se muestra el pseudocódigo que he utilizado para esta función. En los comentarios utilizo los verbos dibujar o pintar, obviamente es una manera de hablar, con PSeInt, que yo sepa, no se pueden usar gráficos.

// Dibuja la hoja de calendario del mes (month) y año (year)
Funcion drawMonth(year,month)
   // Declara las variables:
   // nDM: día del mes que toca escribir
   // lDM: último día del mes
   // week: para guardar los caracteres a mostrar por pantalla
   Definir nDM,lDM Como Entero;
   Definir week Como Cadena;
   drawHeader(year,month);                          // Dibuja la cabecera de la hoja de calendario
   openMonth(year,month);                           // Dibuja los caracteres anteriores a la primera semana
   nDM <- drawFirstWeek(year,month);                 // Dibuja la primera semana del mes
   lDM <- lastDayMonth(year,month);
   Mientras (lDM-(nDM-1))>=7 Hacer                          // Mientras queden más de 7 días
      week = "";                                  // Inicializar week
      nDM <- drawNextWeek(nDM,week);                 // Dibuja las semanas centrales
   FinMientras
   Si lDM!=(nDM-1) Entonces                  // Si no ha llegado al último día
      drawLastWeek(nDM,year,month);                  // Dibuja la última semana
   FinSi
FinFuncion

Funciones monthText y drawHeader

Para mostrar por pantalla la cabecera de la hoja de calendario nos va a hacer falta el mes en forma de texto. Lo vamos a obtener con la función monthText(month), que recibe como parámetro el mes (month) en forma de número y lo devuelve como texto mediante la variable (mT).

Esta función es sencilla, utiliza una estructura de control de selección múltiple para escoger el texto a devolver. Simplemente según el número (del 1 al 12) que month tenga guardado, se le asignará a la variable mT el texto que corresponda.

// Recibe el mes (month) como número y
// devuelve el mismo mes (mT) como texto
Funcion mT <- monthText(month)
   // Declara la variable mT, para contener el texto
   // del mes que corresponda y devolverlo
   Definir mT Como Texto;
   // Dependiendo del número de mes, se le asigna a mT el texto correspondiente
   Segun month  Hacer
      1:
         mT <- 'ENERO';
      2:
         mT <- 'FEBRERO';
      3:
         mT <- 'MARZO';
      4:
         mT <- 'ABRIL';
      5:
         mT <- 'MAYO';
      6:
         mT <- 'JUNIO';
      7:
         mT <- 'JULIO';
      8:
         mT <- 'AGOSTO';
      9:
         mT <- 'SEPTIEMBRE';
      10:
         mT <- 'OCTUBRE';
      11:
         mT <- 'NOVIEMBRE';
      12:
         mT <- 'DICIEMBRE';
      FinSegun
FinFuncion

Con esta función y alguna cosilla más ya se puede mostrar la cabecera por pantalla, lo vemos a continuación.

La función drawHeader(year,month), mostrará por pantalla la cabecera de la hoja de calendario. Recibe como parámetros, el mes (month) y el año (year), y muestra:

  • en la primera línea: el mes y el año,
  • en la segunda línea: el símbolo «igual» (=) repetidamente, para simular un subrayado doble,
  • en la tercera línea: los días de la semana,
  • y en la cuarta línea: otro subrayado doble.
// Dibuja la cabecera de la hoja de calendario del mes (month) y año (year)
Funcion drawHeader(year,month)
   // Declara la variable line, para controlar
   // el número de caracteres que hay que pintar
   // hasta llegar al año
   Definir line Como Entero;
   // Primero un salto de línea
   Escribir ' ';
   // Se le asigna a line el número de caracteres
   // que tiene el mes correspondiente
   line <- Longitud(monthText(month));
   // Se escribe el mes en forma de texto
   Escribir monthText(month) Sin Saltar;
   // Hasta sumar 22 se escriben espacios
   Mientras line<=22 Hacer
   Escribir ' ' Sin Saltar;
   line <- line+1;
   FinMientras
   // Se escribe el año
   Escribir year;
   // Subrayado doble
   Escribir '===========================';
   // Días de la semana
   Escribir 'LU  MA  MI  JU  VI | SA  DO';
   // Otro subrayado doble
   Escribir '===========================';
FinFuncion

El resultado para febrero de 1969 se ve en la siguiente imagen:

Resultado función drawHeader

 

Funciones openMonth y drawFirstWeek

La función openMonth(year,month) recibe como parámetros el mes (month) y el año (year) y no devuelve nada. Empieza a pintar la quinta línea de la hoja de calendario. Dependiendo del día de la semana en el que comience el mes, mostrará por pantalla los caracteres que correspondan, utilizando la variable week. Si el primer día del mes es lunes, no mostrará ninguno.

// Dependiendo del día de la semana en el
// que comience el mes, muestra por pantalla
// los caracteres que corresponden
Funcion week <- openMonth(year,month)
   // Declarar dW para guardar en día de la semana
   // en el que cae el primer día del mes, y la
   // variable week donde guardar los caracteres
   // para empezar la hoja de calendario con
   // la primera semana
   Definir dW Como Entero;
   Definir week Como Cadena;
   dW<-firstDayMonth(year,month);           // Primer día del mes 
    // Según el día de la semana que sea
   // se pintan los caracteres que corresponden
   Segun dW Hacer
      2:
            week <-  ' .  ';
      3:
            week <-  ' .   .  ';
      4:
            week <-  ' .   .   .  ';
      5:
            week <-  ' .   .   .   .  ';
      6:
            week <-  ' .   .   .   .   . | ';
      7:
            week <-  ' .   .   .   .   . |  .  ';
   FinSegun
FinFuncion

La función drawFirstWeek(year,month) recibe como parámetros el mes (month) y el año (year), así como la variable week, para guardar los caracteres que siguen, y devuelve el número del día del mes (nDM) en el que comienza la semana siguiente. Esta función muestra por pantalla los días de la primera semana del mes terminando así, la quinta línea de la hoja del calendario, después devuelve (nDM), para seguir con la semana siguiente mediante la función drawNextWeek(nDM).

// Recibe año (year) y mes (month), así como
// la variable week, para guardar los caracteres que siguen, y
// devuelve el número del día del mes (nDM) en el que comienza la semana siguiente y,
// además, pinta la primera semana del mes 
FuncionnDM <- drawFirstWeek(year,month,week)
   // Declarar las variables necesarias
   Definir nDM Como Entero;                  // Número del día del mes (valor a devolver)
   Definir nDW Como Entero;                  // Número del día de la semana
   Definir i Como Entero;                    // Contador para recorrer la semana

   nDW <- firstDayMonth(year,month);                     // Día de la semana del primer día del mes
   nDM <- 1;                                             // Día 1 del mes
   Para i <- nDW Hasta 7 Hacer                           // Hasta que llegamos al domingo...
      week <- week + ' ';                          // Escribimos un espacio
      week <- week + ConvertirATexto(nDM);                          // Escribir el número del día del mes
      // Sumar 1 al día del mes y al día de la semana
      nDM <- nDM+1;
      nDW <- nDW+1;
      Si nDW==6 Entonces
         week <- week + ' |';                     // Si es sábado
      SiNo
         week <- week + ' ';                     // El resto de días
      FinSi
      Si i!=7 Entonces
        week <- week + ' ';                     // Otro espacio
   FinPara
   Escribir week;
FinFuncion

Su diagrama de flujo es el siguiente:

Diagrama de flujo función drawFirstWeek

 

Función lastDayMonth

La función lastDayMonth(year,month) recibe como parámetro el año (year) y el mes (month) correspondientes y devuelve el número de días (lDM) que tiene el mes. Será una función auxiliar para las funciones drawLastWeek y drawMonth.

// Recibe el año (year) y el mes (month) y
// devuelve el último día del mes (lDM),
// es decir, el número de días del mes
Funcion lDM <- lastDayMonth(year,month)
   // Declarar variables: lY (guarda si es año bisiesto),
   // MesDias (para guardar los días que deben tener los meses),
   // i (para usarlo de contador y recorrer MesDias)
   // y lDM (para guardar el último día del mes).
   Definir lY Como Logico;
   Definir i Como Entero;
   Dimension MesDias[12];
   Definir MesDias Como Entero;
   Definir lDM Como Entero;

   lY <- isLeapYear(year);                  // ¿Es año bisiesto?
   Si lY Entonces
      MesDias[2]<-29;                  // Si lo es, febrero tiene 29 días
   SiNo
      MesDias[2]<-28;
   FinSi

   // Recorrer MesDias y guardar el número de días que tienen el resto de meses
   Para  i<-1 Hasta  12 Hacer
      Si (i==4 O i==6 O i==9 O i==11) Entonces
         MesDias[i]<-30;
      FinSi
      Si (i==1 O i==3 O i==5 O i==7 O i==8 O i==10 O i==12) Entonces
         MesDias[i]<-31;
      FinSi
   FinPara
   lDM <- MesDias[month];                  // El mes (month) tiene (lDM) días
FinFuncion

Función drawNextWeek

La función drawNextWeek(nDM) recibe como parámetro el número del día del mes (nDM), la variable week, para guardar los caracteres a mostrar por pantalla, y devuelve, de nuevo, el número del día del mes (nDM), pero esta vez actualizado al día en el que comienza la semana siguiente. Además, muestra por pantalla las semanas centrales, las que se encuentran entre la primera y la última semana, por medio de la variable week.

// Recibe el número del día del mes (nDM) que toca mostrar por pantalla,
// y la variable week, donde guardar los caracteres a mostrar por pantalla,
//  y devuelve, de nuevo, el número del día del mes (nDM), en el que comienza la semana siguiente.
// Además, pinta las semanas que existen entre la primera y la última semana.
Funcion nDM <- drawNextWeek(nDM, week)
   // Declarar i para usarlo como contador
   Definir i Como Entero;
   // Escribir la semana
   Para i<-1 Hasta 7 Hacer                  // Del lunes al domingo
      Si nDM<10 Entonces                  // Si el número del mes es menor de 10
         week <- week + ' ';                   // Escribir un espacio
      FinSi
      week <- week + ConvertirATexto(nDM);             // Escribir el número del día del mes
      nDM <- nDM+1;                         // Sumar 1 al día del mes
      Si (i<5 O i==6) Entonces                     // Si no hemos llegado al viernes o es sábado
         week <- week + '  ';                      // Escribir dos espacios
      FinSi
      Si i==5 Entonces                     // Si es viernes
         week <- week + ' | ';                         // Escribir espacio-barra-espacio
      FinSi
   FinPara
   Escrirbir week;                                  // Pintar la semana
FinFuncion

El diagrama de flujo de esta función es el siguiente:

Diagrama de flujo función drawNextWeek

Bien, para terminar la hoja de calendario queda la última semana, que se mostrará con la siguientes funciones, drawLastWeek(nDM) y closeMonth().

Funciones drawLastWeek y closeMonth

La función drawLastWeek(nDM) recibe como parámetro el número del día del mes (nDM), el año (year) y el mes (month), y además muestra por pantalla la última semana y cierra la hoja de calendario, llamando a la función closeMonth.

// Recibe como parámetros: el número del día del mes (nDM) que toca mostrar,  por pantalla,
// el año (year) y el mes (month). Además, pinta la última semana y
// cierra la hoja de calendario llamando a la función closeMonth.
Funcion drawLastWeek(nDM,year,month)
   // Declarar variables:
   // i y j, para utilizar como contadores.
   // lDM para guardar el último día del mes.
   // week para guardar caracteres a mostrar por pantalla.
   Definir i,j Como Entero;
   Definir lDM Como Entero;
   Definir weej Como Cadena;
   lDM <- lastDayMonth(year,month);               // Último día del mes
   j <- (lDM-nDM)+1;                             // Número de días que faltan para terminar el mes
   Para i<-1 Hasta j Hacer                      // Escribir semana
      Si i<7 Entonces                      // Si no ha llegado al domingo
        week <- week + ConvertirATexto(nDM);                      // Escribir día
      FinSi
      nDM <- nDM+1;                      // Sumar 1 al día del mes
      Si (i<5) Entonces                      // Si no ha llegado al viernes
         week <- week + '  ';                      // Escribir espacio
      FinSi
      Si i==5 Entonces
         week <- week + ' | ';                      // Si es viernes, espacio-barra-espacio
      FinSi
   FinPara
   closeMonth(j,week);                      // Cerrar la hoja de calendario con los caracteres que correspondan
FinFuncion

El diagrama de flujo de esta función es el siguiente:

Diagrama de flujo función drawLastWeek

 

La función closeMonth(dW,week) recibe como parámetro el número del día de la semana (dW) en el que termina el mes, y la variable week para completar la semana con los caracteres que correspan, y con ello cerrar la hoja de calendario.

// Dependiendo del día de la semana en el que termine el mes,
// muestra los caracteres que corresponden. Recibe el día de la semana
// en el que acaba el mes y la variable week, para
// guardar los caracteres que faltan para
// cerrar la hoja de calendario. Además lo muestra por pantalla.
Funcion closeMonth(dW, week)
   Segun dW  Hacer
      1:
            week <- week + ' .   .   .   . |  .   .';
      2:
            week <- week + ' .   .   . |  .   .';
      3:
            week <- week + ' .   . |  .   .';
      4:
            week <- week + ' . |  .   .';
      5:
            week <- week + ' .   .';
      6:
            week <- week + '   .';
   FinSegun
   Escribir week;
FinFuncion

Bueno, con esto finalizaría el algoritmo calendario. Seguro que es mejorable. Dime, ¿cómo lo hubieras hecho tú?

Si quieres descargar el fichero con el pseudocódigo del algoritmo calendario en PSeInt, puedes hacerlo desde GitHub aquí.

Puedes ver más sobre ejercicios básicos de Pseudocódigo y PSeInt en:

Y si te interesa, este mismo algoritmo lo puedes ver «traducido a Javascript» en Algoritmo Hoja de Calendario en JS

Si quieres estar al tanto de las novedades y publicaciones de esta página web

Suscríbete

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada.

    * (obligatorio)

    Derechos: Tienes derechos, entre otros, a acceder, rectificar, limitar y suprimir tus datos. Envíame un e-mail a contacto@terepebernal.com