miércoles, 4 de diciembre de 2013

COMANDO CRONTAB.

crontab, es el documento en el que se almacenan un conjunto de comandos a realizar, en la fecha que le establezcamos.

Opciones:

Editamos el documento crontab para añadir una nueva tarea (linea) utilizamos crontab -e

Listamos nuestras tareas con crontab -l

crontab -u para utilizar el crontab de otro usuario del sistema.

Especificamos el directorio de crontab con crontab -c directorio 

Por último para borrar nuestro crontab usaríamos crontab-d

Este sería el contenido del fichero crontab:

# Edit this file to introduce tasks to be run by cron.
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
# To define the time you can provide concrete values for
# minute (m), hour (h), day of month (dom), month (mon),
# and day of week (dow) or use '*' in these fields (for 'any').# 
# Notice that tasks will be started based on the cron's system
# daemon's notion of time and timezones.
# Output of the crontab jobs (including errors) is sent through
# email to the user the crontab file belongs to (unless redirected).
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
# For more information see the manual pages of crontab(5) and cron(8)
# m h  dom mon dow   command

AQUÍ IRÁN LAS NUEVAS TAREAS

***** shutdown –r apagado del sistema con sudo.

30 18 * * *       /home/usuario/ejemplo.txt :ejecuta lo siguienta a las seis i media de la tarde.

martes, 3 de diciembre de 2013

GUIONES SHELL (CREAR Y BORRAR USUARIOS, GRUPOS Y CARPETAS PERSONALES).

Hemos realizado un guión shell que nos crea los grupos, usuarios y carpetas personales de usuario indicados en el mismo.

#!/bin/bash

#Crea usuarios, grupos y carpetas de usuario.


#Crear grupos:
groupadd -g 901 asir1
groupadd -g 902 asir2
groupadd -g 903 asir



#Crear usuarios:

for usuario in david jesus juan mario
do
user -g asir1 $usuario
done

for
usuario in tomas ivan alejandro
do
user -g asir2 $usuario
done

for
usuario in david jesus juan mario tomas ivan alejandro
do
user -g asir $usuario
done

#Añadir contraseña a los usuarios
for usuario in david jesus mario juan tomas alejandro ivan
do
read pass
      passwordf=`perl -e 'print crypt("'"$usuario"'","SA"), "\n";'`
     
usermod -p $password $usuario



Ahora vamos a borrar:


#!/bin/bash

#Borra usuarios, grupos y carpetas de usuario.


userdel -r david
userdel -r jesus
userdel -r mario
userdel -r juan
userdel -r tomas
userdel -r alejandro
userdel -r ivan

groupdel asir
groupdel asir1
groupdel asir2

rm -r /home/asir1
rm -r /home/asir2
rm -r /home/asir 

COMANDO AT (PROGRAMACIÓN DE TAREAS).

Con el comando at podemos programar la ejecución de una tarea a una hora determinada.

Importante!
Si no sabemos la hora exacta del sistema, la podremos comprobar con el comando date.
Opciones
atq nos muestra las tareas pendientes de ejecutar.

atrm nos permite eliminar tareas.

Ejemplo

atrm nº de la tarea a eliminar.

PROCESO TOP.

Con este comando podremos ver la lista de procesos que tenemos activos en el sistema.

Nos muestra:


  • El nombre.
  • El PID (Nº de identificación de proceso).
  • El usuario al que pertenecen.
  • El porcentaje de memoria y CPU que están ocupando.
  • El tiempo que lleva activo.
  • La prioridad de dicho proceso.
  • Algunos datos iniciales sobre el número de procesos que hay corriendo, cuantos parados, memoria ocupada, particiones.


DETENER Y MATAR PORCESOS (Control z, Control c).

Control z.

Con esta secuencia de teclas, podemos detener un proceso activo en nuestro sistema.

De esta forma lo podremos activar de nuevo, cuando queramos.

Control c.

Con esta otra secuencia, lo que conseguimos es matar un proceso activo en nuestro sistema.

Para que se active de nuevo el proceso, tendremos que lanzarlo de nuevo.

COMANDO FG (FOREGROUND).

Con este comando conseguiremos volver a activar los procesos que tengamos suspendidos y ponerlos en primer plano.

ejemplo:

Lanzamos un proceso, por ejemplo el navegador:

para ello abrimos una consola y escribimos lo siguiente:

firefox

Detenemos el proceso con control z.

fg para activarlo, lo cual te muestra en la consola el nombre del comando y te lo activa.

En caso de que tengamos varios procesos activos escribiríamos fg 1 para pasarlo a primer plano.

martes, 19 de noviembre de 2013

PERMISOS ESPECIALES EN LINUX (setuid, setgid, stikybit).

Este tipo de permisos especiales, son asignables a archivos y directorios (carpetas).

SETUID  (permisos temporales).

Si hablamos en octal y utilizamos el bit setuid, le estaremos asignando 4000, con lo que podremos ejecutar el archivo al que le asignemos este bit, en caso de ser nosotros los propietarios del mismo.

SETGID

Este bit activa los permisos 2000 en octal, lo cual nos otorga el permiso para entrar en carpetas (directorios) y crear archivos, de forma que se crea como si lo hubiese creado el propietario del directorio.

Ejemplo:

Si el propietario en nuestro sistema linux es root y nosotros somos usuario.

Asignamos el bit setgid, a una carpeta de la cual es propietario root

/Home/root/ejemplo

Creamos un archivo de nombre usuario.

La propiedad del archivo se la asignará a root.

STICKYBIT

Este bit se usa para activar el permiso de acceso a archivos y directorios.

En resumen, todo lo que creemos dentro de un directorio, también creado por nosotros, solo podrá ser borrado o modificado por nosotros.

Ejemplo:

root crea el directorio Exámenes y mete dentro los exámenes de los alumnos de su clase.

Al asignarle el stikybit a ese directorio.

Nadie excepto nosotros podremos modificar o borrar el contenido de ese directorio.

domingo, 28 de julio de 2013

REALIZACIÓN DE CAJAS DE TEXTO, HTML.

Para realizar una caja de texto debemos darle en el campo input type el atributo text.

Después pondríamos el atributo name, que indica el nombre asociado a la caja de texto.

maxlength: Permite indicar el número máximo de caracteres de la caja de texto.

value: Permite indicar el valor inicial que queremos que aparezca en la caja de texto.

REALIZACIÓN DE FORMULARIOS EN HTML.

Para realizar un formulario en HTML, necesitamos conocer las partes que lo componen:

action : Dentro de el introducimos la ruta de la web con la que está relacionado el formulario.

method : Con dos opciones posibles:

  • post : Al producirse cambios en el formulario, y que van a ser mandados a una base de datos.
  • get : Al no producirse cambios de ningún tipo.
Para enviar los datos a una cuenta de correo electrónico, podríamos lo siguiente:
<input type="hidden" name="formulario" value="formulario@ejemplo.com">

Ejemplo:
<form action="http://computersandprogrammers.blogspot.com.es/documentos/form.html" method="post">
   

miércoles, 24 de julio de 2013

COLUMNAS, CELDAS, FILAS Y ENCABEZADOS.

Columnas y filas: Determinadas con la etiqueta <tr>.

Celdas: Determinadas con la etiqueta <td>. Se encuentran dentro de una columna, por lo que se especificaría dentro de un <tr>.

Encabezados: Determinados con la etiqueta <th>, pero eso sí, dentro de una columna (<th>).

IMAGENES.

png: Transparencias.

gif: Imágenes pequeñas.

jpg: Imagenes de alta calidad.

alt: Alternativa.

align: Alineación de la imagen con el texto.

border: Ancho del borde.

width: Ancho de la imagen.

height: Alto de la imagen.

<img src=""> : Dentro de las comillas dobles, pondríamos la url de nuestra imagen a visualizar.

TABLAS.

Determinada con la etiqueta <table>, que indica el inicio o apertura de una tabla.

Opciones:

width : Esta opción especifica el ancho de la tabla.

th y td : Con estas opciones determinamos el ancho de columna.

height : Con esta opción determinamos la altura de la tabla.

border : Esta opción la usamos para asignar un borde a la tabla. Si fuera =0, no habría borde.

cellpadding : Determinamos el espacio entre el borde de la celda y su contenido.

cellspacing : Con ella determinamos el espacio que hay entre una celda y otra.

martes, 23 de julio de 2013

TIPOS DE LISTAS EN HTML.

Ordenadas:

Se declaran con la etiqueta <ol>. Ejemplo:

<ol>
      <li> ejemplo </li>
</ol>

Desordenadas:

Se declaran con la etiqueta <ul>. Ejemplo:

<ul>
     <li> ejemplo </li>
</ul>

MÁS TIPOS DE ENLACES.

Enlaces de descarga, usados mediante la etiqueta <a href=""> texto </a>

Enlaces de correo electrónico: ejemplo:

<a href="mailto:listadecontactos@computersandprogrammers.es">email computersandprogrammers" </a>

TARGET (DESTINOS).

Introducido por Ntescape y acoplada después a explorer y opera.

Viene acompañada de la etiqueta <a>, la cual indica el objetivo en el que se va a cargar la pagina, o  lo que visualizamos al pasar el ratón sobre el enlace.

ANCLAS.

Para nombrarla necesitamos la ruta del documento. Ejemplo:

ejemplo1.html#ancla1

CLASES DE REFERENCIAS.

Relativa: Todos los archivos y documentos están en la misma carpeta.

Absoluta: La veremos a través del siguiente ejemplo:

http://www.ejemplo.es/documentos/ejemplo1.html


  • http: Es el protocolo.
  • www.ejemplo.es: Sería el dominio.
  • documentos: Sería la ruta del archivo.
  • ejemplo1.html: Sería el nombre del archivo.
Nivel inferior: Sería documentos/ejemplo1.html

Nivel superior: Lo definimos con dos puntos. 

HIPERENLACES.

<a> : Crea un ancla.

<a href="http://computersandprogrammers.blogspot.com.es/"> : Crea un enlace a nuestro blog.






TEXTOS EN HTML.

&nbsp; : Deja un espacio en blanco.

&oacute; : Acentúa en este caso la o.

&ordf; : Pone la o como superindice.

&¡excl; :  Crea una apertura de admiración.

<strong> o <b> : Pone el texto en negrita.

<em> <i> : Pone el texto en cursiva.

<u> : Subraya el texto.

CAPAS EN HTML.

<div>, en lenguaje HTML, determina la sección de un documento HTML e inserta un salto de linea.

Con ella aplicamos estilos a nuestra página.

ETIQUETAS HTML.

Se suelen escribir en minúscula. Se abrirán y cerrarán en el mismo orden en que se crearon.

<html>: Se escribe para indicar el inicio de un documento HTML.

<head>: Indica la cabecera del documento HTML. Dentro de está, se encuentra la etiqueta <title>, que indica el título del documento, el cual se verá cuando la página se encuentra en favoritos o marcadores.




VERSIONES DE HTML.

HTML 1.

En 1991 comenzó el desarrollo de este lenguaje.

HTML2 (PLUS).

Empezó en 1993, y no llegó a ser un estándar.

HTML 3.0.

HTML 3.1.

HTML 3.2.

Desarrollado por Netscape y Mosaic.

HTML 4.0.

Creado en 1997.

HTML 4.0.1.

Creado en 1999.

HTML 5.0.

Creado en 2008.


¿QUE ES HTML?

Hipertext Mark-Up Languaje, lenguaje de marcado hipertextual. El navegador interpreta el código html y lo muestra.

viernes, 5 de julio de 2013

Características del Software

Para poder comprender lo que es el software (y consecuentemente la ingeniería del software), es importante examinar las características del software que lo diferencian de otras cosas que los hombres pueden construir. Cuando se construye hardware, el proceso creativo humano (análisis, diseño, construcción, prueba) se traduce finalmente en una forma física. Si construimos una nueva computadora, nuestro boceto inicial, diagramas formales de diseño y prototipo de prueba, evolucionan hacia un producto físico (pastillas de VLSI, tarjetas de circuitos impresos, fuentes de potencia, etc.).
     El software es un elemento de sistema que es lógico, en lugar de físico. Por tanto el software tiene unas características considerablemente distintas a las del hardware:

  1. El software se desarrolla, no se fabrica en un sentido clásico. Aunque existen similitudes entre el desarrollo del software y la construcción del hardware, ambas actividades son fundamentalmente diferentes. En ambas actividades la buena calidad se adquiere mediante un buen diseño, pero la fase de construcción del hardware puede introducir problemas de calidad que no existen (o son fácilmente corregibles) en el software. Ambas actividades dependen de las personas, pero la relación entre las personas dedicadas y el trabajo realizado es completamente diferente para el software. Ambas actividades requieren la construcción de un                  << producto >>, pero los métodos son diferentes.
Los costes del software se encuentran en la ingeniería. Esto significa que los proyectos de software no se pueden gestionar como si fueran proyectos de fabricación.
A mediados de los años ochenta, se introdujo el concepto de << fábrica del software >> en la literatura. Es importante tener en cuenta que este término no implica que la fabricación del hardware y el desarrollo del software sean equivalentes. En vez de ello, el concepto de fábrica de software recomienda el uso de herramientas para el desarrollo automático del software.

  1. El software no se << estropea >>.

  1. La mayoría del software se construye a medida, en  vez de ensamblar componentes existentes. Consideremos la forma en que se diseña y se construye el hardware de control para un producto basado en microprocesador. El ingeniero de diseño construye un sencillo esquema de la circuitería digital, hace algún análisis fundamental para asegurar que se realiza la función adecuada y va al catálogo de ventas de componentes digitales existentes. Cada circuito integrado (frecuentemente llamado un << CI >> o pastilla) tiene un número de pieza, una función definida y válida, una interfaz bien definida y un conjunto estándar de criterios de integración. Después de seleccionar cada componente, puede solicitarse la compra.
Por desgracia, los diseñadores del software no disponen de esa comodidad que acabamos de describir. Con unas pocas excepciones, no existen catálogos de componentes de software. Se puede comprar software ya desarrollado, pero sólo como una unidad completa, no como componentes que pueden reensamblarse en nuevos programas. Aunque se ha escrito mucho sobre << reutilización del software >>, solo estamos comenzando a ver las primeras implementaciones con éxito de este concepto.

2.1 Introducción a los Procesos. (TANENBAUM)

Todas las computadoras modernas pueden hacer varias cosas al mismo tiempo. Mientras ejecuta un programa de usuario, una computadora también puede estar leyendo de un disco y enviando texto a una pantalla o impresora. En un sistema de multiprogramación, la CPU también conmuta de un programa a otro, ejecutando cada uno durante decenas o centenas de milisegundos. Si bien, estrictamente hablando, en un instante dado la CPU está ejecutando sólo un programa, en el curso de un segundo puede trabajar con varios programas, dando a los usuarios la ilusión de paralelismo. A veces se usa el término seudoparalelismo para referirse a esta rápida conmutación de la CPU entre programas, para distinguirla del verdadero paralelismo de hardware de los sistemas multiprocesador (que tienen dos o más CPU que comparten la misma memoria física). Para el ser humano es difícil seguir la pista a múltiples actividades paralelas. Por ello, los diseñadores de sistemas operativos han desarrollado a lo largo de los años un modelo (procesos secuenciales) que facilita el manejo del paralelismo. 

Medición del Rendimiento

El tiempo es la medida del rendimiento de un ordenador: el ordenador que ejecuta la misma cantidad de trabajo en el menor tiempo  es el más rápido. El tiempo de ejecución de un programa se mide en segundos por programa. Pero el tiempo puede ser definido de maneras diferentes, dependiendo de lo que se cuente. La definición más sencilla de tiempo se llama tiempo de reloj (wall clock time), tiempo de respuesta (response time) o tiempo transcurrido (elapsed time). Estos términos se refieren al tiempo total que tarda una tarea en completarse, e incluye los accesos a disco, los accesos a memoria, las actividades de entrada/salida (E/S) y la carga adicional introducida por el sistema operativo.

      Sin embargo, a menudo los computadores son de tiempo compartido, y un procesador podría trabajar en diferentes programas simultáneamente. En estos casos, el sistema podría intentar optimizar la productividad más que tratar de minimizar el tiempo de ejecución de un programa  concreto. Por lo tanto, a menudo se querrá distinguir entre el tiempo transcurrido y el tiempo que un procesador está trabajando para nosotros. El tiempo de ejecución de CPU o simplemente tiempo de ejecución, el cual reconoce esta distinción, es el tiempo que la CPU dedica a ejecutar una tarea concreta y no incluye el tiempo perdido en las actividades de E/S o en la ejecución de otros programas. (Sin embargo, hay que recordar que el tiempo de respuesta que un usuario se encuentra será el tiempo transcurrido para el programa, no el tiempo de CPU.) Además, el tiempo de CPU puede ser dividido en el tiempo de CPU consumido por el programa, llamado tiempo de CPU del usuario, y el tiempo de CPU consumido por el sistema operativo, llamado tiempo de CPU del sistema. La diferenciación entre los tiempos de CPU del usuario y del sistema es difícil de realizar de una manera precisa ya que a menudo es complicado el asignar la responsabilidad de las actividades del sistema operativo a un programa de usuario más que a otro.

      El desglose del tiempo de ejecución de una tarea queda reflejado con el comando de Unix time el cual, por ejemplo, podría retornar lo siguiente:

90.7u  12.9s  2:39  65%

El tiempo de CPU de usuario es 90,7 segundos, el de sistema es 12,9 segundos, el tiempo total transcurrido es 2 minutos y 39 segundos (159 segundos), y el porcentaje del tiempo transcurrido que corresponde a tiempo de CPU es

(90,7 + 12,9) / 159 = 0,65

o el 65%. En este ejemplo, más de una tercera parte del tiempo total de ejecución ha sido consumido esperando la E/S, ejecutando otros programas o ambos.

      A veces, se ignora el tiempo de CPU del sistema cuando se examina el tiempo de ejecución global debido a las imprecisiones cometidas por los sistemas operativos al medir su tiempo de ejecución y a la inexactitud que supone el incluir el tiempo de CPU del sistema cuando se compara el rendimiento de dos máquinas con diferentes sistemas operativos. Por otra parte, el código de sistema en algunas máquinas corresponde a código de usuario en otras, y, como los programas no pueden funcionar sin un sistema operativo que se ejecute por encima de la circuitería, se puede argumentar a favor de usar la suma de los tiempos de CPU del usuario y del sistema como medida del tiempo de ejecución de un programa.

      Por consistencia, mantendremos la distinción entre el rendimiento basado en el tiempo transcurrido y el basado en el tiempo de ejecución de CPU. Usaremos el término rendimiento del sistema para referirnos a tiempo transcurrido en un sistema sin carga, y usaremos rendimiento de CPU para referirnos al tiempo de CPU. Aquí nos centraremos en el rendimiento de la CPU, aunque nuestras argumentaciones sobre la manera de exponer el rendimiento pueden ser aplicadas para el tiempo total de ejecución o para el tiempo de CPU.

      Aunque como usuarios de ordenadores nos importa el tiempo, cuando se examinan los detalles de una máquina es conveniente considerar el rendimiento según otras medidas. En particular, es posible que los diseñadores de computadores quieran considerar una máquina utilizando una medida relacionada con la rapidez con que la circuitería realiza determinadas funciones básicas. Casi todos los ordenadores tienen un reloj que funciona a una frecuencia concreta y determina el momento en que tienen lugar los sucesos en la circuitería. Estos intervalos discretos de tiempo se llaman los sucesos en la circuitería. Estos intervalos discretos de tiempo se llaman ciclos de reloj ( o tics, tics de reloj, periodos de reloj o ciclos). Los diseñadores llaman a la longitud del periodo de reloj tanto el tiempo de un ciclo de reloj completo (p. ej. 2 nanosegundos. o 2 ns) como la frecuencia de reloj (p. ej. 500 megahercios o 500 MHz), que es el inverso del periodo de reloj. 

martes, 18 de junio de 2013

Ordena los valores de un arreglo en orden ascendente

// Este programa ordena los valores de un arreglo en orden ascendente
#include <iostream>

using std::cout;
using std::endl;

#include <iomanip>

using std::setw;

int main()
{
const int tamanoArreglo = 10;
int a[ tamanoArreglo ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };
int mantiene;

cout << "Elementos de datos en el orden original \n";

// despliega el arreglo original
for ( int i = 0; i < tamanoArreglo ; i++ )
cout << setw( 4 ) << a[i];

//ordenamiento burbuja
// ciclo para controlar el numero de pasadas
for ( int pasada = 0; pasada < tamanoArreglo - 1 ; pasada++ )

//ciclo para controlar el numero de comparaciones por pasada
for ( int j = 0; j < tamanoArreglo - 1 ; j++ )

//compara los elementos contiguos y los intercambia si
//el primer elemento es mayor que el segundo
if ( a[j] > a[ j + 1 ] )
{
mantiene = a[j];
a[j] = a[j+1];
a[j+1] = mantiene;
}

cout << "\nElementos de datos en orden ascendente\n";

//muestra el arreglo ordenado
for ( int k = 0; k < tamanoArreglo ; k++ )
cout << setw( 4 ) << a[k];

cout << endl;

system("PAUSE");
return 0;
}

Paso de arreglos y de elementos individuales de arreglos a funciones

// Paso de arreglos y de elementos individuales
// de arreglos a funciones.

#include <iostream>

using std::cout;
using std::endl;

#include <iomanip>

using std::setw;

void modificaArreglo(int [], int);
void modificaElemento( int );

int main()
{
const int tamanoArreglo = 5;
int a[ tamanoArreglo ] = { 0, 1, 2, 3, 4 }; //inicializa a

cout << "Efectos de pasar el arreglo completo por referencia: "
<< "\n\nLos valores del arreglo original son: \n";

// despliega el arreglo original
for( int i = 0 ; i < tamanoArreglo ; i++ )
cout << setw( 3 ) << a[i];

cout << endl;

// pasa el arreglo a hacia modificaArreglo por referencia
modificaArreglo( a, tamanoArreglo );

cout << "Los valores del arreglo modificado son: \n";

// despliega el arreglo modificado
for( int j = 0; j < tamanoArreglo ; j++ )
cout << setw( 3 ) << a[j];

// despliega el valor de a[3]

cout << "\n\n\n"
<< "Efectos de pasar un elemento del arreglo por valor:"
<< "\n\nEl valor de a[3] es " << a[3] << '\n';

// pasa el elemento a[3] del arreglo por valor
modificaElemento( a[3] );

// muestra el valor de a[3]

cout << "El valor de a[3] es " << a[3] << endl;

system("PAUSE");
return 0; // indica terminacion exitosa

}//fin de main

// en la funcion modificaArreglo, "b" apunta hacia
// el arreglo original "a" en memoria.

void modificaArreglo( int b[], int tamanoDelArreglo )
{
// multiplica cada elemento del arreglo por 2
for(int k = 0 ; k < tamanoDelArreglo ; k++ )
b[k] *= 2;
}// fin de la funcion modificaArreglo

// en la funcion modificaElemento, "e" es una copia local del
// elemento a[3] del arreglo que se pasa desde main

void modificaElemento( int e )
{
// multiplica parametros por 2
cout << "Valor en modificaElemento es "
<< ( e *= 2 ) << endl;
}// fin de la funcion modificaElemento

Programa que lee archivos y los muestra en la pantalla

// DAP: Un programa que lee archivos y los muestra
// en la pantalla.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
FILE *fp;
char car;

if(argc != 2)
{
printf("Has olvidado introducir el nombre del archivo. \n");
exit(1);
}

if((fp = fopen(argv[1], "r")) == NULL)
{
printf("No se puede abrir el archivo. \n");
exit(1);
}

car = getc(fp); // lee un caracter

while (car != EOF)
{
putchar(car); //lo muestra en pantalla
car = getc(fp);
}

fclose(fp);

system("PAUSE");
return 0;
}

Un programa que guarda texto en disco

// TAD: Un programa que guarda texto en disco.

#include <stdio.h>
#include <stdlib.h>

int main (int argc, char *argv[])
{
FILE *fp;
char car;

if(argc != 2)
{
printf("Has olvidado introducir el nombre del archivo. \n");
exit(1);
}

if((fp = fopen(argv[1], "w")) == NULL)
{
printf("No se puede abrir el archivo. \n");
exit(1);
}

do
{
car = getchar();
putc(car, fp);
}while (car != 'f');

fclose(fp);

system("PAUSE");
return 0;
}//fin de main

lunes, 17 de junio de 2013

Leer un caracter del teclado y comprobar si es una letra

//Leer un caracter del teclado y comprobar si es una letra

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

int main()
{
char inicial;

printf("Cual es su primer caracter inicial ?:  ");
scanf("%c", &inicial);
if(!isalpha(inicial))
puts("Caracter no alfabético ");

puts("Terminado");
puts("\n");
system("PAUSE");
return 0;
}

Calculo de los numeros de Fibonacci

// Calculo de los numeros de Fibonacci

#include <stdio.h>
#include <stdlib.h>

long int fibonacci(void);

int main()
{
int n,i;
printf("\nCuantos numeros de fibonacci ?:  ");
scanf("%d", &n);
printf("\nSecuencia de fibonacci: 0,1");
for ( i = 2; i < n; i++ )
printf(", %ld", fibonacci());

printf("\n");
    system("PAUSE");
return 0;
}//fin main

long int fibonacci(void)
{
static int x = 0;
static int y = 1;
y = y + x;
x = y - x;
return y;
}

Funcion que devuelve mayor de dos enteros

// La funcion max devuelve el numero mayor de dos enteros

#include <stdio.h>
#include <stdlib.h>

int max(int x, int y)
{
if (x < y)
return y;
else
return x;
}//final de max

int main()
{
int m, n;

printf("Introduzca dos numeros enteros: ");
scanf("%d %d", &m,&n);
printf("Maximo de %d y %d es %d\n", m,n,max(m, n));



system("PAUSE");
return 0; //terminacion exitosa
}//fin de main

Suma de los 10 primeros numeros pares

// Suma de los 10 primeros numeros pares

#include <stdio.h>
#include <stdlib.h>

int main()
{
int suma = 0;
int n;
for(n = 1; n <= 10; n++)
suma += 2*n;

printf("La suma de los 10 primeros numeros pares: %d\n", suma);

system("PAUSE");
return 0; //terminacion exitosa
}//fin de main

Calculo de la media de seis numeros

// Calculo de la media de seis numeros

#include <stdio.h>
#include <stdlib.h>

int main()
{
const int TotalNum = 6;
int ContadorNum = 0;
float SumaNum = 0;
float media;
float numero;

printf("Introduzca %d numeros\n", TotalNum);

while(ContadorNum < TotalNum)
{

scanf("%f", &numero);
SumaNum += numero;
++ContadorNum;
}// fin de while

media = SumaNum/ContadorNum;
printf("Media: %.2f \n", media);

system("PAUSE");
return 0; //terminacion exitosa
}// fin de main

Calculo de calorias

/* El programa realiza un calculo de calorías */

#include <stdio.h>
#include <stdlib.h>

int main()
{
int num_de_elementos, cuenta, calorias_por_alimento, calorias_total;

printf(" Cuantos alimentos ha comido hoy ? ");
scanf("%d", &num_de_elementos);

calorias_total = 0;
cuenta = 1;

printf("Introducir el numero de calorias de cada uno de los ");
printf("%d", num_de_elementos,"alimentos tomados: \n");

while(cuenta++ <= num_de_elementos)
{
scanf("%d", &calorias_por_alimento);
calorias_total += calorias_por_alimento;
}//fin while

printf("Las calorias totales consumidas hoy son = ");
printf(" %d \n", calorias_total);

system("PAUSE");
return 0; //terminacion exitosa
}// fin de main

jueves, 30 de mayo de 2013

Rutinas, ejercicio 8.

8.   Simular un autoincrementado. Rutina para asignar un IdPedido automáticamente a cada nuevo Pedido que no tenga un valor explícito para el campo IdPedido. El valor que se le debe asignar al IdPedido debe ser el entero inmediatamente superior al mayor valor de dicho campo en la tabla Pedidos.

DELIMITER $$
CREATE DEFINER=`root`@`localhost` TRIGGER Before_Insert_Pedidos
BEFORE INSERT ON Pedidos
FOR EACH ROW
BEGIN
         DECLARE v_maxIdPedido INT;
         IF new.IdPedido IS NULL OR new.IdPedido=0 THEN
                     SELECT MAX(IdPedido) INTO v_maxIdPedido FROM Pedidos;
                    
                     SET new.IdPedido = v_maxIdPedido + 1;
         END IF;
END $$
DELIMITER ;

Tabla de referencia:

Rutinas, ejercicio 7.

7.   Rutina para actualizar automáticamente el IdPedido de la tabla DetallesPedidos en el caso de que se modifique el IdPedido de algún registro de la tabla Pedidos.

use Neptuno;
DELIMITER $$
CREATE DEFINER=`root`@`localhost` TRIGGER After_Update_Pedidos
AFTER UPDATE ON Pedidos
FOR EACH ROW
BEGIN
         IF old.IdPedido != new.IdPedido THEN
                     UPDATE DetallesPedidos SET IdPedido = new.IdPedido
                                 WHERE IdPedido = old.IdPedido;
         END IF;
END $$
DELIMITER ;

Tabla de referencia:


Rutinas, ejercicio 6.

6. Rutina que calcula el valor de la comisión que le corresponde al empleado que ha gestionado un pedido concreto.

DELIMITER $$

CREATE DEFINER=`root`@`localhost` FUNCTION `calculaComisionPorPedido`(v_idPedido INT) RETURNS float
BEGIN
         DECLARE v_idEmpleado, v_comision INT;
         DECLARE v_comisionPorPedido, v_totalPedido FLOAT;

         -- Seleccionamos el idEmpleado de ese pedido
         SELECT IdEmpleado INTO v_idEmpleado FROM Pedidos
         WHERE IdPedido = v_idPedido;

         -- Seleccionamos el porcentaje de comisión asociada a ese empleado
         SELECT Comision INTO v_comision FROM Empleados
         WHERE IdEmpleado = v_idEmpleado;

         -- Calculamos la cuantía total del pedido
         SELECT totalPedido(v_idPedido) INTO v_totalPedido;

         -- Calculamos cuánto supone el porcentaje de comisión de esa cuantía
         SELECT v_totalPedido * v_comision / 100 INTO v_comisionPorPedido;

RETURN v_comisionPorPedido;
END
$$

DELIMITER ;

Tabla de referencia:


sábado, 25 de mayo de 2013

Rutinas, ejercicio 5.

5.     Crea una rutina que elimine, de la tabla “acumulado”, los datos correspondientes al año en el que se ejecuta la rutina y, posteriormente, inserte en dicha tabla los puntos acumulados en ese año por cada uno de los tipos de sanción.
Para ello, utiliza un cursor que recorra los registros de “tipoSancion” y, por cada uno de ellos, ejecute una consulta con la que se inserte en la tabla “acumulado” los puntos acumulados por dicho tipo de sanción: 

DELIMITER $$

CREATE DEFINER=`root`@`localhost` PROCEDURE `puntosPorTipoSancion`()
BEGIN
  DECLARE done INT DEFAULT FALSE;

  DECLARE v_idTipoSancion, sumaPuntos INT;

  DECLARE cur CURSOR FOR SELECT idtipoSancion FROM tipoSancion;

  DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;

         DELETE FROM acumulado WHERE anyo = YEAR(CURRENT_DATE);
  OPEN cur;
  read_loop: LOOP
    FETCH cur INTO v_idTipoSancion;
    IF done THEN
      LEAVE read_loop;
    END IF;
         SELECT SUM(puntos) INTO sumaPuntos FROM sancion
         WHERE idtipoSancion = v_idTipoSancion AND YEAR(fecha) = YEAR(CURRENT_DATE);
         INSERT INTO acumulado VALUES (YEAR(CURRENT_DATE), v_idTipoSancion, sumaPuntos);
  END LOOP;
  CLOSE cur;
END

Tabla de referencia:


Rutinas, ejercicio 4.

4.     Crea un script que ejecute el procedimiento anterior el día 1 de enero de cada año.

CREATE EVENT   regalarPuntosAnyo
    ON SCHEDULE EVERY 1 YEAR
         STARTS '2014-01-01 00:00:01'
    DO CALL regalarPunto;

Podéis comprobar la creación correcta del evento con SHOW EVENTS

Tabla de referencia:


Rutinas, ejercicio 3.

3.   Crea un script en el que se le otorgue un punto extra a aquellos conductores que no han tenido ninguna sanción en el año anterior al que se ejecuta el script.

DELIMITER $$

CREATE DEFINER=`root`@`localhost` PROCEDURE `regalarPunto`()
BEGIN

          UPDATE conductor SET puntos = puntos + 1

         WHERE dni NOT IN (

                     SELECT DISTINCT conductor_dni FROM vehiculo,sancion

                     WHERE vehiculo.matricula = vehiculo_matricula AND

                     fecha BETWEEN DATE_SUB(CURRENT_DATE, INTERVAL 1 YEAR) AND CURRENT_DATE

         );
END $$
DELIMITER $$

Resultado: La llamada a la rutina debe indicar que se actualizan 78 filas

Tabla de referencia:


Rutinas, ejercicio 2.

2.     Crea un script para que, cada vez que se inserta una sanción, se le reste automáticamente, al conductor del vehículo denunciado, los puntos correspondientes a dicha sanción.

USE dgt;

DELIMITER $$

CREATE TRIGGER afterInsertSancion AFTER INSERT

    ON sancion FOR EACH ROW

BEGIN

         DECLARE v_dni CHAR(9);

         SELECT conductor_dni INTO v_dni FROM vehiculo WHERE matricula = new.vehiculo_matricula;

          UPDATE conductor SET puntos = puntos - new.puntos

         WHERE dni = v_dni;
   
END$$

DELIMITER ;

Resultado:
INSERT INTO `dgt`.`sancion` (`vehiculo_matricula`, `puntos`, `idtipoSancion`) VALUES ('7592HFT', 2, 3);
Debe hacer que el conductor con DNI '56953022N' pase de tener 12 puntos a tener 10

Tabla de referencia:


Rutinas, ejercicio 1.


1.     Crea un script al que le enviamos un DNI de un conductor y nos devuelve la suma de puntos que ha perdido debido a sanciones: 

DELIMITER $$

CREATE DEFINER=`root`@`localhost` FUNCTION `totalPuntosConductor`(v_dni char(10)) RETURNS int(11)
BEGIN

         DECLARE v_puntos INT;

         SELECT SUM(puntos) INTO v_puntos FROM sancion, vehiculo

         WHERE vehiculo_matricula = matricula AND

         conductor_dni = v_dni;

         RETURN v_puntos;

END $$
DELIMITER;

Resultado:
La llamada a la rutina con el dni '95270924K' debe devolver un valor de 5

Tabla de referencia:





Rutinas almacenadas para la administración de mysql (CURSORES).

Los CURSOR o "cursores", almacenan los registros devueltos por una sentencia sql y recorren su contenido.

Ejemplo de sintaxis de un cursor:

CREATE PROCEDURE curdemo()
BEGIN
  DECLARE done INT DEFAULT FALSE;
  DECLARE a CHAR(16);
  DECLARE cur CURSOR FOR SELECT i FROM tablaPrueba;
  DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;

  OPEN cur;

  read_loop: LOOP
    FETCH cur INTO a;
    IF done THEN
      LEAVE read_loop;
    END IF;
       .
  END LOOP;

  CLOSE cur;
END;
Explicación traducida:

CREAR PROCEDURE demo_cursor()
COMENZAR
  DECLARAR hecho ENTERO FALSO POR DEFECTO;
  DECLARAR a CARACTERES(16);
  DECLARAR cursor CURSOR PARA SELECCIONAR i DESDE tablaPrueba;
  DECLARAR CONTINUAR CONTROLADOR PARA SET NO ENCONTRADO hecho = VERDADERO;

  ABRIR cursor;

  leer_bucle: BUCLE
    BUSQUEDA cursor DENTRO DE a;
    SI hecho ENTONCES
      DEJAR leer_bucle;
    FIN DEL IF;
       .
  FIN DEL BUCLE ;

  CIERRE DEL cursor;
FIN;
Las partes escritas en mayúsculas, deben ir así siempre al realizar la sentencia correctamente. 

Rutinas almacenadas para la administración de mysql (EVENTOS)

Los EVENT, "eventos" o disparadores temporales, son rutinas asociadas a un esquema determinado y las cuales son ejecutadas con los permisos del propio creador del evento.

Se ejecutan para intervalos de tiempo con el comando EVERY, y para un instante con el comando AT.

Los eventos están disponibles en la versión 5.1 de Mysql.

Ejemplo sintaxis:

CREATE EVENT   event_name
    ON SCHEDULE schedule
    DO event_body;

schedule:
    AT timestamp [+ INTERVAL interval] ...
  | EVERY interval
    [STARTS timestamp [+ INTERVAL interval] ...]
    [ENDS timestamp [+ INTERVAL interval] ...]

interval:
    quantity {YEAR | QUARTER | MONTH | DAY | HOUR | MINUTE |
              WEEK | SECOND | YEAR_MONTH | DAY_HOUR | DAY_MINUTE |
              DAY_SECOND | HOUR_MINUTE | HOUR_SECOND | MINUTE_SECOND}
Explicación traducida:
CREAR EVENTO   nombre_evento
    EN HORARIO horario
    REALIZAR cuerpo_evento;

horario:
    EN timestamp [+ INTERVALO intervalo] ...
  | CADA intervalo
    [COMIENZA timestamp [+ INTERVALO intervalo] ...]
    [FINALIZA timestamp [+ INTERVALO intervalo] ...]

intervalo:
    cantidad {AÑO | Cuartos | mes | día | Hora | MINUTO |
               SEMANA | SEGUNDO | MES AÑO | HORAS DEL DÍA | MINUTO día |
               SEGUNDO DIA | MINUTO HORA | SEGUNDA HORA | MINUTO SEGUNDO}
Las partes escritas en mayúsculas, deben ir así siempre al realizar la sentencia correctamente.