Unidad VII Practicas

INSTITUTO TECNOLÓGICO DE CERRO AZUL
MATERIA: ALGORITMOS Y LENGUAJES DE PROGRAMACIÓN UNIDAD: VII
EQUIPO: “LOS K-LACOS” FECHA: MAYO DEL 2008.
NOMBRE DEL ALUMNO: _____________________________________________


1.- ¿Qué es un arreglo?


2.- ¿Qué diferencia existe entre un arreglo unidimensional y un arreglo bidimensional?


3.- ¿Qué sintaxis se utiliza para declarar un arreglo unidimensional en C++?


4.- ¿Qué tipos de operaciones se hacen con los arreglos?


5.- ¿Qué es un vector?


6.- Define el concepto de archivo.


7.- Define el concepto de registro.

Unidad VI Practicas

INSTITUTO TECNOLÓGICO DE CERRO AZUL
MATERIA: ALGORITMOS Y LENGUAJES DE PROGRAMACIÓN UNIDAD: VI
EQUIPO: “LOS K-LACOS” FECHA: MAYO DEL 2008.
NOMBRE DEL ALUMNO: _____________________________________________


1.- ¿Qué son las estructuras de repetición o bucles?


2.- Escribe para qué se utilizan cada una de las siguientes estructuras:
*Repetir mientras


*Repetir hasta


*Repetir desde


3.- ¿Cuál es la diferencia entre un contador y un acumulador?


4.- Menciona al menos 3 tipos de estructuras de repetición (sentencias) que conozcas para cualquier lenguaje de programación.


5.- Analiza el siguiente código que utiliza la sentencia for, después en la parte trasera de la hoja realiza un programa que genere la serie de .5 en .5 hasta 10.

#include
#include
main()
{
int n,r;
r=9;
clrscr();
gotoxy(30,5);printf("***SERIE DE 2 EN 2 HASTA 20 ***");
for(n=2;n<=20;n=n+2)
{
gotoxy(30,r);printf("%d",n);
r++;
}
getche();
return(0);
}

Unidad V Practicas

INSTITUTO TECNOLÓGICO DE CERRO AZUL
MATERIA: ALGORITMOS Y LENGUAJES DE PROGRAMACIÓN UNIDAD: V
EQUIPO: “LOS K-LACOS” FECHA: MAYO DEL 2008.
NOMBRE DEL ALUMNO: _____________________________________________


INSTRUCCIONES: DEFINE MEDIANTE PALABRAS PROPIAS LOS SIGUIENTES CONCEPTOS:
A) SELECTIVA SIMPLE.
B) SELECTIVA DOBLE.
C) SELECTIVA ANIDADA.
D) SELECTIVA MÚLTIPLE.

Unidad IV Practicas

INSTITUTO TECNOLÓGICO DE CERRO AZUL
MATERIA: ALGORITMOS Y LENGUAJES DE PROGRAMACIÓN UNIDAD: IV
EQUIPO: “LOS K-LACOS” .
NOMBRE DEL ALUMNO: _____________________________________________



1.-¿QUE ES UNA FUNCIÓN?


2.-¿DEFINE FUNCIÓN ESTÁNDAR?


3.- MENCIONA LOS EJEMPLOS DE ENTRADA Y SALIDA DE DATOS QUE CONOZCAS:


4.-¿QUÉ ENTIENDES POR PASE POR VALOR?


5.-¿QUÉ ENTIENDES POR PASE POR REFERENCIA?


6.-¿QUÉ ES UN PUNTERO?


7.-¿QUÉ ES PASO DE VARIABLE?

Unidad III Practicas

INSTITUTO TECNOLÓGICO DE CERRO AZUL
MATERIA: ALGORITMOS Y LENGUAJES DE PROGRAMACIÓN UNIDAD: III
TEST PRÁCTICO “CONOCIMIENTO DE PROGRAMACIÓN Y UN LENGUAJE ESTRUCTURADO”
EQUIPO: “LOS K-LACOS” FECHA: 29 DE ABRIL DE 2008.
NOMBRE DEL ALUMNO: _____________________________________________

1.-INSTRUCCIONES: RELACIONA CADA CONCEPTO CON SU INCISO CORRESPONDIENTE


A) PROGRAMA. ( ) Puede ser utilizado para controlar el comportamiento de una máquina, particularmente una computadora. Consiste en un conjunto de símbolos y reglas sintácticas y semánticas que definen su estructura y el significado de sus elementos y expresiones.

B) PROGRAMACIÓN. ( ) Instrucciones de computación estructuradas y ordenadas que al ejecutarse hacen que una computadora realice una función particular.


C) LENGUAJE DE
PROGRAMACIÓN. ( ) la implementación de un algoritmo en un determinado lenguaje de programación, conformando un programa.


2.- DEFINE LA ESTRUCTURA BÁSICA DE UN PROGRAMA.



3.- ESCRIBE DENTRO DEL PARÉNTESIS UNA “F” SI LA ORACIÓN ES FALSA O UNA “V” SI ES VERDADERA.

I.- ( ) Los datos de tipo void se utilizan en la definición de una función para indicar que la
función no devuelve un valor.


II.- ( ) Los datos tipo Char se utilizan cuando necesitamos un mayor numero de dígitos
decimales.

III.- ( ) El tipo de datos lógico Bool es el que te permite usar variables que disponen sólo
de dos posibles valores: cierto o falso.


IV.- ( ) Cuando se requiere manejar datos numéricos de tipo entero, es conveniente
declarar las variables como tipo Int.

V.- ( ) Los datos del tipo float nos permiten la manipulación de hasta 225 caracteres.


4.- EXPLICA CON PALABRAS PROPIAS LOS SIGUIENTES CONCEPTOS.

a) Identificador
b) Proposición de asignación.

5.- COMPLETA LAS SIGUIENTES ORACIONES.

I.- LOS SIMBOLOS ^ , * , / , - , + SON _________________________________


II.- LOS ______________ SON LAS PARTES DE UNA EXPRESIÓN QUE NOS
PERMITEN LA OBTENCIÓN DE UN VALOR.

III.- LAS__________________ NOS PERMITEN IDENTIFICAR CON MAYOR
FACILIDAD LA PRIORIDAD DE LAS OPERACIONES.

6.- EVALÚA LA EXPRESIÓN UTILIZANDO LA PRIORIDAD DE OPERADORES Y OBTÉN EL VALOR DE:

((9+2)*(18-4)+(15/3))2 / ((222/2)-(5*2)*(3+4))2 - ((9-4)+(7+5)-(2*2))2 =




7.- ANALIZA EL SIGUIENTE CÓDIGO, DESPUÉS EN LA PARTE TRASERA DE LA HOJA REALIZA UN PROGRAMA QUE AL INTRODUCIRLE 3 VALORES OBTENGA EL PROMEDIO DE ESTOS.


#include /*libreria que permite manejar datos de entrada y salida*/
#include /*libreria para declaración de variables*/
main() /*inicio del programa*/
{ /*llave de apertura*/
int a,b,c,suma; /*declaraci¢n de las variables necesarias*/
clrscr(); /*limpieza de la pantalla*/
gotoxy(25,5);printf("***PROGRAMA SUMA DE 3 NUMEROS ***"); /*titulo*/
gotoxy(30,20);printf("DIGITA EL PRIMER VALOR : ");scanf("%d",&a); /*1er valor*/
gotoxy(30,21);printf("DIGITA EL SEGUNDO VALOR: ");scanf("%d",&b); /*2do valor*/
gotoxy(30,22);printf("DIGITA EL TERCER VALOR : ");scanf("%d",&c); /*3er valor*/
suma=a+b+c; /*operación*/
gotoxy(30,28);printf("EL RESULTADO ES: %d",suma); /*arrojar resultado*/
getche(); /*Restablece las variables utilizadas*/
return(0); /*Termina la ejecución*/
} /*llave de cierre*/

Unidad II Practicas

INSTITUTO TECNOLOGICO DE CERRO AZUL
MATERIA: ALGORITMOS Y LENGUAJES DE PROGRAMACIÓN
-TEST – UNIDAD II – DESARROLLO DE LÓGICA ALGORÍTMICA- EQUIPO: “LOS K-LACOS”-
NOMBRE DEL ALUMNO:__________________________________________ NUMERO DE CONTROL_____________



1.- ¿CUÁLES SON LOS PASOS PARA LA RESOLUCIÓN DE PROBLEMAS POR COMPUTADORA?


2.- REALIZA UN DIAGRAMA MEDIANTE LA TÉCNICA TOP-DOWN



3.- DEFINE CON TUS PROPIAS PALABRAS LO QUE SON LOS LENGUAJES ALGORITMICOS Y MENCIONA SU CLASIFICACIÓN.



4.- ELABORA UN DIAGRAMA MEDIANTE LA TÉCNICA BOTTON-UP, ACERCA DE UNA GALAXIA.



5.- SE TIENE UN ALGORITMO QUE AL INTRODUCIR 5 VALORES DE CALIFICACIONES DE UN ALUMNO MUESTRE COMO RESULTADO SI EL PROMEDIO DE LAS CALIFICACIONES DEL ESTUDIANTE REBASA EL PUNTAJE NECESARIO PARA APROBAR EL SEMESTRE, CONCLUYENDO SI ESTA REPROBADO O APROBADO. REALIZA LA SEPARACIÓN POR MÓDULOS DEL PROBLEMA DADO.



6.-ELABORA EN LA PARTE TRASERA DE ESTA HOJA EL ALGORITMO EN LENGUEJE NATURAL, EL DIAGRAMA DE FLUJO, EL DIAGRAMA N-S Y EL PSEUDOCÓDIGO PARA RESOLVER EL PROBLEMA DE QUE: AL INTRODUCIR LA EDAD DE UN IDIVIDUO, EL PROGRAMA DETERMINE SI ES MAYOR O MENOR DE EDAD.

Mapas mentales

tema 5.4 videoconferencia

tema 5.4 videoconferencia

tema 5.3 videoconferencia

tema 5.3 videoconferencia

tema 5.2 videoconferencia

tema 5.2 videoconferencia

unidad V videoconferencia

tema 5.1 videoconferencia

tema 4.6 videoconferencia

tema 4.6 videoconferencia

tema 4.5 videoconferencia

tema 4.5 videoconferencia

tema 4.4 videoconferencia

tema 4.4 videoconferencia

tema 4.3 videoconferencia

Tema 4.3 equipo de videoconferencias

tema 4.2 videoconferencia

unidad IV videoconferencia

tema 4.1 de la cuarta unidad

unidad II videoconferencia

esta es la segunda unidad del equipo de videoconferencia (los emo)...

fotos de dinamicas

Tamara explicando las reglas de la dinamica la cual consistia en que de cada equipo pasaba equipo un integrante a reventar un globo con un dardo y dentro de este venia una pregunta y el equipo que la contestara primero ganaba la cantidad de puntos acordada.

unidad VII

UNIDAD VII. ARREGLOS


7.1 ARREGLO UNIDIMENSIONALES
Un arreglo unidimensional es un tipo de datos estructurado que está formado de una colección finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar listas de elementos iguales.
El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o posteriores, esto mediante el uso de un índice para cada elemento del arreglo que nos da su posición relativa.
Para implementar arreglos unidimensionales se debe reservar espacio en memoria, y se debe proporcionar la dirección base del arreglo, la cota superior y la inferior.
REPRESENTACION EN MEMORIA
Los arreglos se representan en memoria de la forma siguiente:
x : array[1..5] of integer
Para establecer el rango del arreglo (número total de elementos) que componen el arreglo se utiliza la siguiente formula:
RANGO = Ls - (Li+1)
donde:
ls = Límite superior del arreglo
li = Límite inferior del arreglo
Para calcular la dirección de memoria de un elemento dentro de un arreglo se usa la siguiente formula:
A[i] = base(A) + [(i-li) * w]
donde :
A = Identificador único del arreglo
i = Indice del elemento
li = Límite inferior
w = Número de bytes tipo componente


Si el arreglo en el cual estamos trabajando tiene un índice numerativo utilizaremos las siguientes fórmulas:
RANGO = ord (ls) - (ord (li)+1)
A[i] = base (A) + [ord (i) - ord (li) * w]

7.1.1 CONCEPTOS BÁSICOS

Un arreglo unidimensional tiene una sola dimensión. En C#, la dimensión se maneja por medio de un par de corchetes.
A los arreglos de una dimensión también se les llama listas.



7.1.2 OPERACIONES ,APLICACIONES
OPERACIONES
Para manejar un arreglo, las operaciones a efectuarse son:
Declaración del arreglo,
Creación del arreglo,
Inicialización de de los elementos del arreglo, y
Acceso a los elementos del arreglo.
A continuación describiremos cada una de estas operaciones, en C#.
Declaración.
La declaración de un arreglo unidimensional consiste en establecer las características del arreglo y sus elementos, por medio de la siguiente sintaxis:
[ ] <> ;
Donde:
Tipo. indica el tipo correspondiente a los elementos del arreglo ,
Identificador. es el nombre del arreglo, y
el par de corchetes, [ ], representa la dimensión del arreglo y encierra un número entero que corresponde al número de elementos del arreglo.
Ejemplos:
int [ ] a ;
float [ ] distancia ;
Artículo [ ] art = new Artículo[ 3];
Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que, durante dicha operación, no se reserva espacio en la memoria.
Creación.
La creación de un arreglo unidimensional consiste en reservar espacio de memoria para todos sus elementos, utilizando la siguiente sintaxis:
<> = new [ tamaño ] ;
Donde:
New. es el operador para gestionar espacio de memoria, en tiempo de ejecución,
Tamaño. es un número entero que representa el número de elementos del arreglo.

Ejemplos:
a = new int [10] ; // Se crea el arreglo a , con 10 elementos de tipo entero.
distancia = new float[ 5] ; // Se crea el arreglo distancia , con 5 elementos de punto flotante y precisión sencilla .Artículo [] art = new Artículo[3];
Artículo [ ] art = new Artículo[ 3]; // Se crean 3 referencias a objetos de la clase Artículo
art[0]= new Artículo(); // Se crea el primer objeto del arreglo art
art[1]= new Artículo(); // Se crea el segundo objeto del arreglo art
art[2]= new Artículo(); // Se crea el tercer objeto del arreglo art

Las dos primeras operaciones de declaración y creación anteriores se pueden agrupar en una sola instrucción, como se muestra enseguida:
int [ ] a = new int [10] ;
float [ ] distancia = new float[5] ;

Inicialización.
Un arreglo es un objeto que,cuando es creado por el compilador, se le asignan automáticamente valores iniciales predeterminados a cada uno de sus elementos, de acuerdo a los siguientes criterios:
Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.
Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.
Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.
Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible agrupar las operaciones de declaración, creación e inicialización en una sola instrucción, por ejemplo:
int [ ] a = { 1, 0,4,-6, 2,9, 23,455, 90,35 };
float [ ] distancia = { 2.50F, 286.45F, 46.75F, 30.62F, 93.00F };
string [ ] pato = { "Hugo", "Paco", "Luís" };

Acceso.
Se puede acceder a los valores de los elementos de un arreglo a través del nombre del arreglo y un subíndice. El subíndice debe escribirse entre corchetes y representa la posición del elemento en el arreglo. Así, podemos referirnos a un elemento del arreglo escribiendo el nombre del arreglo y el subíndice del elemento entre corchetes. Los valores de los subíndices empiezan en cero para el primer elemento, hasta el tamaño del arreglo menos uno.
Ejemplo:
float [ ] distancia = new float[5] ; // Crea el arreglo distancia con 5 elementos. float x = 25F, y = 10F ; // Crea dos variables de punto flotante y precisión sencilla. distancia[0] = x + y ; // El valor asignado al primer elemento es 35. distancia[1] = ++distancia[0] ; // Asigna 36 al segundo elemento. distancia[2] = distancia[1] - distancia[0] + 4 ; // Asigna 5 al tercer elemento. distancia[3] = distancia[2]-- ; // Asigna 5 al cuarto elemento
// y disminuye en 1 el valor del tercero.
distancia[4] = distancia[3] * distancia[2] ; // Asigna 20 al quinto elemento. y = distancia[4] ; // Asigna a y el valor almacenado en el quinto elemento.

APLICACIONEAS
Listas.
Resolvamos el problema de manejar dos listas: una con los nombres de un grupo de alumnos y otra con una calificación para cada uno de los alumnos. Primero se deberán leer los nombres de los alumnos y la calificación que corresponde a cada uno de ellos y después habrá que desplegar dos columnas: una con los nombres de los alumnos y la otra con sus respectivas calificaciones.


La lectura debe lucir de manera similar a la siguiente:
Número de alumnos: 30
Nombre [0] : Calificación[0] :
Nombre [1] : Calificación[1] :
Nombre [2] : Calificación[2] :
......
Nombre [29] : Calificación[29] :
El despliegue en el monitor luciría así:
No.
Nombre
Calif.
1
Hugo
100
2
Paco
90
3
Luís
95
...

...
30
Donald
70
El siguiente código corresponde a un programa que resuelve el problema.
// Lista.cs : Lee una lista de nombres y calificaciones correspondientes a un grupo de
// alumnos de una materia.
using System;using C = System.Console;
public class Lista{
public static void Main()
{
int nAlumnos;
C.Write("Número de alumnos: ");
nAlumnos = Convert.ToInt32(C.ReadLine());
string [ ] alumnos = new string[nAlumnos]; //Crea el arreglo de
//alumnos.
int [ ] calif = new int [nAlumnos]; // Crea el arreglo de calificaciones.
// Lee los elementos de los dos arreglos.
for(int i = 0; i < nAlumnos ; i++){
C.Write("Nombre del alumno [" + i + "] : ");alumnos[i] = C.ReadLine( );
C.Write("Calificación [" + i + "] : ");calif[i] = Convert.ToInt32(C.ReadLine( ));
}
// Despliega los valores de los dos arreglos.
C.WriteLine("No. Nombre Calif.");
for(int i = 0 ; i < nAlumnos ; i++){
C.Write(" " + (i+1) + ".- " + alumnos[ i] );C.WriteLine(" " + calif[i] );
}
}
}

Vectores.
Otra de las aplicaciones de los arreglos es el manejo de vectores. En Física, los vectores sirven para representar velocidades, aceleraciones, etc.
Podemos representar a un vector como un segmento de recta dirigida que tiene magnitud, orientación y sentido.
En un espacio tridimensional, un vector puede expresarse por medio de tres componentes sobre los ejes cartesianos. Cada componente puede, a su vez, expresarse en función de los vectores unitarios i, j, k ,que se ubican en los ejes x, y, z, respectivamente.
Por ejemplo , un vector v1 puede representarse en función de sus componentes como:
v1 = 20i + 15j + 35k
Si tenemos otro vector,
v2 = -5i + 40j + 25k

La suma de los dos vectores sería:
s = v1+v2 = (20-5)i +(15+40)j+(35+25)k
s = 15i + 55j + 60k
Un segmento del programa para este ejemplo sería:
double v1[ ] = new double[3];double v2[ ] = new double[3];double s[ ] = new double[3];
v1[0] = 20;v1[1] = 15;v1[2] = 35;
v2[0] = -5;v2[1] = 40;v2[2] = 25;
for(int i=0; i < 3 ; i++){
s[ i ] = v1[ i ] + v2[ i ] ;
}
7.2 ARREGLO BIDIMENSIONALES

Este tipo de arreglos al igual que los anteriores es un tipo de dato estructurado, finito ordenado y homogéneo. El acceso a ellos también es en forma directa por medio de un par de índices.
Los arreglos bidimensionales se usan para representar datos que pueden verse como una tabla con filas y columnas. La primera dimensión del arreglo representa las columnas, cada elemento contiene un valor y cada dimensión representa una relación
La representación en memoria se realiza de dos formas : almacenamiento por columnas o por renglones.
Para determinar el número total de elementos en un arreglo bidimensional usaremos las siguientes fórmulas:
RANGO DE RENGLONES (R1) = Ls1 - (Li1+1)
RANGO DE COLUMNAS (R2) = Ls2 - (Li2+1)
No. TOTAL DE COMPONENTES = R1 * R2
REPRESENTACION EN MEMORIA POR COLUMNAS
x : array [1..5,1..7] of integer
Para calcular la dirección de memoria de un elemento se usan la siguiente formula:
A[i,j] = base (A) + [((j - li2) R1 + (i + li1))*w]
REPRESENTACION EN MEMORIA POR RENGLONES
x : array [1..5,1..7] of integer
Para calcular la dirección de memoria de un elemento se usan la siguiente formula:
A[i,j] = base (A) + [((i - li1) R2 + (j + li2))*w]
donde:
i = Indice del renglón a calcular
j = Indice de la columna a calcular
li1 = Límite inferior de renglones
li2 = Límite inferior de columnas
w = Número de bytes tipo componente



7.3 CONCEPTOS BÁSICOS

Un arreglo bidimensional tiene dos dimensiones y es un caso particular de los arreglos multidimensionales. En C#, las dimensiones se manejan por medio de un par de corchetes, dentro de los que se escriben, separados por comas, los valores de las dos dimensiones.



7.4 OPERACIONES

Para manejar un arreglo, las operaciones a efectuarse son:

Declaración del arreglo,
Creación del arreglo,
Inicialización de de los elementos del arreglo, y
Acceso a los elementos del arreglo.

A continuación describiremos cada una de estas operaciones, en C#.

Declaración.
La declaración de un arreglo consiste en establecer las características del arreglo y sus elementos, por medio de la siguiente sintaxis:
[ , ] <> ;
Donde:
tipo indica el tipo correspondiente a los elementos del arreglo ,
identificador es el nombre del arreglo, y
el par de corchetes y la coma, [ , ], representan las dimensiones del arreglo y encierra dos números enteros, cuyo producto corresponde al número de elementos del arreglo.
Ejemplos:
double [ , ] matriz ;
int [ , ] ubicación ;
Rama [ , ] árbol; // Rama es una clase.
Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que, durante dicha operación, no se reserva espacio en la memoria.

Creación.
La creación de un arreglo bidimensional consiste en reservar espacio en la memoria para todos sus elementos, utilizando la siguiente sintaxis:
<> = new [ dim1, dim2 ] ;
Donde:
new es el operador para gestionar espacio de memoria, en tiempo de ejecución,
dim1 y dim2 son valores enteros que representan las dimensioes del arreglo.
El tamaño del arreglo es el resultado de multiplicar los valores de las dimensiones y representa el número de elementos del arreglo.
Ejemplos:
matriz = new double [2, 3] ; // Se crea el arreglo matriz, con 6 elementos de tipo
//punto flotante y precición doble .
ubicación = new int[ 4,2] ; // Se crea el arreglo ubicación, con 8 elementos de
//tipo entero de 32 bits .
árbol = new Rama[5,2] ; // Se crea el arreglo arbol, con 10 objetos
//de la clase Rama.
Las operaciones de declaración y creación anteriores se pueden agrupar en una sola instrucción, como se muestra enseguida:
double [ , ] matriz = new double [2,3] ;
int [ , ] ubicación = new int[4, 2] ;
Rama [ , ] alumno = new Rama[5,2] ;


Inicialización.
Un arreglo es un objeto que,cuando es creado por el compilador, se le asignan automáticamente valores iniciales predeterminados a cada uno de sus elementos, de acuerdo a los siguientes criterios:
Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.
Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.
Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.
Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible agrupar las operaciones de declaración, creación e inicialización en una sola instrucción, por ejemplo:

double [ , ] matriz = { {1.5, 0, 4, -6.5, 2 } , {2.3, 9, 3.5, 4.8, 6.2} };
int [ , ] ubicación = { {2, 4} , {6, 8} , {9, 10}, {5 , 1}};
string [ , ] funcionario = { {"Hugo", "jefe"} ,
{ "Paco", "operador "},
{ "Luís","ayudante"} };

Acceso.
Se puede acceder a los valores de los elementos de un arreglo bidimensional a través del nombre del arreglo y dos subíndices. Los subíndices deben escribirse entre corchetes y representa la posición del elemento en el arreglo. Así, podemos referirnos a un elemento del arreglo escribiendo el nombre del arreglo y los subíndices del elemento entre corchetes. Los valores de los subíndices empiezan en cero para el primer elemento, hasta el tamaño del arreglo menos uno.
Ejemplo:
int [ , ] posición = new int[5, 10] ; // Crea el arreglo posición , con 50 elementos de tipo entero.
int x;posición[ 3, 5] = 3 ;
x = posición[ 3, 5] ;



7.5 APLICACIONES


Matrices.
Una matriz es un arreglo rectangular de dos dimensiones, donde el acomodo de los elementos está dispuesto en renglones y columnas.
Ejemplo 1:
Se debe controlar la ubicación de los asistentes a una sala de conferencias por medio de un gafete que tiene escrito el nombre del asistente, la fila y la columna donde se ubica su asiento.
El siguiente segmento de código muestra la solución con arreglos bidimensionales.
string [ , ] asistente = new string[10,12] ;
// Inicializa los valores de los nombres con cadenas vacías.
for(int i=0 ; i < 10 ; i++ ) // Controla la fila.
for(int j=0 ; j < 12 ; j++ ) // Controla la columna.
asistente[ i , j ] = " " ;
// Captura los nombres de todos los asistentes y les asigna sus asientos,
// en el orden en que van llegando.
for(int i=0 ; i < 10 ; i++ ) // Controla la fila.
for(int j=0 ; j < 12 ; j++ ) // Controla la columna.
asistente[ i , j ] = System.Console.ReadLine( );
// Despliega los nombres de todos los asistentes.
for(int i=0 ; i < 10 ; i++ ) // Controla la fila.
for(int j=0 ; j < 12 ; j++ ) // Controla la columna.
System.Console.WriteLine( asistente[ i , j ] );


Ejemplo 2 :
Dadas la matriz A :
10
8
29
15
62
43
16
13
21
78
57
25
30
44
17
y la matriz B :
20
66
31
42
50
92
85
74
69
45
35
61
15
54
12
Elaborar un programa en C# para obtener la suma de ambas matrices:
S = A + B

// SumMatrices.cs : Suma dos matrices de 3 renglones y 5 columnas.

using System;
class Matriz{ public static void Main( ) { double [ , ] A = new double [3,5] ; double [ , ] B = new double [3, 5] ; double [ , ] S = new double [3, 5] ; int i, j ; // Lectura de valores para los elementos de A. for( i = 0 ; i < 3 ; i++ ) for( j = 0 ; j < 5 ; j++) A[ i , j ] = Convert.ToDouble(Console.ReadLine( ));
// Lectura de valores para los elementos de B. for( i = 0 ; i < 3 ; i++ ) for( j = 0 ; j < 5 ; j++) B[ i , j ] = Convert.ToDouble(Console.ReadLine( )) ;

// Suma y despliegue de la matriz resultado. for( i = 0 ; i < 3 ; i++ ) { for( j = 0 ; j < 5 ; j++) { S[ i , j ] = A[ i , j ] + B[ i , j ] ; Console.Write(" " + S[ i , j ] ) ; } Console.WriteLine( ) ; } }
}


7.6 REGISTROS


Los registros del procesador se emplean para controlar instrucciones en ejecución, manejar direccionamiento de memoria y proporcionar capacidad aritmética. Los registros son espacios físicos dentro del microprocesador con capacidad de 4 bits hasta 64 bits dependiendo del microprocesador que se emplee. Los registros son direccionables por medio de una viñeta, que es una dirección de memoria. Los bits, por conveniencia, se numeran de derecha a izquierda (15,14,13…. 3,2,1,0), los registros están divididos en seis grupos los cuales tienen un fin especifico. Los registros se dividen en:

Registros de segmento
Registros de apuntadores de instrucciones
Registros apuntadores
Registros de propósitos generales
Registro índice
Registro de bandera.

REGISTROS DE SEGMENTO.
Un registro de segmento se utiliza para alinear en un limite de párrafo o dicho de otra forma codifica la dirección de inicio de cada segmento y su dirección en un registro de segmento supone cuatro bits 0 a su derecha. Un registro de segmento tiene 16 bits de longitud y facilita un área de memoria para direccionamientos conocidos como el segmento actual. Los registros de segmento son:

Registro CS
Registro DS
Registro SS
Registro ES
Registro FS y GS

Registro CS.
El DOS almacena la dirección inicial del segmento de código de un programa en el registro CS. Esta dirección de segmento, mas un valor de desplazamiento en el registro de apuntado de instrucción (IP), indica la dirección de una instrucción que es buscada para sí ejecución. Para propósito de programación normal, no e necesita referenciar el registro CS.

Registro DS.

La dirección inicial de un segmento de datos de programa es almacenada en el registro DS. En términos sencillos, esta dirección, mas un valor de desplazamiento en una instrucción, genera una referencia a la localidad de un bytes especifico en el segmento de datos.

Registro SS.
El registro SS permite la colocación en memoria de una pila, para almacenamiento temporal de direcciones y datos. El DOS almacena la dirección de inicio del segmento de pila de un programa en el registro SS. Esta dirección de segmento, más un valor de desplazamiento en el registro del apuntador de la pila (SP), indica la palabra actual en la pila que está siendo direccionada. Para propósitos de programación normal, no se necesita referenciar el registro SS.

Registro ES
Algunas operaciones con cadenas de caracteres (datos de caracteres) utilizan el registro esta de segmento para manejar el direccionamiento de memoria. En este contexto, el registro ES esta asociado con el registro DI (índice). Un programa que requiere el uso del registro ES puede inicializarlo con una dirección apropiada.
Registros FS y GS.
Son registros extra de segmento en los procesadores 80386y posteriores a estos procesadores.

REGISTRO APUNTADOR DE INSTRUCCIONES (IP)
El registro apuntador de instrucciones (IP) de 16 bits contiene el desplazamiento de dirección de la siguiente instrucción que se ejecuta. El registro IP esta asociado con el registro CS en el sentido de que el IP indica la instrucción actual dentro del segmento de código que se esta ejecutando actualmente.En el ejemplo siguiente, el registro CS contiene 25A4[0]H y el IP contiene 412H. Para encontrar la siguiente instrucción que será ejecutada el procesados combina las direcciones en el CS y el IP así:Segmento de dirección en el registro CS: 25A40H Desplazamiento de dirección en el registro IP: + 412HDirección de la siguiente instrucción: 25E52H

REGISTROS APUNTADORES.

Los registros apuntadores están asociados con el registro SS y permiten al procesador accesar datos en el segmento de pila los registros apuntadores son dos:
El registro SP
El registro BP

Registro SP.
El apuntador de pila IP de 16 bits esta asociado con el registro SS y proporciona un valor de desplazamiento que se refiere a la palabra actual que esta siendo procesada en la pila.El ejemplo siguiente el registro SS contiene la dirección de segmento 27B3[0]H y el SP el desplazamiento 312H Para encontrar la palabra actual que esta siendo procesada en la pila el microprocesador combina las direcciones en el SS y el PP:Dirección de segmento en el registro SS: 27B30HDesplazamiento en el registro SP: + 312HDirección en la Pila: 27E42H
27B3[0]H 312HDirección del segmento SS Desplazamiento del SP

Registro BP.

El registro BP de 16 bits facilita la referencia de parámetros, los cuales son datos y direcciones transmitidos vía lapida.

REGISTROS DE PROPÓSITOS GENERALES.
Los registros de propósitos generales AX, BX, CX y DX son los caballos de batalla o las herramientas del sistema. Son los únicos en el sentido de que se puede direccionarlos como una palabra o como una parte de un byte. El ultimo byte de la izquierda es la parte "alta", y el ultimo byte de la derecha es la parte "baja" por ejemplo, el registro CX consta de una parte CH (alta) y una parte CL (baja), y usted puede referirse a cualquier parte por si nombre. Ñas instrucciones siguientes mueven ceros a los registros CX, CH y CL respectivamente.
Mov CX, 00Mov CH, 00Mov CL, 00
Los procesadores 80386 y posteriores permiten el uso de todos registros de propósito general, mas versiones de 32 bits; EAX, EBX y EDCX.

Registros AX.
El registro AX, el acumulador principal, es utilizado para operaciones que implican entrada/salida y la mayor parte de la aritmética. Por ejemplo, las instrucciones para multiplicar, dividir y traducir suponen el uso del AX. También, algunas operaciones generan código más eficientes si se refiere al AX en lugar de los otros registros.

Registro BX.
El BX es conocido como el registro base ya que es el único registro de propósitos generales que pueden ser unos índices para direccionamiento indexado. También es común emplear al BX para cálculos.

Registro CX.
El CX es conocido como el registro contador. Puede contener un valor para controlar el número de veces que un ciclo se repite o un valor para corrimiento de bits, hacia la derecha o hacia la izquierda. El CX también es usado para muchos cálculos.

Registro DX.
El DX es conocido como el registro de datos. Algunas operaciones de entrada/salida requieren su uso, y las operaciones de multiplicación y división con cifras grandes suponen al DX y al AX trabajando juntos. Puede usar los registros de propósitos para suma y resta de cifras de 8, 16, 32 bits.

REGISTRO ÍNDICE.
Los registros SI y DI están disponibles para direccionamientos indexados y para sumas y restas. Que son la operaciones de punta.

Registro SI
El registro índice de 16 bits es requerido por algunas operaciones con cadenas (de caracteres). En este contexto, el SI está asociado con el registro DS. Los procesadores 80386 y posteriores permiten el uso de un registro ampliado a 32 bits, el ESI.

Registro DI.
El registro índice destino también es requerido por algunas operaciones con cadenas de caracteres. En este contexto, el Di está asociado con el registro ES. Los procesadores 80386 y posteriores permiten el uso de un registro ampliado a 32 bits, el EDI.

REGISTRO DE BANDERA.
Los registros de banderas sirven parar indicar el estado actual de la maquina y el resultado del procesamiento, Cuando algunas instrucciones piden comparaciones o cálculos aritméticos cambian el estado de las banderas.Las banderas están en el registro de banderas en las siguientes posiciones:bits 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1

Bandera

Las banderas mas comunes son las siguientes:
OF (Over flow flag, desbordamiento).
Indica el desbordamiento de un bit de orden alto (mas a la izquierda) después de una operación aritmética.
DF (Direction flag, Direccion).
Designa la dirección hacia la izquierda o hacia la derecha para mover o comparar cadenas de caracteres.
IF (Interruption flag, Interrupcion).
Indica que una interrupción externa, como la entrada desde el teclado sea procesada o ignorada.
TF (Trap flag, Trampa).
Examina el efecto de una instrucción sobre los registros y la memoria. Los programas depuradores como DEBUG, activan esta bandera de manera que pueda avanzar en la ejecución de una sola interrupción a un tiempo.
SF (Sign flag, Signo).
Contiene el signo resultante de una operación aritmética (0=positivo y 1= negativo).ZF (Zero flag, Zero).
Indica el resultado de una operación aritmética o de comparación (0= resultado diferente de cero y 1=resultado igual a cero).
AF (Auxiliary carry flag, Acarreo auxiliar).
Contiene un acarreo externo del bit 3 en un dato de 8 bits, para aritmética especializada
PF (Parity flag, Paridad).
Indica paridad par o impar de una operación en datos de ocho bits de bajo orden (mas a la derecha).
CF (Carry flag, Acarreo).
Contiene el acarreo de orden mas alto (mas a la izquierda) después de una operación aritmética; también lleva el contenido del ultimo bit en una operación de corrimiento o rotación.


7.7 ARCHIVOS

Un archivo informático es un conjunto de información que se almacena en algún medio de escritura que permita ser leído o accedido por una computadora. Un archivo es identificado por un nombre y la descripción de la carpeta o directorio que lo contiene. Los archivos informáticos se llaman así porque son los equivalentes digitales de los archivos en tarjetas, papel o microfichas del entorno de oficina tradicional. Los archivos informáticos facilitan una manera de organizar los recursos usados para almacenar permanentemente información dentro de un computador.


CONTENIDO DE LOS ARCHIVOS

En lo que concierne al sistema operativo, un archivo es, en la mayoría de los casos, simplemente un flujo unidimensional de bytes (números enteros en el intervalo de 0 a 255), que es tratado por el sistema operativo como una única unidad lógica. Un archivo de datos informático normalmente tiene un tamaño, que generalmente se expresa en bytes; en todos los sistemas operativos modernos, el tamaño puede ser cualquier número entero no negativo de bytes hasta un máximo dependiente del sistema. Depende del software que se ejecuta en la computadora el interpretar esta simplísima estructura básica como por ejemplo un programa, un texto o una imagen, basándose en su nombre y contenido. Los tipos especiales de archivos, como los nodos de dispositivo que representan simbólicamente partes del hardware, no consisten en un flujo de bytes y no tienen tamaño de archivo.
La información de un archivo informático normalmente consiste de paquetes más pequeños de información (a menudo llamados registros o líneas) que son individualmente diferentes pero que comparten algún rasgo en común. Por ejemplo, un archivo de nóminas puede contener información sobre todos los empleados de una empresa y los detalles de su nómina; cada registro del archivo de nóminas se refiere únicamente a un empleado, y todos los registros tienen la característica común de estar relacionados con las nóminas-esto es muy similar a colocar toda la información sobre nóminas en un archivador concreto en una oficina que no tenga ninguna computadora. Un archivo de texto puede contener líneas de texto, correspondientes a líneas impresas en una hoja de papel.
La manera en que se agrupa la información en un archivo depende completamente de la persona que diseñe el archivo. Esto ha conducido a una plétora de estructuras de archivo más o menos estandarizadas para todos los propósitos imaginables, desde los más simples a los más complejos. La mayoría de los archivos informáticos son usados por programas de computadora. Estos programas crean, modifican y borran archivos para su propio uso bajo demanda. Los programadores que crean los programas deciden qué archivos necesitan, cómo se van a usar, y (a menudo) sus nombres.
En algunos casos, los programas de computadora manipulan los archivos que se hacen visibles al usuario de la computadora. Por ejemplo, en un programa de procesamiento de texto, el usuario manipula archivos-documento a los que él mismo da nombre. El contenido del archivo-documento está organizado de una manera que el programa de procesamiento de texto entiende, pero el usuario elige el nombre y la ubicación del archivo, y proporciona la información (como palabras y texto) que se almacenará en el archivo.
Muchas aplicaciones empaquetan todos sus archivos de datos en un único archivo, usando marcadores internos para discernir los diferentes tipo de información que contienen. Los archivos de datos usados por juegos como Doom y Quake son ejemplos de esto.
Los archivos de una computadora se pueden crear, mover, modificar, aumentar, reducir y borrar. En la mayoría de los casos, los programas de computadora que se ejecutan en la computadora se encargan de estas operaciones, pero el usuario de una computadora también puede manipular los archivos si es necesario. Por ejemplo, los archivos de Microsoft Office Word son normalmente creados y modificados por el programa Microsoft Word en respuesta a las órdenes del usuario, pero el usuario también puede mover, renombrar o borrar estos archivos directamente usando un programa gestor de archivos como Windows Explorer (en computadoras con sistema operativo Windows).


IDENTIFICACIÓN Y ORGANIZACIÓN DE ARCHIVOS

Los archivos y carpetas se organizan jerárquicamente. En los sistemas informáticos modernos, los archivos siempre tienen nombres. Los archivos se ubican en directorios. El nombre de un archivo debe ser único en ese directorio. En otras palabras, no puede haber dos archivos con el mismo nombre en el mismo directorio.
El nombre de un archivo y la ruta al directorio del archivo lo identifica de manera unívoca entre todos los demás archivos del sistema informático -no puede haber dos archivos con el mismo nombre y ruta-. El aspecto del nombre depende del tipo de sistema informático que se use. Las primeras computadoras sólo permitían unas pocas letras o dígitos en el nombre de un archivo, pero las computadoras modernas permiten nombres largos que contengan casi cualquier combinación de letras unicode y dígitos unicode, haciendo más fácil entender el propósito de un archivo de un vistazo. Algunos sistemas informáticos permiten nombres de archivo que contengan espacios; otros no. La distinción entre mayúsculas y minúsculas en los nombres de archivo está determinada por el sistemas de archivos. Los sistemas de archivos Unix distinguen normalmente entre mayúsculas y minúsculas, y permiten a las aplicaciones a nivel de usuario crear archivos cuyos nombres difieran solamente en si los caracteres están en mayúsculas o minúsculas. Microsoft Windows reconoce varios sistemas de archivos, cada uno con diferentes políticas en cuanto a la distinción entre mayúsculas y minúsculas. El popular antiguo sistema de archivos FAT puede tener varios archivos cuyos nombres difieran únicamente en las mayúsculas y minúsculas si el usuario utiliza un editor de discos para editar los nombres de archivo en las entradas de directorio. Las aplicaciones de usuario, sin embargo, normalmente no permitirán al usuario crear varios archivos con el mismo nombre pero con diferentes letras en mayúsculas y minúsculas.
La mayoría de las computadoras organizan los archivos en jerarquías llamadas carpetas, directorios o catálogos. (El concepto es el mismo independientemente de la terminología usada.) Cada carpeta puede contener un número arbitrario de archivos, y también puede contener otras carpetas. Las otras carpetas pueden contener todavía más archivos y carpetas, y así sucesivamente, construyéndose un estructura en árbol en la que una «carpeta raíz» (el nombre varía de una computadora a otra) puede contener cualquier número de niveles de otras carpetas y archivos. A las carpetas se les puede dar nombre exactamente igual que a los archivos (excepto para la carpeta raíz, que a menudo no tiene nombre). El uso de carpetas hace más fácil organizar los archivos de una manera lógica.
Cuando una computadora permite el uso de carpetas, cada archivo y carpeta no sólo tiene un nombre propio, sino también una ruta, que identifica la carpeta o carpetas en las que reside un archivo o carpeta. En la ruta, se emplea algún tipo de carácter especial -como una barra- para separar los nombres de los archivos y carpetas. Por ejemplo, en la ilustración mostrada en este artículo, la ruta /Payroll/Salaries/Managers identifica unívocamente un archivo llamado Managers que está en una carpeta llamada Salaries que a su vez está contenida en una carpeta llamada Payroll. En este ejemplo, los nombres de las carpetas y archivos están separados por barras; la superior o carpeta raíz no tiene nombre, y por ello la ruta comienza con una barra (si la carpeta raíz tuviera nombre, precedería a esta primera barra).
Muchos (pero no todos) sistemas informáticos usan extensiones en los nombres de archivo para ayudar a identificar qué contienen. En computadoras Windows, las extensiones consisten en un punto al final del nombre del archivo, seguido de unas pocas letras para identificar el tipo de archivo. Una extensión .txt identifica un archivo de texto; la extensión .doc identifica cualquier tipo de documento o documentación, comúnmente en el formato de archivo de Microsoft Office Word; etc. Incluso cuando se utilizan extensiones en un sistema informático, el grado con el que un sistema informático los reconoce y trata puede variar; en algunos sistemas son obligatorios, mientras que en otros sistemas se ignoran completamente si están presentes.

PROTECCIÓN DE ARCHIVOS

Muchos sistemas informáticos modernos proporcionan métodos para proteger los archivos frente a daños accidentales o intencionados. Las computadoras que permiten varios usuarios implementan permisos sobre archivos para controlar quién puede o no modificar, borrar o crear archivos y carpetas. A un usuario dado se le puede conceder solamente permiso para modificar un archivo o carpeta, pero no para borrarlo; o a un usuario se le puede conceder permiso para crear archivos o carpetas, pero no para borrarlos. Los permisos también se pueden usar para permitir que solamente ciertos usuarios vean el contenido de un archivo o carpeta. Los permisos protegen de la manipulación no autorizada o destrucción de la información de los archivos, y mantienen la información privada confidencial impidiendo que los usuarios no autorizados vean ciertos archivos.
Otro mecanismo de protección implementado en muchas computadoras es una marca de sólo lectura. Cuando esta marca está activada en un archivo (lo que puede ser realizado por un programa de computadora o por un usuario humano), el archivo puede ser examinado, pero no puede ser modificado. Esta marca es útil para información crítica que no debe ser modificada o borrada, como archivos especiales que son usados solamente por partes internas del sistema informático. Algunos sistemas incluyen también una marca oculta para hacer que ciertos archivos sean invisibles; esta marca la usa el sistema informático para ocultar archivos de sistema esenciales que los usuarios nunca deben modificar.

PROTECCIÓN LEGAL DE DATOS DE ARCHIVOS

La protección de datos personales y velar por la privacidad de la información es un tema de suma importancia a nivel de empresas y de países. El mal uso de información personal puede constituir un delito.
Algunos países han creado organismos que se encargan del tema y de legislar respecto del acceso, uso y confidencialidad de los datos.

ALMACENAMIENTO DE ARCHIVOS

En términos físicos, la mayoría de los archivos informáticos se almacenan en discos duros -discos magnéticos que giran dentro de una computadora que pueden registrar información indefinidamente-. Los discos duros permiten acceso casi instantáneo a los archivos informáticos.
En computadoras muy grandes, algunos archivos informáticos pueden almacenarse en cinta magnética. Los archivos también se pueden almacenar en otros medios en algunos casos, como discos compactos grabables, unidades Zip, memorias transportables USB, etc.

RESPALDO DE ARCHIVOS

Cuando los archivos informáticos contienen información que es extremadamente importante, se usa un proceso de respaldo (back-up) para protegerse contra desastres que podrían destruir los archivos. Hacer copias de respaldo de archivos significa simplemente hacer copias de los archivos en una ubicación separada de modo que se puedan restaurar si le pasara algo a la computadora, o si fueran borrados accidentalmente.
Hay muchas maneras de hacer copias de respaldo de archivos. La mayoría de los sistemas informáticos proporcionan utilidades para ayudar en el proceso de respaldo, que puede llegar a consumir mucho tiempo si hay muchos archivos a salvaguardar. Copiar los archivos a otro disco duro en la misma computadora protege contra el fallo de un disco, pero si es necesario protegerse contra el fallo o destrucción de la computadora entera, entonces de deben hacer copias de los archivos en otro medio que puede sacarse de la computadora y almacenarse en una ubicación distante y segura.


SISTEMAS DE ARCHIVOS Y GESTORES DE ARCHIVOS

Artículo principal: Sistema de archivos
La manera en que una computadora organiza, da nombre, almacena y manipula los archivos se denomina globalmente como su sistema de archivos. Todas las computadoras tienen al menos un sistema de archivos; algunas computadoras permiten usar varios sistemas de archivos diferentes. Por ejemplo, en las computadoras Windows más recientes, se reconocen los antiguos sistemas de archivos FAT y FAT32 de las versiones antiguas de Windows, además del sistema de archivos NTFS que es el sistema de archivos normal en las versiones recientes de Windows. NTFS no es más moderno que FAT32; ha existido desde que Windows NT se publicó en 1993.
Cada sistema de archivos tiene sus propias ventajas y desventajas. La FAT estándar solamente permite nombres de archivo de ocho bytes (o ocho caracteres de solo 1 byte) (más una extensión de tres bytes/caracteres) sin espacios, por ejemplo, mientras que NTFS permite nombres mucho más largos que pueden contener espacios, y tener varias letras unicode. Puede llamar a un archivo Registros de nóminas en NTFS, mientras que en FAT estaría limitado a algo como nominas.dat (salvo que estuviera usando VFAT, una extensión de FAT que permite nombres de archivo largos).
Los programas gestores o administradores de archivos son utilidades que le permiten manipular archivos directamente. Le permiten mover, crear, borrar y renombrar archivos y carpetas, aunque no le permiten realmente leer el contenido de un archivo o almacenar información en él. Cada sistema informático proporciona al menos un programa gestor de archivos para su sistema de archivos nativo. En Windows, el gestor de archivos usado más comúnmente es Windows Explorer.

unidad VI

UNIDAD VI. ESTRUCTURAS DE REPETICION.


Los algoritmos vistos hasta el momento han consistido en simples secuencias de instrucciones; sin embargo, existen tareas más complejas que no pueden ser resueltas empleando un esquema tan sencillo, en ocasiones es necesario repetir una misma acción un número determinado de veces o evaluar una expresión y realizar acciones diferentes en base al resultado de dicha evaluación.

Para resolver estas situaciones existen las denominadas estructuras de control que poseen las siguientes características:

• Una estructura de control tiene un único punto de entrada y un único punto de salida.
• Una estructura de control se compone de sentencias o de otras estructuras de control.

Tales características permiten desarrollar de forma muy flexible todo tipo de algoritmos aún cuando sólo existen tres tipos fundamentales de estructuras de control:

• Secuencial.
• Alternativa.
• Repetitiva.

A lo largo de esta lección se presentarán las distintas estructuras de control, la forma de representarlas en la notación algorítmica y las correspondientes sentencias FORTRAN para poder utilizarlas en nuestros programas.

Estructura repetitiva.

La estructura repetitiva o iterativa permite, como su propio nombre indica, repetir una acción (o grupo de acciones); dicha repetición puede llevarse a cabo un número prefijado de veces o depender de la evaluación de una expresión lógica. Existen tres tipos de estructuras repetitivas: desde-hasta, mientras y repetir-hasta.



6.1 REPETIR MIENTRAS.
En la solución de algunos problemas es necesario ejecutar repetidas veces una instrucción o un conjunto de instrucciones. El número de repeticiones se conoce con anterioridad, mientras que en otras depende de cálculos o estados de variables que se dan dentro de la solución del problema.
Para solucionar este tipo de problemas se utiliza un tipo de estructuras a las que se conocen como estructuras de repetición, bucles o ciclos. Un ciclo consiste en un grupo de acciones que se ejecutan repetidas veces dependiendo del cumplimiento de una condición.
Ciclo Mientras.- Este ciclo consiste en un conjunto de instrucciones que se repiten mientras se cumpla una condición. De igual manera que en los condicionales, la condición es evaluada y retorna un valor lógico, que puede ser verdadero o falso. En el caso del ciclo mientras las instrucciones contenidas en la estructura de repetición se ejecutarán solamente si al evaluar la condición se genera un valor verdadero; es decir, si la condición se cumple; en caso contrario, se ejecutará la instrucción que aparece después de Fin mientras.
A diferencia de otros ciclos, el ciclo mientras comienza evaluando la expresión condicional, si el resultado es verdadero se ejecutarán las instrucciones que estén entre el mientras y el fin mientras, al encontrarse la línea fin mientras se volverá a evaluar la condición, si se cumple se ejecutarán nuevamente las instrucciones y así sucesivamente hasta que la condición deje de cumplirse, en cuyo caso, el control del programa pasa a la línea que aparece después de fin mientras. Si en la primera pasada por el ciclo mientras la condición no se cumple las instrucciones que están dentro del ciclo no se ejecutarán ni una sola vez. En diagrama de Chapin (N-S), esta estructura tiene la presentación:
Ejemplos:
1. Un algoritmo para mostrar los números del 1 al 10.
Definición del problema Mostrar listado de números de 1 a 10. Análisis del problema Datos de entrada: ninguno Datos de salida: número Proceso: ninguno Diseño de la solución
Este es un algoritmo muy trivial pero permite revisar la aplicación de la estructura de repetición Mientras. Lo primero a tener en cuenta es la declaración e inicialización de la variable: num = 1. En este caso no solo se está declarando una variable de tipo entero, sino también se está asignando un valor inicial, que será el primer número mostrado. La condición o expresión relacional con la cual se implementa el ciclo es num <= 10, dado que num inicia en 1, la primera vez que se encuentra la instrucción mientras, la expresión es verdadera, por tanto se ejecutan las instrucciones que aparecen al interior del ciclo. Después de haber mostrado el contenido de la variable num, éste cambia, se incrementa en 1.
2. Leer n números y encontrar el valor promedio, el mayor y el menor.
Definición del problema Encontrar el promedio, el mayor y el menor de varios números Análisis del problema Para solucionar este problema, lo primero que hay que plantear es cómo se sabrá cuando terminar la lectura de datos, ya que no se especifica la cantidad de números que serán ingresados y en el planteamiento del problema no se da ninguna condición que permita saber cuando terminar el ciclo. Este tipo de problemas es muy común. Hay dos formas de abordar este ejercicio, la primera consiste en preguntar al usuario con cuantos números desea trabajar y guardar dicho valor en una variable que se utilizará para establecer el ciclo. La segunda consiste en preguntar después de leer cada dato, si se desea ingresar otro. En este ejercicio se utilizará la primera estrategia. Datos de entrada: cantidad de números, número Datos de salida: promedio, mayor y menor Procesos: suma = suma + número promedio = suma / cantidad de números Diseño de la solución
3. La serie Fibonacci comienza con los números: 0, 1, 1, 2, 3, 5, 8, 13, 21, …
Se requiere un algoritmo para generar los primeros 10 números. Definición del problema Generar los 10 primeros números de la serie fibonacci Análisis del problema La serie fibonacci se genera a partir de dos valores iniciales que son el 0 y el 1, que al sumarse dan como resultado 1. El siguiente número se obtiene sumando el último número obtenido con el anterior, en este caso 1 + 1 = 2, luego será 2 + 1 = 3 y así sucesivamente. Datos de entrada: ninguno Datos de salida: serie fibonacci Procesos: a = 0 b = 1 f = a + b Diseño de la solución


6.2 REPETIR...HASTA.
Una variante de la sentencia mientras, es la sentencia repetir. Una de las características de la sentencia mientras es que la condición lógica se evalúa al principio de cada iteración.
En particular, si la condición es falsa cuando la sentencia comienza, entonces el bucle no se ejecuta nunca.
La sentencia repetir-hasta especifica un bucle condicional que se repite hasta que la condición se hace verdadera.
Después de cada iteración el cuerpo del bucle evalúa la condición. Si la condición es verdadera, el bucle se termina y se sale de el, ejecutándose la siguiente sentencia. Si la condición es falsa el bucle se repite.
El pseudocódigo es el siguiente:
Repetir.Sentencias.Hasta (expresión lógica).

Ejemplo:
Volvamos a realizar el ejemplo anterior, donde se desea obtener la suma de tres números ingresados por el usuario. Para acortar, solo colocaré la parte donde se efectúa la suma:
Escribir ("Cuántos números desea ingresar")leer (Total_num)contador <-- 0suma <-- 0repetir leer (núm.) suma <-- suma + numero contador <-- contador + 1hasta (contador = Total_num).
En un bucle repeat...until, primero se ejecuta el bloque de instrucciones y, después, se evalúa la condición. En el caso de que ésta sea falsa, se vuelve a ejecutar el bloque de instrucciones. Y así sucesivamente, hasta que, la condición sea verdadera.Por consiguiente, cuando el flujo de un programa llega a un bucle repeat...until, existen dos posibilidades:
Se ejecuta el bloque de instrucciones y, después, si la condición se evalúa a verdadera, el bloque de instrucciones no se vuelve a ejecutar, de manera que, el bucle repeat...until finaliza, habiendo realizado una sola iteración.
Se ejecuta el bloque de instrucciones y, a continuación, si la condición se evalúa a falsa, el bloque de instrucciones se vuelve a ejecutar. Y así sucesivamente, hasta que la condición sea verdadera.
El de un bucle repeat...until puede ejecutarse una o más veces (iteraciones). También hay que prevenir que el bucle no sea infinito.Una instrucción repetitiva repeat...until permite ejecutar repetidamente (una o más veces) un bloque de instrucciones, hasta que, una determinada condición sea verdadera.Ejemplo 1: De modo que, utilizando un bucle repeat...until, 3.1 Repetitiva mientras, se puede resolver con el código:
program EJE13101;uses Crt;var Contador : Integer;begin ClrScr; GotoXY( 4, 2 ); Contador := 1; { Inicializacion del contador } repeat Write( Contador, ' ' ); { Salida } Contador := Contador + 1; { Incremento } until Contador > 10; { Condicion }end.

Programa (.PAS):
El bucle repeat...until puede iterar una o más veces, por tanto, cuando un bloque de instrucciones debe iterar al menos una vez, es mejor utilizar un bucle repeat...until que un bucle while.


6.3 REPETIR DESDE.

La estructura repetitiva desde (for) es aquella en que el número de iteraciones (repeticiones) del bucle se conoce de antemano y por ello no se precisa poner ninguna condición de salida para detener el bucle. En su lugar, un contador cuenta el número de iteraciones fijadas y se termina cuando llega al valor final.
La estructura for sirve para repetir un código dependiendo de un contador. Un ejemplo:int contador;for (contador = 1; contador<=10; contador++){ printf(“Repetición numero %d\n”, contador);};Primero se crea la variable contador de tipo entero (será la variable de control en el for). Luego se ejecuta la estructura for iniciando la variable contador en 1. Luego se verifica que se cumple la condición contador<=10 y se ejecuta el bloque dentro de la estructura, o sea, imprime en pantalla Repetición número 1.Luego la variable contador es incrementada en uno con la expresión contador++ y el ciclo se inicia otra vez. La variable contador ahora vale 2, por lo tanto se verifica la condición y se vuelve a ejecutar el código. Este proceso se ejecuta hasta que contador toma el número 11 y la condición se hace falsa y no ejecuta el bloque.
Este código imprimirá en pantalla lo siguiente:
Repetición numero 1Repetición numero 2Repetición numero 3Repetición numero 4Repetición numero 5Repetición numero 6Repetición numero 7Repetición numero 8Repetición numero 9 Repetición numero 10
Las tres expresiones que componen la estructura for en C son opcionales, por lo tanto se pueden omitir en ciertos casos. Si se omite la primera (la inicialización de la variable de control), significa que la variable se inicializa en otra parte del programa. Si se omite la segunda expresión, la estructura for entraría en un ciclo infinito, lo cual es considerado un error. Si se omite la tercera expresión significa que la variable de control es calculada dentro del bloque de for.La tercera expresión puede ser tanto un incremento como un decremento en uno o más. También puede ser más compleja agregando más instrucciones con el uso de la coma. Por ejemplo:for (contador = 1; contador<=10; suma += contador, contador += 2)La tercera expresión no sólo suma contador de dos en dos sino que además en cada repetición ejecuta la operación suma += contador.Índice - Anterior: Estructura de repetición while - Siguiente: Estructura de repetición do-while
El funcionamiento de la estructura es el siguiente:
• En primer lugar, se asigna a la variable índice el valor de inicio.
• El bucle se ejecuta mientras índice no alcance el valor de fin.
• En cada iteración el valor de índice es incrementado según el paso indicado y se ejecuta la acción o grupo de acciones encerrados en el bucle.
• En caso de que no se indique ningún paso el que se empleará será +1.

1. Las estructuras de control permiten alterar el flujo secuencial de los algoritmos que hemos visto hasta el momento.

2. Una estructura de control:
• Tiene un único punto de entrada y un único punto de salida.
• Se compone de sentencias o de otras estructuras de control.

3. Existen tres tipos fundamentales de estructuras de control:
• Secuencial.
• Alternativa.
• Repetitiva.

4. La estructura secuencial es una lista consecutiva de acciones donde el orden de aparición indica el orden de ejecución.

5. La estructura alternativa se presenta en tres formas:
• Simple.
• Doble.
• Multialternativa.

6. La estructura alternativa simple permite evaluar una expresión lógica y ejecutar una acción si dicha expresión es cierta.

7. La estructura alternativa doble permite evaluar una expresión lógica y ejecutar una acción si dicha expresión es cierta y otra acción si dicha expresión es falsa.

8. La estructura multialternativa consiste en una expresión selectora que puede tomar n valores diferentes y ejecuta una acción diferente por cada posible valor de la expresión selectora.

9. La estructura repetitiva se presenta en tres formas:
• Estructura desde-hasta
• Estructura mientras
• Estructura repetir-hasta

10. La estructura desde-hasta permite repetir la ejecución de una acción un número determinado de veces.

11. La estructura mientras repite una acción mientras una expresión lógica sea cierta; esta estructura puede ejecutarse 0 ó más veces.

12. La estructura repetir-hasta repite una acción hasta que una expresión lógica sea cierta; esta estructura siempre se ejecuta 1 vez al menos y no existe en el lenguaje FORTRAN aunque aparece en otros lenguajes de programación.

unidad V

UNIDAD V. ESTRUCTURA SELECTIVA

Las estructuras selectivas se utilizan para tomar decisiones lógicas; de ahí que se suelan denominar también estructuras de decisión o alternativas.

En las estructuras selectivas se evalúa una condición y en función del resultado de la misma se realiza un opción u otra. Las condiciones se especifican usando expresiones lógicas. La representación de una estructura selectiva se hace con palabras en pseudocódigo (if, then, else o bien en español si, entonces, sino), con una figura geométrica en forma de rombo o bien con un triángulo en el interior de una caja rectangular.

Estructuras de Control

Por lo regular en un programa los enunciados son ejecutados uno después del otro, en el ordén en que aparecen escritos. Esto se conoce como ejecución secuencial. Sin embargo, existen enunciados que le permiten al programador especificar que el enunciado siguiente a ejecutar pueda ser otro diferente al que sigue en secuencia. Esto se conoce como transferencia de control.

Las estructuras selectivas o alternativas pueden ser:

simples
dobles
múltiples



5.1ESTRUCTURA DE SELECCIÓN SIMPLE.


Se identifican porque están compuestos únicamente de una condición. La estructura si - entonces evalúa la condición y en tal caso:
Si la condición es verdadera, entonces ejecuta la acción Si (o acciones si son varias). Si la condición es falsa, entonces no se hace nada.
Español Inglés Si If Entonces then fin_si endif
Ejemplo 1. Construir un algoritmo tal, que dado como dato la calificación de un alumno en un examen, escriba “Aprobado” en caso que esa calificación fuese mayor que 8. Salidas: mensaje de aprobado si se cumple la condición. Entradas: calificación
Datos adicionales: un alumno aprueba si la calificación es mayor que 8 Variables: Cal = calificación Algoritmo: Inicio Leer (cal) Si cal > 8 entonces Escribir (“aprobado”) Fin_si Fin

//Este programa al dar tu edad te dice si eres mayor o menor de edad sencillo pero ayuda.
//Para este programa se utiliza la sentencia if(condicion) o en Pseudocodigo Si(condicion) y else o sino.
import javax.swing.J Option Pane;
class ifcondicional{
public static void main(String args[]){
//Declaracion de variables
//Variable tipo cadena
String a;
//Variable Tipo entero.
int edad;
//En esta parte del programa se pide al usuario que nos de su edad
a=J Option Pane.showInputDialog(“Introduce Tu Edad:”);
edad=Integer.parseInt(a);
//En esta parte se utiliza la sentencia if con la condicion de si la edad es mayor o igual a 18 se imprimera el msn eres mayor de edad,
if(edad>=18){
System.out.println(“Eres Mayor De Edad”);
}
//Else solo se ejecutara cuando la edad se menor a 18 y la condicion anterios no se cumpla
else{
System.out.println(“Eres Menor De Edad”);

}
}
}
//Espero que le entiendan copien tal como esta y ejecutenlo en jgrasp o en su compilador.


La estructura de selección simple evalúa una condición, si ésta es verdadera ejecuta una o varias instrucciones, si es falsa continua la ejecución normal del programa.

La representación gráfica de la estructura de selección simple es:


Expresión
Booleana

Instrucciones

Verdadero

Falso


El pseudocódigo correspondiente es (en español):

Si entonces

fin_si

En ingles:

If then

end_if

La estructura de selección simple se codifica en Visual Basic tal y como se muestra a continuación:
If Then

End if
No es fácil definir el concepto de programación estructurada, pero se podría considerar como un conjunto de técnicas que, utilizadas en el diseño de un programa, facilitan la escritura, lectura y seguimiento del mismo.
Siempre se ha considerado a la sentencia IR A (GOTO) el principal impedimento de la programación estructurada. De hecho, ya se expresaba en estos términos el profesor Edgar Dijkstra, considerado el padre de la programación estructurada en su libro "Goto Statement Considered Harmful".
En 1966, Böhm y Jacopini demostraron que un programa se puede escribir utilizando tan sólo tres tipos de estructuras de programación:
Secuenciales
Selectivas
Iterativas
La estructura secuencial ya se estudió en el epígrafe anterior. Se analizarán ahora las estructuras selectivas (bifurcativas condicionadas) y las iterativas.


ESTRUCTURAS SELECTIVAS

En muchas ocasiones, las circunstancias que nos rodean condicionan la forma en que debemos actuar. Desde el punto de vista de programación ocurre algo similar, y, según se cumpla o no una determinada condición, será necesario actuar de una u otra manera.
Las estructuras de programación que nos permiten tomar este tipo de decisiones son las estructuras selectivas, que pueden ver a su vez de tres tipos:

Simples
Dobles
Múltiples
Simples: ejecutan una secuencia de acciones sólo si se cumple una determinada condición.

Sintaxis - Pseudocódigo:
SI ENTONCES
Acción 1 : Acción n
fin-SI
La forma de representar esta estructura en diagramas de flujos y diagramas N/S se encuentra en las figuras siguientes.










Ejemplo:

Introducir 100 números por teclado, de forma que el ordenador nos avise cuando introducimos un número par, y nos muestre al final del proceso el total de números pares introducidos.

Algoritmos Pares
Var
H : entero CC : entero C : entero N : entero
Inicio
H = 0 CC = 0 C = 0
Etq: CC = CC + 1
Leer (N) H = N MOD 2 SI H = 0 ENTONCES
escribir ("detectado número par") C = C + 1
fin-SI SI CC < 100 ENTONCES

fin-SI escribir ("Han sido detectados", C," números pares")
Fin
Veamos el diagrama de flujo correspondiente a este algoritmo:







5.2ESTRUCTURA SELECTIVA DOBLE:

En las estructuras selectivas simples se ejecutaban una serie de acciones sólo en el caso de que se cumpliese una condición. Una vez terminada la ejecución de tales acciones, se continuaba con el flujo natural del programa, que es el proceso que se hubiera seguido en caso de no satisfacerse la condición.
En cambio, en la estructura selectiva doble, si se cumple la condición se ejecutan un conjunto de acciones, mientras que si no se cumple, se ejecuta otro conjunto de acciones diferentes. Resulta, por tanto, imposible que se ejecuten ambos conjuntos en secuencia, uno tras otro.

Sintaxis - Pseudocódigo:
SI ENTONCES
acción 1a acción 2a : acción na
SI NO
acción 1b acción 2b : acción nb
fin-SI

La sintaxis correspondiente al diagrama de flujo y N/S son como sigue:


Ejemplo:

Realizar pseudocódigo y diagrama de flujo de un programa que calcule el precio de la entrada de una persona a un parque de atracciones, sabiendo que:

Los niños < 15 años pagan 50 pesetas.
Las personas >= 15 años pagan 150 pesetas.
Al calcular un precio, el algoritmo pregunta si hay más clientes. En caso afirmativo repetimos el proceso. En caso contrario, abandonamos el programa.

Análisis:

El proceso es el siguiente:

Recoger la edad de cliente.
Si la edad < 15, establecer precio en 50 Ptas.
Si la edad >= 15, establecer precio en 150 Ptas.
Esperar a que el usuario diga si quiere continuar con el programa.
En caso afirmativo repetir el proceso. En caso contrario abandonar el programa.

Pseudocódigo:

Algoritmo Parque
Var
Edad: entero Precio: entero Res: cadena
Inicio
Eti1: leer (edad)
Si Edad < 15 Entonces
Precio = 50
si-no
Precio = 150
Fin-si
Escribir (precio) Escribir ("¿Hay más clientes (Si/No)? ") Leer (Res)
Si (Res = "Si") Entonces
IR A Eti1;
Fin-si
Fin

El diagrama de flujo correspondiente a este pseudocódigo se encuentra en la siguiente figura:






5.2ESTRUCTURAS SELECTIVAS ANIDADAS

La estructura selectiva es anidada cuando dentro de alguna acción de ésta, se encuentra otra estructura selectiva y la(s) acción(es) de esta puede contener otra selectiva y esta otra más; es decir cuando después de una decisión se debe tomar otra, después otra y así sucesivamente.


5.3ESTRUCTURAS SELECTIVAS MÚLTIPLES:

Las estructuras selectivas estudiadas hasta el momento nos permiten evaluar la condición en resultado booleano exclusivamente (si/no).
Sin embargo, hay ocasiones en que la gama de opciones es mucho más amplia. Por ejemplo, consideremos el caso de un local comercial de ordenadores y periféricos, donde cada periférico y cada ordenador tendrían un precio determinado.
Un hipotético programa que controlase las ventas y facilitase los precios, debería preguntar qué periférico se va a comprar. Según de qué periférico se tratase, establecería el precio correspondiente. Como se puede observar, si tal establecimiento vende ordenadores, impresoras, módems y ratones, el abanico de posibilidades se ha ampliado de dos a cuatro.


Existe una estructura selectiva que permite trabajar con más de dos elementos susceptibles de ser seleccionados. Se conoce como estructura selectiva múltiple y su formato es el siguiente:
Según hacer
valor1:
acción 1a acción 2a : acción na
valor2:
acción 1b acción 2b : acción nb ...
valorn:
acción 1z acción 2z : acción nz
cualquier otro:
acción 1 : acción n
fin-según

La representación de la estructura SEGÚN-SEA en diagrama de flujo y N/S, es como sigue:





Ejemplo:

Imaginemos un sistema informático, al que, por razones de seguridad, sólo tienen acceso cuatro personas: Eva, Juan, Pedro y María.
Imaginemos también que cada una de estas cuatro personas puede realizar una serie de acciones sobre el sistema, aunque tienen otras restringidas en función de su cargo.
Establezcamos la jerarquía en cuatro niveles según la siguiente tabla:
Realizar el algoritmo que permita la entrada al sistema sólo a los usuarios autorizados y en el nivel que les corresponde.
Algoritmo Seguridad
Var
nombre: cadena nivel: entero
Inicio
Eti1: leer ("nombre") según-sea nombre hacer
"Eva": nivel = 1 "María": nivel = 4 "Juan": nivel = 2 "Pedro": nivel = 3 cualquier otra: escribir ("acceso denegado") ir a Eti1
fin-según según-sea nivel hacer
1: acceso libre 2: acceso con X restricciones 3: acceso con Y restricciones 4: acceso con Z restricciones
fin-según
fin

Si este algoritmo fuese un programa real de control de acceso, en aquellos lugares donde encontramos los accesos libre o con restricción X, irían las órdenes que permiten la entrada real al sistema. Esta segunda estructura del tipo SEGÚN-SEA podría considerarse la "llave" que abre el cerrojo del sistema.
El lector podrá observar que en el segundo SEGÚN-SEA no aparece la opción cualquier-otra. La explicación es muy simple. La variable que actúa como condición del segundo SEGÚN-SEA, sólo se trata a lo largo del algoritmo en las acciones del primer SEGÚN-SEA, con lo cual estamos seguros de que si el programa llega al segundo SEGÚN-SEA, NIVEL sólo puede valer 1, 2, 3 ó 4 y no existe otro valor posible.
El diagrama de flujo correspondiente a esta estructura se halla en la siguiente figura:

unidad IV

UNIDAD IV. FUNCIONES

4.1. FUNCIONES.

Es posible definir funciones con un número variable de argumentos. O bien tambien se puede definir una función con un número variable de argumentos, sin más que añadir un argumento final al que se le asigna una lista con todos los argumentos adicionales.




4.1.1 DEFINICIÓN DE FUNCIONES.

Funciones estándar.

Las funciones estandar se dividen en grupos, todas las funciones que pertenecen al mismo grupo estan declaradas en el archivo de cabecera.

Para incluir alguna función perteneciente a estas cabeceras debemos escribir líneas de código como se muestra de ejemplo:
#include

4.2. ENTRADA Y SALIDA DE DATOS.

Proporciona un método para transferir información entre dispositivos de (E/S) de almacenamiento interno y de (E/S) externas. Los periféricos conectados a una computadora necesitan enlacé de comunicación especial para funcionar como una interfaces con la unidad de procesamiento central.

El propósito del enlace de comunicación es resolver las diferencias que existen en la computadora central y de cada periférico.
Se llama interfaces porque se comunica tanto con el canal del procesador como con el dispositivo periférico.

4.3. FUNCIONES DEFINIDAS POR EL USUARIO.

Algunos objetos permiten especificar funciones que serán evaluadas durante la renderización para determinar la superficie de estos objetos. En este aspecto las funciones son bastante diferentes de las macros, que se evalúan durante el tiempo de análisis pero no afectan de ninguna otra manera a la renderización. Adicionalmente, se puede llamar a estas funciones en cualquier lugar en el que se permita utilizar una función en coma flotante, incluso durante el análisis. La sintaxis es idéntica a las expresiones en coma flotante, sin embargo sólo pueden usarse funciones en coma flotante que se apliquen a valores en coma flotante
Estas se pueden invocar en consultas o en otras instrucciones o expresiones, como columnas calculadas o expresiones de cadena. Las funciones con valores escalares se pueden ejecutar mediante la instrucción EXECUTE.

4.3.1 PASE POR VALOR

El pase por valor significa que al compilar la función y el código que llama a la función, ésta recibe una copia de los valores de los parámetros que se le pasan como argumentos. Las variables reales no se pasan a la función, sólo copias de su valor.

Cuando una función debe modificar el valor de la variable pasada como parámetro y que esta modificación retorne a la función llamadora, se debe pasar el parámetro por referencia. En este método, el compilador no pasa una copia del valor del argumento; en su lugar, pasa una referencia, que indica a la función dónde existe la variable en memoria

4.3.2 PASE POR REFERENCIA

La referencia que una función recibe es la dirección de la variable. Es decir, pasar un argumento por referencia es, simplemente, indicarle al compilador que pase la dirección del argumento.
Por defecto, los parámetros de una función se pasan por valor (de manera que si cambias el valor del argumento dentro de la función, no se ve modificado fuera de ella). Si deseas permitir a una función modificar sus parámetros, debes pasarlos por referencia.

4.4 PUNTEROS

Un puntero (o apuntador) es una variable manipulable que referencia una región de memoria; en otras palabras es una variable cuyo valor es una dirección de memoria. Si se tiene una variable ' p ' de tipo puntero que contiene una dirección de memoria en la que se encuentra almacenado un valor ' v ' se dice que p apunta a v.
Los punteros son de amplia utilización en programación y casi todos los lenguajes permiten la manipulación de los mismos. La razón de ser principal de los punteros reside en manejar datos alojados en la zona de memoria dinámica (aunque también se pueden manipular objetos en la zona estática), bien sean datos elementales, estructuras (struct en C) u objetos pertenecientes a una clase (en lenguajes Orientados a Objetos).



4.4.2 PASO DE VARIABLE

Establece una variable local o global para un valor especificado. Si no existe una variable, este paso de guión creará una. Un nombre de variable tiene las mismas restricciones de nomenclatura que un nombre de campo.
Las variables locales y globales se pueden crear y utilizar en cálculos. Una variable local sólo se puede utilizar en pasos de guión en el guión que se ejecuta actualmente. El valor de una variable local se borra cuando se sale del guión. Una variable global se puede utilizar en un cálculo o guión en cualquier parte de un archivo, por ejemplo, otros guiones o ruta de archivo. El valor de una variable global no se borra hasta que se cierra el archivo. Las variables locales y globales (o incluso dos variables locales en guiones diferentes) pueden tener el mismo nombre pero se consideran como variables distintas y pueden almacenar valores distintos.

unidad III

UNIDAD III. “CONOCIMIENTO DE PROGRAMACIÓN Y UN LENGUAJE ESTRUCTURADO”


3.1 INTRODUCCION A LA PROGRAMACION


A principios de la década de los ochenta llegaban a los hogares de los usuarios los primeros microordenadores. Máquinas casi olvidadas, como los Sinclair ZX-81, o como el mítico Sinclair ZX-Spectrum, el Amstrad CPC-464, etc.
Todos estos equipos tenían un punto en común: el único software con que se entregaban era, por regla general, un sencillo intérprete de lenguaje BASIC. Cuando el usuario conectaba su ordenador, no encontraba un entorno gráfico, en su lugar encontraba una pantalla con una línea de comandos, esperando a recibir órdenes. Cuando se conseguía combinar varias órdenes consecutivas, obteniéndose un resultado satisfactorio, ya se sabía programar. En cierto sentido programar es, por lo tanto, enseñar a una máquina a hacer algo.


3.1.1 DEFINICION DE PROGRAMA

Es un conjunto de instrucciones u ordenes basadas en un lenguaje de programación que una computadora interpreta para resolver un problema o una función Especifica:

Es la relación ordenada de actividades, en informática se le conoce como la serie codificada de instrucciones.
Redacción de un algoritmo en un lenguaje de programación.
Conjunto de instrucciones ordenadas correctamente que permiten realizar una tarea o trabajo específico.
Toda secuencia de instrucciones o indicaciones destinadas a ser utilizadas, directa o indirectamente, en un sistema informático para realizar una función o una tarea o para obtener un resultado determinado, cualquiera que fuere su forma de expresión y fijación.
Conjunto secuenciado de instrucciones que quedan escritas en un lenguaje determinado con unos fines específicos. Aunque en el lenguaje común con frecuencia se denomina programa al sistema operativo, la diferencia estriba, precisamente, en la especificidad de aquél frente al carácter de gestión global de éste. La palabra software engloba ambos.






3.1.2 DEFINICION DE PROGRAMACION

Se conoce como programación de computadores a la implementación de un algoritmo en un determinado lenguaje de programación, conformando un programa. Mientras que un algoritmo se ejecuta en una máquina abstracta que no tiene limitaciones de memoria tiempo, un programa se ejecuta en una máquina real, que sí tiene esas limitaciones. El lenguaje de programación puede ser de alto nivel, medio nivel o bajo nivel, en función del grado de abstracción.


3.1.3 DEFINICION DEL LENGUAJE DE PROGRAMACION

Es aquel elemento dentro de la informática que nos permite crear programas mediante un conjunto de instrucciones, operadores y reglas de sintaxis; que pone a disposición del programador para que este pueda comunicarse con los dispositivos hardware y software existentes.


3.2 INTRODUCCION Y ORIGENES DEL LENGUAJE

Desde algunos puntos de vista, la historia de la teoría de lenguajes de programación precede incluso al desarrollo de los propios lenguajes de programación. El cálculo lambda, desarrollado por Alonzo Church, Max HL. Solis Villareal y Stephen Cole Kleene en la década de 1930, es considerado ser uno de los primeros lenguajes de programación del mundo, incluso pese a que tenía intención de modelar la computación más que ser un medio para que los programadores describan algoritmos para un sistema informático. Muchos lenguajes de programación funcional se han caracterizado por proveer una "fina apariencia" al cálculo lambda [1], y muchos se describen en sus términos.

El primer lenguaje de programación (como tal) que se propuso fue Plankalkül, que fue diseñado por Konrad Zuse en los años 40, pero no fue conocido públicamente hasta 1972 (y no implementado hasta 2000, cinco años después de la muerte de Zuse).El primer lenguaje de programación ampliamente conocido y exitoso fue Fortran, Desarrollado entre 1954 y 1957 por un equipo de investigadores en IBM liberados por John Backus. El éxito de FORTRAN condujo a la creación de un comité de científicos para desarrollar Un lenguaje de programación "universal"; el resultado de Su esfuerzo fue ALGOL 58.

Separadamente, John McCarthy del MIT desarrolló el Lenguaje de programación Lisp (basado en el cálculo Lambda), el primer lenguaje con orígenes académicos en Conseguir el éxito. Con el triunfo de estos esfuerzos iniciales, los lenguajes de programación se convirtieron en un tema candente en la investigación en la década de 1960 y en adelante.

Algunos otros eventos claves en la historia de la teoría de lenguajes de programación desde entonces:

En la década de 1950, Noam Chomsky desarrolló la Jerarquía de Chomsky en el campo de la lingüística; un descubrimiento que impactó directamente a la teoría de Lenguajes de programación y otras ramas de la informática.

En la década de 1960, el lenguaje Simula fue desarrollado por Ole-Johan Dahl y Kristen Nygaard; muchos consideran que es el primero lenguaje orientado a objetos; Simula también introdujo el concepto de corrutinas.

Durante 1970:

Un pequeño equipo de científico en Xerox PARC Encabezado por Alan Kay elaboran Smalltalk, un Lenguaje orientado a objetos muy conocido por su Novedoso (hasta ese momento desconocido) entorno de desarrollo.

Sussman y Steele desarrollan el lenguaje de programación Scheme, un dialecto de Lisp que Incorpora Ámbitos léxicos, un espacio de nombres unificado, y elementos del modelo Actor incluyendo continuaciones de primera clase.

Backus, en la conferencia del Premio Turing de 1977, asedió el estado actual de los lenguajes industriales y propuso una nueva clase de lenguajes de programación ahora conocidos como lenguajes de programación funcional.

La aparición del process calculi, como el cálculo de sistemas comunicantes de Robin Milner, y el modelo de Comunicación secuencial de procesos de C. A. R. Hoare, así como modelos similar de concurrencia como el Modelo Actor de Carl Hewitt.

La aplicación de la teoría de tipos como una disciplina a los lenguajes de programación, liderada por Milner; esta aplicación ha conducido a un tremendo avance en la teoría de tipos en cuestión de años.

En la dećada de 1990:

Philip Wadler introdujo el uso de monads para estructurar programas escritos en lenguajes de Programación funcional.












3.3 ESTRUCTURA BASICA DE UN PROGRAMA

La estructura exacta de un programa depende del lenguaje que utilicemos y el entorno en el cual lo creemos. Sin embargo, hay algunos principios generales:

Un cargador - Todo programa necesita ser cargado en la memoria por el sistema operativo. De esto se encarga el intérprete.

Definición de los datos - La mayoría de los programas operan con datos y por lo tanto en el código fuente debemos definir que tipo de datos vamos a utilizar en el programa. Esto se realiza de manera diferente en los distintos lenguajes. Todos los lenguajes que usaremos tienen la posibilidad de crear una nueva definición de datos simplemente al utilizar los datos. Veremos esto en la próxima sección.

Instrucciones - Son la parte central del programa. Las instrucciones manipulan los datos que hemos definido, realizan cálculos, muestran los resultados, etc.

La mayoría de los programas siguen una de dos estructuras:

Programas de lotes

Estos se ejecutan típicamente desde una línea de comando o automáticamente desde otra aplicación (tipo scheduler) y tienden al siguiente patrón:

Inicialización interna de los datos
Lectura de los datos ingresados
Procesamiento de los datos
Visualización o ejecución de los resultados

Programas controlados por eventos.

La mayor parte de las interfaces gráficas (y los sistemas de control presentes en un horno a microondas o una cámara por ejemplo) responden a eventos. Esto significa que el Sistema Operativo envía un evento al programa y este los responde tan pronto como estos le llegan. Los eventos incluyen acciones del usuario como apretar una tecla, mover el mouse, etc, y operaciones propias del sistema operativo tales como la actualización del reloj, el refresco de la pantalla, etc.

Los programas controlados por eventos son generalmente así:

Inicialización interna de los datos
Espera de los eventos
Identificación de los eventos y actuación en consecuencia


Características comunes a todos los programas

Hace tiempo Edsgar Dijkstra desarrolló el concepto de la programación estructurada. Esto significa que todos los programas pueden estructurarse de las siguientes cuatro formas:

Secuencias de instrucciones
Bucles
Bifurcaciones
Módulos

Además de estas estructuras los programas necesitan otras características que los hacen útiles:

Datos
Operaciones (sumar, restar, comparar, etc.)
Capacidad de Entrada/Salida (para mostrar resultados)

Una vez que se comprende cómo un lenguaje particular implementa estos conceptos, uno está preparado para escribir un programa en ese lenguaje.



3.4. DATOS

El dato (del latín datum), es una representación simbólica (numérica, alfabética, etc.), atributo o característica de una entidad. El dato no tiene valor semántico (sentido) en sí mismo, pero convenientemente tratado (procesado) se puede utilizar en la realización de cálculos o toma de
decisiones. Es de empleo muy común en el ámbito informático.

En programación un dato es la expresión general que Describe las características de las entidades sobre las cuales opera un algoritmo.

Un dato por sí mismo no constituye información, es el procesador de los datos lo que nos proporciona Información.


3.4.1 TIPOS DE DATOS

Existen muchas clasificaciones para los tipos de datos, y dependiendo de la fuente que mires, te mostrarán una u otra. A continuación tienes una de las posibles clasificaciones:

Tipos estáticos

Casi todos los tipos de datos son estáticos, la excepción son los punteros y no se tratarán debido a su complejidad. Que un tipo de datos sea estático quiere decir que el tamaño que ocupa en memoria no puede variar durante la ejecución del programa. Es decir, una vez declarada una variable de un tipo determinado, a ésta se le asigna un trozo de memoria fijo, y este trozo no se podrá aumentar ni disminuir.

Tipos dinámicos

Dentro de esta categoría entra solamente el tipo puntero. Este tipo te permite tener un mayor control sobre la gestión de memoria en tus programas. Con ellos puedes manejar el tamaño de tus variables en tiempo de ejecución, o sea, cuando el programa se está ejecutando.

Los punteros quizás sean el concepto más complejo a la hora de aprender un lenguaje de programación, sobre todo si es el primero que aprendes. Debido a esto, no lo trataremos.
Además, lenguajes que están muy de moda (por ejemplo Java) no permiten al programador trabajar con punteros.

Tipos simples

Como su nombre indica son los tipos básicos en Pascal. Son los más sencillos y los más fáciles de aprender. Por todo esto, serán en los que nos centremos.
Los tipos simples más básicos son: entero, lógico, carácter y real. Y la mayoría de los lenguajes de programación los soportan, no como ocurre con los estructurados que pueden variar de un lenguaje a otro.

Tipos estructurados

Mientras que una variable de un tipo simple sólo referencia a un elemento, los estructurados se refieren a colecciones de elementos. Las colecciones de elementos que aparecen al hablar de tipos estructurados son muy variadas: tenemos colecciones ordenadas que se representan mediante el tipo array, colecciones sin orden mediante el tipo conjunto, e incluso colecciones que contienen otros tipos, son los llamados registros.

Tipos ordinales

Dentro de los tipos simples, los ordinales son los más abundantes. De un tipo se dice que es ordinal porque el conjunto de valores que representa se puede contar, es decir, podemos establecer una relación uno a uno entre sus elementos y el conjunto de los números naturales. Dentro de los tipos simples ordinales, los más importantes son:

El tipo entero (integer)
El tipo lógico (boolean)
El tipo carácter (char)

Tipos no-ordinales

Simplificando, podríamos reducir los tipos simples no-ordinales al tipo real. Este tipo nos sirve para declarar variables que pueden tomar valores dentro del conjunto de los números reales.


A diferencia de los tipos ordinales, los no-ordinales no se pueden contar. No se puede establecer una relación uno a uno entre ellos y los número naturales. Dicho de otra forma, para que un conjunto se considere ordinal se tiene que poder calcular la posición, el anterior elemento y el siguiente de un elemento cualquiera del conjunto.¿Cuál es el sucesor de 5.12? Será 5.13, o 5.120, o 5.121, ...

Después de ver una de las posibles clasificaciones para los tipos de datos, pasemos a ver los que nos interesan: los tipos simples. Realmente de los tipos simples veremos los más básicos, que son: integer, boolean, char y real. Además, también hablaremos un poco de las cadenas de caracteres, los llamados strings.

nota: a continuación sólo se comentará qué es cada tipo, no se explicará su declaración, esto puedes verlo si vas a la sección correspondiente.

El tipo integer (entero)

Como ya habrás leído el tipo de datos entero es un tipo simple, y dentro de estos, es ordinal.

Al declarar una variable de tipo entero, estás creando una variable numérica que puede tomar valores positivos o negativos, y sin parte decimal.
Este tipo de variables, puedes utilizarlas en asignaciones, comparaciones, expresiones aritméticas, etc. Algunos de los papeles más comunes que desarrollan son:

• Controlar un bucle .
• Usarlas como contador, incrementando su valor cuando sucede algo.
• Realizar operaciones enteras, es decir, sin parte decimal
• Y muchas más...

El tipo boolean (lógico)

El tipo de datos lógico es el que te permite usar variables que disponen sólo de dos posibles valores: cierto o falso. Debido a esto, su utilidad salta a la vista, y no es otra que variables de chequeo. Nos sirven para mantener el estado de un objeto mediante dos valores:

si/no
cierto/falso
funciona/no funciona
on/off
etc.






El tipo real (real)

Como ya has visto, Pascal soporta el conjunto entero de números. Pero no es el único, también te permite trabajar con números pertenecientes al conjunto real. El tipo de datos real es el que se corresponde con los números reales. Este es un tipo importante para los cálculos. Por ejemplo en los estadísticos, ya que se caracterizan por tratar fundamentalmente con valores decimales.

nota: Aunque pueda que estés acostumbrado a escribir con coma los decimales, te advierto que en Pascal y en todos los lenguajes de programación se escribe con un punto. Por ejemplo: 3.1416

Los tipos char y string (carácter y cadena)

Con el tipo carácter puedes tener objetos que representen una letra, un número, etc. Es decir, puedes usar variables o constantes que representen un valor alfanumérico. Pero ojo, cada variable sólo podrá almacenar un carácter. Sin embargo, con las cadenas de caracteres (strings) puedes contener en una sóla variable más de un carácter. Por ejemplo, puedes tener en una variable tu nombre.



3.4.2 IDENTIFICADORES

En los lenguajes informáticos, los identificadores son elementos textuales (también llamados símbolos) que nombran entidades del lenguaje. Algunas de las de entidades que un identificador puede denotar son las variables, las constantes, los tipos de dato, las etiquetas, las subrutinas, los paquetes y las subrutinas (procedimientos y funciones).

En muchos lenguajes algunas secuencias tienen la forma léxica de un identificador pero son conocidos como palabras clave (o palabras reservadas). Lo habitual es que si un identificador se corresponde con una palabra clave o reservada, éste ya no pueda utilizarse para referirse a otro tipo de entidades como variables o constantes (en unos pocos lenguajes, como PL/1, esta distinción no está del todo clara).



3.4.3 ALMACENAMIENTO, DIRECCIONAMIENTO Y REPRESENTACIÓN EN MEMORIA.

• ALMACENAMIENTO:

Hay dos clases, almacenamiento primario, que son los que usa la CPU directamente (memoria principal, memoria caché, etc) y el almacenamiento secundario, a los cuales la CPU no accede directamente, sino que deben almacenarse previamente en uno primario. Son de almacenamiento secundario los discos magnéticos, ópticos, cintas magnéticas, tambores magnéticos, etc.El almacenamiento de datos puede usarse también para copias de seguridad, ver backup.Con el correr de los años, el almacenamiento de datos informáticos ha ido bajando de precio. Por ejemplo, 1 GB de memoria en 1956 costaba 8,2 millones de dólares. En 1980, 184 mil dólares; en 1990 eran 5.200 dólares; en 2000 eran 12 dólares, y en 2006 fueron 1,2 dólares.

DIRECCIONAMIENTO

Los llamados Modos de direccionamiento son las diferentes maneras de especificar en informática un operando dentro de una instrucción (lenguaje ensamblador). Cómo se especifican e interpretan las direcciones de memoria según las instrucciones. Pueden ser:

Inmediato: En la instrucción está incluido directamente el operando.

Directo: El campo de operando en la instrucción contiene la dirección en memoria donde se encuentra el operando.

Indirecto: El campo de operando contiene una dirección de memoria, en la que se encuentra la dirección efectiva del operando.

Absoluto: El campo de operando contiene una dirección en memoria, en la que se encuentra la instrucción.

De registro: Sirve para especificar operandos que están en registros.

Indirecto mediante registros: El campo de operando de la instrucción contiene un identificador de registro en el que se encuentra la dirección efectiva del operando.

De desplazamiento: Combina el modo directo e indirecto mediante registros

De pila: Se utiliza cuando el operando está en memoria y en la cabecera de la Pila.

• REPRESENTACION DE MEMORIA

Podemos representar a las colas de dos formas :

Como arreglos
Como listas ordenadas

En esta unidad trataremos a las colas como arreglos de elementos, en donde debemos definir el tamaño de la cola y dos apuntadores, uno para accesar el primer elemento de la lista y otro que guarde el último.

En lo sucesivo, al apuntador del primer elemento lo llamaremos F, al de el último elemento A y MAXIMO para definir el número máximo de elementos en la cola.

COLA (DEFINICION)

Una cola es una estructura de almacenamiento, donde la podemos considerar como una lista de elementos, en la que éstos van a ser insertados por un extremo y serán extraídos por otro. Las colas son estructuras de tipo FIFO (first-in, first-out), ya que el primer elemento en entrar a la cola será el primero en salir de ella. Existen muchísimos ejemplos de colas en la vida real, como por ejemplo: personas esperando en un teléfono público, niños esperando para subir a un juego mecánico, estudiantes esperando para subir a un camión escolar, etc.



3.4.4 PROPOSICIÓN DE ASIGNACIÓN.

La forma de una proposición de asignación es: a = b donde b es una expresión permitida, y a es el nombre de la variable donde se dejará el valor resultante de evaluar b.
Por expresión permitida se entiende a aquella expresión matemática que ocupa las operaciones y funciones nombradas como existentes, y escritas de la forma que para ellas se señala, respetando así la sintaxis en cada instrucción.
El signo igual, " = ", de a = b tiene el sentido de asignar a la variable a el valor que resulte de evaluar la expresión permitida b. Es decir, a = b. Que no es la misma definición usada en matemáticas para el signo: = .

El computador, al ejecutar una proposición de asignación evalúa la expresión del lado derecho del signo igual con los valores que en ese momento tengan las variables ahí ocupadas. Así, la expresión entregará valores probablemente distintos en las diversas ocasiones que por programa se evalúe esa expresión. Las siguientes son proposiciones de asignación correctas, A = 2.5 TO = 1 + XT I = I + 1 Y no son correctas las siguientes:

A + B = C 20 = 16.2 + 3.8 AL = (AT+3.4) / 110.302


3.5. OPERADORES, OPERANDOS Y EXPRESIONES

OPERADORES.

En todos los lenguajes de programación se utilizan operadores para efectuar operaciones aritméticas.Combinando las variables y constantes en expresiones aritméticas por medio de funciones adecuadas. Una expresión es un conjunto de datos o funciones unidos por operadores aritméticos, los cuales son: SUMA, RESTA, MULTIPLICACION, DIVISION, EXPONENCIAL Y MODULO.




OPERADOR LOGICO

En ocasiones en los programas se necesitan realizar comparaciones entre distintos valores, esto se realiza utilizando los operadores relaciones, los cuales son: Mayor que, menor que, menor igual que, mayor igual que, igual a, distinto a o diferente de.

OPERANDO.

Referente a la parte de la instrucción de lenguaje máquina de la computadora que designa la dirección de los datos con los que se debe operar.

EXPRESIONES.

Las expresiones son combinaciones de constantes, variables, símbolos de operación, paréntesis y nombres de funciones especiales. Por ejemplo:
a + (b + 3) / c

Cada expresión toma un valor que se determina tomando los valores de las variables y constantes implicadas y la ejecución de las operaciones indicadas. Una expresión consta de operadores y operandos. Según sea el tipo de datos que manipulan, se clasifican las expresiones en: Aritméticas, Relacionales ,Lógicas


3.5.1 PRIORIDAD DE OPERADORES, EVALUACIÓN DE EXPRESIONES

Prioridad

Se llama prioridad al orden en el que se evalúa una expresión. 4D tiene una estricta prioridad izquierda-a-derecha. Por ejemplo: 3+4*5 devuelve 35 porque la expresión es evaluada como 3+4, dando 7, el cuál es multiplicado por 5, resultando 35. Se pueden utilizar paréntesis para cambiar la prioridad izquierda-a-derecha. Por ejemplo:
3+(4*5) devuelve 23 porque se evalúa primero la expresión (4*5), por estar entre paréntesis. El resultado es 20, lo cual es añadido el 3, dando el resultado final 23. Se pueden insertar paréntesis dentro de otros grupos de paréntesis. Es necesario asegurarse de que cada paréntesis izquierdo tiene su correspondiente derecho. La falta o el uso incorrecto de los paréntesis puede provocar resultados inesperados o expresiones no válidas.

EVALUACIÓN DE EXPRESIONES

Cuando en una expresión concurre mas de una operación, los paréntesis indicarán prioridad, es decir, la operación encerrada entre paréntesis se realizará en primer lugar. Además, algunos operadores tendrán preferencia sobre otros. Por ejemplo, en la operación a + b / c, primero se realizará b / c y posteriormente se le sumará a. En caso de que el programador quiera que se sume primero a y b para posteriormente dividir por c, tendríamos que hacer (a + b) / c. Si todos los operadores de una expresión tienen la misma prioridad, la operación se hará de izquierda a derecha, salvo cuando tengamos exponenciales, en tal caso, el orden será de derecha a izquierda, por ejemplo, al hacer 2**3**2 resulta el valor 2**9 = 512


3.6. PROCESO DE CREACIÓN DE UN EJECUTABLE

En Java, en principio, no se pueden crear autoejecutables ya que este es un lenguaje multiplataforma y los archivos autoejecutables son dependientes de la plataforma. Esto provoca que tengamos que usar la consola para ejecutar nuestros programas; lo que supone un gran inconveniente para usuarios sobre todo acostumbrados a los entornos gráficos. Existen varias soluciones para este asunto. Aquí se explican tres de ellas. La primera es la de crear ejecutables dependientes de la plataforma ; la segunda permite hacer más fácil la ejecución en cada plataforma sin impedir su ejecución en otra plataforma; la tercera es válida para cualquier plataforma y aporta otras muchas posibilidades. Podemos crear un ejecutable de la plataforma de varias maneras: Podemos usar traducir el código java a código C con Toba o J2C. De esta forma sólo nos queda compilar el código C para crear el ejecutable.

Toba es un proyecto libre cuyo desarrollo ha quedado estancado cuando Java iba por la versión 1.1, pero podemos descargarlo todavía desde su página web. J2C lo puedes encontrar aquí (creo; cuando veas la página sabrás el porqué de mis dudas), Existe un compilador que además de permitirnos, como cualquier otro compilador, crear bytecodes a partir de ficheros .java, nos da la posibilidad de compilar el fuente (archivos .java) para obtener un ejecutable de la plataforma y también permite crear un ejecutable de la plataforma a partir del bytecode. De esta forma el código obtenido es mucho más rápido. El programa se llama GJC y forma parte la familia de compiladores GCC del proyecto GNU que se desarrolla bajo la GPL (General Public License). Si lo que queremos es crear un archivo ejecutable .exe (para plataforma Windows) y prescindir de la cualidad de multiplataforma de este lenguaje, lo que hay que hacer es conseguir un programa que realice esta tarea. Esto lo hacen algunas IDE’s y el programa Jto Exe. Al crear un .exe lo que hacemos es sustituir los archivos de clase de Java, al contrario que la siguiente opción que complementa y no sustituye.

En particular el programa Jto Exe necesita de la máquina virtual de Java para poder ejecutar el programa de modo seguiremos necesitando instalar la JVM al contrario que las dos opciones anteriores.