Bitácora Ing. Computación e Informática

"Hola Mundo" (Java)

2007-11-10T18:31:00.000-03:00

Aquí va el típico : "Hola Mundo" en Java

Antes que nadan tienen que tener instalado el compilador de Java. Aquí dejo la guía para que vean como se hace

http://www.dcc.uchile.cl/~vramiro/CC10A/

//Declaramos nuestra Clase
Class HolaMundo{

//Main
public static void main(String []args){

//Mensaje que saldra por Salida Estandar
System.out.println("Hola Mundo");

}
}

UML

2007-11-10T18:17:00.000-03:00

Lenguaje Unificado de Modelado:

_Es un lenguaje gráfico que permite el modelado de sistemas de software mediante el uso de diagramas:

Diagrama de clases
Diagrama de componentes
Diagrama de objetos
Diagrama de estructura compuesta (UML 2.0)
Diagrama de despliegue
Diagrama de paquetes
Diagrama de casos de uso
Diagrama de secuencia
Otros...

Es importante resaltar que UML es un "lenguaje" para especificar y no para describir métodos o procesos.

fuente: http://es.wikipedia.org/wiki/Lenguaje_Unificado_de_Modelado

Programacion Orientada a Objetos

2007-11-03T00:25:00.000-03:00

Defnición:

Método de implementación en el que los programas están organizados como colecciones de objetos, donde cada uno es instancia de alguna clase, y donde todas las clases son miembros de una jerarquía de clases conectadas por relaciones de herencia.

Características:

- Todo es un objeto que almacena datos y al que se le puede hacer peticiones.
- Un programa es un conjunto de objetos que intercambian mensajes.
- Cada objeto tiene su propia memoria que está compuesta por otros objetos.
- Cada objeto tiene un tipo de mensajes que puede recibir y procesar.
- Todos los objetos de un cierto tipo pueden procesar los mismos mensajes.

Clases:

Estructura de datos abstracta junto con las operaciones que se pueden realizar con ella. Un objeto es una instancia de una clase.

Dentro de lo que es el estado del objeto cabe distinguir entre las variables de instancia (datos distintos en cada instancia) y las variables de clase (datos comunes a todas las instancias), además tenemos métodos de instancia (que trabajan con el estado de una instancia de clase) y métodos de clase (que funcionan igual en todas las instancias).

Como una clase describe un conjunto de objetos con características y comportamientos idénticos, se puede pensar en una clase como si fuera un tipo.

Ocultamiento de información: principio según el cual fuera del objeto sólo se muestran los detalles mínimos necesarios para poder iniciarlo o acceder a él.

Ventajas

- Modularidad: Se puede escribir y mantener el código para un objeto aparte del código para los demás.
- Encubrimiento de detalles de implementación: Puede mantener información privada y proteger métodos cuyos detalles de implementación pueden cambiar.

Las relaciones entre objetos: Se distinguen cuatro tipos à instanciación, asociación, agregación y herencia.

Las relaciones de instancia son del tipo “es un/a”. Un objeto está asociado con otro si lo usa a través de mensajes que le envía (asociación).

-Agregación:

La manera en que se puede construir una clase u objeto en términos de otras clases u objetos ya existentes. Estas relaciones son del tipo “tiene un/a”.

Se puede distinguir entre dos tipos de objetos formados por agregación:

1- Objeto monolítico: No parece desde afuera que se ha construido a partir de otros objetos.
2- Objeto compuesto: Parece estar construido de otros objetos, en el sentido de que se puede acceder a su estructura desde afuera. Se distinguen dos variantes, el compuesto heterogéneo (compuesto por objetos distintos) y el compuesto homogéneo (compuesto por objetos iguales).

-Herencia:

La manera en que se puede definir una clase u objeto como extensión de otra clase u objeto.

Todas las subclases heredan el estado (en términos de las declaraciones de variables) y los métodos de la superclase. Aún así las subclases no se limitan al estado y comportamiento dado por la superclase, sino que pueden añadir nuevas variables y métodos a los que hereden.

Características del lenguaje Java:

-Simple y orientado a objetos: Simple de aprender, alta reutilización y bibliotecas.
-Robusto y seguro: Tipificación fuerte, recolección de basura.
-Interpretado y portable: Se compila el bytecode, interpretado por JVM.
-Distribuido y alto desempeño: Movilidad de código.
-Multi-hilo: Mejora la interactividad de las aplicaciones.
-Dinámico: Permite enlace y carga dinámica de clases.

Ejemplo:

Public class HolaMundo {
public satic void main(String[] args) {

System.out.println(“Hola Mundo”);

}
}

Ejercicios de Recursividad

2007-09-26T17:28:00.001-04:00

Multiplicación por Duplicación

FunciónDuplica(int a, int b, suma){
if(b==1)
suma+=a;
return suma;

else
if(b%2!=0)
suma+=a;
return FunciónDuplica(int a*2, int b/2, suma);
}

Se pide encontrar el Máximo Común Divisor entre dos números.

FunciónMDC(int a, int b){

//Caso Base

if(a==b)
return a;

//Caso Recursivo
else
return FunciónMDC(a%b, b%a);
}

TDA o Tipo de Datos Abstracto

2007-09-23T14:51:00.000-04:00

La abstracción de datos consiste en obviar y ocultar las características de un objeto, para que luego, en nuestro programa, solo se utilice el nombre.

Ejemplo:

Cuando yo digo la palabra “perro”, usted no necesita que yo le diga lo que hace el perro. Usted ya sabe la forma que tiene un perro y también sabe que los perros ladran. De manera que yo abstraigo todas las características de todos los perros en un solo término, al cual llamo “perro”.

En programación ésto nos permite un gran ahorro de tiempo y líneas de código, debido a que si necesitamos hacer operaciones, en éste caso, con algún perro, sólo necesitamos hacer referencia a "perro" y no tenemos que estar definiendo a cada momento que es un perro.

Con ésto, además, logramos que la programación sea mas estructurada, ordenada y eficiente.

Al hecho de guardar todas las características y habilidades de un objeto por separado se le llama Encapsulamiento.

Algo muy importante en los TDAs, es que estós tienen que tener por obligación operadores. Si éstos no existiecen, por algún motivo, el/los dato/s dejarían de ser tipo abstracto. En definitiva, los datos de tipo abstracto tiene que tener definidos sus propios operadores (+, -, *, etc).

Aplicacción de TDA en C:

Para éste ejemplo se define un objeto círculo con sus respectivos operadores para calcular su área.

# include

typedef struct circulo circulo;

struct circulo {
  // Datos
float radio;

// Operaciones
float (*area)(circulo);
void  (*create)(circulo *,float);
};

// Implementación de las operaciones float p1( circulo c) {
    return 3.1416 * c.radio *c.radio ;
}

void p2(circulo *c, float r) {
    c->radio = r;
}

int main() {
  circulo t;
  t.create = p2;
t.area   = p1;
  t.create(&t,5);
  printf("%f %f\n",t.radio,t.area(t));
  return 1;
}

Fuente(s): http://es.wikipedia.org/wiki/TAD
http://www.e-services.cl/unabwiki/doku.php?id=tad

The Sorter

2007-09-03T06:27:00.001-04:00

Si no entendiste las metodologías de ordenamiento, te dejamos este lindo video explicativo. Eso si tienes que saber ingles -.-

Recursividad o Recursión.

2007-08-28T21:22:00.000-04:00

La recursividad es una técnica importante dentro de la programación, en la cual se hace el uso de una función que se llama a si misma una cantidad definida de veces para llegar a un resultado. Dentro de esta función no se usan ciclos, ya que esta técnica se puede decir que simula uno. Por esto mismo cualquier ciclo de tipo for, while, do-while, etc.puede ser transformado a recursivo. Una función recursiva debe tener:

- Un punto de finalización.

- Una parte recursiva.

Los valores que se van retornando en la parte recursiva deben tender al punto de finalización para que no se quede llamando infinitamente. El beneficio de la recursividad es que resulta muy ligera, son de códigos mas simples y es de fácil lectura. Aquí les dejo unos ejemplos básicos y clásicos que se usan para ver la funcionalidad de este método. Lo ideal es que hagan la traza de estos programas y vean como se hace la auto llamada de la función y como se mueven las variables, etc.

Ejemplos:

1) Determinar el factorial de un numero N:

int factorial(int N) {

if (N==0)
return 1; // Si N=0 se devuelve 1 con lo que se termina la auto llamada.
else //Si es distinto de 0....
return N*Factorial(n-1); // Se retorna la multiplicación del
// numero por la auto llamada a la funcion

} //Fin de la función.

__________________________________________

2) Mostrar el elemento numero N de la serie de Fibonacci (0112358...)

int Fib(int N) {

if ( (N==0) || (N==1) ) //Si el elemento N es uno de los 2 primeros numeros de la serie...
return 1; //Devolvemos 1 y con eso se termina la auto llamada.
else // Si el elemento N es distinto a los 2 primero numeros de la serie...
return Fib(n-1)+Fib(n-2); // Se hace la suma de los 2 numeros
// anteriores mediante la autollamada de la función.

} //Fin de la función

__________________________________________

3) Mostrar el resultado de una potencia

int Potencia(int base, int exponente) {

if (exponente==0) //Si el exponente es = 0...
return 1; // Se retorna 1
else // si es distinto a 0...
return ( base * Potencia(base,exponente-1) ); // se multiplica la base
//por la auto llamada a la función dirigida al exponente-1.

} //Fin de la función

__________________________________________

4) Sumar los elementos de un arreglo global A de 10 elementos considerando desde el ultimo numero hasta el primero.

int Sumar( int i ) { // i = largo del arreglo .

if (i<0) // Si el contador i es menor que 0.
return 0; //Devolvemos 0 y con esto se termina la auto llamada.
else // Si no es 0.
return A[i] + Sumar( i-1 ) ; //se retorna el valor que esta dentro de A[i]
//y se le suma la auto llamada a la función.
} //Fin de la función

__________________________________________

5) Determinar el máximo común divisor entre el numero M y N (M: numero mayor, N: numero menor).

int MCD(int M, int N) {

int V; //Se declara la variable que mantendra el valor a retornar.
if ( (M%N)==0 ) //Si el resto de la división de M/N es = 0
V=N; //Se guarda en la variable V (para retornar) el valor de N que seria el Min.Co.Div.
else //Si no
V=MCD(N,M%N); //Se auto llama la funcion reduciendo los numeros.
return V;

} //Fin de la función

__________________________________________

Métodos de ordenamiento básicos

2007-08-21T21:00:00.000-04:00

En este articulo vamos a mostrar los algoritmos, ventajas y desventajas de los 3 métodos de ordenamiento mas comunes y básicos. Estos son: burbuja, selección, inserción.

Los métodos de ordenamiento son necesarios para que luego de ordenar, se puedan buscar datos de una manera mucho mas rápida y eficiente aplicando distintas técnicas.

Ordenamientos Internos y Externos

Internos: los valores a ordenar están en memoria principal, por lo que se asume que el tiempo que se requiere para acceder cualquier elemento sea el mismo (a[1], a[500], etc).

Externos: Los valores a ordenar están en memoria secundaria (disco, cinta, cilindro magnético, etc), por lo que se asume que el tiempo que se requiere para acceder a cualquier elemento depende de la última posición accesada (posición 1, posición 500…)

Existen tres casos al ordenar información

1) El peor caso para el algoritmo es cuando la información que se tiene está ordenada al revés.

2) El Mejor es cuando la información está ordenada.

3) El caso Promedio es cuando la información está ordenada al azar.

Método de ordenamiento Burbuja

for ( i=1; i<n;i++)
for( j=0;j<n-1;j++) {
if (a[j] > a[j+1])
temp = a[j];
a[j]= a[j+1];
a[j+1]= temp;
}

Ventajas:

- Fácil implementación.

- No requiere memoria adicional.

Desventajas:

- Muy lento.

- Realiza numerosas comparaciones.

- Realiza numerosos intercambios.

Metodo de ordenamiento por selección

for (i=0; i<TAM - 1; i++){
pos_men = Menor(lista, TAM, i)
temp = lista[i];
lista[i] = lista [pos_men];
lista [pos_men] = temp; }

Menor(lista,TAM,i) es una función que busca el elemento menor del arreglo llamado lista que se encuentra entre las posiciones i y la posición TAM, y devuelve la el identificador. A continuación se encuentra el código de la función:

int menor (tipo arreglo, int largo, int j) {
tipo menor=arreglo[j];
int pos_menor=j;
for (j++;j<largo-1;j++)
if (arreglo[j]<menor) {
menor=arreglo[j];
pos_menor=j;
}
return pos_menor;
} //Fin del for

Ventajas:

- Fácil implementación.

- No requiere memoria adicional.

- Realiza pocos intercambios.

- Rendimiento constante: poca diferencia entre el peor y el mejor caso.

Desventajas:

- Lento.

- Realiza numerosas comparaciones.

Ordenamiento por inserción

for (i=1; i<TAM; i++) {
temp = lista[ i ];
j = i - 1 ;
while ( (lista[ j ] > temp) && (j >= 0) ) {
lista[ j+1] = lista[ j ] ;
j-- ;
} //Fin while
lista [ j+1] = temp;
}//Fin for

Ventajas:

- Fácil implementación.

- Requerimientos mínimos de memoria.

Desventajas:

- Lento.

- Realiza numerosas comparaciones

Quicksort

El algoritmo quicksort es quizá el más eficiente de los algoritmos de ordenamiento, debido a que su complejidad es mínima y por lo tanto su tiempo de ejecución también es mínimo. Se divide la lista en dos sublistas y ordenarlas en forma independiente cada una. El proceso de partición es repetido hasta llegar a listas de tamaño 1 (que están ordenadas).

Lo central en este método es encontrar un método eficiente para particionar la lista en dos partes, tal que:

Todos los elementos de una sub-lista deben ser menores que un elemento llamado pivote.
Todos los elementos en la otra sub-lista deben ser mayores que el pivote.

Si asumimos que los elementos de la lista están almacenados en un arreglo, el método para particionar el arreglo en dos es como sigue:

Escoja un elemento en el arreglo como pivote. Por conveniencia, usaremos el primer elemento del arreglo.
Ponga un índice al segundo elemento del arreglo (i1) y otro al último elemento (i2).
Decremente i2 hasta que encuentre un elemento con valor menor que el pivote o i2 llegue a i1. Incremente i1 hasta que encuentre un elemento mayor que el pivote o hasta que i1 llegue a i2. Llamaremos a este proceso “búsqueda”.
Si los dos índices son distintos, los dos elementos del arreglo (los apuntados por i2 e i1) están fuera de lugar, por lo que se intercambian. Repita el paso anterior de búsqueda, resumiendo la operación donde se había quedado.
Si los dos índices son iguales y el valor que ambos índices apuntan es menor que el pivote, intercambielos. El arreglo está ahora particionado por el elemento referenciado por i2 (o i1). La localización del pivote separa el arreglo en una porción donde todos sus valores son menores que el pivote, y otra porción donde todos sus valores son mayores que el pivote.

Referencia: http://www.e-services.cl/unabwiki/doku.php?id=ordenamiento

Manejo de archivos en C (Parte I)

2007-08-16T14:42:00.001-04:00

Los nombres de archivos constan de tres partes:

Dispositivo:Archivo.EXT

- Dispositivo: El nombre del disco en donde vamos a trabajar.

- Archivo: nombre del archivo (8 caracteres máximo).

- .EXT: Extensión del archivo (3 caracteres máximo).

Crear un archivo y almacenar datos

La creación de archivos y almacenamiento de datos se realiza en cuatro pasos básicos:

Puntero del archivo (Paso 1)

Es un puntero de tipo FILE que apunta hacia la dirección del archivo. Al abrir, leer o realizar cualquier accion sobre el archivo se debe llamar a este puntero.

Código:

FILE *puntero_del_archivo;

- FILE: Es el tipo de dato del puntero, como se esta trabajando con un archivo se utiliza el tipo FILE.

- Puntero_del_archivo: nombre que se le da al puntero, este puede ser cambiado por el que quieras.

Indicar al puntero el archivo que se va a trabajar (Paso 2)

En esta parte usando la función fopen se indica al puntero el archivo en el cual queremos trabajar. El archivo indicado se abre con el permiso de escritura o lectura que uno le indique.

Código:

puntero_del_archivo = fopen(“archivo.txt”,”w”);

La función fopen tiene 2 partes:

- “archivo.txt”: Es el nombre del archivo en el que vamos a trabajar.

- “w”: es el permiso que se da para utilizar el archivo. En este caso es “w”, que significa: “Abierto para escritura. Los datos son escritos desde el principio o se crea un nuevo archivo (si no existe)”. Al final del artículo se mostraran todos los tipos de datos.

Ingreso de carácter al archivo (Paso3)

En esta parte se usa la función putc para ingresar solo un carácter y se le dice que trabaje con el archivo que indica el puntero. Cada ves que se aplique la función putc se ingresara el carácter indicado, pero sin reemplazar el anterior, es algo un poco “mágico” que solamente tienes que repetir la función y todo se va a ir escribiendo sin problemas, sin indicarle posición, ni línea, ni nada. (Se va a escribir carácter tras carácter desde que se abre el archivo).

Código:

putc(‘c’, puntero_del_archivo);

Aquí se ingresa el carácter ‘c’ en el archivo puntero_del_archivo. Recuerda que siempre tienes que escribir el carácter entre comillas simples ‘c’ y no entre comillas dobles “c”.

Cierre del archivo (Paso4)

Aquí se cierra el programa usando la función fclose indicando el puntero del archivo.

Código:

fclose(puntero_del_archivo)

Codigo completo:

#include

main() {

FILE *puntero_del_archivo;

puntero_del_archivo = fopen(“archivo.txt”,”w”);

putc(‘c’,puntero_del_archivo);

fclose(puntero_del_archivo);

}

Almacenamiento de una cadena de caracteres

Almacenamiento de un string

Para realizar el almacenamiento de caracteres es necesario ir ingresando carácter por carácter por lo cual si tenemos un string lo tenemos que recorrer usando un for o un while.

Código:

Int LS=strlen(caracteres); //Largo del string

for (i=0;i

putc(caracteres[i],puntero_del_archivo);

Almacenamiento de escritura directa del teclado

Almacena valores escritos directamente del teclado, en tiempo “real”, o por lo menos casi instantáneamente. Este método consiste en un while que esta todo tiempo iterando hasta que uno ingresa un valor por teclado (clic en alguna tecla), al hacer esto el programa detiene el while e ingresa el valor al archivo y luego continua iterando hasta que se presiona la tecla Enter (valor: ‘\r’).

Código:

While ( (caracter = getchar() )!= ‘\r’)

caracter = putc(caracter, puntero_del_archivo);

La función getchar retorna el carácter ingresado por el stream de entrada, que seria el teclado, lo guarda en la variable caracter y lo compara con ‘\r’. Si es distinto de ‘\r’ ingresa el carácter al archivo mediante putc.

Lectura de datos de un archivo

Para leer archivos no es muy distinto que guardarlos, solamente hay que cambiar el tipo de escritura a lectura (“r”) y cambiar la función putc por getc devuelve valores de un archivo de texto.

Código:

#include

main() {

FILE *puntero_del_archivo;

char caracter;

puntero_del_archivo = fopen(“archivo.txt”,”r”);

while (( caracter = getc(puntero_del_archivo) ) != EOF)

printf(“%c”,caracter);

fclose(puntero_del_archivo);

}

Como se puede ver se cambio el tipo de escritura/lectura del archivo abierto en la función fopen, se cambio por “r” que es el tipo de lectura normal: “Abierto para lectura, el archivo debe existir”. Luego viene el while donde la función getc ingresa un carácter del archivo y lo guarda en carácter el cual se compara con EOF (End Of File) que significa que no hay más datos que mostrar. Si es distinto a EOF imprime el carácter y vuelve a hacer la comparación.

Lista de tipos de escrituras

a	Abierto para añadir datos. Los datos nuevos se añaden al final del archivo o se crea un archivo nuevo (si no existe).
r	Abierto para lectura. El archivo debe existir.
w	Abierto para escritura. Los datos son escritos desde el principio o se crea un nuevo archivo
a+	Abierto para lectura y añadir datos. Si el archivo no existe se crea.
r+	Abierto para lectura y escritura. El archivo debe existir.
w+	Abierto para lectura y escritura. Se escribe desde el principio del archivo.

Tabla extraída del libro indicado más abajo.

Les dejo un link de una página Web donde pueden encontrar toda la información sobre estas y otras funciones, la dirección es: http://www.conclase.net/c/librerias/funciones.php

Espero que les sirva todo este material, se pueden hacer muchas cosas útiles con estas pocas líneas de código, sirve mucho. ¡Saludos!

Toda la información puesta aquí fue aprendida del libro “Programación estructurada en C”, de James L. Antonakos y Kenneth C. Mansfield Jr.

Empezamos II.

2007-08-14T17:11:00.000-04:00

Hola a todos!. Antes que nada quisiera presentarme.Mi nombre es Pablo Barrera (Mordelon), soy estudiante de Ing. en Informática y soy compañero de Gonzalo =P.

Al igual que Gonzalo desde muy pequeño, me interesó el mundo de la informática, recuerdo que mi bichito por el mundo de la computación empezó el día en que mi padre compró el primer pc de la casa, por haya por año 1996, era un 386 xD; me recuerdo que era muy moderno para esa tiempo, con 1gb de memoria =O... En fin, siempre me preguntaba como le hacia un computador para funcinar, como se hacían los programas, como es que se creaban los virus, etc. entonces de hay que me interesé por saber, por aprender y creo que está carrera es una de las mejores vías para poder resolver mis intereses de niño ^^.

Por ahora, lo que aprendido me ha gustado mucho y está cumpliendo lejos mis espectatias que tenía sobre la carrera, y estoy convencido de que si pongo(ponemos)mucho empeño en lo que tanto nos apaciona, seguro seremos unos grander profesionales en el rubro de la informática =D.

Por otro lado espero poder ayudar mucho en Gonzalo en está "Bitácora Informatica", pues me tiene muy emosionado la idea...bueno no tengo que dar las gracias por ser parte de esto =).

Saludos y espero estar pronto con agunos apuntes sobre Java.

Mordelon

Diseño de programas

2007-08-11T22:35:00.000-04:00

Bueno, esto es un tema que a veces puede parecer un poco "obvio", pero para alguien que esta empezando puede que no lo sea. Son cosas que uno se da cuenta al tiempo de estar programando directamente o cuando ya se empieza a tratar de resolver problemas de un nivel mas complejo(o cuando te lo enseñan).

El diseño de programas es una tarea bastante difícil y a veces un poco frustrante cuando se están realizando grandes proyectos, sistemas o solo un problema de alta complejidad. Cuando uno ya esta cómodo con algún lenguaje empieza a tratar de resolver problemas cada ves más grandes hasta que llega el punto donde este te supera y no sabes muy bien como “abordarlo” o desde donde partir. En este resumen voy a escribir en pocas palabras métodos que facilitan el proceso creativo del algoritmo, y por lo tanto, la llegada al resultado necesitado.

El diseño de programas consiste en dos fases principales: resolución del problema y una de trabajo en la computadora. Por ahora nos concentraremos solamente en la resolución del problema, luego se vera la fase de trabajo junto con el funcionamiento de compilación.

Resolución del problema

Análisis del problema

En esta parte se requiere información exacta y precisa sobre el problema a solucionar. Se debe examinar cuidadosamente el problema e ir identificando los tipos de información que el programa va a tener que manejar y procesar para después llegar al resultado requerido. En esta parte hay que ser muy cuidadoso y leer varias veces el texto o la información que nos están entregando y que se desea automatizar, ya que si no se tiene un perfecto conocimiento de esto se va a perder mucho tiempo en volver a leer y en rescribir código por no comprender lo que nos están pidiendo.

Diseño y verificación del algoritmo

La manera ideal para lograr crear un algoritmo consiste en tomar el problema inicial y dividirlo en varios “sub problemas” los cuales deben ir en orden de ejecución dentro del programa y resolver cada uno por su parte. Al realizar esto ahorras mucho tiempo gastado en pensar como resolver el problema directamente. Este método se conoce como “Divide y vencerás”. La idea es llegar a tener una gran lista de problemas más sencillos de resolver que están ligados unos a otros por variables que se pasan entre ellos. Para problemas más amplios se necesita hacer distintos niveles de refinamiento que van generando más sub problemas. Este proceso se llama “refinamiento paso a paso o sucesivos” (stepwise refinement).

“Muchos programadores principiantes no comprenden la necesidad de diseñar un algoritmo antes de escribir el programa y tratan de omitir este proceso solucionando el problema con la codificación del programa directamente pensando que así se ahorrará tiempo. Esto parece razonable, pero no es así: no se ahorra tiempo. La experiencia demuestra que el proceso completo de diseño de un programa con las dos fases enunciadas anteriormente simplifica la solución y reduce tiempo. Aunque en problemas sencillos es donde más fácil resulta la codificación directa del lenguaje, nuestra opinión es que se acostumbre desde el principio al diseño de algoritmos. Su codificación al lenguaje le resultará muy fácil con solo conocer las reglas especificas del camino.” Libro: “Problemas de la metodología de la programación”, Luis Joyanes.

Algoritmos

La idea principal de los algoritmos es dividir todo un problema en distintos pasos a seguir para llegar a la solución de este. Para que un algoritmo sea eficaz debe cumplirse que:

- Debe ser preciso

- Tener un orden

- Debe ser Definido, o sea que al resolverlo dos veces se debería llegar al mismo resultado.

- Debe tener un fin.

El algoritmo también consta de tres partes que son:

- Entrada

- Proceso

- Salida

Lo ideal es que el algoritmo sea lo más claro posible para que así sea fácil la traducción al lenguaje de programación que se compilara y luego ejecutara en la computadora.

Verificación de algoritmos

En esta etapa se debe verificar manualmente si el algoritmo realizado esta cumpliendo su función de llegar al resultado. Para esto se debe hacer la prueba utilizando la mayor cantidad de valores posibles. Esto se realiza siguiendo paso por paso el algoritmo y anotando en una hoja de papel todos los resultados.

Herramientas de programación

Hay distintas herramientas que se pueden utilizar en la creación de algoritmos, estas son:

- Diagramas de flujo.

- Pseudocódigo.

- Diagramas de Nassi-Shneiderman (N-S).

Nota: Clic para ver su definición según Wikipedia.

Los diagramas de flujo son una herramienta de programación que funciona de manera grafica mostrando los distintos pasos a seguir de un algoritmo, los cuales están representados por figuras.

Como alternativa del diagrama de flujo apareció el Pseudocódigo que funciona con palabras de idioma español o ingles que representan al algoritmo pero de una manera mas similar de cómo se vería mas trabajada o cercana al lenguaje de programación.

Los diagramas N-S son una mezcla de los diagramas de flujo (gráfico) y el Pseudocódigo (escrito).

En otro momento entraremos en detalle de cada una de estas herramientas, por ahora es solamente algo generalizado.

Diagrama de flujo, adrformacion.com

Todo lo escrito aquí fue un resumen generalizado la parte teórica del capitulo 1 del libro “Problemas de la metodología de la programación” de Luis Joyanes.

Espero que les haya sido de ayuda este pequeño texto y ojalá no tenga malos comentarios o cosas sin sentido, acepto solo agradecimientos, felicitaciones y criticas CONSTRUCTIVAS (no supe como remarcarlo más xD).

Empezamos.

2007-08-10T00:02:00.000-04:00

Bienvenidos!. Mi nombre es Gonzalo Pérez, estudiante de Ingeniería en computación e informática y antes de empezar les quiero contar un poco de mis inicios en esto.

Estoy en primer año de esta carrera que es la que yo he querido estudiar desde que era niño, por lo que siempre fue mi primera opción de estudios universitarios desde que tengo memoria. Yo me “inicie” en la informática al entrar en la educación media, buscando formas de aprender sobre programación o cualquier tema que tenga que ver con computación pero me costaba mucho trabajo encontrar un lugar en Internet donde ir poder aprendiendo sobre estos temas de manera gradual.

En primero medio me inicie en la programación estudiando Delphi. Tuve muchos problemas ya que mi método de aprendizaje funcionaba mediante prueba y error con códigos que encontraba en Internet, por lo que me costaba mucho avanzar parejo y decidí dejar este lenguaje un poco de lado y probar con otro (no me sentí cómodo con el). Luego me oriente en las páginas Web y encontré PHP, y desde ese momento que estoy aprendiendo a hacer paginas Web dinámicas en este lenguaje que también aprendí a prueba y error y hasta hace poco mi manera de escribir los códigos era “muy carretera” y poco eficiente (ahora esta en “carretera” a secas, jajajaja).

Este año entre a la universidad a estudiar Ingeniería en computación e informática, pase mi primer semestre y ahora estoy comenzando el segundo. Hoy se me ocurrió la idea de crear un Blog donde yo pueda ir volcando todo lo que vaya aprendiendo sobre informática.

Les aviso que yo no tengo grandes conocimientos de informática, esto lo hago para que los que no tienen o no encuentran lugares para aprender puedan ver mis apuntes tomados de la universidad o directamente de lo que aprendo aquí en mi escritorio, y recuerden que esto es una bitácora de lo que voy aprendiendo, no son manuales ni tutoriales de nada, ni tampoco me las doy de profesor.

Nota: si encuentran algún error de código, de información mal redactada o de conceptos erróneos por favor avísenme para hacer los cambios necesarios.

Bueno, espero comentarios constructivos para que todos aprendamos bien y no tengamos problemas, Saludos!!!.