martes, 13 de noviembre de 2012

Ejercicio de Alter Table / Base de Datos

Autor: Benjamín Navarrete O.
Competencia: Trabajo en Equipo
Palabras Clave: Alter, MySQL, Base, Datos, Ejercicios.




Hola de nuevo ! hoy traemos una nueva entrada al repositorio sobre Base de datos. Para que tengan una breve reseña, Una base de datos es un conjunto de datos pertenecientes a un mismo contexto y almacenados sistemáticamente para su posterior uso. En este sentido, una biblioteca puede considerarse una base de datos compuesta en su mayoría por documentos y textos impresos en papel e indexados para su consulta. En la actualidad se pueden usar programas informáticos tales como MySQL, Oracle, Postgress entre otros, para Manipular estas bases de datos de tal manera que nosotros podamos consultar sobre alguna entrada en específico. Ej: el valor de un producto en una base de datos de un supermercado o el rut o dato de alguna persona que este en la base de datos de un hospital, etc.


En esta entrada mostraremos específicamente como se implementa el uso de Alter table, comando que consiste para modificar, renombrar o eliminar una tabla de una base de datos


y obviamente sin olvidar el trabajo en equipo que hubo en la actividad, a continuación les mostraremos el problema a desarrollar.



Descripción de la Actividad


El contexto del ejercicio es el siguiente:

    Este mes hubo evaluación de desempeño en una de las principales empresas de telefonía del país y se decidió poner a prueba al departamento informático ya que la información de las bases de datos no es totalmente clara.

Nuestro jefe preocupado por lo ocurrido nos dice.
Jefe- Es importante cambiar el modo en que hace guardamos la información actualmente y llegar a la optimización que nos permita ahorrar espacio y apresurar las búsquedas.
Por lo que pedimos la estructura del sistema de bases de datos y se nos entrega esto.

create table clientes_domesticos(
id int not null auto_increment,
nombre_completo text,
ciudad text,
email text,
direccion varchar(12),
telefono varchar(8),
pago_mensual int(10),
minutos_usados int(3),
minutos_plan int(8),
primary key(id)
);
Un registro de la tabla es de esta manera.





Ahora el ejercicio a hacer, en base a los datos que nos han entregado es : 
1.- Nombre completo no es una columna atómica, elimínela y agregue las que sean necesarias utilizando el tipo de dato correcto, no pierda la información ya almacenada de Nombre completo

2.- Agregue el campo pago anual que es el pago mensual por 12 meses.

Solución


Para hacer que nuestra tabla fuese más personalizada le cambiamos el nombre original que fue asignado anteriormente como “clientes_domesticos” por “ Clientes_Telefonica”.


Desarrollo del problema.



CREATE TABLE Clientes_Telefonica( //creación de la tabla id INT NOT NULL AUTO_INCREMENT, // se define la id como campo NO NULO, es decir, que no puede presentar filas sin ningún dato.

nombre_completo TEXT, // campos con su respectivo tipo de dato. Dato de tipo TEXT es extremadamente grande y no es eficiente usarlo en nombres ya que ocuparía mas memoria lo que seria innecesario.

ciudad TEXT,
email TEXT , 

direccion VARCHAR(12),// tipo varchar es una cadena donde se pueden ingresar datos como caracteres y tiene un rango de almacenamiento de 65532 bytes.
telefono VARCHAR(8),

pago_mensual INT(10), // tipo int es un dato de tipo entero el cual tiene un rango de [-8000000,8000000] aproximadamente.

minutos_usados INT(3),

minutos_plan INT(8),

PRIMARY KEY(id)//se define id como clave principal de la cual dependen todos los datos del registro. );

 INSERT INTO // es un comando que se utiliza para ingresar los datos en cada columna que se le asigne posteriormente.

Clientes_Telefonica(nombre_completo,ciudad,email,direccion,telefono,pago_mensual,minutos_usados,minutos_plan)VALUES("Felipe Alejandro Pardo Gomez","Temuco","fap@live.cl","las canteras #234","8728987","20000","30","40") Insertar en la tabla Clientes_Telefonica, con orden que se puede ver entre los ( ) luego se ingresar los respectivos valores deseados.

INSERT INTO Clientes_Telefonica(nombre_completo,ciudad,email,direccion,telefono,pago_mensual,minutos_usados,minutos_plan)VALUES("Alejandro Esteban Pardo Gomez","Temuco","Ale@live.cl","av.alemania #540","98765432","40000","80","120"),

(" Maria Alejandra Ponce Rios","Valdivia","Apr@hotmail.com","los dominicos #345","7895647","30000","60","60"),

("Camila Fernanda Figueroa Hernandez","Santiago","camif@live.cl","vitacura #670","67890545","25000","30","30"),

("Javier Ignacio Rojas Espinoza ","Talca","jrojas@hotmail.com,","El prado #234","67893454","40000","100","100"),

("Carolina Fernanda Estrada Lopez","Santiago","carolita@hotmail.com","rio negro #346","78034251","30000","50","50"),

("Barara Consuelo Sandoval Horta","Temuco","bcs@live.cl","rodo #234","67923023","6000","20","20"),

("Camilo Esteban Paredes Celis","Temuco","cpc@live.cl","andes #2334","93488211","35000","70","70"),

("Carla Alejandra Sandoval Espinpza","Temuco","carli@hotmail.com","rodo #567","87323924","10000","15","25"),("Juan Pablo Rodriguez Castro","Temuco","xerox@live.cl","Calderon#580","78348912","50000","200","250")

Anteriormente se realizo el ingreso de datos a la tabla por nuestro compañero Javier Rojas, la cual en un comienzo se vió así:


















Se procede a modificar la tabla para llegar a la primera forma normal (1FN) que es la de atomicidad para eso utilizaremos el comando ALTER TABLE.
Como se muestra detalladamente a continuación:

ALTER TABLE Clientes_Telefonica ADD COLUMN primer_nombre VARCHAR(15)AFTER nombre_completo // se ingresa el comando ALTER TABLE para crear una nueva columna llamada primer_nombre que puede contener un máximo de 15 caracteres.


ALTER TABLE Clientes_Telefonica ADD segundo_nombre VARCHAR(15)AFTER primer_nombre, ADD apellido_paterno VARCHAR(15)AFTER segundo_nombre,ADD apellido_materno VARCHAR(15) AFTER apellido_paterno

// nuevamente se ingresa el comando ALTER TABLE para la creación tres nuevas columnas llamadas segundo_nombre, primer_apellido y segundo_apellido. Las cuales se van ubicando después de la columna anteriormente creada lo cual se lo indica el comando AFTER.













Procedemos a ingresar los códigos en el siguiente orden:
Definición de los comandos que presenta el código a utilizar:



















1.) UPDATE Clientes_Telefonica SET primer_nombre= SUBSTRING_INDEX (nombre_completo ,' ', 2 );
Lo que hacemos al ingresar este comando en copiar las dos primeras palabras de la columna nombre_completo y luego pegarla en la columna primer_nombre.






2.)
UPDATE Clientes_Telefonica SET segundo_nombre= SUBSTRING_INDEX (primer_nombre,' ', -1); 
//Al ingresar el siguiente código lo que se hace es copiar la segunda palabra de la columna primer_nombre y pegarla en la columna segundo nombre.





3.)
UPDATE Clientes_Telefonica SET primer_nombre= SUBSTRING_INDEX (nombre_completo ,' ', 1);
Con esta parte del código se procede a borrar el segundo nombre que esta en la columna primer nombre lo cual es indicado por el.





4.)
UPDATE Clientes_Telefonica SET apellido_paterno= SUBSTRING_INDEX (nombre_completo ,' ',-2);
Luego volvemos a ingresar este código pero copiamos los dos apellidos y los trasladamos a la columna apellido_materno, específicamente eso se indica en (nombre_completo,' ',-2).




5.)
UPDATE Clientes_Telefonica SET apellido_materno= SUBSTRING_INDEX (apellido_paterno ,' ',-1);
Con este comando hacemos el mismo procedimiento la diferencia es que movemos de apellido_paterno a apellido_materno.




6.)
UPDATE Clientes_Telefonica SET apellido_paterno= SUBSTRING_INDEX (apellido_paterno ,' ',1);
El siguiente código lo que hace es borrar el apellido materno que se encuentra dentro de la columna apellido_materno





Desarrollo problema Nº2:































Reflexión

    a pesar de que el trabajo en equipo no se puede evidenciar muy bien en la actividad ya realizada, puedo decir que los integrantes eramos 4 y cada uno tuvo que encargarse de alguna parte del trabajo, ya sea sacando screenshots a las tablas, otro insertando los datos a las tablas, otro  modificando las tablas y así se pudo lograr un trabajo muy eficiente y rápido. En cuanto a los problemas nos sirvieron de mucha ayuda, ya que son los comandos basicos que una persona debe manejar si quiere aprender a usar las bases de datos y poder consultar en ellas. Cualquier consulta o duda de esta actividad la pueden preguntar en el muro de esta entrada :)

domingo, 11 de noviembre de 2012

Arreglos Programación II

Autor: Benjamín Navarrete O.
Competencia: Aplica las Ciencias de la Ingeniería
Palabras Clave: Ejercicio, Java, Arrays, Capicúa.


Descripción de la Actividad


  Bienvenidos ! hoy les mostraré una actividad que tuve que realizar en clases, que trata principalmente sobre el uso de arreglos (arrays). Para que tengan un breve resumen, un "arreglo" o "array" en el ámbito de la informática es  un grupo o una colección finita, homogénea y ordenada de elementos. Vale decir, es una "variable" en la que se pueden almacenar varios elementos, ya sean numeros(int), cadenas(String), o carácteres(chars).
       La actividad que les vamos a mostrar consiste en un ejercicio que dice así:

   -9- Analice y resuelva el problema de saber si un arreglo de números enteros tiene al menos 1 numero capicúa.

El programa además de hacer eso...debe pedirle al usuario el tamaño que tendrá el arreglo.

Un numero capicúa es aquel que se lee igual tanto al derecho o al revés.
ejemplo : 12321, 222333444333222, 123454321.


algunos ejemplos serían como:

  Entrada: (arreglo 3 espacios)  12321 111  451  -->[P] --> "existen numeros capicúa dentro del arreglo"

Entrada: (arreglo 5 espacios)  111 222 333 444 555  -->[P] --> " NO existen numeros capicúa dentro del arreglo"



Solución

El diagrama de flujo de este problema sería así:
Diagrama de Flujo

y el Código en java resultante  en base al diagrama de flujo sería este:



import java.util.Scanner;


import java.util.Scanner;


public class Capicua {


    public static void main(String[] args) {



        int numero;

        int falta, numeroInvertido, resto;

        Scanner leer = new Scanner(System.in);

        System.out.println("ingrese largo del arreglo");

        numero = leer.nextInt();

        int[] a = new int[numero];

        for (int i = 0; i < numero; i++) {

            System.out.println("ingrese numero del arreglo " + i);

            a[i] = leer.nextInt();

            System.out.println("arreglo " + i + "= " + a[i]);

        }

        for (int j = 0; j < numero; j++) {


            if (a[j] >= 0) {


                falta = a[j];

                numeroInvertido = 0;

                resto = 0;



                while (falta != 0) {

                    resto = falta % 10;

                    numeroInvertido = numeroInvertido * 10 + resto;

                    falta = falta / 10;

                }



                if (numeroInvertido == a[j]) {

                    System.out.println("El espacio "+j+" del arreglo es capicua");

                } else {

                    System.out.println("El espacio "+j+" del arreglo no es capicua");

                }

            } else {

                System.out.println("el espacio "+j+" del arreglo es menor a 0");

            }

        }

    }

}

Si se pudieron dar cuenta, hice más que decir que existía al menos un numero capicúa en el arreglo, mas bien en la salida puse si cada numero era un arreglo o no lo era, lo cual es aún más específico.

Reflexión

   Como segunda actividad puesta en mi repositorio de programación, debo decir que estos tipos de ejercicios sirven mucho para poder ejercitar la capacidad de razonar en cuanto a crear programas que satisfagan alguna necesidad. Cabe mencionar que el arreglo mostrado en este problema es "unidimensional", que por otra parte  existen arreglos bidimensionales y multidimensionales como lo son las matrices, etc. si tienen alguna duda sobre el problema, no duden en consultarme mediante este blog :).

domingo, 21 de octubre de 2012

Actividad de Programación I


Autor: Benjamín Navarrete O.
Competencia: Aplica las Ciencias de la Ingeniería
Palabras Clave: String, Ejercicio, Java, Intercalar, Cadenas



Descripción de la Actividad


 Hola ! Esta actividad pertenece a Programación I de primer año del primer semestre de la carrera Ingenieria civil informática, ejercida en la Universidad Católica de Temuco.
El ejercicio que les voy a mostrar mas adelante se los mostraré para que vean como se puede interactuar de ésta, y de muchas maneras con string (cadenas). El enunciado del ejercicio es el siguiente: "  Cree un programa en el cual se ingresen 2 palabras por teclado,  para que después el programa intercale esas palabras. Ej :  palabra 1: asdf
                                                                                     palabra 2 : qwer

                                                                                     Resultado: aqswdefr


 Dar algunos ejemplos más claros serian algo asi como:

hola, amigo -> [P] -> haomliago

hablando , corriendo -> [P] -> hcaobrlrainednodo

pepe, gumercindo -> [P] -> pgeupmeercindo

ubicando la primera letra de la primera palabra, seguido de la primera letra de la segunda palabra, despues siguiendo con la segunda letra de la primera palabra y con la segunda letra de la otra palabra y así sucesivamente.


un pseudocódigo para desarrollar el problema sería asi:



escribir "ingrese primera palabra"
leer palabra1
escribir "ingrese segunda palabra"
leer palabra2

si(largo palabra1 es = al largo palabra2){
  sino si( largo palabra1 > largo palabra2){

     reemplazo = (valor absoluto del largo de la palabra1) - (largo palabra2)
para( indice = 0 Indice hasta valor de reemplazo con paso 1 hacer){
  palabra2 = palabra2 + "_"
       }
} sino{  reemplazo = (valor absoluto del largo de la palabra1) - (largo palabra2)
para( indice = 0 Indice hasta valor de reemplazo con paso 1 hacer){
  palabra1 = palabra1 + "_ "
    }

}

largo = largo palabra1

para( indice = 0 Indice hasta valor de largo con paso 1 hacer){
 palabra nueva = palabra nueva + carácter "indice" palabra1 + carácter "indice" palabra2
 }

palabra nueva  = palabra nueva.reemplazar "_" por " "

escribir palabra nueva


y el código en java sería así:



import java.util.Scanner;
public class Ejercicio5_IntercalarPalabra {
    public static void main(String[] args) {
        
        Scanner leer = new Scanner(System.in);
        String palabra1, palabra2, nuevo ="";
        int largo, reemplazo;
       
        System.out.println("Ingrese dos palabras");
        System.out.println("Palabra 1");
        palabra1 = leer.nextLine();
        System.out.println("Palabra 2");
        palabra2 = leer.nextLine();
        
        if(palabra1.length() == palabra2.length()){
        }else if(palabra1.length() > palabra2.length()){
            reemplazo = Math.abs((palabra1.length() - palabra2.length()));
            for(int i = 0; i < reemplazo;i++){
                palabra2 += "_";
            }
        }else{
            reemplazo = Math.abs((palabra1.length() - palabra2.length())); 
             for(int i = 0; i < reemplazo;i++){
                palabra1 += "_";
            }
        }
            largo = palabra1.length();
        
        for (int i = 0; i < largo; i++){
            nuevo += palabra1.charAt(i) + "" + palabra2.charAt(i);
            
        }
        nuevo = nuevo.replaceAll("_", "");
        System.out.println(nuevo);
        
    }
}


reflexión


Para mí esta actividad sirvió para ver cómo se puede interactuar entre Strings como en este caso intercalando dos palabras, también en la forma de analizar el problema, viéndolo desde muchos puntos de vista, ya que éste se puede escribir de muchísimas maneras, y todas llegando al mismo resultado, todo dependiendo de la forma de reflexionar y de pensar de la persona que está programando. Por eso esta actividad también sirve para ver la diversidad o de las miles de maneras que se puede crear un programa con distinto código o siguiendo una misma lógica. Ejercicios como éstos son los que nos hacen ejercitar nuestra mente de ingenieros y pensar de una manera más analítica al momento de hacer las cosas o de la toma de decisiones.

Está abierta la posibilidad para que puedan consultar todas sus dudas :)
       

Instalación de Windows Server 2003 como caso de Estudio


Autor: Benjamín Navarrete O.
Competencia: Gestión en Tecnologías de la Información
Palabras Clave: Windows, Server, Instalación, Sistema, Operativo, Imágenes




Descripción de la Actividad

La siguiente actividad se basa en primer lugar, instalar un sistema operativo paso a paso mediante imágenes para así poder aprender a utilizar distintos sistemas orientados a las metodologías de trabajo. En segundo lugar, el funcionamiento de Windows Server 2003 como tal, siguiendo una serie de pasos, los cuales eran:


1. Instalar Window 2003 server.

2. Probar la creación de usuarios y grupos (cada miembro del grupo es un usuario), identificar los distintos grupos de usuario existentes en el sistema e indicar la funcionalidad de cada un de ellos.

3. Revisar la administración de servicios del sistema (procesos en segundo plano), indicar como se configuran los servicios en el sistema.

4. Revisar los permisos y atributos de archivos: Probar estos permisos y atributos con los usuarios y grupos creados.

5. Revisar y documentar los principales aspectos de la configuración de Red del sistemas.

6. Revisar el visor de sucesos y documentar cada uno de sus reportes.


cada paso con sus respectiva Screenshot.


Solución

Instalación del Sistema operativo Mediante un emulador de sistemas operativos llamado VirtualBox



Desarrollo de las Actividades















Reflexión

Al finalizar esta primera actividad refiriéndose a instalación de sistemas operativos, nos dimos cuenta de que es fundamental comprender cada función que abarca el trabajo de un ordenador y su respectivo SO, en este caso un servidor. También nos dimos cuenta de que su instalación no fue compleja ya que poseíamos conocimiento previo y similar de instalación de un sistema operativo Windows, además de su comprensible guía de instalación e interfaz que lo hace aún más fácil de operar.

   Nuevamente los invitamos a aportar alguna idea o a comentarnos de algo que los dejo con alguna duda :)
       

domingo, 9 de septiembre de 2012

Circuito Millonario

Autor: Benjamín Navarrete
Competencia: Desarrollo de Software (Nivel 1)
Palabras Clave: Robot, NXC , lego , circuito ,sensores ,Subrutinas

Descripción de la Actividad


La actividad consistía en que debíamos programar un robot explorador, que sea capaz de recorrer una pista de obstaculos establecida por un concurso de televisión y competir contra los otros robots que participen para obtener la mayor cantidad de puntaje. La pista constaba de 3 secciones en las que se deben realizar diferentes funciones:
1. Primero tenemos un laberinto el cual se tiene que superar con éxito.
2. Luego una ruta establecida por señales especiales en el suelo que deben ser seguidas,
3. Y finalmente tenemos una sección en la cual los robots deben detectar la mayor
cantidad de puntos de bonificación antes de que el robot impacte 3 veces en los
obstaculos de la pista.

Solución


 Para comenzar plantearemos el Pseudocódigo de nuestra solución:



Variables  :
Avanza, utilizar (x).
Giro  en grados ( y ).
Sensores :
Luz (a) , Tacto (b), Ultrasonido (c)
Task main (){
El robot  x  , se activa (b) detectando la pared del laberinto  
Luego el  robot ( y,90) a la izquierda ,(X) detectando la pared con (c),
Luego (y,90) a la derecha , (x)  detectando la ultima pared con (c),
(y,90) a la derecha , (x) hasta llegar a la línea negra activando (a)
Detecta el umbral correspondiente y luego (x)  hasta terminar la línea negra,
Luego ( y ) a la izquierda, activando nuevamente el  (a) y luego detecta el color blanco y
(x)  además activa (b) para detectar la paredes de la pista y asi (x) aleatoriamente hasta encontrar los círculos negros  e ir sumando puntos cada vez que suma puntos suena un pito  , el programa finaliza una vez que se hayan sumando los puntos necesarios.




Y el código quedó de esta manera:

#define UMBRAL 40
#define CERCA 10//cm
//subrutina laberinto
sub laberinto () {
      SetSensorTouch(IN_1);
     SetSensorLowspeed(IN_4);

                             //primer recorrido
                 OnFwd(OUT_BC,50);
                 Wait(900);
                 while(SensorUS(IN_4)> CERCA);
                 OnFwd(OUT_B,35);  // giro en su propio eje
                 OnRev(OUT_C,30);
                 Wait(800);
                 //segundo reccorido
                 OnFwd(OUT_BC,40);
                 Wait(500);

                 while(SensorUS(IN_4)> CERCA);
                 OnRev(OUT_B,20);
                 OnFwd(OUT_C,45);
                 Wait(900);
                 //tercero
                 OnFwd(OUT_BC,50);
                 while(SensorUS(IN_4)> CERCA);
                 OnRev(OUT_B,20);
                 OnFwd(OUT_C,40);
                 Wait(750);
                 //recto
                 OnFwd(OUT_BC,50);
                 Wait(2300);
                 OnFwd(OUT_C,40);
                 OnRev(OUT_B,20);
                 Wait(300); 
                 Off(OUT_BC);
}
//subrutina linea negra
sub lineanegra () {
SetSensorLight(IN_3);
OnFwd(OUT_BC,50);
PlayTone(3000,500);
while (true)
{
if (Sensor(IN_3) > UMBRAL)
{
OnRev(OUT_B, 30);//giro
Wait(20);
OnFwd(OUT_C,30);

until(Sensor(IN_3) <= UMBRAL);
OnFwd(OUT_BC, 30);

Off(OUT_BC);
}
//subrutina puntos negros
sub puntosNegros () {
int j=0;
int a=150;
while (j<3){
NumOut(60,30,a);
Wait(500);

OnFwd(OUT_B,40);
OnFwd(OUT_C,40);
 if(Sensor(IN_3) <= UMBRAL){
Off(OUT_BC);
Wait(1000);
a=a+30;
NumOut(60,30,a);
Wait(500);
PlayTone(50,500);
OnRev(OUT_C,50);
Wait(Random(500)+1000);
}
if(SENSOR_1==1){
OnRev(OUT_BC,60);
Wait(500);

PlayTone(150,500);
OnRev(OUT_C,70);
OnFwd(OUT_B,70);
Wait(360);
j++;
a=a-50;
NumOut(60,30,a);
Wait(500);
}
}
Off(OUT_BC);
Wait(100);
PlayTone(500,500);
Wait(500);
PlayTone(250,500);
Wait(500);
PlayTone(70,500);
Wait(500);
NumOut(60,30,a);
Wait(20000);
}


task main ()
 {
laberinto () ;
lineanegra () ;
puntosNegros () ;
}





Reflexión
si bien la actividad no se logró como se esperaba, igualmente pudimos aprender muchas cosas como lo eran las sub-rutinas. Quizás nos faltó implementarlas de mejor manera pero desde esa actividad comenzamos a familiarizarnos mucho más con los sensores de luz, ultrasonido y tacto.

Si tienes algún aporte de esto, alguna opinión a lo que no pudimos solucionar, te invito a que comentes :)