Saturday, June 11, 2005

The Backus-Naur form (BNF)

La forma de Backus-Naur (BNF) (también conocido como forma normal de Backus) es un metasyntax usado para expresar gramáticas independientes del contexto: es decir, una manera formal de describir lenguajes formales. BNF se utiliza extensamente como notación para las gramáticas de los lenguajes de programación de la computadora, de los sistemas de comando y de los protocolos de comunicación. Pueden también ser utilizados como notación para representar partes de gramáticas de la lengua natural. Por ejemplo vea la gramática para el metro en la poesía de Venpa. La mayoría de los libros de textos para la teoría y/o la semántica del lenguaje de programación documentan el lenguaje de programación en BNF. Algunas variantes, por ejemplo ABNF, tienen su propia documentación.

BNF fue nombrado originalmente después de Juan Backus y más adelante (en la sugerencia de Donald Knuth) también después de Peter Naur. Eran dos pioneros en informática, especialmente en el arte del diseño del recopilador. La forma de Backus-Naur o las gramáticas de BNF tiene semejanzas significativas a las reglas de la gramática de Panini, y a veces también se refiere como forma de Panini-Backus. BNF fue creado como parte de crear las reglas para ALGOL 60.

Multiplica los primeros 100 números primos

/*
* Created on 06/11/2005
*
* Multiplica los primeros 100 números primos
*
*/
package estructura;

/**
* @author vns
*
*/
public class Mult100Primos {

/**
*
*/
public Mult100Primos() {
super();

}

public static void main(String[] args) {

double[] primos = generarPrimos();
double resultado = 1;

for (int i = 0; i < primos.length; i++) {
resultado = resultado * primos[i];
}

System.out.println("La multiplicación de los primeros 100" +
" números primos es " + resultado);
}

//generar números primos
public static double[] generarPrimos(){
double[] lista = new double[100];
int numero = 0;

for (int i = 0; i < lista.length; i++) {
for(;;){
numero++;
if (esPrimo(numero)) {
lista[i] = numero;
break;
}
}
}

return lista;
}

//checkea si es primo
public static boolean esPrimo(int primo){

if (primo == 1) {
return true;
}

if (primo <= 0 ) {
return false;
}

for (int i = 2; i < (primo - 1) ; i++) {
if ( (primo % i) == 0) {
return false;
}
}

return true;
}
}

El mayor de tres números

/*
* Created on 06/11/2005
*
*/
package estructura;

/**
*
* @author vns
*/
public class Mayor3 {

/**
*
*/
public Mayor3() {
super();

}

public static void main(String[] args) {

if (args.length == 0 || args.length > 3){
System.out.println("Escriba un tres números, ejemplo: 1 2 3");
System.exit(0);
}

int max = Integer.parseInt( args[0] );

for (int i = 1; i <= 2 ; i++ ){
if ( max < Integer.parseInt( args[i] ) ) {
max = Integer.parseInt( args[i] );
}
}

System.out.println("El número mayor es " + max );
}
}

Declaracion de tipos de Datos

/*
* Created on 06/11/2005
*
* Declaracion de tipos de Datos
*/
package estructura;

import java.io.IOException;

/**
*
*/
public class TiposDatos {

/**
* Constructor por el check exception
*/
public TiposDatos() throws IOException {
super();
}

//Días de la semana
String[] semana = {"domingo","lunes","martes","miercoles",
"jueves","viernes","sabado"};

//valores de la edad para una persona
byte edad = 0;

//lista de supermercado
java.util.ArrayList lista = new java.util.ArrayList();

//archivo de texto
java.io.BufferedReader archivo = new java.io.BufferedReader(
new java.io.FileReader("archivo.txt") );

}

Analizador sintáctico

Un analizador sintáctico es un programa que reconoce si un una o varias cadenas de carácteres forman parte de un determinado lenguaje.

Los lenguajes habitualmente reconocidos por los analizadores sintácticos son los lenguajes libres de contexto. Cabe notar que existe una justificación formal que establece que los lenguajes libres de contexto son aquellos reconocibles por un autómata de pila, de modo que todo analizador sintáctico que reconozca un lenguaje libre de contexto es equivalente en capacidad computacional a un autómata de pila.

Los analizadores sintácticos fueron extensivamente estudiados durante los años 70 del siglo XX, detectándose numerosos patrones de funcionamiento en ellos, cosa que permitió la creación de programas generadores de analizadores sintáticos a partir de una especificación de la sintaxis del lenguaje, tales y como yacc, GNU bison y javacc.

Palindramo y Factorial

/*
* Created on 06/11/2005
*
* Un palíndromo(del griego palin dromein, volver a ir hacia atrás)
* es una palabra, número o frase que se lee igual hacia adelante
* que hacia atrás. Si se trata de un numero, tambien se llama capicúa.
*/
package estructura;

/**
* @author vns
*
* Busca si una palabra es Palidramo
*/
public class Palindramo {

private StringBuffer palabra = new StringBuffer();

/**
*
*/
public Palindramo(StringBuffer palabra) {
super();

this.palabra = palabra.reverse();
this.palabra.trimToSize();
}

public boolean isPalindromo(String palabra){
if (palabra.compareTo(this.palabra.toString()) == 0)
return true;
else
return false;
}

public static void main(String[] args) {

if (args.length == 0 || args.length > 1){
System.out.println("Escriba un argumento para la palabra");
System.exit(0);
}

Palindramo palindramo = new Palindramo(new StringBuffer(args[0]));

if (palindramo.isPalindromo(args[0])) {
System.out.println("Es palindramo" + " " + args[0]);
} else {
System.out.println("No es palindramo" + " " + args[0]);
}
}
}
==========================================================
/*
* Created on 06/11/2005
*
* Busca el factorial de un número
*/
package estructura;

/**
* @author vns
*
*/
public class Factorial {

private int r = 0;

/**
*
*/
public Factorial(String n) {
super();
int num = Integer.parseInt(n);
r = num;
num = num - 1;
while(num > 0){
r = r*(num);
num = num - 1;
}

}

/**
* Misma operación pero recursiva
*
* @param n
* @return
*/
public static int factorial(int n){
if (n == 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}

public static void main(String[] args) {

if (args.length == 0 || args.length > 1){
System.out.println("Escriba un argumento para el número");
System.exit(0);
}

Factorial factorial = new Factorial(args[0]);
System.out.println("El numero factorial es: " + factorial.r);
}
}

Definiciones:

Una variable corresponde a un área reservada en la memoria principal del ordenador, longitud fija o variable, en donde el programa puede almacenar valores.

Una constante es un valor fijo

tipo de dato a partir de los valores permitidos y las operaciones que se puedan llevar a cabo sobre estos valores.

Un algoritmo es un conjunto finito de instrucciones o pasos que sirven para ejecutar una tarea o resolver un problema.

En programación orientada a objetos se denomina polimorfismo a la capacidad del código de un programa para ser utilizado con diferentes tipos de datos u objetos. También se puede aplicar a la propiedad que poseen algunas operaciones de tener un comportamiento diferente dependiendo del objeto (o tipo de dato) sobre el que se aplican.

La Programación Orientada a Objetos (POO ú OOP según siglas en inglés) es una metodología de diseño de software y un paradigma de programación que define los programas en términos de "clases de objetos", objetos que son entidades que combinan estado (es decir, datos) y comportamiento (esto es, procedimientos o métodos). La programación orientada a objetos expresa un programa como un conjunto de estos objetos, que se comunican entre ellos para realizar tareas.

Las clases son declaraciones o abstracciones de objetos, lo que significa, que una clase es la definición de un objeto. Cuando se programa un objeto y se definen sus características y funcionalidades, realmente se programa una clase.

Monday, June 06, 2005

Bienvenidos al weblogs de estructura de datos

Este es el weblogs de estructura de datos

Victor Sosa 2003-7013