Código

2 1646

Un programa que pedían en la Universidad, especialmente en la clase de Inteligencia artificial fue el programa de las 8 reinas, el cual consiste en poner 8 reinas en un tablero de ajedrez sin que estás se amenacen.

Movimientos posibles de la reina
Movimientos posibles de la reina

Y se podía desarrollar en cualquier lenguaje, en este caso fue en perl.

#/usr/bin/perl
$N = 8;
for ($i = 0; $i < $N; $i++)
{
    for ($j = 0; $j < $N; $j++)
    {
        $tablero->[$i][$j] = "X";
    }
}

&Ajedrez (0);
&imprimir ();

sub Ajedrez
{
    local ($fila) = @_;
    local ($i, $j);
    local ($linea) = 0;
    if ($fila == $N)
    {
        return (1);
    }
while ($linea < $N)
{
    if (&test ($fila, $linea))
    {
        $tablero->[$fila][$linea] = "Q";
        if (&Ajedrez ($fila + 1))
        {
            return 1;
        }
        $tablero->[$fila][$linea] = "X"
    }
    $linea++;
}
return (0);
}

sub test
{
    local ($fila, $linea) = @_;
    local ($r, $l);
    $r = $fila;
    $l = $linea;
    while ($r >= 0 && $l >= 0)
    {
        if ($tablero->[$r][$l] eq "Q")
        {
            return (0);
        }
        $r--;
        $l--;
    }
    $r = $fila;
    $l = $linea;
    while ($r >= 0 && $l < $N)
    {
        if ($tablero->[$r][$l] eq "Q")
        {
            return (0);
        }
        $r--;
        $l++;
    }
    $r = $fila;
    $l = $linea;
    while ($r >= 0)
    {
        if ($tablero->[$r][$l] eq "Q")
        {
            return (0);
        }
        $r--;
    }
    return (1);
}

sub imprimir
{
    local ($i, $j);
    for ($i = 0; $i < $N; $i++)
    {
        print "\n\t\t\t";
        for ($j = 0; $j < $N; $j++)
        {
            print " $tablero->[$i][$j] ";
        }
    }
}

Para correrlo basta con mandar a llamar el interprete de perl, con el programa, y la salida del mismo sería la siguiente:

/usr/bin/perl reinas.pl

Q X X X X X X X
X X X X Q X X X
X X X X X X X Q
X X X X X Q X X
X X Q X X X X X
X X X X X X Q X
X Q X X X X X X
X X X Q X X X X

Espero les sirva…

1 1444

Una de los posibles usos de el modificador static es compartir el valor de una variable miembro entre objetos de una misma clase. Si declaramos una variable miembro de una clase, todos los objetos que declaremos basándonos en esa clase compartirán el valor de aquellas variables a las que se les haya aplicado el modificador static, y se podrá modificar el valor de este desde todas.
Un caso en el que nos podría ser muy útil este modificador, es en una clase que nos diga la cantidad de objetos que se han creado basándose en ella. Podemos meter una linea de código en el constructor que incremente la variable contador con el modificador static, y así cada vez que se declare un objeto el contador se incrementará. Desde cualquier objeto podremos consultar el valor del contador. El codigo sería algo así:

class Clase {
static int contador;
Clase() {
contador++;
}
int getContador() {
return contador;
}
}

class Codigo {
public static void main(String[] args) {
Clase uno = new Clase();
Clase dos = new Clase();
Clase tres = new Clase();
Clase cuatro = new Clase();
System.out.println("Hemos declarado " + uno.getContador() + " objetos.");
}
}

Esto tiene varias ventajas, porque además de ahorrarnos algunas posiciones de memoria (porque todos objetos comparten la misma) podemos crear variables compartidas, cosa que abre la puerta a suculentas posibilidades.

14 24474

[Gracias al comentario de desempleado, hago el cambio de titulo, por uno más ad-hoc al post]

Uno de los pilares principales de la programación es el uso de variables. En Java encontramos muchos tipos de variables, capaces de almacenar todos los tipos de datos que necesitemos. Pero al estar hablando de programación Orientada a Objetos tenemos que diferenciar entre variables y objetos.

Las variables, en Java, son llamados primitivos. Simplemente almacenan un valor. En cambio, un objeto es un conjunto de variables y métodos.

Como aún no hemos tratado los conceptos de clase y objeto, tan importantes en Java, la explicación anterior puede parecer difusa. No se preocupen, que cuando tenga realmente claros los mecanismos de declaración y uso de clases escribiré un post aclaratorio sobre ellas. Hasta el momento, los que tienen nociones sobre programación, pueden ver a las variables primitivas como siempre los han visto.
Tenemos distintos tipos de primitivos :

boolean: Este tipo de variable solo puede tomar dos valores, o true o false. Por defecto, si no se le asigna ningún valor, le corresponde el valor false.

char: Las variables de caracteres pueden contener cualquier carácter, tanto números, como letras, como signos. El valor por defecto es NULL.

byte: Esta variable puede comprender valores numéricos enteros entre -128 y +127. Se caracteriza por su ligereza, ya que solo ocupa 8 bits (un byte), pero su utilidad es reducida.

short: Igual que byte, pero ocupando el doble de memoria (dos bytes) y permitiendo asignar valores mucho má grande (exactamente desde -32768 hasta 32767). También debe ser un valor entero.

int: Ocupa 32 bits (4 bytes), pero permite asignar valores en un rango especialmente grande; desde -2147483648 hasta 2147483647. Como en los tipos byte y short, el valor por defecto es 0.

long: Las variables tipo long ocupan 64 bits (8 bytes), ya que sus valores pueden jugar dentro de un rango amplísimo (de -9223372036854775808 a 9223372036854775807 :D). Al igual que sus hermanos pequeños (byte, short e int), su valor por defecto es 0. Una cosa muy importante es que a la hora de asignar un valor a este tipo de variables, tienes que indicar que se trata de un long añadiendo una L (mayúscula) al final del numero. Luego publicaré un ejemplo práctico.

float: Hasta ahora hemos hablado de variables para almacenar enteros, pero muchas veces necesitaremos representar números reales con decimales y demás. Para esto sirve float (y su hermana mayor, double). Ocupa 32 bits. Su precisión es muy pobre, y se pueden obtener resultados extraños trabajando con números grandes. Trataremos este tema en más profundidad en próximos comentarios, apoyado de código fuente.

double: Igual que float, pero mayor, ocupando 64 bits. Intenta arreglar los problemas de la coma flotante simple (float).

Ahora que ya sabemos los tipos de primitivos con los que contamos, y que la declaración de variables es simplemente:

tipoPrimitivo nombreVariable;,

debemos saber que hay algunas convenciones a la hora de dar nombre a las variables, para hacer código más entendible. Las variables deben hablar de los datos que contienen, cosa que permite una mejor identificación. No podemos dar el nombre haceCalor a un primitivo tipo string que contiene el nombre del usuario de la aplicación, solo provocaría confusión a la hora de mejorar/ampliar/estudiar el código. Un nombre adecuado para la variable sería nombreUsuario. Como habrán notado, la primera letra del nombre de variable siempre debe estar en minúscula, y si usamos más de una palabra la primera letra de la segunda palabra la ponemos en mayúscula. Así, si queremos dar nombre a una variable que contenga el numero de días del mes de febrero, podríamos poner numeroDiasFebrero. Otra cosa importante es que no se pueden usar palabras reservadas de Java, como class o main.

Cuando tenemos una variable declarada (para seguir el lenguaje estricto de Java deberíamos decir “un primitivo referenciado”), toca asignarle un valor. Esto se hace mediante el operador =. Ahí van algunos ejemplos :

byte contador;
contador = 100;
short dieciseisBits;
DieciseisBits = 30500;
boolean verdaderoFalso;
verdaderoFalso = true;

Espero sea de utilidad.


Warning: Parameter 1 to W3_Plugin_TotalCache::ob_callback() expected to be a reference, value given in /home/admin/web/k4ch0.org/public_html/wp-includes/functions.php on line 3594