28 Diciembre 2011
Enunciado:
Se trata de realizar un programa que muestre por pantalla la hoja del calendario de cualquier mes y año comprendido entre los años 1601 y 3000. El problema debe pedir el mes y el año sólo una vez para cada ejecución.
Se debe tener en cuenta que el día 1 de enero de 1601 fue lunes y que son años bisiestos los múltilplos de 4 excepto los que son múltiplos de 100 y que no son también múltiplos de 400.
Código:
#include <stdio.h>
typedef enum TipoDia {
lunes, martes, miercoles, jueves, viernes, sabado, domingo
}; /* Nuevo tipo enumerado para manejar los días de la semana. Lunes = 0, domingo = 6 */
/* constantes y variables globales a usar en el programa*/
int mes, anyo, diaDelMes;
/* Función para determinar si un año en concreto es bisiesto o no */
bool EsBisiesto (int anyo) {
if ((anyo % 400 == 0)) {
return true;
} else if ((anyo % 4 == 0) && (anyo % 100 != 0)) {
return true;
} else {
return false;
}
}
/* Función para calcular el día de la semana con la que comienza un mes de un año */
TipoDia DiaDeLaSemana (int anyo, int mes) {
int CuentaTotal;
int CuentaAnyos = 0;
int CuentaMeses = 0;
int DiasPorMes;
int DiasAnyo;
int DiaSemana;
/* Calcula el número de días transcurridos desde el (1/1/1601) hasta el (1/1/año a calcular) */
for (int k = 1601; k <= anyo-1; k++) {
if (EsBisiesto (k)) {
DiasAnyo = 366;
} else {
DiasAnyo = 365;
}
CuentaAnyos = CuentaAnyos + DiasAnyo;
}
/* Calcula el número de días transcurridos desde el (1/1/año a calcular) hasta el (1/mes a calcular/año a calcular) */
for (int k = 1; k <= mes-1; k++) {
if ((k == 1)|| (k == 3) || (k == 5) || (k == 7) || (k == 8) || (k == 10)) {
DiasPorMes = 31;
} else if (k == 2) {
if (EsBisiesto (anyo)) {
DiasPorMes = 29;
} else {
DiasPorMes = 28;
}
} else {
DiasPorMes = 30;
}
CuentaMeses = CuentaMeses + DiasPorMes;
}
CuentaTotal = CuentaAnyos + CuentaMeses; /* Calcula el número de días transcurridos desde el (1/1/1601) hasta el (1/mes a calcular/año a calcular) */
DiaSemana = CuentaTotal % 7; /* Si == 0 es lunes, == 1 es martes, etc... */
return TipoDia (DiaSemana);
}
/* Procedimiento para imprimir el resultado */
void ImprimirCalendario (int mes, int anyo) {
int DiasPorMes;
const int NumColumnas = 7;
int NumFilas;
int diaDelMes;
/* Número de días del mes a calcular*/
if ((mes == 1) || (mes == 3) || (mes == 5) || (mes == 7) || (mes == 8) || (mes == 10) || (mes == 12)) {
DiasPorMes = 31;
} else if (mes == 2) {
if (EsBisiesto (anyo)) {
DiasPorMes = 29;
} else {
DiasPorMes = 28;
}
} else {
DiasPorMes = 30;
}
/* Número de filas del calendario, 4, 5 o 6 */
if ((DiasPorMes == 31) && (DiaDeLaSemana (anyo, mes) >= 5) ) {
NumFilas = 6;
} else if ((DiasPorMes == 30) && (DiaDeLaSemana (anyo, mes) == 6) ) {
NumFilas = 6;
} else if ((DiasPorMes == 28) && (DiaDeLaSemana (anyo, mes) == 0) ) {
NumFilas = 4;
} else {
NumFilas = 5;
}
/* Impresión del nomnbre del mes */
if (mes == 1) {
printf( "ENERO%22d\n", anyo );
} else if (mes == 2) {
printf ( "FEBRERO%20d\n", anyo );
} else if (mes == 3) {
printf ( "MARZO%22d\n", anyo );
} else if (mes == 4) {
printf ( "ABRIL%22d\n", anyo );
} else if (mes == 5) {
printf ( "MAYO%23d\n", anyo );
} else if (mes == 6) {
printf ( "JUNIO%22d\n", anyo );
} else if (mes == 7) {
printf ( "JULIO%22d\n", anyo );
} else if (mes == 8) {
printf ( "AGOSTO%21d\n", anyo );
} else if (mes == 9) {
printf ( "SEPTIEMBRE%17d\n", anyo );
} else if (mes == 10) {
printf ( "OCTUBRE%20d\n", anyo );
} else if (mes == 11) {
printf ( "NOVIEMBRE%18d\n", anyo );
} else {
printf ( "DICIEMBRE%18d\n", anyo );
}
printf ( "===========================\n" );
printf ( "LU MA MI JU VI | SA DO\n" );
printf ( "===========================\n" );
diaDelMes = 1;
/* Primera fila del mes */
for (int j = 0; j < NumColumnas; j++) {
if (j < DiaDeLaSemana (anyo, mes)) {
if (j == 0) {
printf ( " ." );
} else if (j == 4) {
printf ( " . | " );
} else if (j == 5) {
printf ( " ." );
} else {
printf ( " .");
}
} else {
if (j == 0) {
printf ( "%2d", diaDelMes - DiaDeLaSemana (anyo, mes) );
} else if (j == 4) {
printf ( " %2d | ",diaDelMes - DiaDeLaSemana (anyo, mes) );
} else if (j ==5) {
printf ( "%2d",diaDelMes - DiaDeLaSemana (anyo, mes) );
} else {
printf (" %2d",diaDelMes - DiaDeLaSemana (anyo, mes) );
}
}
diaDelMes = diaDelMes + 1 ;
}
printf (" \n");
/* Una iteración por número de filas centrales */
for (int i = 0; i < NumFilas-2; i++) {
for (int j = 0; j < NumColumnas; j++) {
if (j == 0) {
printf ( "%2d", diaDelMes - DiaDeLaSemana (anyo, mes) );
} else if (j == 4) {
printf ( " %2d | ",diaDelMes - DiaDeLaSemana (anyo, mes) );
} else if (j ==5) {
printf ( "%2d",diaDelMes - DiaDeLaSemana (anyo, mes) );
} else {
printf (" %2d",diaDelMes - DiaDeLaSemana (anyo, mes) );
}
diaDelMes = diaDelMes + 1 ;
}
printf ( "\n" );
}
/* Última fila del mes */
for (int j = 0; j < NumColumnas; j++) {
if ((diaDelMes - DiaDeLaSemana (anyo, mes)) <= DiasPorMes ) {
if (j == 0) {
printf ( "%2d", diaDelMes - DiaDeLaSemana (anyo, mes) );
} else if (j == 4) {
printf ( " %2d | ",diaDelMes - DiaDeLaSemana (anyo, mes) );
} else if (j ==5) {
printf ( "%2d", diaDelMes - DiaDeLaSemana (anyo, mes) );
} else {
printf (" %2d", diaDelMes - DiaDeLaSemana (anyo, mes) );
}
} else {
if (j == 0) {
printf ( " ." );
} else if (j == 4) {
printf ( " . | " );
} else if (j == 5) {
printf ( " ." );
} else {
printf ( " .");
}
}
diaDelMes = diaDelMes + 1;
}
}
/* Programa Principal */
int main () {
/* Entrada de los dos datos que necesitamos: mes y año */
printf( "¿Mes (1..12)?" );
scanf( "%d", &mes );
printf( "¿Año (1601..3000)?" );
scanf( "%d", &anyo );
printf( "\n" );
if (mes < 1 || mes > 12) {
return 0;
} else if (anyo < 1601 || anyo > 3000) {
return 0;
} else {
ImprimirCalendario (mes, anyo);
}
}
servido por JOSHUA
3 comentarios
compártelo
7 Diciembre 2011
SEGUNDA PRÁCTICA: ROMBOS.
Enunciado de la práctica:
Esta práctica consiste en realizar un programa que imprima por pantalla rombos concéntricos dibujados con los caracteres '@', 'o' y '.'.
El programa solicitará, como dato de entrada, la longitud del lado del rombo más externo (es decir, su número de caracteres). De fuera hacia dentro, el primer rombo estará formado por caracteres '@', el segundo por caracteres '.', el tercero por caracteres 'o', el cuarto nuevamente por caracteres '.', el quinto por caracteres '@', el sexto también por caracteres '.', el séptimo por caracteres 'o' y así sucesivamente.
El rombo siempre debe quedar ajustado a la izquierda de la pantalla y estar separado con una línea en blanco después de la pregunta ¿lado del rombo?
El tamaño más grande del rombo será de 20 caracteres de lado. El programa no deberá imprimir nada para tamaños cero o negativo, ni para tamaños superiores a 20.
La secuencia cíclica de caracteres repite siempre este esquema: '@.0.'
Esta secuencia puede implementarse utilizando el operador % de resto de división.
Solución:
/************************************
* NOMBRE: #Perico#
* PRIMER APELLIDO: #Palotes#
* SEGUNDO APELLIDO: #Zutano#
* DNI: #99999999W#
* EMAIL: #99999999@yahoo.es#
************************************/
#include <stdio.h>
int main() {
int lado; /* lado del rombo */
/* Leer el lado del rombo deseado */
printf( "¿Lado del rombo?" );
scanf( "%d", &lado );
/* saltar una línea */
printf( "\n" );
/* Condicional para que el programa no se ejecute si el lado es menor a 0 o mayor de 20 */
if( lado > 0 && lado <= 20) {
/* Una iteración por cada línea del rombo en la parte superior */
for( int linea = 1; linea <= lado; linea++) {
/* Paso 1º: Espacios en blanco a la izquierda del rombo */
for( int posicion = 1; posicion <= lado - linea; posicion++ ) {
printf( " " );
}
/* Paso 2º: Escribir caracteres en cada línea hasta la mitad del rombo */
for( int posicion = 1; posicion <= linea; posicion++ ) {
if( posicion % 4 == 1) {
printf( "@" );
} else if( posicion % 4 == 2) {
printf( "." );
} else if( posicion % 4 == 3) {
printf( "o" );
} else {
printf( "." );
}
}
/* Paso 3º: Escribir caracteres en cada línea desde la mitad del rombo hasta el final */
for( int posicion = linea - 1; posicion >= 1; posicion-- ) {
if( posicion % 4 == 1) {
printf( "@" );
} else if( posicion % 4 == 2) {
printf( "." );
} else if( posicion % 4 == 3) {
printf( "o" );
} else {
printf( "." );
}
}
/* Pasar a la línea de abajo */
printf( "\n" );
}
/* Una iteración por cada línea del rombo en la parte inferior */
for( int linea = lado + 1; linea <= (lado * 2) - 1; linea++ ) {
/* Paso 1º: Espacios en blanco a la izquierda del rombo */
for( int posicion = 1; posicion <= linea - lado; posicion++ ) {
printf( " " );
}
/* Paso 2º: Escribir caracteres en cada línea hasta la mitad del rombo */
for (int posicion = 1; posicion <= lado - (linea - lado); posicion++ ) {
if( posicion % 4 == 1) {
printf( "@" );
} else if( posicion % 4 == 2) {
printf( "." );
} else if( posicion % 4 == 3) {
printf( "o" );
} else {
printf( "." );
}
}
/* Paso 3º: Escribir caracteres en cada línea desde la mitad del rombo hasta el final */
for( int posicion = lado - (linea - lado + 1); posicion >= 1 ; posicion--) {
if( posicion % 4 == 1) {
printf( "@" );
} else if( posicion % 4 == 2) {
printf( "." );
} else if( posicion % 4 == 3) {
printf( "o" );
} else {
printf( "." );
}
}
/* Pasar a la línea de abajo */
printf( "\n" );
}
}
}
servido por JOSHUA
1 comentario
compártelo
29 Octubre 2011
Con el procedimiento printf se imprimían en pantalla datos. Pero, ¿cómo se introducen datos en el programa? Una de las formas es mediante el procedimiento scanf.
1. El procedimiento scanf:
Este procedimiento está definido en el módulo de librería denominado stdio (). Sirve para leer datos de entrada y almacenarlos en variables declaradas anteriormente.
scanf( cadena con formatos, &variable1, &variable2, ...., &variableN );
Las variables van precedidas del carácter &.
servido por JOSHUA
sin comentarios
compártelo
29 Octubre 2011
La UNED emplea el lenguaje de programación C+- (C más menos). Está constituido por un subconjunto del vocabulario de los lenguajes C y C++.
Resolución de la primera práctica de la asignatura de Fundamentos de Programación, Grado en ingeniería informática, de la UNED:
Enunciado: Imprimir en pantalla los datos personales del alumno. Estos datos son: NOMBRE, PRIMER APELLIDO, SEGUNDO APELLIDO, DNI y EMAIL. Los datos personales del alumno deben coincidir con los datos incluidos en la cabecera.
/************************************
* NOMBRE: #Perico#
* PRIMER APELLIDO: #Palotes#
* SEGUNDO APELLIDO: #Zutano#
* DNI: #99999999#
* EMAIL: #Perico@yahoo.es#
************************************/
#include <stdio.h>
int main() {
printf( "Perico\n" );
printf( "Palotes\n" );
printf( "Zutano\n" );
printf( "99999999\n" );
printf( "Perico@yahoo.es" );
}
servido por JOSHUA
sin comentarios
compártelo
23 Octubre 2011
Los resultados de un programa deben ser emitidos al exterior del computador a través de un dispositivo de salida de datos: pantalla (lo más habitual), impresora, etc. Las acciones que envían resultados al exterior se llaman, en general, operaciones de escritura. Estas operaciones se definen como procedimientos.
1. El procedimiento printf:
Este procedimiento está definido en el módulo de librería denominado stdio (<stdio.h>). Imprime en la pantalla del ordenador una cadena de caracteres, valores de variables, etc.
a. Cadena de caracteres:
printf( "En un lugar de la Mancha "); Esto escribe en la pantalla: En un lugar de la Mancha
b. Cadena con formatos:
Se debe indicar qué tipo de formato posee el valor que se quiere mostrar en pantalla. La forma más simple de especificar el formato es mediante %codigo. Se usa el carácter % seguido de una letra de código que indica qué tipo de formato se debe aplicar.
Algunos formatos son:
%d proviene del inglés: decimal (número entero)
%f proviene del inglés: fixed point (número real)
%e proviene del inglés: exponential (número real con notación exponencial)
%g proviene del inglés: general (número real con o sin notación exponencial)
%c proviene del inglés: character (un carácter)
%s proviene del inglés: string (una cadena de caracteres)
Se puede añadir después del símbolo %: número.número (por ejemplo: %5.2f) Esto indica que el valor se va a mostrar ocupando 5 caracteres y 2 decimales.
Ejemplos:
printf( "%d", 1500 / 10); Resultado: 150
printf( "Resultados: %d & %d", 15 * 10, -5); Resultado: Resultados: 150 & -5
printf( "%15.3f", 5.3); Resultado: ..........5.300
servido por JOSHUA
sin comentarios
compártelo
22 Octubre 2011
El artículo 69 del Texto Refundido de la Ley sobre Régimen del Suelo y Ordenación Urbana, aprobado por el Real Decreto 1.346/1976, de 9 de abril (en adelante TRLS/76) establece:
"1. Cuando transcurran cinco años, desde la entrada en vigor del Plan o Programa de Actuación Urbanística sin que se llevase a efecto la expropiación de los terrenos que, con arreglo a su calificación urbanística, no sean edificables por sus propietarios, ni hayan de ser objeto de cesión obligatoria por no resultar posible la justa distribución de los beneficios y cargas en el polígono o unidad de actuación, el titular de los bienes o, sus causahabientes advertirán a la Administración competente de su propósito de iniciar el expediente de justiprecio, que podrá llevarse a cabo por ministerio de la Ley si transcurrieren otros dos años desde el momento de efectuar la advertencia.
A tal efecto, el propietario podrá presentar la correspondiente hoja de aprecio, y si transcurrieren tres meses sin que la Administración la acepte, podrá aquél dirigirse al Jurado provincial de Expropiación, que fijará el justiprecio conforme a los criterios de esta Ley y de acuerdo con el procedimiento establecido en los artículos 31 y siguientes de la Ley de Expropiación Forzosa.
2. A los efectos de lo establecido en el párrafo anterior, la valoración se entenderá referida al momento de la iniciación del expediente de justiprecio por ministerio de la Ley y los intereses de demora se devengarán desde la presentación por el propietario de la correspondiente tasación".
Al término del período de cinco años no se inicia automáticamente un procedimiento expropiatorio por ministerio de la Ley. Transcurrido dicho plazo el interesado puede presentar una advertencia ante la Administración competente para expropiar a fin de que ejerza de oficio su facultad expropiatoria. Si la inactividad persistiese durante los dos años siguientes, el interesado puede iniciar el expediente de justiprecio mediante la presentación de su hoja de aprecio. Dicho momento, el de la presentación de la hoja de aprecio, es el inicio del expediente de justiprecio, y determina el momento a que ha de referirse la valoración de los bienes objeto de expropiación.
El expediente de expropiación no se inicia a los cinco años. Tampoco se inicia con la presentación de la advertencia por parte del interesado. El texto de la Ley establece que desde dicha advertencia la Administración posee la facultad de iniciar de oficio el procedimiento. Si la Administración no lo inicia, es el interesado el que puede iniciarlo mediante la presentación de la hoja de aprecio. Por lo tanto, es coincidente el inicio del expediente expropiatorio con el inicio del expediente de justiprecio. Ambos coinciden con el día de la presentación de la hoja de aprecio ante la Administración expropiante.
En el caso del TRLS/08, la disposición transitoria tercera establece:
1. Las reglas de valoración contenidas en esta Ley serán aplicables en todos los expedientes incluidos en su ámbito material de aplicación que se inicien a partir de la entrada en vigor de la Ley 8/2007, de 28 de mayo, de Suelo.
Las reglas de valoración del TRLS/08 se aplicarán, pues, cuando la presentación de la hoja de aprecio en la Administración se haya realizado en fecha posterior a la de la entrada en vigor de la Ley 8/2007, de 28 de mayo, de Suelo. Es decir, posteriormente al 1 de julio de 2007.
servido por JOSHUA
sin comentarios
compártelo
11 Octubre 2011
Las constantes y las variables deben ser declaradas en el programa antes de ser utilizadas.
1. CONSTANTES:
Una constante es un valor fijo que se utiliza en el programa. El valor debe ser siempre el mismo y no debe cambiar.
La declaración de constantes con nombre consiste en asociar un identificador a dicho valor constante. Por ejemplo:
const float Pi = 3.14159265;
La declaración con nombre se inicia con la palabra const, y a continuación se escribe el tipo y nombre de la constante, seguidos del signo igual y el valor asociado.
Una posibilidad es declarar el valor en forma de expresión. En este caso la expresión se denomina expresión constante. Por ejemplo:
const float diametro = 2*radio;
2. VARIABLES:
Una variable es un valor que puede ser modificado cuantas veces se desee. El valor se almacena en la memoria hasta que se almacena un nuevo valor diferente. Por ejemplo:
int base, altura;
float volumen, area;
Sentencias de autoincremento y autodecremento: es bastante frecuente la necesidad de incrementar en uno el valor de una variable. La sentencia de autoincremento es mediante el símbolo ++. La sentencia de autodecremento es mediante el símbolo --. Por ejemplo:
variable++;
variable--;
servido por JOSHUA
sin comentarios
compártelo
24 Septiembre 2011
Un tipo de dato se define como una colección de valores posibles y las operaciones significativas que se pueden hacer sobre ellos.
En el lenguaje C++ hay varios tipos de datos predefinidos. Los más importantes son: int, float, char y bool.
Int. El tipo entero:
Los valores de este tipo son los valores numéricos enteros positivos y negativos. Coincide con el concepto matemático de los números enteros. Sin embargo, el rango de valores nunca es infinito, como en matemáticas. El rango depende de la plataforma (procesador, sistema operativo y compilador) que se esté utilizando.
Para 16 bits --> El rango va desde: -32.768 ........0......... 32.767 (2 elevado a 15)
Para 32 bits --> El rango va desde: -2.147.483.648 ........0........ 2.47.483.647 (2 elevado a 31)
Para 64 bits --> El rango va desde: -9.223.372.036.854.775.808 .........0........ 9.223.372.036.854.775.807 (2 elevado a 63)
Se puede hacer referencia al valor mínimo mediante el nombre simbólico INT_MIN, y al valor máximo mediante INT_MAX. El rango admisible será, por tanto: INT MIN ...... 0 ........ INT_MAX.
Float. El tipo real:
Los valores de este tipo son los valores numéricos reales positivos y negativos. Esta representación puede no ser exacta, debido a que no hay infinitos decimales. Nunca podrá ser posible una representación exacta de valores como Pi o e. En estos casos se manejan valores aproximados.
Para 32 bits; 6 cifras decimales --> El rango va desde: -3.4E+38 ......... -1.2E-38 / 0 / +1.2E-38......+3.4E+38
Para 64 bits; 15 cifras decimales --> El rango va desde: -1.7E+308............-2.3E-308 / 0 / +2.3E-308.......+1.7E+308
Char. El tipo carácter:
Los valores de este tipo son caracteres. Los valores ocupan 8 bits e incluyen el repertorio ASCII de 7 bits (letras inglesas mayúsculas y minúsculas. Algunos signos de puntuación y códigos de control) además de otros caracteres no ASCII que dependen de la tabla de caracteres establecida. La colección de valores del tipo char incluyen caracteres alfabéticos, numéricos, de puntuación y caracteres de control.
servido por JOSHUA
sin comentarios
compártelo
