Índice

Introducción .................................................................................................................. 2
Arreglo unidimensionales ..................................................................................................... 3
Ejemplo: ................................................................................................................................... 5
Arreglo bidimensionales ....................................................................................................... 6
Crear arreglos bidimensionales ..................................................................................... 6
Operaciones con arreglos bidimensionales ................................................................. 7
Archivos ............................................................................................................................... 8
Elaboración de programas .................................................................................................. 11
Conclusión................................................................................................................... 14
Bibliografía .................................................................................................................. 15

Algoritmos y lenguajes de programación 1

 Introducción

En la presente investigación de la materia algoritmos y lenguajes de

programación se aborda temas de la unidad 5 que se llama Arreglos y
archivos en el cual se llevo acabo una investigación de diversas fuentes y se
encontraron dichos temas que desglosan la unidad 5.

Dicha unidad nos habla de los Arreglos y archivos, y un arreglo es una

colección de datos (cada uno de los cuales es del mismo tipo). Cada pieza
del arreglo se llama elemento. Para acceder a un elemento de un arreglo,
utiliza el operador de corchetes ( [] ) y un índice entero que indica la ubicación
del elemento en el arreglo.

Algoritmos y lenguajes de programación 2

 Arreglo unidimensionales

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.

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.

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:

<tipo> [ ] < identificador > ;

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:

Algoritmos y lenguajes de programación 3

< identificador > = new <tipo> [ 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.

Algoritmos y lenguajes de programación 4

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.

Algoritmos y lenguajes de programación 5

 Arreglo bidimensionales

Los arreglos bidimensionales son tablas de valores. Cada elemento de un arreglo

bidimensional está simultáneamente en una fila y en una columna.
En matemáticas, a los arreglos bidimensionales se les llama matrices, y son muy
utilizados en problemas de Ingeniería.
En un arreglo bidimensional, cada elemento tiene una posición que se identifica
mediante dos índices: el de su fila y el de su columna.

Crear arreglos bidimensionales

Los arreglos bidimensionales también son provistos por NumPy, por lo que
debemos comenzar importando las funciones de este módulo:

from numpy import *

Al igual que los arreglos de una dimensión, los arreglos bidimensionales también
pueden ser creados usando la función array, pero pasando como argumentos una
lista con las filas de la matriz:

a = array([[5.1, 7.4, 3.2, 9.9],

[1.9, 6.8, 4.1, 2.3],
[2.9, 6.4, 4.3, 1.4]])

Todas las filas deben ser del mismo largo, o si no ocurre un error de valor:

>>> array([[1], [2, 3]])

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: setting an array element with a sequence.

Los arreglos tienen un atributo llamado shape, que es una tupla con los tamaños de
cada dimensión. En el ejemplo, a es un arreglo de dos dimensiones que tiene tres
filas y cuatro columnas:

>>> a.shape
(3, 4)

Los arreglos también tienen otro atributo llamado size que indica cuántos elementos
tiene el arreglo:

>>> a.size
12

Algoritmos y lenguajes de programación 6

Por supuesto, el valor de a.size siempre es el producto de los elementos
de a.shape.
Hay que tener cuidado con la función len, ya que no retorna el tamaño del arreglo,
sino su cantidad de filas:

>>> len(a)
3

Las funciones zeros y ones también sirven para crear arreglos bidimensionales. En
vez de pasarles como argumento un entero, hay que entregarles una tupla con las
cantidades de filas y columnas que tendrá la matriz:

>>> zeros((3, 2))

array([[ 0., 0.],
[ 0., 0.],
[ 0., 0.]])

>>> ones((2, 5))

array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])

Lo mismo se cumple para muchas otras funciones que crean arreglos; por ejemplom
la función random:

>>> from numpy.random import random

>>> random((5, 2))
array([[ 0.80177393, 0.46951148],
[ 0.37728842, 0.72704627],
[ 0.56237317, 0.3491332 ],
[ 0.35710483, 0.44033758],
[ 0.04107107, 0.47408363]])

Operaciones con arreglos bidimensionales

Al igual que los arreglos de una dimensión, las operaciones sobre las matrices se
aplican término a término:

>>> a = array([[5, 1, 4],

... [0, 3, 2]])
>>> b = array([[2, 3, -1],
... [1, 0, 1]])

>>> a + 2
array([[7, 3, 6],
[2, 5, 4]])

Algoritmos y lenguajes de programación 7

>>> a ** b
array([[25, 1, 0],
[ 0, 1, 2]])

Cuando dos matrices aparecen en una operación, ambas deben tener exactamente
la misma forma:

>>> a = array([[5, 1, 4],

... [0, 3, 2]])
>>> b = array([[ 2, 3],
... [-1, 1],
... [ 0, 1]])
>>> a + b
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: shape mismatch: objects cannot be broadcast to a single
shape

Archivos

Operaciones de escritura en archivos

El archivo de cabecera fstream.h define las

clases ifstream, ostream y fstream para operaciones de lectura, escritura y
lectura/escritura en archivos respectivamente. Para trabajar con archivos debemos
crear objetos de éstas clases de acuerdo a las operaciones que deseamos efectuar.
Empezamos con las operaciones de escritura, para lo cual básicamente declaramos
un objeto de la clase ofstream, después utilizamos la función miembro open para
abrir el archivo, escribimos en el archivo los datos que sean necesarios utilizando el
operador de inserción y por último cerramos el archivo por medio de la función
miembro close, éste proceso está ilustrado en nuestro primer
programa, archiv01.cpp.

//***********************************************
// archiv01.cpp
// Demuestra la escritura básica en archivo
// ©1999, Jaime Virgilio Gómez Negrete
//***********************************************

#include <fstream.h>

Algoritmos y lenguajes de programación 8

 int main()
{
ofstream archivo; // objeto de la clase ofstream

archivo.open("datos.txt");

archivo << "Primera línea de texto" << endl;

archivo << "Segunda línea de texto" << endl;
archivo << "Última línea de texto" << endl;

archivo.close();
return 0;
}

En el programa se ha creado un objeto de la clase ofstream llamado archivo,

posteriormente se utiliza la función miembro open para abrir el arcivo especificado
en la cadena de texto que se encuentra dentro del paréntesis de la función.
Podemos invocar a la función constructora de clase de tal manera que el archivo
también se puede abrir utilizando la siguiente instrucción:

ofstream archivo("datos.txt"); // constructora de ofstream

Naturalmente, al utilizar la función constructora ya no es necesario utilizar la función

miembro open, ésta forma de abrir un archivo es preferida porque el código es más
compacto y fácil de leer. De la misma forma que se utilizan manipuladores de salida
para modificar la presentación en pantalla de los datos del programa, igual es
posible utilizar éstos manipuladores al escribir datos en un archivo como lo
demuestra el programa archiv02.cpp, observe que se utiliza un constructor para
crear y abrir el archivo llamado Datos.txt:

//***********************************************
// archiv02.cpp
// Demuestra el uso de manipuladores
// ©1999, Jaime Virgilio Gómez Negrete
//***********************************************

#include <iostream.h>
#include <fstream.h>

Algoritmos y lenguajes de programación 9

 #include <iomanip.h>

int main()
{
ofstream archivo("Datos.txt"); // constructor de ofstream
int numero;

cout << "Introduzca un numero:" << endl;

cin >> numero;
archivo << "El valor introducido en base 10 es: " << numero << e
ndl;

archivo << resetiosflags(ios::dec);

archivo << setiosflags(ios::oct);
archivo << "en base octal es: " << numero << endl;

archivo << resetiosflags(ios::oct);

archivo << setiosflags(ios::hex);
archivo << "y en base hexadecimal es: " << numero << endl;
archivo << setiosflags(ios::uppercase|ios::showbase);
archivo << "utilizando los manipuladores uppercase y showbase"
<< " el valor es: " << numero << endl;

archivo << resetiosflags(ios::uppercase|ios::showbase);

archivo << resetiosflags(ios::hex);
archivo << setiosflags(ios::showpos|ios::showpoint|ios::fixed);
archivo << "Utilizando los manipuladores showpos," << " showpoin
t y fixed: " << (float)numero << endl;

archivo << resetiosflags(ios::showpos|ios::showpoint|ios::fixed)

;
archivo << "Finalmente el valor es " << numero << endl;

archivo.close();

return 0;
}

Modos de apertura de archivo

Al especificar la apertura de un archivo como se ha mostrado en los programas

anteriores, el programa sobreescribe cualquier archivo existente
llamado Datos.txt en el directorio de trabajo del programa. Dependiendo del
propósito del programa es posible que sea necesario agregar datos a los ya
existentes en el archivo, o quizá sea necesario que las operaciones del programa
no se lleven a cabo en caso de que el archivo especificado exista en el disco, para
éstos casos podemos especificar el modo de apertura del archivo incluyendo un
parámetro adicional en el constructor, cualquiera de los siguientes:

 ios::app Operaciones de añadidur

Algoritmos y lenguajes de programación 10

 ios::ate Coloca el apuntador del archivo al final del mismo.
 ios::in Operaciones de lectura. Esta es la opción por defecto para objetos de la
clase ifstream.
 ios::out Operaciones de escritura. Esta es la opción por defecto para objetos de la
clase ofstream.
 ios::nocreate Si el archivo no existe se suspende la operación.
 ios::noreplace Crea un archivo, si existe uno con el mismo nombre la operación se
suspende.
 ios::trunc Crea un archivo, si existe uno con el mismo nombre lo borra.
 ios::binary Operaciones binarias.

Elaboración de programas

Un programa es un conjunto de instrucciones que al ser ejecutadas resuelven un

problema para el cual han sido diseñadas.
Para la elaboración de un programa se deben tener en cuenta un conjunto de
reglas de sintaxis de forma que el programa sea correcto.

Estructura de un programa
Los elementos de un programa se pueden dividir en:
1. Palabras reservadas: Son un conjunto de palabras especiales que nos sirven
para definir la estructura del programa, y solo se pueden usar para el fin para
el que están reservadas.
2. Identificadores: Son los nombres que aparecen en el programa dados por el
usuario. Son por tanto los nombres de variables, de constantes, de
subprogramas y nombres de tipos creados por el usuario.
3. Características especiales: Sirven como separadores entre sentencias, por
ejemplo el ;.
4. Instrucciones.
La estructura de un programa tiene 3 partes:

1. Entrada de datos: Normalmente se va a ejecutar a través de instrucciones de

lectura, y en lo que se le pide al usuario la información que el programa va a
necesitar para ejecutarse y se hace a través de lecturas.

2. Acciones de un algoritmo: parte en la que resuelve el problema usando los

datos de entrada.

Dentro de esta parte, a su vez se distinguirán dos partes:

- Declaración de variables,
- Instrucciones del programa.

Algoritmos y lenguajes de programación 11

 3. Salida: Mostrar en un dispositivo de salida los resultados de las acciones
anteriormente realizadas. Son acciones de escritura.

Instrucciones
Para que una instrucción se ejecute tiene que ser llevada a memoria. En cuento al
orden de ejecución de las instrucciones, el programa puede ser de dos tipos:

- Programas lineales: Se va ejecutando una instrucción después de otra y el

orden de ejecución es igual al orden de escritura.
- Programas no lineales: Las instrucciones no se ejecutan en el mismo orden
en el que aparecen escritas, sino que se realizan saltos que nos mandan de
unas instrucciones a otras.

Las instrucciones que podemos encontrar en un programa son:

1. Instrucciones de inicio y fin.

2. Instrucciones de asignación a través de las cuales se da valor a una variable.
3. Instrucciones de lectura/escritura, cuyo objetivo es introducir o sacar información
por dispositivos periféricos.
4. Instrucciones de bifurcación: Alternan el orden de ejecución del programa. Salto
a otra instrucción que no es la siguiente:
4.1. Bifurcación incondicional: El salto se produce siempre que el programa vaya
a esa instrucción (Goto – ir a). Este tipo de instrucción está en desuso.
4.2. Bifurcación condicional: Se ejecutan un conjunto de instrucciones u otras
dependiendo del valor devuelto al evaluar una condición.

Datos
Se puede definir los datos como objetos o elementos tratados a lo largo de diversas
operaciones en un determinado programa.

Para los datos se presentan tres características:

- Un nombre que los diferencia del resto.
- Un tipo que nos determina las operaciones que podemos hacer con ese dato.
- Un valor que puede variar o no a lo largo de las operaciónes.

Los datos pueden ser:

- Simples: Un elemento.
- Compuestos: Varios elementos.

Los tipos de datos pueden ser de forma general:

- Estándar: Que vienen en el sistema por defecto.
- No estándar: Son los que crea el usuario.

Dentro de los tipos de datos estándar, lo mas importantes son:

Algoritmos y lenguajes de programación 12

- Numéricos.
- Lógicos.
- Caracteres.

Algoritmos y lenguajes de programación 13

 Conclusión

Algoritmos y lenguajes de programación 14

 Bibliografía
 Desconocido. (2014). Arreglos unidimensionales. Mayo 28, 2017, de
gayatlacomulco Sitio web:
http://www.gayatlacomulco.com/tutorials/progorientobjetos/t11.htm

 Desconocido. (2017). Arreglos bidimensionales. Mayo 28, 2017, de

programación Sitio web: http://progra.usm.cl/apunte/materia/arreglos-
2d.html

 Julio César Brizuela. (2011). Manejo de archivos en C++. Mayo 28, 2017,
de Cool C/C++ Sitio web:
http://www.programacionenc.net/index.php?option=com_content&view=a
rticle&id=69:manejo-de-archivos-en-c&catid=37:programacion-
cc&Itemid=55

 Equipo de profesores del centro documental . (2011). Sistemas

electrotecnicos y automáticos. Mayo 28, 2017, de users Sitio web:
file:///Users/melissa/Documents/tarea%20algoritmo%20pdf.pdf

Algoritmos y lenguajes de programación 15