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íbetePuedes ver el resultado de este ejemplo en pseudocódigo para febrero de 1969 en la siguiente imagen:
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
FinAlgoritmoY el diagrama de flujo correspondiente:
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
FinFuncionEl diagrama de flujo para esta función será el siguiente:
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
FinFuncionEl diagrama de flujo para esta función será el siguiente:
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
FinFuncionEl diagrama de flujo para esta función será el siguiente:
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
FinFuncionFunciones 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
FinFuncionCon 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:
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
FinFuncionLa 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;
FinFuncionSu diagrama de flujo es el siguiente:
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
FinFuncionFunció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
FinFuncionEl diagrama de flujo de esta función es el siguiente:
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
FinFuncionEl diagrama de flujo de esta función es el siguiente:
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;
FinFuncionBueno, 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:
- Algoritmos en Pseudocódigo con PSeInt. Lo más básico
- Algoritmo Día de la semana de una fecha con PSeInt. Reutilizando funciones
- Arreglos y parámetros por referencia en pseudocódigo con PSeInt
- Funciones de fecha en Pseudocódigo con PSeInt
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
A V I S O
Hola, si sueles venir por aquí sabrás que desde el 2 de marzo de 2020 no he parado de responder a peticiones de ayuda para ejercicios de algoritmos en PSeint. Tengo que parar de hacerlo, al menos de momento, terminó el confinamiento por el Covid-19 y no me da la vida; he vuelto a trabajar y tengo que recuperar lo no trabajado, y además tengo un proyecto entre manos que no quiero desatender.
Aquí tienes un montón de ejemplos que te pueden servir de ayuda para resolver tu ejercicio. Si pulsas CTRL+F (buscar) y añades las palabras adecuadas puedes moverte por la página y encontrar lo que buscas.
Aún me queda por responder algunos comentarios y lo haré. Pero a partir de hoy (14 de Junio de 2020) desactivo los comentarios temporalmente, porque no voy a poder atenderlos, y tampoco contestaré a peticiones de ayuda que me lleguen al correo electrónico o redes sociales y que consistan en realizar ejercicios, no me importará ponerte un enlace a algún ejercicio que ya esté hecho y que crea que es similar y pueda ayudarte, pero poco más.
Lo siento, yo también estoy aprendiendo e intento ganarme la vida con esto.