Introducción a Prolog

Hoy les comparto una breve introducción al lenguaje de Programación Prolog.

La palabra PROLOG proviene del acrónimo (PROgrammation LOGique) o programación lógica.

Es un lenguaje de programación que fue introducido por la Universidad de Aix-Marseille (Marsella, Francia) por los profesores Alain Colmerauer y Philippe Roussel al inicio de los 70's.

Sabiendo lo anterior, pasemos a la sintaxis. Prolog se compone por los siguientes elemento:

-Constantes
-Variables
-Hechos
-Relaciones
-Reglas
-Consultas

Constantes
Pueden ser números enteros o flotantes, cadenas de caracteres en minúsculas o cadenas de caracteres entre comillas ("").

Ejemplos: 56, 873.123, hola, adiós, "Hola"

Variables
Cadena de caracteres que comienza con mayúscula o con "_". 

Ejemplos: X, Juan, _hola, _  

Hechos
Un hecho es una afirmación y se conforma por un predicado, seguido de unos paréntesis, entre los que se coloca un sujeto y posterior a los paréntesis se coloca un punto. 

    predicado(sujeto). 

Ejemplo: hombre(luis).

Y se lee, Pedro es hombre.

Relaciones
Las relaciones dentro de prolog se conforman de un predicado, seguido de unos paréntesis, entre los que se coloca un sujeto seguido de una coma "," y seguido de otro sujeto. Posterior a los paréntesis se coloca un punto.

    predicado(sujeto1,sujeto2).

Ejemplo: progenitor(luis,juan).

Reglas
Las reglas son suposiciones en base a lo que ya sabemos (hechos) y se componen de un hecho sin punto al final, seguido de dos puntos y un guión medio (":-") que significa "entonces" o "si", seguido de un uno o mas hechos o reglas separados por comas (",") o punto y coma (";"), donde la coma es el operador lógico "and" y el punto y coma es el operador lógico "or".

    predicado(sujeto1,...,sujetoN) :- predicado1(sujeto1,...,sujetoN) , predicado2(sujeto1,...,sujetoN) ; predicado3(sujeto1,...,sujetoN).

Ejemplo: padre(luis,juan) :- progenitor(luis,juan) ,  hombre(luis).

El ejemplo anterior se lee, Luis es padre de Juan si, Luis es progenitor de Juan y Luis es hombre.

Consultas
Una consulta en prolog se compone de el predicado de una regla, seguido de paréntesis, que contienen los sujetos o variables requeridas por dicha regla, y los un punto posterior a los paréntesis.

    regla(sujeto1,sujeto2,variable1).

Ejemplo: padre(luis,juan).  padre(X,Y). padre(luis,X). padre(X,juan).

Y se lee, ¿Es Luis, padre de Juan?

Hay dos maneras de realizar una consulta:

1- Mandando como parámetro valores específicos como en el ejemplo 1, donde se obtendrá como resultado "True" o "False", True si es verdad según los hechos y reglas establecidas y False en caso contrario.

    padre(luis,pedro).
    False 
 
2- Mandando una o mas variables como en los ejemplos posteriores, donde se obtendrá como resultado todos los posibles valores que pueden llegar a tomar dichas variables:

    padre(luis,X).
    X=juan

Dato extra
 
Los comentarios van antecedidos del símbolo "%".

    % Esto es un comentario.

Cuando se utiliza el operador lógico AND (","), se debe cumplir la condición tanto de la izquierda como de la derecha del signo para que sea verdadero el resultado.

Cuando se utiliza el operador lógico OR (";"), el resultado solo es falso cuando la condición tanto de la izquierda como la de la derecha son falsas.

Si queremos comparar dos elementos utilizaremos "==", si ambos elementos son iguales, retorna verdadero, si no es así, retorna falso.

El operador "not" nos sirve para negar una comparación, un hecho, una regla, etc. Y va antes de cualquiera de estos elementos.

    not(X==Y)

Donde se indica que esa condición sera verdadera si X es diferente de Y.

Esto es todo por este tutorial, espero que les sea de mucha utilidad, cualquier cosa no duden en comentarla y de antemano muchas gracias.

Fuente:
http://www.itnuevolaredo.edu.mx/takeyas/apuntes/Inteligencia%20Artificial/Apuntes/IA/Prolog.pdf Consulta el 23 de Agosto del 2015.

http://ce.azc.uam.mx/profesores/mjm/pub/prolog.pdf Consulta el 23 de Agosto del 2015.

Instalar SWI-Prolog en Linux

Hoy les comparto un mini tutorial sobre como instalar SWI-Prolog en Linux.

Pero antes que comenzar. ¿Qué es SWI-Prolog?
SWI-Prolog es una implementación en código abierto del lenguaje de programación Prolog, comúnmente utilizado para la enseñanza y aplicaciones web semánticas.

Sabiendo eso, comencemos.

Abrimos nuestra terminal y escribimos el siguiente comando para instalar software-properties-common ya que lo requiere SWI-Prolog:

sudo apt-get install software-properties-common

Una vez hecho esto, generamos un repositorio con:

sudo apt-add-repository ppa:swi-prolog/stable

Nos pedira que oprimamos la tecla "Enter" para continuar.

Ya que se genero el repositorio lo siguiente es actualizar el sistema para que se considere el cambio en el repositorio que generamos:

sudo apt-get update

Actualizar el sistema puede tomar un tiempo.

Y por ultimo instalamos SWI-Prolog con el siguiente comando:

sudo apt-get install swi-prolog

Nos pedira seleccionar la tecla "Enter" para continuar la instalación.

Y con esto, SWI-Prolog estara listo para utilizarse, podemos comprobar si se instalo correctamente con el siguiente comando:

swipl --version

Este comando nos mostrara la versión de nuestro SWI-Prolog.

Para ejecutar SWI-Prolog basta con escribir en nuestra terminal:

swipl

Para utilizarlo de manera sencilla, recomiendo generar nuestro archivo de Prolog (.pl), con cualquier editor de texto y guardarlo con la extensión .pl

Una ves que contemos con nuestro archivo .pl basta con acceder en la terminar a la ubicación de nuestro archivo .pl y ejecutar el siguiente comando:

swipl -f archivo.pl

Y solo sustituimos la palabra "archivo" por el nombre de nuestro archivo y con esto ya podemos hacer consultas y probar nuestro programa.

Espero y este mini tutorial les sea de mucha utilidad para instalar y utilizar SWI-Prolog.

Cualquier duda o aclaración no duden en comentarla, y de antemano muchas gracias.

Fuente:
https://www.nuigalway.ie/information-solutions-services/servicesforstaff/software/softwarea-z/s-t/swi-prolog/ Consultado el 23 de Agosto del 2015.

Empates en el ajedrez

Ahora les comparto una breve publicación dedicada a los empates en el ajedrez. Decidí dedicar una publicación solo a esto porque es un tema de suma importancia y porque hay varias maneras de que se de un empate en este juego. Pero antes de comenzar me gustaría compartirles la publicación anterior acerca de los movimientos básicos en el ajedrez.

Una manera de declarar tablas que se da de manera automática son las tablas por ahogamiento del rey. Esta situación se da cuando se cumplen tres condiciones:

1- El rey no se encuentra amenazado por ninguna pieza del contrincante
2- Si el rey cambia de posición a cualquier casilla, se ve amenazado por piezas enemigas.
3- No contamos con mas piezas o las piezas con las que contamos no se pueden mover.

Si estas 3 condiciones se cumplen se declaran tablas por ahogamiento del rey, ya que el jugador no puede mover ninguna pieza de lugar, pero no recibió el jaque mate, para perder el juego.

Tablas por triple repetición: Si se llega a la misma posición de las piezas en tres ocasiones durante la partida, cualquiera de los dos jugadores puede declarar tablas. La única condición en este caso es que se declare tablas exactamente a la tercera ocasión que se de la misma posición de las piezas, si se realiza una jugada mas, después de la tercera ocasión, se anula la posibilidad de declarar empate por este medio.

A continuación les compartiré un breve ejemplo de esto, esta sera la posición que tomaremos como base y la que se repetirá, es momento de que las piezas negras muevan:

La torre se mueve y amenaza al rey, pero el rey no puede tomar a la torre porque de hacerlo así, la torre que se encuentra junto al rey negro tomaría rey y seria el fin del juego:

El rey blanco se mueve para evitar la amenaza de la torre negra:

La torre se mueve y amenaza de nuevo al rey y al igual que en la amenaza anterior, el rey no puede tomar torre:

El rey se mueve de nuevo para evitar la amenaza de la torre y retorno a la posicion inicial, lo que hace que esta sea la segunda ocacion que se repite. Si el proceso anterior se repite de nuevo, cualquier jugador podria declarar tablas.

La regla de los 50 movimientos: Para poder valernos de esta regla para declarar un empate se requiere que se cumpla la siguiente condición:

- Durante 50 movimientos de cada jugador no se ha llevado a cabo ningún progreso en la partida. (se toma como progreso el mover un peón o tomar alguna pieza del rival).

Cualquiera de los jugadores puede declarar empate si se cumple esta condición, si se realiza cualquier movimiento después de cumplirse esta condición, es imposible declarar empate por este medio.

Material insuficiente para dar mate: Para declarar empate bajo estas circunstancias es necesario que ningún jugador cuente con las piezas necesarias para llevar a cabo un jaque mate. 

Se consideran como material insuficiente las siguientes situaciones:

-Rey contra Rey
-Rey y Caballo contra Rey
-Rey y Alfil contra Rey
-Reyes con un Alfil del mismo color

Empate por acuerdo mutuo: Este tipo de empate se da cuando ambos jugadores acuerdan que sera un empate, esa es la única condición para valerse de este tipo de empate.

Y esto seria todo respecto a los empates, espero y esta publicación les sea de mucha utilidad y un consejo que les puedo dar es: "Si la partida ya esta perdida lo mejor que podemos hacer es buscar un empate" o al menos eso es a lo que me he mentalizado desde que juego ajedrez.

Cualquier duda, consejo, aclaración, sugerencia, no duden en comentarla. Y de antemano muchas gracias por leer esto.

Fuente:
http://ajedrez.about.com/od/rulesofchess/a/Types-Of-Draws-In-Chess.htm

Movimientos básicos en el ajedrez

Ahora les vengo a explicar de manera muy breve los movimientos básicos de las piezas en el ajedrez, con lo que ya podremos comenzar a jugar partidas y el resto sera cosa de practica. Y antes de comenzar este tutorial, les comparto las publicaciones anteriores sobre ajedrez si es que son de su interés: Introducción al ajedrez y Historia del ajedrez. Espero y este tutorial les sea de ayuda y les agrade, comencemos.

El rey es la pieza mas importante del juego, pero a la ves es una de las piezas que cuentan con la menor cantidad de movimientos y por eso es indispensable protegerlo a toda costa. El rey se puede desplazar hacia cualquier posición del tablero, pero solo una casilla y en la siguiente imagen se muestras todos los posibles movimientos del rey respecto a su posición:

La dama es una de las piezas mas importantes en las partidas de ajedrez, ya que es la pieza que cuenta con mas movimientos, y puede llegar a cambiar el rumbo de una partida de ajedrez. La dama se puede desplazar en cualquier dirección de tablero (vertical, horizontal o diagonal) y cualquier cantidad de casillas, como se muestra a continuación:

El alfil tiene parte de los movimientos de la dama ya que se puede mover de manera diagonal cualquier cantidad de casillas. Algo importante que debemos tomar en cuenta es que al iniciar una partida de ajedrez contamos con un alfil posicionado en una casilla blanca y otro en una casilla negra y sin importar la cantidad de casillas que los desplacemos siempre continuaran en una casilla del mismo color, de no ser así el alfil se movió de manera incorrecta, a continuación les muestro una imagen con los posibles movimientos de un alfil, respecto a su posición:

La torre es la otra pieza del tablero que cuenta con parte de los movimientos de la dama, ya que se puede desplazar de manera vertical u horizontal cualquier cantidad de casillas en el tablero como se muestra a continuación

:
Los movimientos del caballo en ocasiones se les complican a las personas que están comenzando a conocer el juego pero no es algo tan complicado, el movimiento del caballo asemeja un salto, ya que es la única pieza capaz de moverse sin importar que piezas amigas o enemigas se crucen en su camino, en otras palabras, es la única pieza capaz de saltar a cualquier otra pieza. Pero como funciona el movimiento del caballo? El movimiento del caballo se puede visualizar de 2 maneras distintas:

-Como una "L": desplazándose 2 casillas de manera vertical u horizontal y posteriormente 1 casilla de manera opuesta, como es esto, si se desplaza 2 casillas de manera horizontal en cualquier dirección, la siguiente casilla solo puede deslizarse de manera vertical en cualquier dirección, y viceversa. En este caso el caballo es capas de formar 8 "L"'s con sus posibles movimientos.

-Como una "Y": desplazándose 1 casilla de manera vertical u horizontal y posteriormente 1 casilla de manera diagonal hacia la misma dirección, como es esto, si el caballo se desplaza 1 casilla hacia arriba (manera vertical), el siguiente movimiento solo se puede realizar de manera diagonal ascendente, ya sea la casilla superior izquierda o superior derecha a la del movimiento anterior. En este caso el caballo es capas de formar 4 "Y"'s distintas.

El peón es la pieza con el movimiento mas sencillo de todas las piezas, solo se puede deslizar una casilla hacia adelante por turno como se muestra a continuación:

Algo que es de suma importancia es, si el peón continua en su posición inicial (si no se ha movido desde que inicio el juego), el jugador puede decidir desplazarlo una o dos casilla hacia adelante (esto solo si el peón continua es su posición inicial, de no ser así, solo se puede desplazar una casilla), como se muestra a continuación:

Ahora otro punto a tomar en cuenta, como tomamos las piezas contrarias? Esto es algo muy sencillo, si nuestra pieza puede posicionarse en la casilla de la pieza contraria, entonces podemos tomarla, así de sencillo. Y sera decisión del jugador tomar la pieza o posicionarse en otro lugar. Cabe resaltar que solo podemos realizar un movimiento por turno.

Algo de suma importancia al momento de tomar piezas es: el peón es la única pieza que tiene un movimiento distinto a la hora de desplazarse, que a la hora de tomar piezas. Anteriormente explique como se puede desplazar el peón, ahora, si queremos tomar una pieza con el peón, el movimiento no sera de forma vertical, sino de forma diagonal. Si la pieza contraria se encuentra a una casilla en forma diagonal de nuestro peón, como se muestra a continuación:

:
Tendremos dos opciones:

-Tomar la pieza contraria con nuestro peón:

-Avanzar nuestro peón si es que se encuentra amenazado por la pieza contraria:

Y por ultimo les explicare dos movimientos especiales que necesitan ciertas características para llevarse a cabo:

-Peón al paso: El peón al paso es una especie de castigo para un jugador, y lo explicare a detalle, si en algún momento del juego posicionamos nuestro peón a dos casillas de la linea de peones contraria como se muestra a continuación:

Y se llega a dar el caso en el que el rival quiera mover uno de sus peones (utilizare el peón del ejemplo), si lo desplaza una casilla su peón se vera amenazado y lo podremos tomar con el nuestro:

Y sera decisión nuestra tomar el peón o avanzar:

Por tal motivo es casi seguro que nuestro rival avance el peón dos casillas en lugar de una y es aquí donde entra el "Peón al paso":

Si nuestro rival avanza su peón dos casillas para evitar que lo tomemos con nuestro peón como "castigo" nosotros podemos valernos del "Peón al paso" para tomar su peón, al utilizar esta jugada, podemos tomar el peón contrario como si este se hubiera desplazado solo una casilla y nuestro peón se posiciona el la casilla en la que debería quedar al tomar el peón contrario que avanzo solo una casilla:

Cuando esto suceda, debemos indicarle al jugador contrario que utilizamos el "Peón al paso", ya que se trata de un caso muy especifico.

-Enroque: El enroque cosiste en intercalar posiciones entre el rey y la torre y se puede dar en dos casos distintos:

-Enroque corto:  Para poder efectuar el enroque corto es necesario que se cumplan al pie de la letra tres condiciones:

1- El rey y la torre derecha del rey no deben de haberse movido en ningún momento durante la partida.

2- No debe haber ninguna pieza que se interponga entre el rey y la torre derecha.

3- Ni el rey ni la torre deben de encontrarse amenazados por alguna pieza enemiga antes o después de efectuar el enroque.

Si estas tres condiciones se cumplen, entonces podemos efectuar el enroque corto que consiste en los siguientes movimientos:

-El rey se desplaza dos casillas a la derecha
-La torre se posiciona a la izquierda del rey

-Enroque largo:  Para poder efectuar el enroque largo es necesario que se cumplan al pie de la letra tres condiciones:

1- El rey y la torre izquierda del rey no deben de haberse movido en ningún momento durante la partida.

2- No debe haber ninguna pieza que se interponga entre el rey y la torre izquierda.

3- Ni el rey ni la torre deben de encontrarse amenazados por alguna pieza enemiga antes o después de efectuar el enroque.

Si estas tres condiciones se cumplen, entonces podemos efectuar el enroque largo que consiste en los siguientes movimientos:

-El rey se desplaza dos casillas a la izquierda
-La torre se posiciona a la derecha del rey

Y por ultimo una regla mas y otra de las que también pueden cambiar el rumbo de la partida es:

-Si alguno de nuestros peones logra llegar a la ultima linea del tablero, se puede cambiar por cualquier pieza de las siguientes según la elección del jugador: Dama, Torre, Alfil o Caballo.

En este caso elegiré una dama:

Y con esto concluyen los movimientos básicos, y ya estaremos listos para comenzar a practicarlos en una verdadera partida de ajedrez. Mientras mas partidas juguemos sera mas fácil recordar dichos movimientos y comenzar a contemplar los posibles movimientos del rival.

Espero y este tutorial sea de su agrado y les sea de mucha utilidad. Cualquier cosa no duden en comentarla.

Introducción al ajedrez

Hoy les vengo a compartir una breve introducción al ajedrez, en esta publicación les explicare de manera muy sencilla el objetivo del juego y en publicaciones posteriores hablare un poco sobre la historia del ajedrez, los movimientos de las piezas y algunas aperturas, espero y sea de su agrado, cualquier cosa no duden en comentarla.

El ajedrez es un juego de estrategia entre dos oponentes. Cada jugador dispone de 16 piezas que se acomodan en un tablero dividido en 64 casillas. El tablero dispone de 8x8 casillas alternando entre el color blanco y negro. Un jugador utilizara las piezas blancas, mientras su contrincante utilizara las piezas negras.

Cada jugador cuenta con 1 Rey, la pieza mas importante en el juego.

Una Dama que siempre va colocada al lado del rey y en la casilla del mismo color a ella (si la dama es blanca. va en la casilla blanca y viceversa), la pieza con la mayor cantidad de movimientos y que en la mayoría de las partidas es capaz de decidir el rumbo del juego.

2 Alfiles que se posicionan al lado del rey y la dama respectivamente.

2 Caballos que se posicionan a los lados de los alfiles.

2 Torres que se posicionan al lado de los caballos y que se encuentran a los extremos el tablero.

8 Peones posicionados una linea adelante de todas las piezas mencionadas anteriormente.

Y la posición inicial de todas las piezas juntas seria la siguiente.

El objetivo del juego es derrocar al rey contrario con nuestras piezas. Si el rey es amenazado por alguna pieza del enemigo esto se considera un Jaque al rey. Cuando el rey se encuentra en jaque existen solo 4 posibilidades, mover al rey a una casilla donde no se encuentre amenazado por ninguna pieza enemiga, posicionar una de nuestras piezas entre la pieza enemiga y nuestro rey para evitar la amenaza (de ser posible, no en todas las ocasiones se puede hacer esto), capturar la pieza que esta amenazando a nuestro rey (esta siempre es la mejor opción y no siempre es posible), y por ultimo, si no podemos llevar a cabo ninguna de las 3 posibilidades anteriores, este es un Jaque mate y por lo tanto el final del juego.

Espero y esta breve introducción sea de su agrado y les sea de utilidad, posteriormente habrá mas publicaciones acerca de ajedrez.

Y como dato extra, las imágenes del tablero son generadas el la pagina siguiente, por si es del interés de alguien:

http://es.lichess.org/editor

JSON en Android con PHP y MySQL

Para iniciarse con esto, una buena recomendación que les puedo dar es esta librería y empecemos.
Primero descargamos la librería , es un .jar:

Ahora en el paquete llamado app de nuestro árbol de archivos del proyecto:

Hacemos click derecho  y de ahí:
new->Module
y nos debe de lanzar a la siguiente ventana:

Y elegimos importar  .jar
Ahora nos lanzara a una ventana donde elegiremos la ruta de nuestro archivo .jar que descargamos de la pagina.

Ahora nos vamos a build.gradle (Module:app) y agregamos lo siguiente en dependencies:

compile 'com.loopj.android:android-async-http:1.4.7'

Y ahora veamos la pagina con la que vamos a interactuar en el servidor:

La tabla de la base de datos que consultaremos es:

Todo la comunicación la usaremos desde un método que llamaremos  ObtDatos(), lo que se va hacer es obtener los datos de apellido, edad  y puntos y los mostraremos en un listView,

public void ObtDatos()
    {
        AsyncHttpClient client=new AsyncHttpClient();
        String url="http://192.168.61.13/loggeo.php";
        RequestParams parametros= new RequestParams();
        EditText nombre=(EditText)findViewById(R.id.NombreLgoTxt);
        parametros.put("Nombre",nombre.getText().toString());

        client.post(url, parametros, new AsyncHttpResponseHandler() {
            @Override
            public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
                if (statusCode == 200) {
                    //Llamar a la funcion
                    CargarLista(obtDatosJSON(new String(responseBody)));
                    Log.i("Respuesta:", new String(responseBody));
                    Log.i("Datos:", "No Fallo");
                }
            }

            @Override
            public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
                Log.i("Datos:", "Maldad: Fallo");
            }
        });
    }

CargarLista(obtDatosJSON(new String(responseBody))); nos va a llevar a cargar los datos obtenidos de la consulta del servidor en un listView:

public void CargarLista(ArrayList datos)
    {
        ListView listView=(ListView)findViewById(R.id.listViewLoggeo);
        ArrayAdapter adapter=new ArrayAdapter(this,android.R.layout.simple_list_item_1,datos);
        listView.setAdapter(adapter);

    }

    public ArrayList obtDatosJSON(String resupesta)
    {
        ArrayList listado=new ArrayList<>();
        try
        {
            JSONObject jsonObject= new JSONObject(resupesta);
            String texto="Nombre="+jsonObject.getString("Nombre");
            listado.add(texto);

            texto="Apellido="+jsonObject.getString("Apellido");
            listado.add(texto);

            texto="Edad="+jsonObject.getString("Edad");
            listado.add(texto);

            texto="Puntos="+jsonObject.getString("Puntos");
            listado.add(texto);

        }catch (Exception error)
        {

        }
        return listado;
    }

Hacemos una interfaz parecida a esta:
Liga xml

Al correr la aplicación tendremos:

Espero les haya servido este  tutorial, por su atención gracias!

Fuentes:
https://www.youtube.com/watch?v=oLm_5GKHJCI  consultada el 16 de julio del 2015.

SQLite en Android

SQLite es lo ideal cuando queremos trabajar con bases de datos en dispositivos móviles. Su uso es bastante sencillo, así que a continuación mostraremos una manera sencilla de manejo de base de datos en Android.
La base de datos que crearemos no tendra mucha dificultad, solo contendrá una sola tabla llamada Alumno, pongo la sintaxis en SQL:
 CREATE TABLE Alumno (Codigo INTEGER PRIMARY KEY,
                         Nombre TEXT NOT NULL,
                         Telefono TEXT NOT NULL,
                         Carrera TEXT NOT NULL);

 Primero crearemos una clase llamada AlmacenBase.java
AlmacenBase.java

package com.example.ultron.practicabasedatos;

import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

import java.util.Vector;

/**
 * Created by ultron on 13/07/15.
 */
public class AlmacenBase extends SQLiteOpenHelper {
    public AlmacenBase(Context context) {
        super(context,"AlumnosPro",null,1);
        /*
        Se manda al constructor de la clase padre para genera un entorno lógico de tu base de datos.
        Parametros:
        Contexto: Contexto de la aplicación
        Nombre de la base de datos
        Si se tiene un cursor que se puede utilizar como guia o referencia el objeto es cursorFactory, si no lo hay, null
        Número de versión
         */
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL("CREATE TABLE Alumno (Codigo INTEGER PRIMARY KEY,Nombre TEXT NOT NULL, Telefono TEXT NOT NULL, Carrera TEXT);");
        /*
        Se sobreescribe el metodo onCreate de la clase padre esto con la
        intención de tener una estructura lógica de la base, en memoria ya se creo,
        pero aun no esta almacenada en el teléfono.
         */
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
//Control de versiones de la base de datos
    }


}

Ahora crearemos la clase DataBaseManager.java que servirá como ayudante en el manejo de la base de datos.
DataBaseManager.java

package com.example.ultron.practicabasedatos;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;

import java.io.File;

/**
 * Created by ultron on 13/07/15.
 */
public class DataBaseManager {

  //****Clase para administrar la base de datos con la que trabajaremos****//
    /*
    Tablas de la base de datos:
    CREATE TABLE Alumno (Codigo INTEGER PRIMARY KEY,
                         Nombre TEXT NOT NULL,
                         Telefono TEXT NOT NULL,
                         Carrera TEXT NOT NULL);
     */
    String nombre="Nombre",telefono="Telefono",carrera="Carrera",codigo="Codigo";//Variables que serviran como referencias a los atributos de la tabla Alumnos
    AlmacenBase helper; //Clase que realiza la conexion
    SQLiteDatabase db; //Objeto que nos sirve como enlace lógico con la base de datos
    public DataBaseManager(Context context)
    {
        helper=new AlmacenBase(context); //Se crea el objeto de conexion
        db=helper.getWritableDatabase();//Si no existe la base se crea y si existe se habre en modo escritura
    }

    public ContentValues generaContenedorAlumno(int codigoP,String nombreP,String telefonoP,String carreraP)
    {
        /*
        Contenedor que genera un diccionario para los atributos a ingresar a la base de datos
        Un diccionario solo son tublas de elementos con algun significado, en este caso lo estructuramos
        con los parametros que recibimos.
         */
        ContentValues valores=new ContentValues();
        valores.put(codigo,Integer.toString(codigoP));
        valores.put(nombre,nombreP);
        valores.put(telefono,telefonoP);
        valores.put(carrera,carreraP);
        return valores;
    }

    public void insertar(int codigoP,String nombreP,String telefonoP,String carreraP)
    {
        /*
        La inserción de registros a la tabla se realiza con un metodo ya establecido de la clase SQLiteDatabase
        llamado insert, es conveniente y recomendable hacerlo por su facilidad de uso sus parametros:
        Tabla:El nombre de la tabla en la que se realizara la inserción.
        nullColumnHack: El nombre de la o las columnas donde se recibiran valores null, si no los hay, mandar null.
        valores: Los valores, mapeados en un ContentValue para su simplicidad

        El método retornara el ID de la ultima fila insertada se se realizo con exito, de lo contrario
        retornara -1
         */
        //TABLADestino null ContentValues
        db.insert("Alumno", null, generaContenedorAlumno(codigoP, nombreP, telefonoP, carreraP));
    }

    public  void eliminar(int codigoP)
    {
        /*
        Metodo establecido de SQLiteDatabase para eliminar registros:
        Parametros:
        Tabla: La tabla afectada
        Clausula Where: Campo =?   ---->WHERE Campo=
        Argumentos del Where: Como pueden ser varios se utiliza un arreglo de Strings

         */
        //TABLADESTINO  
        db.delete("Alumno", codigo + "=?", new String[]{Integer.toString(codigoP)});
    }

    public void actualiza(int codigoP,String nombreP,String telefonoP,String carreraP)
    {
        /*
        Método para actualizar las filas,
        recibe como parametros:
        Tabla: Tabla afectada.
        Valores: ContentValue con la lista de los valores de la tabla, junto los no actualizados, como si se realisase una insercion.
        Clausula Where: Campo =?   ---->WHERE Campo=
        Argumentos del Where:Como pueden ser varios se utiliza un arreglo de Strings

        Retornara el numero de filas afectadas.
         */
        //TABLADESTINO   
        db.update("Alumno", generaContenedorAlumno(codigoP, nombreP, telefonoP, carreraP), codigo + "=?", new String[]{Integer.toString(codigoP)});
    }
    public Cursor buscar(int codigoP)
    {
        /*
        Este método retornara un Cursor con el resultado de la consulta, los parametros son:
         Tabla: Nombre de la tabla afectada.
         Columns: La lista de las columnas requeridas en un arreglo de Strings
         Selección o condición: Columna =?  -----> WHERE Columna=
         Argumentos de la condición: Arreglo de Strings de los campos a usar como referencia
         groupBy
         having
         orderBy
         limit
         */

        /*****Un Cursor es un contenedor de resultados random para resultados de Querys en SQL*****/
        //TABLABUSQUEDA DATOS_REQUERIDOS  
        String[] columnas=new String[]{codigo,nombre,telefono,carrera};
        return db.query("Alumno",columnas,codigo + "=?",new String[]{Integer.toString(codigoP)},null,null,null,null);
    }

    public void EliminarBase()
    {
        /*
        Para eliminar la base de datos se tiene que hacer un enlace lógico con el directorio de la base
        para eso se pide el directorio con getPath.
        directorio es el enlace lógico.
        deleteDatabase eliminara la base si directorio es diferente de null.
        Retornara true si se concreto la operación, false en caso contrario.
         */
        final String path=db.getPath();
        File directorio=new File(path);
        db.deleteDatabase(directorio);
    }
}

Terminada la creación de estas bases de datos que son esenciales para el funcionamiento de nuestra app, lo siguiente es crear la primera actividad llamada "Agregar.java". Esta actividad servira para agregar registros a nuestra base.
Agregar.java

package com.example.ultron.practicabasedatos;

import android.media.MediaDescription;
import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;


public class Agregar extends ActionBarActivity {

    AlmacenBase Base;
    EditText nombreTxt,telefonoTxt,CarreraTxt,CodigoTxt;
    Button agregarBtn;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_agregar);

        //Referencias al layout
       nombreTxt=(EditText)findViewById(R.id.NombreTxt);
        telefonoTxt=(EditText)findViewById(R.id.TelefonoTxt);
        CarreraTxt=(EditText)findViewById(R.id.CarreraTxt);
        CodigoTxt=(EditText)findViewById(R.id.CodigoTxt);

       agregarBtn=(Button)findViewById(R.id.AgregarAlumnoBtn);

         agregarBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                DataBaseManager dbm=new DataBaseManager(getApplicationContext());//Manager de la base de datos
                String nombre=nombreTxt.getText().toString();
                String telefono=telefonoTxt.getText().toString();
                String codigo=CodigoTxt.getText().toString();
                String carrera=CarreraTxt.getText().toString();

                int CodigoEnt=Integer.parseInt(codigo);


                dbm.insertar(CodigoEnt,nombre,telefono,carrera);//Insercion en la base de datos
                nombreTxt.setText("");
                telefonoTxt.setText("");
                CodigoTxt.setText("");
                CarreraTxt.setText("");
                //Limpiamos formulario
            }
        });

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_agregar, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

Ahora nos dirigimos al  layout, al activity_agregar.xml por cuestiones de espacio no subiré los xml de la aplicación puedes descargarlos de este link para que te des una idea de como sera diseñada la aplicación.

Ahora crearemos la activity Buscar.java
Buscar.java

package com.example.ultron.practicabasedatos;

import android.database.Cursor;
import android.provider.ContactsContract;
import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

import org.w3c.dom.Text;

import java.util.StringTokenizer;


public class Buscar extends ActionBarActivity {
    AlmacenBase Base;
    Button buscar;
    int Codigo;
    EditText CajaCodigo;
    TextView nombreTV,telefonoTV,carreraTV;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_buscar);

        //Referencias al layout
        buscar=(Button)findViewById(R.id.BuscarBtn);
        CajaCodigo=(EditText)findViewById(R.id.CodigoTxt);
        telefonoTV=(TextView)findViewById(R.id.MuestraTelefonolbl);
        nombreTV=(TextView)findViewById(R.id.MuestraNombreLbl);
        carreraTV=(TextView)findViewById(R.id.MuestraCarreraLbl);
        buscar.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
            DataBaseManager dbm=new DataBaseManager(getApplicationContext());//Manager para la base de datos
            Codigo=Integer.parseInt(CajaCodigo.getText().toString());//Se obtiene el codigo
                Cursor res=dbm.buscar(Codigo);//Buscamos resultados
                if(res!=null)
                {
                    //Mostramos resultados de la query
                    res.moveToNext();
                    nombreTV.setText("");
                    nombreTV.setText(res.getString(1).toString());

                    telefonoTV.setText("");
                    telefonoTV.setText(res.getString(2).toString());

                    carreraTV.setText("");
                    carreraTV.setText(res.getString(3).toString());
                }

            }
        });
    }



    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_buscar, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

En seguida creamos la activity Modificar.java
Modificar.java

package com.example.ultron.practicabasedatos;

import android.database.Cursor;
import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;


public class Modificar extends ActionBarActivity {

    Button buscar,actualizar;
    int Codigo;
    EditText nombreTxt,telefonoTxt,carreraTxt,codigoTxt;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_modificar);

        nombreTxt=(EditText)findViewById(R.id.NombreModTxt);
        telefonoTxt=(EditText)findViewById(R.id.TelefonoModTxt);
        carreraTxt=(EditText)findViewById(R.id.CarreraModTxt);
        buscar=(Button)findViewById(R.id.BuscarBtn);
        actualizar=(Button)findViewById(R.id.ActualizarBtn);
        codigoTxt=(EditText)findViewById(R.id.CodigoModTxt);
        buscar.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                DataBaseManager dbm=new DataBaseManager(getApplicationContext());
                Codigo=Integer.parseInt(codigoTxt.getText().toString());
                Cursor res=dbm.buscar(Codigo);
                if(res!=null)
                {
                    res.moveToNext();
                    nombreTxt.setText("");
                    nombreTxt.setText(res.getString(1).toString());

                    telefonoTxt.setText("");
                    telefonoTxt.setText(res.getString(2).toString());

                    carreraTxt.setText("");
                    carreraTxt.setText(res.getString(3).toString());
                }

            }
        });

        actualizar.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                DataBaseManager dbm=new DataBaseManager(getApplicationContext());
                int codigo=Integer.parseInt(codigoTxt.getText().toString());
                String nombre=nombreTxt.getText().toString();
                String telefono=telefonoTxt.getText().toString();
                String carrera=carreraTxt.getText().toString();
                dbm.actualiza(codigo,nombre,telefono,carrera);

                nombreTxt.setText("");
                telefonoTxt.setText("");
                carreraTxt.setText("");
            }
        });

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_modificar, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

Ya casi para terminar el Eliminar.java
Eliminar.java

package com.example.ultron.practicabasedatos;

import android.database.Cursor;
import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;


public class Eliminar extends ActionBarActivity {

    EditText nombreTxt,telefonoTxt,carreraTxt,codigoTxt;
    Button buscar,eliminar;
    int Codigo=0;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_eliminar);

        /*
        Referenciamos los elementos del Layout con la clase de java
         */
        nombreTxt=(EditText)findViewById(R.id.NombreElTxt);
        telefonoTxt=(EditText)findViewById(R.id.TelefonoElTxt);
        carreraTxt=(EditText)findViewById(R.id.CarreraElTxt);
        buscar=(Button)findViewById(R.id.BuscarElBtn);
        eliminar=(Button)findViewById(R.id.EliminarElBtn);
        codigoTxt=(EditText)findViewById(R.id.CodigoElTxt);
        /*
        Primero hay que buscar el elemento que se desea eliminar.
         */
        buscar.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                DataBaseManager dbm = new DataBaseManager(getApplicationContext());//Se invoca a la clase que nos guia a travez de la base de datos
                Codigo = Integer.parseInt(codigoTxt.getText().toString());//Obtenemos el codigo
                Cursor res = dbm.buscar(Codigo);//Buscamos el elemento segun el codigo ingresado
                if (res != null) {
                    //Mostramos resultados
                    res.moveToNext();
                    nombreTxt.setText("");
                    nombreTxt.setText(res.getString(1).toString());

                    telefonoTxt.setText("");
                    telefonoTxt.setText(res.getString(2).toString());

                    carreraTxt.setText("");
                    carreraTxt.setText(res.getString(3).toString());
                }

            }
        });

        eliminar.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                DataBaseManager dbm = new DataBaseManager(getApplicationContext());//Se declara el manager de la base de datos
                dbm.eliminar(Codigo);//Eliminamos usando el codigo como parametro
            }
        });
    }


    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_eliminar, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

Por ultimo nos vamos a nuestro MainActivity.java
MainActivity.java

package com.example.ultron.practicabasedatos;

import android.content.Intent;
import android.database.sqlite.SQLiteDatabase;
import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;


public class MainActivity extends ActionBarActivity {
    Button agregar,buscar,modificar,eliminar;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        DataBaseManager dbm=new DataBaseManager(this);
        agregar=(Button)findViewById(R.id.AgregarBtn);
        buscar=(Button)findViewById(R.id.BuscarBtn);
        modificar=(Button)findViewById(R.id.ModificarBtn);
        eliminar=(Button)findViewById(R.id.EliminarBtn);

        agregar.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent i = new Intent(MainActivity.this, Agregar.class);
                startActivity(i);


            }
        });

        buscar.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent i = new Intent(MainActivity.this, Buscar.class);
                startActivity(i);


            }
        });

        modificar.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent i = new Intent(MainActivity.this, Modificar.class);
                startActivity(i);


            }
        });

        eliminar.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent i = new Intent(MainActivity.this, Eliminar.class);
                startActivity(i);


            }
        });

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

Ahora en nuestro AndroidManifest.xml agregamos el permiso de escritura y lectura en almacenamiento externo.

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

Y nuestra aplicación se tiene que ver así:

Google Maps en Android

Hola, vamos a hacer una aplicación usando el API de google maps.
Primero crearemos el proyecto.

A continuación elegiremos la versión de android con la que trabajaremos.

Ahora elegiremos la Activity de mapas que se nos da por defecto.

Le asignamos el nombre que deseemos.

Y nos posicionamos en google_maps_api.xml, en su proyecto esta en la carpeta de values.

De aquí seleccionamos el link que viene en los comentarios y  accedemos a el en nuestro navegador, es la linea completa solo tache información de las direcciones y claves que se generan por desarrollador.

En la pagina solo crearemos las credenciales, solo es cuestión de aceptar términos y condiciones y dar siguiente, y nos mandara a una pagina que contendrá una tabla como esta:

Esta clave nos sirve para muchas aplicaciones pero se distribuye por desarrollador, no la podemos pasar a otras personas, por si hicieran mal uso de esto. Lo siguiente es copiar la clave que esta en la columna derecha la tabla que les mostré, la "Calve de la API". Solo seleccionamos y copiamos.

Ahora nos vamos a google_maps_api.xml de nuestro proyecto.

Aquí lo que haremos es sustituir la leyenda "YOUR KEY_HERE" por la clave de la API que acabamos de copiar.

Y ahora nos dirigimos a la clase MapsActivity.java y  nos aseguramos que nuestro código se asemeje a este:

package com.example.ultron.practicamapasauge; //Aqui es el nombre del paquete de su proyecto

import android.support.v4.app.FragmentActivity;
import android.os.Bundle;

import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.OnMapReadyCallback;
import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.MarkerOptions;

public class MapsActivity extends FragmentActivity implements OnMapReadyCallback {

    private GoogleMap mMap;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_maps);
        setUpMapIfNeeded();
        SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
                .findFragmentById(R.id.map);
        mapFragment.getMapAsync((OnMapReadyCallback) this);
    }

    @Override
    protected void onResume() {
        super.onResume();
        setUpMapIfNeeded();
    }

    private void setUpMapIfNeeded() {
       if (mMap == null) {
            mMap = ((SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map))
                    .getMap();
            if (mMap != null) {

            }
        }
    }

    @Override
    public void onMapReady(GoogleMap googleMap) {
        LatLng CUCEI = new LatLng(20.656945, -103.324512); //Enviamos coordenadas de nuestro objeto de latitudes
        googleMap.addMarker(new MarkerOptions().position(CUCEI).title("CUCEI"));//Agregamos la marca con su titulo
        googleMap.moveCamera(CameraUpdateFactory.newLatLng(CUCEI));//Movemos la camara a donde correspone la marca que hicimos.
    }
}

Ya teniendo esto, corremos nuestra aplicación y lo que debe de aparecernos en nuestra pantalla es lo siguiente:

Pueden agregar cuantas marcas ustedes deseen en el metodo onMapReady.

Para obtener las latitudes de un sitio, solo se van a Maps y buscan el sitio al que desean hacer referencia en su aplicación.

Damos click derecho sobre la marca.

Y elegimos la opción ¿Que hay aquí?

Y nos devolverá las latitudes del sitio del marcador, las copiamos y las llevamos al objeto LatLng que usaremos para la respectiva marca.
Espero les sea de utilidad este tutorial, gracias por su atención.

Fuentes:
https://developers.google.com/maps/documentation/android/start consultada el 16 de julio del 2015