Arreglos

Un arreglo es una estructura de datos que permite asignar una cantidad de memoria para
almacenar varios datos, la cual cumple con las siguientes características:

1. Todo el conjunto de datos se los puede acceder con un mismo nombre. Recuerde que el
nombre hace referencia a una dirección en la memoria.
2. Todos los datos que se van a almacenar en el arreglo deben ser del mismo tipo ( por lo
tanto, la misma cantidad de memoria para cada campo del arreglo).
3. Todos los campos referenciados por el mismo nombre deben ser contiguos. Este punto
junto con el anterior, garantizan la ubicación desde el primer elemento hasta el último.
4. La localización de una dirección de un campo específico utiliza el nombre (el cual hace
referencia al primer elemento del grupo), y la ubicación dentro del grupo. Con estos
elementos más el punto que deben ser del mismo tipo, permiten al administrador de la
memoria acceder al dato específico. Ej.

Nombre arreglo V1 Dirección memoria 1000

Cantidad de campos 20
Tipo de dato Entero (2 bytes de tamaño)

5Lo anterior indica que hay un grupo de 20 datos identificados con V1 que son de tipo entero
los cuales se van a ubicar a partir de la dirección 1000, donde el primer dato queda en la
posición 1000, el segundo en la dirección 1002, el tercero en la 1004, …..

De lo anterior podemos concluir:

- Que el tamaño total del arreglo es de 40 bytes
- Que el primer elemento está a partir de la dirección de memoria 1000, el segundo en la
1002, el tercero en 1004, así hasta 1038 donde se encuentra el dato 20.

Cabe anotar que la ubicación del campo se realiza internamente, el programador tan solo tiene
que definir el arreglo, es decir, el nombre, el tamaño y el tipo. Con esta información el
administrador de la memoria accede al campo específico aplicando una simple operación. Ej.

Ubicar en el anterior arreglo el campo 9

Fórmula general
Nombre del arreglo (dirección) + tipo del campo * ubicación

V1 + (2 * 9)
V1 está haciendo referencia a la dirección 1000
Tipo de campo entero 2 bytes
Ubicación 9

V1(9)

1000 + (2*9) = 1018

Ubicación 0 es válida
V1+(2*0)=1000

0 - 19 // posiciones validas dentro del arreglo V1

Esto indica que el campo de memoria referenciado por V1(9) está ubicado en la dirección
1018.
Recuerde que esto no lo tiene que hacer el programador, esto es lo que ocurre internamente y
lo realiza el sistema operativo con los programas que se encargan de la administración de la
memoria.

5. Definción de un arreglo en Pseint. Se lo realiza en dos pasos,

- se define el nombre de la variable y su tipo.
- se define el tamañoprimero se define

De acuerdo al ejemplo del punto 4 la definición sería:

Definir V1 como entero

Dimension V1(20)

Con lo anterior se establece que se va a trabajar un arreglo de 20 posiciones de tipo entero

con el nombre único V1

El tamaño del arreglo puede ser una variable lo cual permite definir en ejecución el tamaño
del arreglo de la siguiente forma:

Definir V1 como entero

Escribir “Tamaño del vector “
Leer tam
Dimension V1(tam)

6. La referencia a un campo específico de un arreglo se lo realiza así:

Nombre_arreglo ( ubicación )
La ubicación es un valor que no debe exceder a la cantidad de campos definidos en el
arreglo.
Esto indica que donde exista un nombre de una variable, seguida por paréntesis, hace
referencia a un campo de memoria que hace parte de un arreglo (variable arreglada). Ej:

V1(10)

Hace referencia a un único campo de memoria que forma parte de un arreglo con nombre
V1 y de éstos se refiere al campo que esta ubicado en la posición 10.

Manejo de arreglos en Python

El arreglo como se lo está especificando hasta el momento y que lo trabajan muchos lenguajes
como C, C++, o java entre otros, son estructuras estáticas que definen la cantidad de campos y
el tipo de dato asociado antes de ser utilizados y permanecen con ese tamaño durante la
ejecución del programa. Python no da esta posibilidad pero trabaja la estructura de datos
dinámica denominada lista, la que permite almacenar elementos que son objetos
mediante un orden definido. Las listas son estructuras de datos mutables, lo que
significa que podemos añadir, eliminar o modificar sus elementos.
A diferencia de los arreglos tradicionales cuyos elementos son del mismo tipo y la
asignación de memoria es contigua, los objetos de las listas son heterogéneos,
donde sus elementos pueden ser de todos los tipos de datos que se manejan en
Python y en la memoria no son contiguos.

Ejemplo
data = [‘Tenerife’, {‘cielo’: ‘limpio’, ‘temp’: 24}, 3718, (28.2933947, -16.5226597)]

Del ejemplo se tiene:

- La lista tiene un único nombre data

- Los [ ] permiten definir una lista, donde el formato es:

Nombre_identificador=[cero o más objetos]

- Se está definiendo una lista data con 4 elementos

- Los 4 elementos son de diferentes tipos, string o cadena, diccionario, entero y tupla.
El que se pueda definir datos de diferentes tipos, brinda a la programación una
estructura de datos dinámica que puede apoyar mucho en la construcción de
soluciones computacionales.

- Los objetos no son contiguos pero si tienen un orden específico el cual va a permitir
acceder a cualquier objeto de la misma forma en que se lo realiza en los arreglos. El
orden para el ejemplo es

data
-4 -3 -2 -1
[‘Tenerife’, {‘cielo’: ‘limpio’, ‘temp’: 24}, 3718, (28.2933947, -16.5226597)]
0 1 2 3

- La referencia a un campo específico se lo realiza con el nombre y el índice

data[ 2 ] o data[-2]
correspondiente al valor entero 3718

Otros ejemplos de definición

empty_list=[ ]
languages = [‘Python’, ‘Ruby’, ‘Javascript’]
fibonacci = [0, 1, 1, 2, 3, 5, 8, 13]

la primera define una lista vacía, las otras dos listas se definen con objetos homogéneos,
con string y enteros respectivamente.

6. La ubicación de un campo específico dentro del arreglo o lista se lo realiza con índices,
los cuales se los puede trabajar de la siguiente forma:

- Indice como constante

- Indice como variable
- Indice como resultado de una expresión aritmética entera

El índice para las tres formas asociadas debe ser de tipo entero.

Ejemplo. Para ilustrar los índices definimos un arreglo de 15 campos

Definir A como entero
Dimensión A(15)

Nombre arreglo A

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

Nombre lista A.

A=['', '', '', '', '', '', '', '', '', '', '', '', '','']

A
['', '', '', '', '', '', '', '', '', '', '', '', '','']
0 1 2 3 4 5 6 7 8 9 10 11 13 14

Ejemplo índice constante:

A(10) hace referencia siempre a una variable que pertenece al arreglo de campos A ubicada
en la posición 11.

15 21
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
A(10)
El tratamiento con esta variable es el mismo que se ha trabajado normalmente con todas las
otras variables que no pertenecen a un arreglo; la diferencia radica en que la variable de un
arreglo debe involucrar los paréntesis y los índices.
El tratamiento de una variable perteneciente a un arreglo con las diferentes instrucciones es el
siguiente:

Asignación

A(10)  20 Asigna a este campo el valor de 20

A[10]=20;

A
['', '', '', '', '', '', '', '', '', '', 20, '', '','']
0 1 2 3 4 5 6 7 8 9 10 11 13 14

Variable  Expresión

A(10)  A(10) +1

A[10]= A[10] + 1;

A
['', '', '', '', '', '', '', '', '', '', 21, '', '','']
0 1 2 3 4 5 6 7 8 9 10 11 13 14
Lectura

Leer A(9)
A[9]=int(input(‘dato 9 =‘)
Esto se puede realizar en Python porque se definió A con 15 elementos de lo
contrario saca error

Introduce desde el teclado un valor específico al campo de la posición 10 del arreglo A

Escritura
Escribir A(10)
print(A[10])

Muestra la información que se encuentra almacenada en el arreglo A o en la lista en la

posición 10

Decisión
Si A(10) < 15 ….

if A[10]<15: …….

Ejemplo índice como variable:

La ubicación no es siempre una constante entera como se especifico anteriormente, también

se la trabaja con una variable de tipo entero, donde se lleva el valor de la posición del campo
que se quiere acceder, y al estar los campos ubicados en forma contigua esta variable de tipo
entero funcionalmente es un contador.

La referencia va a ser de la siguiente forma:

NombreVariableArreglo ( variable_indice )

NombreLista [ variable_indice ]

Donde variable_indice es un campo donde se va a almacenar un valor entero que va a ser

referencia a un campo específico.

Ejemplo

Variable Indice I
Variable Arreglo A

Si se tiene A(I) o A[ I ], solo puede hacer referencia a un campo específico, el campo al que
se hace referencia depende del valor que se encuentre almacenado en la variable I.

Acceso al campo 6

Necesita que en el campo I se encuentre almacenado el valor 6. Esto se conoce como una
referencia indirecta.
I6

A
15
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
I
A(I) hace referencia a la información almacenada en el campo 6

A(I)15

Si se tienen las siguientes variaciones de I se tendría

II+1
A(I)20
II+1
A(I)25
I6

A
15 20 25
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
I

Para lista A

A
['', '', '', '', '', '', 15, '', '', '', '', '', '','']
0 1 2 3 4 5 6 7 8 9 10 11 13 14

I=6
A[I]=15;
I=I+1;
A[I]=20;
I=I+1;
A[I]=25;
I=I-4;
A[I]=100

A
['', '', '', '', '', '', 15, '', '', '', '', '', '','']
0 1 2 3 4 5 6 7 8 9 10 11 13 14

I puede ser un contador

Y su variación seria:

II+1
II-1
El que el índice se lo pueda trabajar como variable, permite accesar en forma muy flexible los
campos del arreglo o los objetos de lista, tan solo se debe controlar la variable índice para
saber a que campo se puede acceder. Como los campos son contiguos la identificación de
cada uno de ellos se lo realiza en forma secuencial (0, 1, 2, 3, 4, ….) lo que permite
fácilmente llegar a cada uno de ello con una variable contador, que al introducirla dentro
de un ciclo se puede recorrer todos los campos del arreglo.

Leer CD
I0
Mientras (I<=CD-1) hacer
Leer A(I)
II+1
Fin mientras

En lenguaje python

a=[] # define una lista con 0 elementos

cd=int(input(‘cantidad de datos del vector’)
i=0
while i<cd:
[Link](int(input(‘dato (‘,i,’) = ’)
i=i+1

En listas se tiene la function append() para adicionar datos a la lista. El dato se adiciona
siempre al final

Teniendo en cuenta que CD es la cantidad de campos del vector o de la lista, las acciones
anteriores van a permitir leer información en todos los campos de arreglo.

Indice como expresión.

La posición del campo puede estar representada también por una expresión que entregue
como resultado un valor entero.

Ej: copiar el valor del campo ubicado en la posición 7, al campo ubicado en la posición 5.

Se lo puede realizar de la siguiente forma:

I5
A( I )  A( I+2 ) donde I+2 = 7

I=5
A[ I ] = A[ I+2 ]

En muchos problemas relacionados con vectores se necesita trabajar, más de una posición de
un vector a la vez, si estas son las posiciones contiguas se las puede trabajar de la siguiente
forma:

I es un índice que va a trabajar una posición específica.

Si I = 4

Si A(I) es un elemento de un vector, los elementos vecinos son:

A ( I+1) el dato inmediatamente superior posición 5

A ( I- 1 ) es el dato inmediatamente inferior posición 3

Cuando un ejercicio necesita trabajar con datos de un vector en forma contigua, no hay
necesidad de crear otro índice.

Tipos de arreglos:

Lo especificado anteriormente esta relacionado con arreglos unidimensionales o vectores,

pero hay muchos otros tipos de arreglos, los cuales se diferencian por la forma en que se
trabajan en la memoria. Dentro de la memoria se puede acceder en forma secuencial de uno
en uno, arreglo unidimensional o moverse de grupo en grupo de acuerdo a un índice.

Los arreglos se clasifican de acuerdo al número de índices que se utilizan para determinar
una posición, estos pueden ser:

Arreglo Unidimensional. Conocidos también como vector. Necesita para ubicar un campo
del arreglo un índice y se los representa así:

Nombre_del_arreglo ( Indice )

Nombre_de_la_lista [ Indice ]

Ejemplo. Los arreglos a los que hemos hecho referencia en los puntos anteriores son
unidimensionales.

A(I+1) es un campo que pertenece a un arreglo unidimensional o vector

Arreglo Bidimensionales. Se conocen también como Matriz. Necesitan para ubicar un

campo del arreglo dos índices y se los representa de la siguiente forma

Nombre_del_arreglo ( Indice para filas, Indice para columnas)

Nombre_de_la_lista [ Indice para filas] [ Indice para columnas]

Ejemplo:

M (1,3) hace referencia al campo de una matriz de nombre M ubicado en la fila 1, columna
3.
Esquemáticamente una matriz se la representa de la siguiente forma. Esta forma debe servir
para trabajar un modelo mental.
M 3X4
M
0 1 2 3

1 **

Esta matriz M tiene 3 filas y cuatro columnas, y el campo marcado con ** hace referencia al
elemento M ( 1, 3) ubicado en la fila 1 columna 3

Arreglos bidimensionales en Python

Los arreglos bidimensionales se trabajan con listas, en donde todos los elementos de la lista
son listas con la misma cantidad de elementos. El ejemplo que se viene trabajando se lo mira
de la siguiente forma:
Para entender mejor la definición se va a tener la matriz llena con ceros

0 1 2 -> filas
M=[[0, 0, 0, 0 ], [0, 0, 0, 0], [0, 0, 0, 0]]
0 1 2 3 0 1 2 3 0 1 2 3 -> columnas

O también se la mira de la siguiente forma:

M=[[0, 0, 0, 0 ],
[0, 0, 0, 0],
[0, 0, 0, 0] ]

El número de elementos de la lista mayor corresponde al número de filas (en el ejemplo 3) y

la cantidad de elementos de cada una de las listas internas corresponde al número de columnas
(en el ejemplo 4), por lo tanto esta lista representa una matriz de 3X4
Para hacer referencia a uno de los campos se lo realiza de la siguiente forma

M[2][3] hace referencia al

M=[[0, 0, 0, 0 ],
[0, 0, 0, 0],
[0, 0, 0, 0] ]

Arreglos n-dimensionales

Necesitan para ubicar un campo del arreglo n índices (n>2) y se los representa de la siguiente
forma:
Nombre_del_arreglo ( Indice 1, Indice 2, … Indice n )
Nombre_del_arreglo [ Indice 1] [ Indice 2] … [Indice n ]

Ejemplo arreglo con tres índices. Ubicar el elemento N (2,1,3)

Arreglo N

**

20

Este arreglo es de 3 dimensiones, los cuales se los interpreta de la siguiente forma:

1 hace referencia a la profundidad

2 hace referencia a la fila
3 hace referencia a columna

De los arreglos anteriores los más utilizados son los arreglos unidimensionales o vectores y
los arreglos bidimensionales o matrices, los n-dimensionales ya exigen aplicación específica,
dependiendo del problema que se quiera solucionar.

Tres dimensiones con listas e inicializados en cero se lo ve de la siguiente forma

0 1
----------------------------------------- ----------------------------------------- -------------
0 1 2 0 1 2 0
M=[[[0, 0, 0, 0 ], [0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0 ], [0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0 ],
0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3

3 -> profundidad
----------------------------
1 2 ->columna
[0, 0, 0, 0], [0, 0, 0, 0]]]
0 1 2 3 0 1 2 3 ->fila

Para hacer referencia a un elemento específico se debe tener en cuenta que los índices se los
va a trabajar de la siguiente forma:

M[profundidad][fila][columna]

Realizar estas dos acciones a la lista planteada

M[0][1][2] = 30

M[2][1][2] = 30
M=[[[0, 20, 0, 0 ], [0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0 ], [0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0 ],

[30, 0, 0, 0], [0, 0, 0, 0]]]

Arreglos unidimensionales
Un arreglo unidimensional generalmente se lo llama vector.

Recorrido de un vector o arreglo unidimensional:

Para recorrer un vector se utiliza un índice, el cual debe ser controlado por un contador
(implica utilizar el índice como variable) y por un ciclo.
Para poder recorrer un vector se debe conocer la cantidad de elementos que lo conforman,
para así poder establecer la variación del contador y por tanto la repetición del ciclo.

Se realizan recorridos para:

Leer CD
I0
Mientras (I<=CD-1) hacer
Leer A(I), Asignación o Escribir
II+1
Fin mientras

CD es la cantidad de datos del vector A

Recorrido de una lista trabajando como vector

Se debe conocer la cantidad de elemento en la lista

CD=int(input(‘cantidad de datos ‘)
I=0
while I<CD:
Leer,Asignación o Escribir
I=I+1

Asignar valores a las posiciones de un arreglo.

Leer información en el arreglo o entrar datos al arreglo
Mostrar información del arreglo, o sacar información del arreglo

Ejemplos:

Llenar un vector A de N elementos con unos.

Modelo mental
Es importante tener las características generales del modelo mental, para así saber que es lo
que debemos buscar para la conformación del algoritmo.

Elementos que se deben manejar claramente.

Memoria
Variable simple
Definición de un arreglo
Para que sirve un arreglo
Definición de un índice
Manejo claro de los contadores
Manejo claro de los ciclos
Variable arreglada
Relación de la estructura lista con arreglo

Gráficamente el modelo mental lo debe visualizar de la siguiente forma:

0 1 2 3 4 5 6

A
0
1
2
3
4
5
6

Aquí hay dos ejemplos de arreglos unidimensionales los cuales mentalmente se los debe
asociar como un conjunto de estantes que deben ser llenados con información del mismo
tipo.
Estos estantes deben tener un nombre y cada celda debe tener una posición. Para trabajar con
el arreglo entonces, debe tener bien claro que se necesita un índice que le va a permitir
acceder a cualquier posición del arreglo.

Ejemplos:

Llenar un vector A de N elementos con unos.

Retomando el ejercicio

El arreglo se lo debe mirar con un antes y un después

antes
cantidad de elementos del vector

7
A
1 1
0 1 2 3 4 5 6
I

A[0]=1;
A[1]=1;
Después

A
1 1 1 1 1 1 1
0 1 2 3 4 5 6
I I I
Agregar características computacionales

Lo primero es identificar en el gráfico elementos claros.

Estos son: el nombre y el manejo del índice establecido por la secuencia de datos que aparece
identificando cada posición.

Nombre Arreglo A
Cantidad de elementos 7 (N)

0 1 2 3 4 5 6
I I I

Indice para llegar a las posiciones (I)

Ahora la pregunta es: ¿Cómo se llega al después?

Para esto se debe tener claro que para poder llenar información en una variable, se lo hace con
lectura o con asignación, con la lectura se llena valores dinámicos desde el teclado, con
asignación se puede llenar valores constantes, como lo pide el ejercicio que es 1

Ej:

A(0)  1
A
1
0 1 2 3 4 5 6

El cual solo llenaría un valor, para llenar todos, se necesita realizar un ciclo para que una
variable contador pueda generar la secuencia del 0 al 6 y aprovechar cada variación para
llegar acceder a un campo. Para éste ejercicio se utiliza la variable contador I de la siguiente
forma

I0
Mientras ( I<= N-1) haga
A(I)  1
I I + 1
Fin mientras

El ciclo presenta iteraciones que van a estar controlados por el índice I, en cada iteración se
garantiza que el valor del índice I permita acceder un campo específico del arreglo y realizar
con el, la acción determinada, en este caso A(I)  1. Una vez terminado el ciclo se obtiene
como resultado lo siguiente:

A
1 1 1 1 1 1 1
0 1 2 3 4 5 6
I I I I I I I

Aquí se muestra cuales fueron los valores que tomo el I.

El ejercicio completo queda

Inicio
Leer N
I0
Mientras ( I<= N-1) haga
A( I )  1
I I + 1
Fin mientras
Fin

Manejo en pseint

Algoritmo llenarunosvector
Dimension A(10)
Definir A,I,N como entero

Leer N
I0
Mientras ( I<= N-1) haga
A( I )  1
I I + 1
Fin mientras
FinAlgoritmo

Programa en lenguaje Python

#llenar unos en una lista de 10 elemento;

A=[1,1,1,1,1,1,1,1,1,1]

Python permite en la definición llenar una serie de elementos en la lista

Ejercicio anterior utilizando ciclo y función append()

#llenar unos en una lista cantidad dada de elementos

n=int(input('Cantidad de elementos de la lista ->'))

A=[] #inicialmente vacía
i=0
while i<n:
[Link](1)
i=i+1
print(A) #muestra toda la lista
Algoritmo llenarunosvector2
Definir A,I,N como entero
Leer N
Dimension A(N)

I<-0
Mientras I<= N-1 hacer
A(I)<-1
I<-I + 1
Fin mientras

I<-0
Mientras ( I<= N-1) hacer
Escribir A(I)
I<-I + 1
Fin mientras
FinAlgoritmo

Programa en python
#llenar unos en una lista cantidad dada de elementos

n=int(input('Cantidad de elementos de la lista ->'))

A=[] #inicialmente vacía
i=0
while i<n:
[Link](1)
i=i+1

i=0
while i<n:
print('\ndato (',i, ')-> ',A[i])

Ejercicio arreglos 2

Se tiene un arreglo de N posiciones, llenar el campo de las posiciones pares con unos y
campo de las posiciones impares con ceros. Tomamos la posición 0 como par

antes
A

0 1 2 3 4 5 6

después

N=7
A
1 0 1 0 1 0 1
0 1 2 3 4 5 6
I

I es par?
Si
A(I) <- 1
No
A(I) <- 0

La esencia del ejercicio es evaluar la ubicación en el arreglo, lo que se hace con una variable
contador I, que dentro de un ciclo va a tomar valores entre 0 y 6. Cómo esta va variando, se
debe preguntar lo siguiente:

I es par?
Si o No, según su respuesta se hacen las acciones respectivas.

O sea,

I mod 2 = 0?
Si
A(I)<- 1
No
A(I) <- 0

El algoritmo queda:

Algoritmo llenarunoscerosvector

Definir A,I,N como entero

Escribir "Cantidad de datos del vector "

leer N
Dimension A(N)

I <- 0
Mientras ( I<= N-1) hacer
Si ( I mod 2 = 0 ) Entonces
A(I) <- 1
Sino
A(I) <- 0
Fin si
I <- I + 1
Fin mientras

I <- 0
Mientras ( I<= N-1) hacer
Escribir A(I)
I <- I + 1
Fin mientras

FinAlgoritmo

Programa en python

#llenar unos pares, cerso impares

n=int(input(‘Cantidad de elementos de la lista ->’))
A=[] #inicialmente vacía
i=0
while i<n:
if i%2==0:
[Link](1)
else:
[Link](0)
i=i+1
i=0
while i<n:
print(‘\ndato (‘,i,’)->’,A[i])

Ciclo Para o for

El ciclo para o for, permite repetir un conjunto de instrucciones un número conocido de

veces, es un caso especial de un ciclo mientras controlado por un contador y tiene el siguiente
funcionamiento

Formato

Para VariableContador <- Inicio Hasta Límite con Paso Incremento o decremento
Acciones
Fin para

Ejemplo

Para I<-1 hasta 10 con paso 1

Acciones por cada iteración
Fin para

Ciclo for en Python

Python permite recorrer aquellos tipos de datos que sean iterables, es decir, que admitan
ser recorridas, utilizando la sentencia for.
Algunos ejemplos de tipos y estructuras de datos que permiten ser iteradas (recorridas) son:
cadenas de texto, listas, diccionarios, ficheros, etc.

La sentencia for permite realizar esta acción.

Formato

for variable in estructura de datos iterable :

Acciones dentro del ciclo

Variable va a tomar todos los valores de la estructura de datos iterable

#llenar unos pares, ceros impares

n=int(input(‘Cantidad de elementos de la lista ->’))
A=[] #inicialmente vacía
i=0
while i<n:
if i%2==0:
[Link](1)
else:
[Link](0)
i=i+1
for i in A:
print('\ndato ',i)

for controlado por un contador en Python. Para esto se utiliza la función range() la cual va
establecer rangos de números de acuerdo a sus parámetros

Formato
range(start, stop,step):
• start: Es opcional y tiene valor por defecto 0.
• stop: es obligatorio (siempre se llega a 1 menos que este valor).
• step: es opcional y tiene valor por defecto 1.
range( La variable puede ser cualquier nombre)

Rango: [0, 1, 2]

for i in range(0, 3):

print(i)

for i in range(3): # No hace falta indicar el inicio si es 0

print(i)

Utilización de variable

c=3
for i in range(c): # No hace falta indicar el inicio si es 0
print(i)

Con paso diferente a 1

Variación de 2

Rango: [1, 3, 5]

for i in range(1, 6, 2):

print(i)

Variación de -1
Rango: [2, 1, 0]
for i in range(2, -1, -1):
print(i)

Ejemplos

El for es un caso especial de while

i=1;
while (i<=10){

i=i+1;
}

Ciclo para es de enfoque cuantitativo. Como indica el formato tiene una variable Contador, el
límite que debe alcanzar el contador y un incremento o decremento que debe tener el
contador, el cual va a garantizar que el límite se alcance. En este formato de Pseint el
incremento o decremento de la variable contador es implícito, esto significa que la variación
no se especifica, el paso indica que es lo que pasa en cada iteración con la variable contador.

El siguiente ejemplo muestra un ciclo que va a tener variaciones de la variable contador de 1

en 1.

Para I<- 0 Hasta N-1 con Paso 1

Escribir A(I)
Fin para

En python

for i in range(n):
print('dato ',i, '=',A[i])

Variacion de 2 en 2

Para I<- 0 Hasta N-1 con Paso 2

Escribir A(I)
Fin para

for i in range(n,2):
print('dato ',i, '=',A[i])

El incremento o decremento de la variable contador se da cada vez que se alcanza el Fin para
o cuando se terminan las instrucciones que se repiten.
Ejercicio anterior con ciclo para o for

Inicio
Leer N
Para I<- 0 hasta N-1 con Paso 1
A(I)<- 1
Fin Para
Fin

Programa en lenguaje Python

#llenar unos en una lista cantidad dada de elementos

n=int(input('Cantidad de elementos de la lista ->'))

A=[] #inicialmente vacía
for i in range(n)
[Link](1)
print(A) #muestra toda la lista

El ejercicio 2 queda

Inicio
Leer N
Para I<-0 Hasta N-1 con paso 1
Si ( I mod 2 = 0 ) Entonces
A(I) <- 1
Sino
A(I) <- 0
Fin si

Fin para

Fin

Programa en lenguaje Python

#llenar unos pares, ceros impares

n=int(input('Cantidad de elementos de la lista ->'))

A=[] #inicialmente vacía
for i in range(n):
if i%2==0:
[Link](1)
else:
[Link](0)
i=i+1
for i in A:
print('\ndato ',i)
En este ejercicio, se especifica la definición del tamaño del vector en forma dinámica, en
donde el tamaño del arreglo está determinado por un valor que es digitado. Las acciones
siguientes son las que permiten esta dinamicidad.

Recorrido para leer información en un vector.

La información dentro de un vector va a ser llenada desde el teclado. Para poder llenar la
información se utiliza la instrucción de lectura. Ej.

Leer A( 0 )
>20
Esta instrucción permite llenar información en el campo 1 del arreglo A desde el teclado,
entonces al ejecutarse se llena únicamente un valor.

A
20 15
0 1 2 3 4 5 6

Leer A( 4 )

>15

Esto significa que se ha llenado desde el teclado el valor de 20 en el campo de la posición 0

del arreglo A

Para poder llenar toda la información de un vector, se debe establecer un ciclo controlado con
una variable contador que me permita visitar todas las posiciones asi:
La variable contador va a ser la variable I

Leer N // N es la cantidad de datos que va a leer

I 0
Mientras ( I<=N-1 ) hacer // Este ciclo va a repetir las instrucciones N veces
Leer A(I)
II+1
Fin mientras

En Python como no se define desde un comienzo la lista con un tamaño fijo, los espacios se
van generando al tiempo que se va adicionando un elemento con la siguiente instrucción.

[Link](int(input(‘dato ‘,i,’->’)

No se maneja un indice como tal para ingresar una información

Recuerde que append() adiciona cada dato al final, entonces la entrada de datos en una lista
queda:

#llenar datos enteros en la lista ciclo while

N=int(input('Cantidad de datos -> ')

A=[ ] #define una lista A
i=0
while i<N:
[Link](int(input('dato ',i, '->')
i=i+1

Con un ciclo para queda

Leer N
Para I<-0 hasta N-1
Leer A( I )
Fin para

En lenguaje python

#llenar datos enteros en la lista

N=int(input('Cantidad de datos -> ')

A=[ ] #definer una lista A
for i in range(N)
[Link](int(input('dato ',i, '->')))

Por cada iteración de las instrucciones dentro del ciclo, la variable I permite ubicarse en cada
posición del arreglo y se va a llenar la información en el respectivo campo.

Leer A( I ) llena el campo de acuerdo al valor almacenado en I

Con el ciclo se garantiza que el índice I va a tomar valores desde el 0 hasta el 6 (N-1).

Una vez finalizado el ciclo el vector quedará con los datos totalmente lleno.

A
20 5 8 3 9 8 2
0 1 2 3 4 5 6

En Python por cada iteración del ciclo, la variable i va determinando la posición en que
se va a adicionar un dato con append().

Recorrido para mostrar datos de un vector. Para mostrar la información de un vector se

debe visitar campo por campo con un índice y utilizar una instrucción de salida para ese
campo.
El siguiente código me permite mostrar la información del arreglo A controlada cada posición
con la variable I.

I 0
Mientras ( I<=N-1 ) haga
Escribir A( I )
II+1
Fin mientras
En Python mostrar la lista se la puede realizar mostrar de diversas formas utilizando la
función print.

Mostrar elemento por elemento con ciclo

i=0;
while i<=n-1:
print('\nDato ',i, ') = ',A[i])
i=i+1;

Sin ciclo queda

print(A)

print(A) muestra la lista con los elementos dentro de los corchetes

Con un ciclo para queda

Para I=0 hasta N-1 con paso 1

Escribir A( I )
Fin para

Lenguaje Python

for i in range(N):
print('\nDato ',i, ' ->',A[i])

Recorridos dentro de un ejercicio de aplicación.

Para los ejercicios de aplicación con arreglos se deben manejar conceptos claves y ejercicios
básicos. Los siguientes conceptos se deben manejar muy bien para trabajar con arreglos.

Recorrido de un vector
Sacar el mayor y el menor de un vector
Buscar un valor y su posición en un vector
Intercambiar datos de un vector
Ordenar un vector
Buscar un dato en un vector ordenado
Generar un vector a partir de otro
Insertar un dato en un vector ordenado
Eliminar un dato de un vector

Los mismos conceptos se los aplica a las listas

Entendiendo estos ejercicios básicos se pueden realizar muchos de los ejercicios de

aplicación.

Nota Importante: Cada ejercicio de aplicación tiene como elemento clave, manejar muy bien
los índices de los vectores o listas, recuerde que dependiendo del ejercicio se pueden
manejar varios índices sobre un mismo vector o una misma lista.
Ejercicio 1
Llenar un conjunto de datos numéricos en un vector y obtener la suma de los numéros.

0 1 2 3 4 5 6

El anterior vector está vacío y se está determinando que tiene en la cantidad de elementos 7.
Si se quiere llegar al vector lleno como el siguiente se debe realizar lo siguiente:

Leer cantidad de datos

Recorrer el vector y por cada campo ubicado leer información.

Los paso para llenar la información sería:

Leer N // Cantidad de datos

Para I<-0 hasta N-1 con paso 1
Leer A(I)
Fin para

Con estas acciones se tiene el siguiente vector:

A
20 5 8 3 9 8 2
0 1 2 3 4 5 6

Ahora con la información en la memoria se va a realizer la suma, para lo cual se tiene que la
suma con un dato a la vez va a tener las siguientes variaciones

sum
20 25 33 36 45 53 55

Con la siguiente asignación

sum<-0 antes de recorrer los datos
sum<- sum+A(I)

Suma = 20+5+ 8 + 3 + 9 + 8 + 2 = 55

Pasos genéricos

Definir variables
Leer vector
Recorrer vector para sumar cada dato
Mostrar sum

Algoritmo promedioVector

Definir A, I, N,SUM Como Entero

Leer N
Dimension A(N)
 Para I<-0 hasta N-1
Leer A( I )
Fin para
I<- 0
SUM<-0
Mientras ( I<=N-1 )
SUM<-SUM+A(I)
I <- I + 1
Fin mientras
Escribir SUM

FinAlgoritmo

Programa en lenguaje Python

n=int(input('Cantidad de elementos de la lista '))

a=[]
for i in range(n):
[Link](f'Valor [ {i} ] = ' )
sum=0
for i in range(n):
sum=sum+a[i];

print('Suma = ',sum)

Ejercicio 1
Llenar un conjunto de datos numéricos en un vector y obtener el promedio de los números
pares del vector.

Cantidad de datos para el vector 7

Datos 20 5 8 3 9 8 2

Resultado

Promedio pares (20+8+8+2)/4 = 38 / 4 = 9,5

El análisis que se va a realizar para este ejercicio es el mismo que se tiene para todos los
ejercicios anteriores, con el concepto adicional de que ahora los datos van a estar en un
arreglo, por lo que se tiene lo siguiente:

Esto sería una vez se ha leído la información en el vector A

Cantidad de datos 7
A
20 5 8 3 9 8 2
0 1 2 3 4 5 6

Una vez con los datos en la memoria se va a recorrer el vector A para hallar la información
esperada:
Regla de un dato a la vez.
Cantidad de datos 7

A
20 5 8 3 9 8 2
0 1 2 3 4 5 6

A[0]
20 es par? 5es par? 8 es par? 3 es par? 9 es par? 8 es par? 2 es par?
Si No Si no No Si Si
20 28 36 38
1 2 3 4

Promedio = 38/4 = 9,5

Teniendo el modelo de un dato a la vez se tiene lo siguiente:

SUMP CONP PROMP

38 / 4 = 9,5

Pasos genéricos

Definir variables
Leer vector
Recorrer vector y por cada dato
Determinar si el dato es par
Si es par sumarlo y contarlo
Hallar promedio con la suma y el contador y mostrarlo

Controlando la división por cero queda

Algoritmo PromedioParesVector
Definir A,I,N,SUMP,CONP como entero
Definir PROMP Como Real

Escribir "Cantidad de datos del vector "

leer N
Dimension A(N)

// Leer vector

Para I<-0 hasta N-1

Leer A(I)
Fin para
// Recorre el vector para determinar si es par
// Si es par sumarlo y contarlo
I<- 0
SUMP<-0
CONP<-0
 Mientras ( I <= N-1 ) Hacer
Si ( A(I) mod 2 = 0) Entonces
SUMP<-SUMP+A(I)
CONP <- CONP+1
Fin si
I<-I+1
Fin mientras
Si (CONP>0) Entonces// Hallar el promedio con el sumador y contador
PROMP <- SUMP/CONP
Escribir " Promedio pares = ",PROMP
Sino
Escribir " No hay números pares "
Fin si

FinAlgoritmo

Programa en lenguaje Python

n=int(input('Cantidad de elementos del vector '))

a=[]
for i in range(n):
[Link](int(input(f'Valor [ {i} ] = ' )
sump=0
conp=0
for i in range(n):
if a[i]%2==0:
sump=sump+a[i]
conp=conp+1
if conp>0:
promp=sump/conp
print('Promedio pares = ',promp)
else
print('No hay pares en el vector')

Ejercicio
Llenar un conjunto de datos numéricos en un arreglo unidimensional o vector y obtener el
mayor y el menor de ese vector

Primer modelo mental

Cantidad de datos 7

Datos 3 5 8 1 9 8 2

Mayor 9
Menor 1

Leer Vector
Cantidad de datos 7

A
3 5 8 1 9 8 2

0 1 2 3 4 5 6

Mayor 9
Menor 1

El modelo anterior es el resultado de mirar todos los datos, y como son pocos se puede llegar
a la conclusión establecida.

Segundo modelo mental.

Criterio: Un dato a la vez, es decir solo se tiene posibilidad de mirar un dato del vector y
generalmente va desde el primero hasta el último

A
3 5 8 1 9 8 2
****
0 1 2 3 4 5 6
Mayor
3
Menor
3

Primer elemento del vector. Con el primer elemento del vector que es 3, mentalmente se
establece que el 3 es el mayor y el menor. Con esto se obtiene un elemento que puede ser
comparado con los demás elementos del vector.

Para el segundo y demás elementos del vector se tiene:

Cantidad de elementos
7
A
3 5 8 1 9 8 2

0 1 2 3 4 5 6
Mayor 5>3? 8>5? 1>8? 9>8? 8>9? 2>9?
3 Si Si No Si No No
Menor Mayor Mayor 1<3? Mayor 8<1? 2<1?
3 5 8 Si 9 no no
Menor
1

Mayor 9
Menor 1

Pasos genéricos

Definir variables
Leer Vector A
Asignar mayor y menor con el valor de la posición 0 del vector
Recorrer vector A desde la posición 1 y por cada elemento del vector realizar
Comparar cada dato con mayor y menor y realizar los respectivos cambios
Mostrar mayor y menor

Algoritmo resultante
Con inicio desde 0

Algoritmo mayorMenorVector
// Leer Vector
Definir A,I,CN,Mayor,Menor como entero

Escribir "Cantidad de datos del vector "

leer CN
Dimension A(CN)

Para I<- 0 hasta CN-1

Leer A(I)
Fin Para
// Asignar mayor y menor con el valor de la primera posición del vector
Mayor<-A(0)
Menor<-A(0)
I<-1
// Recorre vector desde la posición 2 y evalúa cada dato con el mayor y el menor
Mientras I<=CN-1 hacer
Si A(I)>Mayor
Entonces
Mayor<-A(I)
Fin si
Si A(I)<Menor
Entonces
Menor<-A(I)
Fin si

I<-I+1
Fin mientras
// Muestra el resultado de la evaluación
Escribir "Mayor =",Mayor
Escribir "Menor =",Menor

FinAlgoritmo

Programa en lenguaje Python

#mayor y menor de una lista con datos numéricos

n=int(input('Cantidad de elementos del vector '))

a=[]
for i in range(n):
[Link](int(input(f'Valor [ {i} ] = ' )
mayor=a[0]
menor=a[0]
for i in range(1,n):
if a[i]>mayor:
mayor=a[i]
else:
if a[i]<menor:
menor=a[i]
print('Mayor = ',mayor)
print('\nMenor = ',menor)

Este programa en Python se puede mejorar, haciendo uso de funciones que actúan sobre listas
que manejan datos numéricos como elementos.

Las funciones son: min() para obtener el valor mínimo, max() para obtener el valor máximo y
sum para obtener la suma de los valores de la lista. Con estas funciones el programa queda:

Programa en lenguaje Python

#mayor y menor de una lista con datos numéricos

n=int(input('Cantidad de elementos del vector '))

a=[]
for i in range(n):
[Link](int(input(f'Valor [ {i} ] = ' )
mayor= max(a)
menor=min(a)
print('Mayor = ',mayor)
print('\nMenor = ',menor)

Ejercicio básico 2

Buscar un elemento en un vector y su posición y terminar a penas lo encuentre.

Primer modelo mental

Llenar un vector con datos numéricos y buscar un dato dado en él.

Esquema anterior

cd
7

Buscar el dato 9

3 5 8 1 9 8 2

Dato 9 si esta y esta en la posición 5

Con vectores

3 5 8 1 9 8 2
*****
0 1 2 3 4 5 6

dato
Dato a buscar 9

Resultado

Dato 9 está en la posición 4

Dato a buscar 10

Resultado dato 10 no está arreglo

Segundo modelo
Este modelo aparece cuando se aplica el criterio de un dato a la vez

Si el dato a buscar es 9 lo que hace después de tener los datos en el vector es lo siguiente:

Dato
9

3 5 8 1 9 8 2

1 2 3 4 5 6 7
9=3? 9=5? 9=8? 9=1? 9=9?
No No No No Si
Siguiente Siguiente Siguiente Siguiente Lo
dato dato dato dato encontró

Posición
5

Se va a trabajar con una bandera denominada encontró que inicialmente, antes del ciclo va a
tomar el valor de 0 y cuando haya un valor igual tomará el valor de 1, al final del ciclo se
evalúa la bandera para determinar si se encontró o no, si la bandera es 0 no se encontró el dato
y si es 1 si está.

La búsqueda se realiza con un ciclo con los siguientes elementos

Variable de control del ciclo I

Condición compuesta del ciclo: En este caso se va a trabajar la condición con 2 elementos

(I<=CD-1 & Encontro=0)

(i<cd-1 && encontro==0)

Como se entiende está condición, Si el dato se encuentra dentro del vector la bandera
Encontro cambiará al valor de 1 y por tanto la condición Encontro=0 se va a volver falsa y
toda la condición del ciclo se vuelve falsa y por tanto terminará el ciclo, pero si no está
Encontró nunca va a cambiar, entonces la que se vuelve falsa es la condición I<=CD-1, lo que
indica que los datos del vector se acabaron.

La condición compuesta obliga a evaluar cual condición simple se vuelve falsa, si Bandera=0
o I<=CD -1 después del ciclo. Generalmente cuando se trabaja con bandera se evalúa la
condición con bandera es decir.

Si Encontro=0

Con estas aclaraciones se determinan los pasos genéricos

Pasos genéricos

Definir variables
Leer Vector
Leer dato a buscar en el vector
Inicializar bandera encontró en 0
Recorrer el vector A y por cada dato
Comparar cada dato con el dato buscado
Si es igual cambiar bandera encontró a 1 y guardar posición
Evaluar bandera y Mostrar resultado de la búsqueda

Algoritmo

Inicio
// Leer Vector
Leer CD
Para I<-0 hasta CD-1 con paso 1
Leer A(I)
Fin Para

// Leer dato a buscar

Leer dato

// Asignar 0 a la variable encontro

Encontro<-0

I<-0
// Recorre vector desde la posición 1 y evalúa cada dato con el dato a buscar
Mientras ( I<=CD-1 & Encontro=0 ) haga
Si (A(I)=Dato)
Entonces
Encontro<-1
Pos<-I
Sino
I<-I+1
Fin si
Fin mientras
// Muestra el resultado después de evaluar la bandera Encontró
Si Encontro=1
Entonces
Escribir “Dato “,dato, “Está en la posición “,Pos
Sino
Escribir “Dato “,dato, “no esta en el arreglo”
Fin si
Fin

El siguiente ejercicio utiliza mensajes para la entrada de datos

Programa en lenguaje Python

#buscar un dato en un lista y su posición

cd=int(input('Cantidad de elementos del vector ')

a=[]
for i in range(n):
[Link](int(input(f'Valor [ {i} ] = ' )
dato=int(input('digitar dato a buscar ->')

b=0
i=1
while i<cd and b==0:
if a[i]==dato:
b=1;
pos=i
else
i=i+1
if b==0:
print('Dato ',dato, 'Está en la posición ',Pos)
else
print('Dato ',dato, 'No se encuentra en la lista')

Ejercicio

Leer una serie de N datos numéricos en un vector y encontrar el promedio de los números
múltiplos de 5 y el promedio de los múltiplos de 3.

cd
7 leer

A
3 5 8 10 9 8 30

0 1 2 3 4 5 6
I I=I+1 I I I I I

3mul5? 5mul5? 8mul5? 10mul5? 9mul5? 8mul5 A[i]mul5?

No Si No Si No ? Si
5 15 No 45=15+30
 1 2 3
30mul3
A[0] A[1] 8 mul3? 10mul3? 9mul3? 8mul3 Si
3mul3? 5mul3? No No Si ?
Si No no 42
3 12 3
1 2

Sm5 cm5 prm5

(5+10+30)/3= 45/3 = 15 sm5=sm5+A[I] cm5=cm5+1
Sm3 cm3 prm3
(3+9+30)/3= 42/3 = 14 sm3=sm3+A[I] cm3=cm3+1

Promedio de multiplo de 5 = 15
Promedio de multiplo de 3 = 14

Pasos genéricos

Definir variables
Leer datos del vector
Recorrer vector y por cada dato hacer
Preguntar si es multiplo de 5
Si es multiplo de 5 sumarlo y contarlo
Preguntar si es multiplo de 3
Si es multiplo de 3 sumarlo y contarlo
Calcular y mostrar promedio de multiplo 5
Calcular y mostra promedio de multiplo de 3

Programa en lenguaje Python

cd=int(input(‘Cantidad de elementos del vector ‘))

a=[]
for i in range(cd):
[Link](int(input(f'Valor [ {i} ] = ' )
sum3=0
sum5=0
con3=0
con5=0
#recorrer el vector
for i in range(cd):
if a[i] % 5==0:
sum5=sum5+v[i]
con5=con5+1

if a[i] % 3==0:
sum3=sum3+v[i]
con3=con3+1
if cm5>0:
prm5=(float)sum5/com5;
 print('\npromedio múltiplos de 5 = ',prm5)
else:
print('\nno hay múltiplos de 5 ')

if cm3>0:
prm3=(float)sum3/con5;
print('\npromedio múltiplos de 3 = ',prm3)

else:
print('\nno hay múltiplos de 3 ')

Ejercicio 2

Leer una serie de N datos numéricos en un vector e intercambiar el elemento de la posición

0 con el menor del vector. En otras palabras dejar el dato menor del vector en la posición 0

Para esto se debe tener en cuenta que se va a buscar el dato menor y la posición que ocupa
para intercambiarlo con el dato que esta en la posición 0

Si se tiene el siguiente vector después de leer, se tiene que el dato menor es el 1 que está en la
posición 3 y se lo va a intercambiar por el dato que está en la posición 0

7
Leer vector
A
20 5 8 1 9 8 2
******
0 1 2 3 4 5 6
I I
8<5 1<menor
no
Pos 3
Menor
1
Menor I
1
Aux <- A(0)
A(0) <- A(3)
A(3) <-Aux

El vector resultante entonces queda

A
1 5 8 20 9 8 2

0 1 2 3 4 5 6
Menor
pos
Para intercambiar los datos se debe tener presente que no se puede hacer este intercambio
directamente, sino que se debe utilizar un auxiliar de la siguiente forma:

AuxA(0)
A(0)  A(pos)
A(pos)  Aux

Aux=A[0]
A[0] = A[pos]
A[pos] = Aux

Donde pos es la posición donde quedo el dato menor

El ejercicio genérico queda:

Definir variables
Leer Vector A
Determinar el dato menor del vector A y su posición (menor, pos)
Intercambiar el dato de la posición 0 del vector con el dato de la posición del menor (pos)
Mostrar vector A

Algoritmo menorVectorPrimeraPos
Definir A,N,I,Menor,Pos,Aux como entero

Dimension A(20)

// Leer vector A
Leer N
I <- 0
Mientras (I <= N-1) hacer // Ciclo para leer datos en el vector A
Leer A(I)
I <- I +1
Fin mientras

// Encontrar el menor y su posición

Menor <- A(0)

Pos <- 0
I<-1
Mientras ( I <= N-1 ) hacer // Ciclo para buscar el menor de los datos
Si A(I) < Menor
Entonces
Menor  A(I)
Pos <- I
Fin si
I <- I + 1 // se ubica en la siguiente posición del vector
Fin mientras

// Intercambiar posición 0 con el dato de la posición del menor

Aux<-A(0)
 A(0) <- A(pos)
A(pos) <- Aux

// Mostrar vector
I <- 0
Mientras (I <= N-1) haga // Ciclo para escribir datos del vector A
Escribir A(I)
I <- I +1
Fin mientras
FinAlgoritmo

Programa en lenguaje Python

cd=int(input('Cantidad de elementos del vector ')

# leer lista
for i in range(cd):
[Link](int(input(‘Digitar valor ( ',i, ' ) = ')
cin>>a[i];
menor=a[0]
pos=0
i=1
while i<=cd-1:
if a[i]<menor:
menor=a[i]
pos=i
i=i+1
aux=a[0]
a[0]=a[pos]
a[pos]=aux
i=0
while i<=cd-1:
print(‘Dato ( ',i, ' ) = ',a[i])
i=i+1

Con el ejercicio anterior lo que se hace es ordenar ascendentemente el primer dato, hallando
el menor de los datos del vector e intercambiando con el de la posición 0. El siguiente
ejercicio va a realizar varias veces lo anterior disminuyendo el tamaño del vector en un
posición, para dejar totalmente ordenado el vector.

Ejercicio

Leer un serie de N datos numéricos en un vector e intercambiar el elemento de la posición 0

con el menor del vector, el elemento de la posición 1 con el menor de los restantes, el de la
posición 2 con el menor de los restantes, y así sucesivamente hasta el penúltimo dato del
vector con el último. Esto lo que determina es que el vector queda ordenado
ascendentemente.

El ejercicio anterior ordena solamente un dato, y va a servir para ordenarlos todos, lo que se
va a ser es volver dinámica la posición a ordenar que es 0, con una variable J que va a ir
desde la posición 0 hasta la cantidad de datos menos dos (N-2), o sea hasta el penúltimo, lo
cual determina otro ciclo, dejando el ciclo controlado por la I como un ciclo interno,
encargado de buscar el menor de los datos que faltan.
Estos dos ciclos tienen la siguiente connotación:

El ciclo controlado por el contador J se va a ubicar en la posición que se va a intercambiar

una vez se tenga el menor y su posición

El ciclo contralado por la I que va a iniciar desde el elemento siguiente a J es decir:

IJ+1

y va a ir hasta N, es el que va a buscar el menor de los datos restantes del vector y su posición,
para intercambiarse con el dato de la posición J .

El modelo mental se lo vería de la siguiente forma:

Para ordenar el primer elemento se tiene: se busca en el ciclo controlados por el índice I

A
20 5 8 1 9 8 2

0 1 2 3 4 5 6
pos

J I I I I I I
Menor Menor
20 1
Pos Pos
0 3

0 1 2 3 4 5 6

Con J se controla la posición a ordenar que inicialmente es 0

Con I se busca el menor en los datos restantes
Una vez obtenido el menor que es 1 y está en la posición 3, se hace el intercambio de los dos
elementos asi:

AuxA(J)
A(J)  A(pos)
A(pos)  Aux

Quedando la posición J es decir la 1 ordenada

Para la segunda posición se incrementa J a 1 y se obtendría lo siguiente:

A
1 5 8 20 9 8 2

0 1 2 3 4 5 6

J I I I I I
Menor Menor
 5 2
Pos Pos
1 6

0 1 2 3 4 5 6

Para ordenar el segundo dato ya no se tiene en cuenta el primero ya que la J se incrementa y

se ubica en el segundo dato y la I comienza en la posición J+1.

Siempre para buscar el menor se inicia menor con el dato que está en J y su posición en J,
para tener un valor con quién comparar.

Según esto el menor de los restantes es 2 y queda en la posición 6, por los que el intercambio
se hace entre estas dos posiciones representadas por J y Pos, y queda así:

A
1 2 8 20 9 8 5

0 1 2 3 4 5 6
J I I I I
Menor Menor
8 5
Pos Pos
2 6

0 1 2 3 4 5 6

Se incrementa la J, ahora es 2 lo cual indica que se va a ordenar la posición 2 y quedaría

A
1 2 8 20 9 8 5

0 1 2 3 4 5 6
J I I I I
Menor Menor
8 5
Pos Pos
2 6

Menor 5 y Pos 6, con lo cual se hace el intercambio.

Al hacer el intercambio queda:

A
1 2 5 20 9 8 8

0 1 2 3 4 5 6

J I I I
 Menor Menor Menor
20 9 8
Pos Pos Pos
3 4 5

Con los siguientes datos se realiza lo mismo y se obtiene.

A
1 2 5 8 9 20 8

0 1 2 3 4 5 6

J I I
Menor Menor
9 8
Pos Pos
4 6

A
1 2 5 8 8 20 9

0 1 2 3 4 5 6

J I
Menor Menor
20 9
Pos Pos
5 6

Al incrementarse la J queda lista para ordenar el elemento 4, de la misma forma que se hizo lo
anterior, y así con las demás hasta que J llega al valor de 5 (N-2) el cual tiene que compararse
con el último que es 6 y a su vez es I (IJ+1) es decir N-1. El vector por lo tanto queda así:
A
1 2 5 8 8 9 20

0 1 2 3 4 5 6

De acuerdo con lo anterior se puede especificar lo siguiente:

Que el ordenamiento de un vector de esta forma necesita dos índices y por lo tanto para este
caso dos ciclos
- Indice J para ubicar la posición del elemento que se va a ordenar
- Indice I para buscar el elemento menor de los elementos restantes del vector y su
posición (pos) para poder intercambiar con el elemento a ordenar.
El ciclo controlado por J va a ser externo, y el índice controlado por I va a ser interno, eso
significa que el ciclo de I va a terminarse primero.
El límite del ciclo externo controlado por J va hasta N-2 y el interno controlado por I va hasta
N-1
El ciclo interno inicia con I<-J+1.

Pasos genérios

Definir variables
Leer vector A
Recorrer vector A con índice J y por cada elemento realizar
Buscar el menor con el índice I de los datos que faltan(I=j+1) y su posición en Pos
Intercambiar el dato de la posición J con el dato menor ubicado en la posición pos
encontrada
Mostrar vector A

Algoritmo ordenarVector
Definir A,N,I,J,Menor,Pos,Aux como entero

// Definir variables
// Las siguientes instrucciones leen los datos en el vector A
Leer (N)
I0
Mientras (I <= N-1) haga // Ciclo para leer datos en el vector A
Leer ( A(I) )
I  I +1
Fin mientras
J 0
Mientras J<=N-2 hacer // Recorrer el vector A con el Indice J
// inicia con el menor del vector que falta y la posición en J
Menor  A(J)
Pos  J
IJ+1 // I va a comenzar con el valor siguiente de J
Mientras ( I <= N-1 ) hacer // Ciclo para determinar el menor de los restantes del
//vector
Si A(I) < Menor
Entonces
Menor  A(I)
Pos  I
Fin si
II+1
Fin mientras
// finalizado este ciclo se obtiene el menor y su posición (Pos), se lo va a intercambia
// con elemento en la posición J
AuxA(J)
A(J)  A(pos)
A(pos)  Aux
JJ+1 // Se ubica en el siguiente elemento a ordenar
Fin mientras
Mientras (I <= N-1) haga // Ciclo para escribir datos en el vector A
 Escribir A(I)
I  I +1
Fin mientras
Fin

Con rojo se especifica el control del ciclo J y con azul que es interno las acciones que se
realizan con el ciclo controlado por I

#ordenar una lista

cd=int(input('Cantidad de elementos del vector ')

# leer lista
a=[]
for i in range(cd):
[Link](int(input('Digitar valor ( ',i, ' ) = ')
cin>>a[i];
for j in range(cd-2):
menor=a[0]
pos=0
i=j+1
while i<=cd-1:
if a[i]<menor:
menor=a[i]
pos=i
i=i+1
aux=a[j]
a[j]=a[pos]
a[pos]=aux
i=0
while i<=cd-1:
print(‘Dato ( ',i, ' ) = ',a[i])
i=i+1

Python ofrece funciones que permiten ordenar directamente una lista y mostrar la información
sin necesidad de un ciclo

cd=int(input('Cantidad de elementos del vector ')

// leer lista
a=[]
for i in range(cd):
[Link](int(input(‘Digitar valor ( ',i, ' ) = ')
cin>>a[i];
[Link]()
print(a)

Ejercicio

El siguiente ejercicio va a mostrar otro método de ordenamiento de un vector.

Ejercicio
Ordenar un vector ubicando el elemento menor en la posición a ordenar, intercambiando el
valor de este, con cada elemento que sea menor en el vector a medida que se lo vaya
recorriendo.

Es decir:

A
1 2 5 20 9 8 8

0 1 2 3 4 4 6
j i i i i

con el manejo de los intercambios entonces, el algoritmo va a manejar para el ordenamiento

dos ciclos:

- Ciclo controlado por J para ubicarse en el elemento a ordenar

- Ciclo controlado por I para recorrer los elementos después de J e intercambiar cada
vez que un elemento sea menor

Pasos genéricos

Leer vector A
Recorrer vector A con J hasta el penúltimo y por cada dato en la posición realizar
Compararlo con los elementos restantes controlados por I
Si el elemento en la posición I es menor
Intercambiarlos
Mostrar vector A

El algoritmo queda

Inicio
Leer (N)
I <- 0
Mientras (I <= N-1) haga // Ciclo para leer datos en el vector A
Leer ( A(I) )
I <- I +1
Fin mientras
J<-0
Mientras J<= N-2 hacer

I<-J+1 // comienza en el siguiente de J

Mientras ( I <= N-1 ) haga // Ciclo para buscar el menor de los datos
Si A(I) < A(J)
Entonces
Aux <- A(J)
A(J) <- A(I)
 A(I) <- Aux
Fin si
I <- I + 1 // se ubica en la siguiente posición del vector
Fin mientras
J<-J+1
Fin mientras

I0
Mientras (I <= N-1) haga // Ciclo para escribir datos del vector A
Escribir ( A(I) )
I  I +1
Fin mientras
Fin

Programa en Python

#ordenar una lista

cd=int(input('Cantidad de elementos del vector ')

// leer lista
a=[]
for i in range(cd):
[Link](int(input('Digitar valor ( ',i, ' ) = ')
cin>>a[i];
while j<=cd-2:
i=j+1
while i<=cd-1:
if a[j]<a[i]:
aux=a[j]
a[j]=a[i]
a[i]=aux
i=i+1
j=j+1

while i<=cd-1:
print(‘Dato ( ',i, ' ) = ',a[i])
i=i+1

Ejercicio

Buscar un dato en un vector

Este ejercicio ya se analizó anteriormente, pero se lo hizo con una condición compuesta
controlando el ciclo mientras, para que apenas se lo encuentre finalice el ciclo, esta versión
recorre todo el vector y se queda con la posición del último que encuentra

Modelo mental

A
5 8 5 5 7 2 7
 1 2 3 4 5 6 7

Dato a buscar

Respuesta el dato 7 se encuentra en el vector en la posición 5, pero también está en la posición

7, este ejercicio se queda con el de la posición 7.

Siguiendo las reglas de construcción de un algoritmo se establece que después de leer el

vector a y el Dato a buscar en el vector se hace lo siguiente:

Cada dato del vector se lo compara con el dato a buscar

5=7? No
8=7? No
5=7? No
5=7? No
7=7? Si, en este momento se establece que el dato si se encuentra en el vector y se lo va
a realizar a través de la bandera encontró la cual se va a cambiar a uno.
Y la posición donde está es la 5
El modelo sigue preguntando
2=7? No

7=7? Si, nuevamente ratifica la variable encontró y la posición queda en 7.

Con elementos computacionales quedaría así

Si A(i) == Dato
Entonces
Encontro 1
Pos  i
Fin si

Esta situación está mejorada en el ejercicio anterior se puede mejorar pero no en este
algoritmo.

Pasos genéricos
definir variables
leer vector a
leer dato a buscar
hacer bandera encontro en 0
Recorrer el vector a y por cada dato
preguntar si es igual al dato a buscar
Si es igual
hacer la bandera encontró en 1 y guardar posición
Si la bandera encontró es igual a 1
Si es uno, dato si está en el vector y en la posición encontrada
Si no es uno, dato no está en el vector

Algoritmo buscarDatoVector
 // definicio de variables

definir n,a,b como entero

leer na
Dimension a(na)
definir i,x,encontro,dato,pos como entero

// Leer vector a
i<-0
mientras i<= na-1 hacer
leer a(i)
i<-i+1
FinMientras

// Leer dato a buscar

leer dato

x<-0 // se ubica al comienzo del vector a

encontro <- 0 // inicia la bandera

Mientras (x<= na-1 y encontro==0) Hacer

si (a(x) == dato)
Entonces
// El dato se encuentra en el vector

pos <- x
encontro <-1
fin si
x<-x+1
FinMientras
// va a mostrar el resultado evaluando la bandera encontro
Si encontro ==1
Entonces
Escribir "Dato ",dato," si se encuentra en el vector en la posición ",pos
SiNo
Escribir "Dato ",dato," no se encuentra en el vector "
FinSi

FinAlgoritmo

Programa en lenguaje Python

n=int(input('Cantidad de elementos del vector ')

a=[]
// leer lista
for i in range(n):
[Link](int(input('Digitar valor ( ',i, ' ) = ')

dato=int(input('Dato a buscar '))

b=0;
i=0;
while i<=n-1 and b==0:
if a[i]==dato:
b=1;
pos=i;
else:
i=i+1;

if b==1:
print('dato ',dato, 'se encuentra en la posición ',pos)
else:
print('dato ',dato, 'no se encuentra en la lista ')

Python ofrece instrucciones que permiten aplicar directamente la búsqueda

#segunda solución

n=int(input('Cantidad de elementos de la lista '))

a=[]
# leer lista
for i in range(n):
[Link](int(input(f' Digitar valor ( {i} ) = ')))

dato=int(input('Dato a buscar '))

b=dato in a
if b==True:
pos=[Link](dato)
if b==True:
print('dato ',dato, ' se encuentra en la posición ',pos)
else:
print('dato ',dato, 'no se encuentra en la lista ')

Ejercicio
Se tiene un arreglo con n datos numéricos donde hay varios datos que se repiten, formar un
nuevo vector a partir de este, sin datos repetidos

Modelo mental
Recuerde que el modelo mental es el primer paso para alcanzar la solución ya que, si no es
capaz de modelar en la mente lo que va a realizar, menos lo va a poder programar

Entonces

Se tiene un vector con datos repetidos

na
7

A
5 8 5 5 7 2 7
0 1 2 3 4 5 6
I I I I I I I

El vector resultante es el siguiente:

nb
3
B
5 8 7 2

Este es el primer modelo mental que se debe plantear.

El segundo modelo mental es la especificación de cada uno de los pasos que se realizan para
llegar al segundo vector.

El vector B es el resultado del vector A, donde solo llega un dato de los diferentes del vector
A

Para controlar esto, cada dato del vector A se lo va a buscar en el vector B, utilizando el
algoritmo que se miró en el ejercicio pasado, sin tener en cuenta la posición, simplemente si
está o no en el arreglo B.

Si el dato el dato de A está en B, significa que no se debe llenar, ya que quedaría repetido, y si
no está significa que es la primera vez que aparece y debe llenarse en B.

Cantidad de datos del vector a es 7

na
7

y numero de datos de B va a empesar en 0

nb
0

A
5 8 5 5 7 2 7

0 1 2 3 4 5 6
I I I
5 esta en 8 está en
B? B?
No No
Llenar Llenar 8 en
dato en B B

Toma el primer dato de A

dato 5 esta en el vector B?.

Para responder esta pregunta se debe buscar el dato 5 en el vector B, el cual por ser el primer
dato a evaluar de A no se va a encontrar, entonces:

Como no se encuentra lo llena y queda el vector B asi:

B
5

0 1 2 3

El siguiente dato del vector A es el 8, se realiza lo mismo

8 está en el vector B?
No, entonces se llena en el vector B

B
5 8

0 1 2 3

El siguiente dato del vector A es el 5, se realiza lo mismo

5 está en el vector B?
Si, entonces no se llena en B porque quedaría repetido.

Así ocurre con los demás datos de A, para obtener finalmente el siguiente vector de B

B
5 8 7 2

0 1 2 3

Lo anterior es un modelo mental de lo que se debe realizar, el cual computacionalmente se va

a tener lo siguiente

Para acceder cada dato del vector A se debe tener un índice contador i y la cantidad de datos
del vector (na), esto me genera las siguientes acciones.

i<-0
Mientras ( i<= na-1 ) Hacer // queda listo para recorrer vector A

Con ciclo para

Para i<- 0 hasta na-1 con paso 1

Para el vector B se debe tener un índice que lo recorra x y la cantidad de datos nb. El ciclo
que lo recorre es:

x <- 0
Mientras (x<=nb-1 ) Hacer
Con ciclo para

Para x<- 0 hasta nb-1 con paso 1

la pregunta

5 está en el vector B?

Significa que se debe buscar el valor 5 que es A(i) en el vector B

Se lo realiza con el siguiente código:

Encontro<-0
x<-0
Mientras (x<=nb-1 & Encontro=0) hacer
Si A(i) = B(x)
Entonces
Encontró<-1
Fin si
x <- x+1
Fin mientras
Si (Encontro=0)

Este código busca un dato de A representado por A(i) y utiliza una bandera para determinar si
esta o no está

La variable Encontro es la que indica si está o no (1 si está y 0 no está) y se evalúa así

Si Encontro = 0
Entonces
Se debe llenar el dato en B

Para poder llenar un dato en B se debe tener un índice que indique donde se va a llenar, de lo
contrario no se llenaría ningún dato.

Para este ejercicio se va a utilizar la variable nb que es la que indica la cantidad de valores
que va llenando en B, cada vez que se llena un dato en B esta variable se incrementa en 1, e
indica la cantidad de elementos que tiene B

Las siguientes acciones permiten llenar el dato de A en B

B(nb)  A(i)
nbnb+1

nb<-nb+1 indica que hay un nuevo dato en B por lo tanto la cantidad de datos debe
incrementarse, y a su vez se lo utiliza como índice para ingresar datos.

Con estos elementos computacionales que explican un modelo mental, las siguientes acciones
genéricas tienen sentido

Definir variables
 1. Leer Vector A
2. Recorrer vector A y por cada dato de este vector
Buscar dato de A en el vector B
si no está
llenarlo en el vector B
3. Mostrar vector B

Se incluye como paso genérico Definir Variables, esto significa que toda variable que aparece
dentro del algoritmo se la debe definir. En el programa PseInt se utiliza la siguiente
instrucción para hacerlo

El algoritmo resultante es el siguiente:

Algoritmo vectorSinRepetidos
definir na,A,B como entero;
definir i,x,nb,b1,Encontro como entero
Escribir “Cantidad de datos del vector : “
Leer na
Dimension A(na),B(na)

// na cantidad de datos en A
// i para recorrer vector A
// x para recorre vector B
// Encontro bandera para buscar dato del vector A en el vector B
// nb cantidad de datos del vector B

// leer vector A

i<-0
mientras i<= na-1 hacer
leer A(i)
i<-i+1
FinMientras

// recorrer vector A para llenar el vector B sin repetidos.

i<-0 // se ubica al comienzo del vector a

nb<- 0 // hasta este momento no hay datos en el vector b

mientras ( i<= na-1) hacer // Ciclo para recorrer vector a y por cada dato a(i)

Encontro<-0 // bandera para buscar un dato de a en b

x<-0 // va a recorrer vector b que aún no tiene datos

mientras (x<= nb-1 & Encontro = 0) hacer // este ciclo recorre el vector b con
el indice x
// busca a(i) en el vector b comparando asi:
si (A(i) == B(x))
Entonces
Encontro<-1
 fin si
x<-x+1
FinMientras
// En este momento se averigua que paso en el ciclo, si el dato se encuentra la
//bandera b1 va a cambiar a 1 sino esta la bandera va a quedar en 0. La primera
// vez no entra al ciclo porque no hay datos en b, por tanto el b1 queda en 0

Si Encontro=0
Entonces
// Si el dato no está en b entonces se llena de la siguiente forma

B(nb) <- A(i)

nb<-nb+1
FinSi
i<-i+1
FinMientras
// Después de este ciclo en b quedan los datos que ya no están repetidos
// y tiene nb elementos y se los va a mostrar asi:

x<-0
Mientras x<=nb-1 hacer
escribir B(x)
x<-x+1
FinMientras

FinAlgoritmo

Programa en lenguaje Python

#Formar una lista sin repetidos a partir de otro lista

na=int(input('Cantidad de elementos de la lista '))

a=[]
b=[]
# leer lista
for i in range(na):
[Link](int(input(f' Digitar valor ( {i} ) = ')))
i=0
nb=0
while i<na:
#buscar dato a[i] en b
x=0
encontro=0
while x<nb and encontro==0:
if a[i]==b[x]:
encontro=1
x=x+1
if encontro==0:
[Link](a[i])
nb=nb+1
 i=i+1
for i in range(len(b)):
print('Dato (',i, ') =',b[i]

Segunda forma en Python

#Formar vector sin repetidos a partir de otro vector

na=int(input('Cantidad de elementos de la lista '))

a=[]
b=[]
# leer lista
for i in range(na):
[Link](int(input(f' Digitar valor ( {i} ) = ')))
i=0
while i<na:
#buscar dato a[i] en b
encontro=a[i] in b
if encontro==False:
[Link](a[i])
i=i+1
for i in range(len(b)):
print('Dato (',i, ') =',b[i]

Ejercicio

Se tienen dos vectores con datos numéricos y con datos repetidos, formar un tercer vector con
los elementos comunes de estos dos vectores sin repetidos.

Modelo mental, A y B son los arreglos

A
9 5 8 1 5 8 2

0 1 2 3 4 5 6
i

B
10 5 2 1 4 8 2

0 1 2 3 4 5 6
j

Llenar un tercer arreglo con los datos cumunes sin repetidos

C
5 8 1 2

0 1 2 3
X
Pasos genéricos

[Link] variables
[Link] vector A
[Link] vector B
[Link] el vector A y por cada dato
Buscar el dato de A en el vector B
Si el dato se encuentra en el vector B
Buscar el dato en el vector C
Si no se encuentra llenar dato en C
[Link] vector C

Para resolver la union de los datos de dos vectores

El vector U es para la unión de los dos vectore

U
9 5 8 1 2 10 4

0 1 2 3 4 5 6

Esto es lo que se obtiene mirando todos los datos de los arreglos, y es a donde se tiene que
llegar o sea el vector C es el objetivo.

Ahora se establece un segundo modelo mental que es involucrar elementos computacionales

Elementos que se deben identificar,

Cantidad de elementos del vector

Indices de cada vector
Nombres del vector

Después de leer los vectores A y B se tiene

NA
7
A
9 5 8 1 5 8 2

0 1 2 3 4 5 6
I I

I
NB
7
B
10 5 2 1 4 8 2
0 1 2 3 4 5 6

J
NC
0

C
5

0 1 2 3
1 2 3 4
X

Según lo anterior se tiene que I va a recorrer el vector A, J va a recorrer el vector B y X va a

recorrer el vector C

NC es la cantidad de elementos del Vector C y en un comienzo parte con 0 datos.

Como se llena este vector siguiendo el concepto de que solo se puede ver un dato de los
vectores a la vez?

Como solo se puede ver un dato a la vez se tiene:

Primer dato de A (I=0) es 9. Qué pasa con este dato, va o no al vector C?,
La respuesta es no, porque al buscarlo en el vector B no se encuentra.
Y como se lo busca en el vector B si se hace un dato a la vez.
Se compara el dato de A con cada uno de los elementos del vector B, en el caso del 9 no se va
a encontrar
Se toma entonces el segundo dato de A que es 5, el cual si se encuentra en el vector B, por lo
tanto se determina si se llena en C, como el 5 no está en C se llena

C
5

0 1 2 3
X

El siguiente dato de A es 8 (I=3), se lo busca en B desde el comienzo y se encuentra que el 8

esta en B, por lo tanto podría ir a C, para esto se lo debe buscar recorriendo C que hasta el
momento tiene un solo dato que es 5 por lo tanto va.

C
5 8

0 1 2 3
X

De igual forma con el siguiente elemento de A que es 1 (I=4), esta en B y no está en C por lo
tanto se llena
C
5 8 1

0 1 2 3
X

El siguiente elemento de A es 5, el cual si se encuentra en B, pero también está en C, por lo

tanto no se llena.

De igual forma ocurre con el 8, que está en B y también en C, entonces no se llena en C.

El siguiente dato de A es 2 el cual está en B, pero no está en C, por lo tanto se llena.

C
5 8 1 2

0 1 2 3
X

Pasos Generales
Definr variables
1. Leer vector A
2. Leer Vector B
3. Recorrer Vector A y por cada dato del vector realizar
Buscar el dato del vector A en el Vector B
Si el dato se encuentra en B
Buscar el dato del vector A en el vector C
Si el dato no se encuentra
Llenar dato en vector C
4. Mostrar vector C

Nota: Son importantes estos pasos genéricos para la programación y son el resultado del
modelo mental, siguiendo la regla de un dato a la vez.

Algoritmo sin_titulo
// Definir variables

definir NA,NB,A,B como entero;

definir I,X,J,Encontro1,Encontro2,C,NC como entero

escribir "cantidad de datos vector a"

leer NA
Dimension A(NA)
escribir "cantidad de datos vector b"
leer NB
Dimension B(NB),C(NA)
// La dimensión de C es maximo el número de datos de A

// NA cantidad de datos en A
 // I para recorrer vector A
// J para recorrer vector B
// X para recorrer vector C
// Encontro1 bandera para buscar en B
// Encontro2 bandera para buscar en C
// NB cantidad de datos del vector B
// NC cantidad de datos del vector C

// leer vector a

Escribir “ Datos del vector A “

I<-0
mientras I<= NA-1 hacer
leer A(I)
I<-I+1
FinMientras

// leer vector b
Escribir “Datos del Vector B “
J<-0
mientras J<= NB-1 hacer
leer B(J)
J<-J+1
FinMientras

// recorrer vector A para buscar dato en el vector B. A se recorre con I y B con J

// se trabaja con la bandera Encontro1 para saber si el dato de a está en el vector B

I<-0 // se ubica al comienzo del vector A

NC<- 0 // hasta este momento hay cero datos en el vector C

mientras I<= NA-1 hacer // Ciclo para recorrer vector A y por cada dato A(I)
Encontro1<-0 // bandera para buscar un dato de A en B
J<-0 // va a recorrer vector B
mientras (J<= NB-1 & Encontro1=0) hacer // este ciclo recorre el vector b con
el indice J
// busca A(I) en el vector b comparando asi:
Si (A(I) = B(J))
Entonces
// si son iguales significa que son comunes y por lo tanto la
// bandera se coloca en 1
Encontro1<-1
fin si
J<-J+1
FinMientras
// En este momento se averigua que paso en el ciclo, si el dato de A esta en B
// la bandera Encontro1 vale 1 sino está la bandera es igual a 0
Si (Encontro1=1)
Entonces
// Con la variable X se va a recorrer el vector C para buscar el elemento
// A(I)
X<-0
 Encontro2<-0
mientras (X<= NC-1 & Encontro2=0) hacer // Ciclo que recorre el
vector C con X
// busca A(I) en el vector C comparando asi:
Si A(I) == C(X)
Entonces
// si son iguales significa que el dato ya se ha llenado y
// coloca la bandera Encontro2 en 1
Encontro2<-1
fin si
X<-X+1
FinMientras
Si (Encontro2 = 0)
Entonces
// El dato no está en C entonces se llena en el vector C
C(NC)<-A(I)
NC<-NC+1
// NC contiene la cantidad de datos en C
FinSi

FinSi
I<-I+1
FinMientras
// Después de este ciclo en C quedan los datos comunes de A y B sin repetidos
// y tiene NC elementos y se los va a mostrar asi:

X<-0
Mientras X<=NC-1 hacer
escribir C(X)
X<-X+1
FinMientras
// Información a tener en cuenta: todo vector para poder ser recorrido debe tener
// una cantidad de datos, en este caso para el vector c es nc y se debe utilizar un
// índice para recorrerlo en este caso l

FinAlgoritmo

Programa en lenguaje Python

#Formar vector sin repetidos a partir de otro vector

a=[]
b=[]
na=int(input('Cantidad de elementos de la lista uno '))
# leer lista uno
for i in range(na):
[Link](int(input(f' Digitar valor ( {i} ) = ')))
nb=int(input('Cantidad de elementos de la lista dos '))
# leer lista dos
for i in range(nb):
[Link](int(input(f' Digitar valor ( {i} ) = ')))

i=0
nc=0
while i<na:
#buscar dato a[i] en b
j=0
encontro1=0
while j<nb and encontro1==0:
if a[i]==b[j]:
encontro1=1
x=x+1
if encontro1==1:
x=0
encontro2=0
while x<nc and encontro2==0:
if a[i]==c[x]:
encontro2=1
x=x+1
if encontro2==0
[Link](a[i])
nc=nc+1
i=i+1

for i in range(len(c)):
print('Dato (',i, ') =',c[i]

Segunda forma aplicando funciones

#Formar vector sin repetidos a partir de otro vector

a=[]
b=[]
na=int(input('Cantidad de elementos de la lista uno '))
# leer lista uno
for i in range(na):
[Link](int(input(f' Digitar valor ( {i} ) = ')))

nb=int(input('Cantidad de elementos de la lista dos '))

# leer lista dos
for i in range(nb):
[Link](int(input(f' Digitar valor ( {i} ) = ')))

i=0
nc=0
while i<na:
#buscar dato a[i] en b
encontro1=a[i] in b
if encontro1==True:
encontro2=a[i] in c
if encontro2=False:
[Link](a[i])
i=i+1
for i in range(len(c)):
print('Dato (',i, ') =',c[i]

Ejercicio

Leer una serie de datos numéricos en un vector, determinar el promedio de los primos y de los
Fibonacci en el vector.

Leer vector

CD
7
A
9 5 8 7 5 13 2

0 1 2 3 4 5 6
I

SUMP CP PROMP
Promedio primos = (5+7+5+13+2)/ 5 =32/5= 6,4
SUMF CF PROMF
Promedio Fibonacci = (5+8+5+13+2)/ 5 = 33/5 = 6,6

Conceptos
Arreglos – Recorrido
Primo
Fibonacci
Suma
Contador
Promedio

Leer Vector
NDA
Cantidad de datos 7

A
9 5 8 7 5 13 2

0 1 2 3 4 5 6
I I I I
A(I) A(I) A(I) A(I)
9 es 5 es 8 es pri? 7 es
primo? primo? No primo?
no Si Si
5 12
9es fibo? 1 2
No
 5 es fib? 8 es fibo? 7 es fib?
Si Si No
5 13
1 2

Sump / Cp
Promp=32 / 5
Sumf/ Cf
Promf = 33 / 5

Promedio primos = 6,4

Promedio Fibonacci = 6,6

Promedio primos = (5+7+5+13+2)=32/5=6,4

Promedio Fibonacci = (5+8+5+13+2) = 33/5 = 6,6

Conceptos que se deben tener claros. Como se determina si es primo y como se determina si
es Fibonacci

A(I) es primo?

// Determinar si es primo
C<-1
CD <- 0
Mientras ( C<=A(I) ) Hacer
Si ( A(I) mod C = 0) Entonces
CD <- CD+1
Fin si
C <- C+1
Fin mientras
Si ( CD = 2 ) Entonces // A(I) es primo

A(i) es Fibonacci?

P<-0
B<-1
T<-0
Mientras (T<A(I)) hacer
T<-P+B
P<-B
B<-T
Fin mientras
Si (T=A(I) ) Entonces // A(I) es Fibonacci

Pasos genéricos

Definir variables

1. Leer Vector A
 2. Recorrer vector A y por cada dato hacer lo siguiente
Determinar si el dato de A es primo
Si es primo Sumarlo y Contarlo
Determinar si el dato de A es Fibonacci
Si es Fibonacci Sumarlo y Contarlo
3. Calcular promedio primo y mostrarlo
4. Calcular promedio Fibonacci y mostrarlo

Algoritmo PromPriFib
// Definir variables

Definir A, I,NDA, C, CD, P, B, T , SUMP,CP,SUMF,CF como Entero

Definir PROMP, PROMF como Real

Escribir “ CANTIDAD DE DATOS DEL VECTOR “

Leer NDA
Dimension A(NDA)

// Leer Vector A

Para I <- 0 Hasta NDA-1 con paso 1

Leer A(I)
Fin para

// Recorrer Vector A para determinar suma y contadores de primos y Fibonacci

SUMP<-0
CP<-0
SUMF<-0
CF<-0
Para I <- 0 Hasta NDA-1 con paso 1

// Determinar si es primo
C<-1
CD <- 0
Mientras ( C<=A(I) ) Hacer
Si ( A(I) mod C = 0) Entonces
CD <- CD+1
Fin si
C <- C+1
Fin mientras
Si ( CD = 2 ) Entonces // el numero A(I) si es primo
SUMP<- SUMP+A(I)
CP<- CP+1
Fin si
// Determinar Si A(I) es Fibonacci
P<-0
B<-1
T<-0
Mientras ( T < A(I) ) Hacer
T<- P+B
 P<-B
B<-T
Fin mientras
Si ( T= A(I) ) Entonces // el numéro A(I) es Fibonacci
SUMF <- SUMF + A(I)
CF <- CF + 1
Fin si
Fin para

// Mostrar promedio primos

Si ( CP > 0 ) Entonces
PROMP <- SUMP/CP
Escribir “ PROMEDIO DE PRIMOS = “, PROMP
Sino
Escribir “No hay números primos “
Fin si

// Mostrar promedio Fibonacci

Si ( CF > 0 ) Entonces
PROMF <- SUMF/CF
Escribir “ PROMEDIO DE FIBONACCI = “, PROMF
Sino
Escribir “No hay números fibonacci “
Fin si

Fin algoritmo

Programa en lenguaje Python

a=[]
nda=int(input('Cantidad de elementos de la lista '))
# leer lista uno
for i in range(nda):
[Link](int(input(f' Digitar valor ( {i} ) = ')))
sump=0
cp=0
sumf=0
cf=0
for i in range(nda):
c=1
cd=0
while c<=a[i]:
if a[i]%c==0:
cd=cd+1
else:
c=c+1
if cd==2:
sump=sump+a[i]
cp=cp+1
 a=0
b=1
t=0
while t<a[i]:
t=a+b
a=b
b=t
if t==a[i]:
sumf=sumf+a[i]
cf=cf+1
if cp>0:
promp=sump/cp
print('Promedio primos -> ',promp)
else:
print('No hay primos en la lista')

if cf>0:
promf=sumf/cf
print('Promedio fibonacci -> ',promf)
else:
print('No hay fibonacci en la lista')

Ejercicio

Leer una serie de N datos numéricos en un vector, varios de ellos repetidos y determinar las
veces que se repite cada uno de estos.

Este ejercicio se lo va a realizar de dos formas para demostrar que puede haber varias
soluciones para un problema.

El método 1 va a utilizar un vector auxiliar para mantener los datos que ya han sido contados
El método 2 va a utilizar dos vectores uno para guardar los datos que ya han sido contados y
otro para llevar la cuenta

Método 1

Modelo mental

a. Especificamos los datos ejemplo para el ejercicio

4 7 2 5 7 6 4 2 7 5 4 6

b. determinamos a partir de estos datos el resultado que esperamos.

4 está 3 veces
7 está 3 veces
2 está 2 veces
5 está 2 veces
6 está 2 veces

Lo que se ha planteado hasta el momento permite determinar el objetivo que se pretende

alcanzar con la solución y los datos que se necesitan para esto.
De acuerdo al planteamiento del problema este modelo mental es el primer intento de lo que
se pide.

Los modelos mentales deben ir incorporando más características de acuerdo a las del
problema.

Segundo modelo mental asociando el concepto de arreglo

A
4 7 2 5 7 6 4 2 7 5 4 6

0 1 2 3 4 5 6 7 8 9 10 11
I

b. determinamos a partir de estos datos el resultado que esperamos.

4 está 3 veces
7 está 3 veces
2 está 2 veces
5 está 2 veces
6 está 2 veces

Cuando se plantea este modelo su mente debe ir asociando los elementos computacionales
que se relacionan directamente con el concepto de arreglo.

El siguiente modelo mental debe permitir establecer el proceso para llegar al resultado, para lo
cual se debe ajustar el modelo mental inicial a un modelo que se asemeje al funcionamiento
computacional, con el propósito de ir identificando en éste, elementos básicos de
instrucciones computacionales.

El funcionamiento computacional va a realizar operaciones con cada uno de los datos del
arreglo y no con todos a la vez, como aparentemente lo plantea el modelo mental, esto obliga
a tener claridad en lo que se debe realizar en cada tiempo.

Modelo mental por tiempos

4 7 4 5 7 6 2 2 7 5 4 6

0 1 2 3 4 5 6 7 8 9 10 11

4 se cuenta?
si
1 2 3
7 se cuenta?
si
1 2 3
No se cuenta
1 2
no se cuenta
1 2
1 2
No se cuenta
 No se cuenta
No se cuenta
No se cuenta
No se cuenta

El anterior ejercicio mental le permite identificar los elementos que se necesitan evaluar para
cada elemento del arreglo.

De lo anterior se puede apreciar que para el número cuatro se inicia un contador ya que es la
primera vez que se cuenta y se recorre posición por posición preguntando si es igual, en cuyo
caso se incrementa el contador. De igual forma para el número 7, para el 4 no se debe contar
porque ya se lo contó. Entonces cada vez que aparezca un dato que ya se contó, no se lo
cuenta. Solo se cuenta los que aparecen por primera vez

De lo anterior se concluye que se debe controlar si el dato se ha contado o no, lo que implica
un subproceso que permita llevar una historia de los datos que se han contado, con los cuales
se pueda determinar en forma precisa estos puntos.

Esto determina que el modelo mental cambie de la siguiente forma:

4 7 4 5 7 6 2 2 7 5 4 6

0 1 2 3 4 5 6 7 8 9 10 11
I J J J
I

4 ya se A(I)=A(J
conto? A(I)=A(J) A(I)=A(J ) 4=7? 4=6? 4=2? 4=2? 4=7? 4=5? 4=4 4=6
No 4=7? ) 4=5? No No No No No No Si No
No 4=4? No 3
1 Si
2 7=7? 7=6? 7=2? 7=2? 7=7? 7=5? 7=4? 7=6?
7 ya se 7=5? Si No No No Si no no No
contó? 7=4? No
No No
2 3
1

4 ya se
contó? 5=7? 5=6? 5=2? 5=2? 5=7? 5=5? 5=4? 5=6?
Si 5 ya se no no no no no No Si no
conto?
no
2
1

El ejemplo para cuatro datos del vector, determina que por cada dato se realizo:

Dato ya se conto?
Si se indica que No se lo cuenta recorriendo el vector a partir de la posición del dato, y luego
se debe marcar que ya se contó.

En el modelo que se lleva hasta el momento, se tendría que los contados son:

4 7 5

Estos se debe ir manteniendo en la memoria como contados, de tal forma que cada vez que se
tenga otro dato del vector para contar, se los debe comparar con los que ya se contaron, por lo
que deben estar almacenados en un espacio de memoria.
Con los conocimientos que tenemos, los datos que no se han contado se los debe almacenar en
un arreglo, asimilando el ejercicio al que se había realizado anteriormente, cuando se creó el
arreglo con los datos no repetidos.

Este vector se llamará CONTADOS

Entonces hasta el momento se tendría

CONTADOS

4 7 5
0 1 2

Ahora cada que se tome un dato del vector se preguntará si ya se contó, buscándolo en el
vector CONTADOS, si no está se lo debe contar, y luego de esto se debe almacenar el dato
contado en el vector contados, para que no se vuelva a contar.

Lo que se ha hecho con lo anterior es determinar antes de construir la solución todo un

proceso mental de lo que se debe realizar de acuerdo a como el computador lo haría. Aquí se
aplica el concepto de llenar un vector a partir de otro y sirve para controlar si ya se ha contado
un dato del vector A.

Cuando se termine de recorrer todos los datos del vector A, el vector contados va a quedar asi:

CONTADOS
4 7 5 6 2

0 1 2 3 4

Asociar elementos computacionales al modelo

NA
12

A
4 7 4 5 7 6 2 2 7 5 4 6

0 1 2 3 4 5 6 7 8 9 10 11
I j j j J J J J J J

j 1 2
J=I+1

X
0
CONTADOS
4

0 1 2 3 4
X X
Z

La pregunta ¿ya se contó?, del modelo mental, entonces implica realizar una búsqueda en
CONTADOS

Para esto se debe manejar el concepto de como se realiza la búsqueda en un vector

El elemento a buscar en el vector CONTADOS es del vector A en la posición I osea, A(I)
La respuesta a esta búsqueda es está o no está
Si está es porque ya se contó

Computacionalmente la búsqueda del elemento A(I) en el vector CONTADOS que tiene X

elementos, recorrido con el índice Z y manejada con un switche B sería:

B0
Z0
Mientras (Z <= X-1 and B=0) haga
Si ( A(I) = CONTADOS(Z))
Entonces
B 1
Sino
Z Z+ 1
Fin si
Fin mientras
Si (B=0)
Entonces

Computacionalmente contar datos se realiza después de no encontrar el dato en el vector

CONTADOS osea, cuando la bandera B es igual a 0

Entonces, si B=0, Significa que el dato no se encuentra en contado y hay que contarlo
recorriendo el vector A con otro índice diferente a I en este caso J, y se lo realiza después del
dato indicado por I o sea J <- I+1 y el contador iniciaría en 1

J I+1
Con  1
Mientras ( J<= N-1) haga
Si (A(I) = A(J))
Entonces
Con Con + 1
Fin si
J<-J+1
Fin mientras

Con lo anterior se cuenta el dato A(I) y se debe llenado en CONTADOS y mostrar su

resultado así:

CONTADOS(X)  A(I)
X X+ 1
Escribir (‘dato ‘, A(I),” “, Con, ‘ Veces’)

Ahora, si el swicthe B termina en 1 significa que el dato se encuentra en el vector

CONTADOS y no se debe realizar nada porque ya se contó y se avanzaría al siguiente dato
del vector A incrementando el índice I

Los pasos genéricos quedan de la siguiente forma

Definición de variables
1. Leer vector A
 2. Recorrer vector A y por cada dato de este realizar
Determinar si el dato ya se contó //Buscar el dato en el vector CONTADOS
Si el dato no se ha contado //El dato no está en el vector
Realizar la cuenta en el vector A desde la posición en que está
mas 1(j=i+1)
Introducir el elemento del vector A en el vector CONTADOS
Mostrar la cuenta

Con estos pasos genéricos El algoritmo total es entonces:

Algoritmo RepetidosVectorMetodo1
definir A,I,J,CONTADOS,Z,X,B,Con Como Entero

// Definir variables
// Leer vector
Leer N
Dimension A(N)
Dimension CONTADOS(N)

Para I<- 0 hasta N-1

Leer A(I)
Fin para

I<- 0
X<-0
Mientras (I<=N-1) hacer // Recorrer el vector A para contar elementos
// Busca el dato A(I) en el vector contados
B<-0
Z<-0
Mientras (Z <= X-1 & B=0) hacer
Si ( A(I) = CONTADOS(Z) )
Entonces
B<- 1
Sino
Z<- Z+ 1
Fin si
Fin mientras
Si (B=0)
Entonces // El dato A(I) no se ha contado
J<- I+1
Con <- 1
Mientras ( J<= N-1) hacer // Ciclo para contar A(I)
Si (A(I) = A(J))
Entonces
Con<- Con + 1
Fin si

J<-J+1
Fin mientras
CONTADOS(X) <- A(I) // Identifica que A(I) ya se contó
X<- X+ 1
Escribir "dato ", A(I), " ", Con, " Veces"
 Fin si
I<-I+1
Fin mientras

FinAlgoritmo

Programa en Lenguaje programa Pythonb

#Formar vector sin repetidos a partir de otro vector

a=[]
contados=[]
n=int(input('Cantidad de elementos de la lista uno '))
# leer lista uno
for i in range(n):
[Link](int(input(f' Digitar valor ( {i} ) = ')))

x=0
i=0
nc=0
while i<n:
#buscar dato a[i] en contados
b=0
z=0

while z<x and b==0:

if a[i]==contados[z]:
b=1
z=z+1
if b==0:
con=1
j=i+1
while j<n:
if a[i]==a[j]:
con=con+1
j=j+1
[Link](a[i])
x=x+1
print('Dato ',a[i], ' ',con, ' veces')
i=i+1

Ejercicio en Python 2, aplicando la función count() para las listas

#Contar las veces que se repiten los datos de una lista

a=[]
contados=[]
n=int(input('Cantidad de elementos de la lista uno '))
# leer lista uno
for i in range(n):
[Link](int(input(f' Digitar valor ( {i} ) = ')))
for i in range(len(a)):
b=a[i] in contados #determina si a[i] está en la lista contados
if b==False:
con=[Link](a[i])
print('dato ',a[i], 'esta ',con,' veces')
[Link](a[i])

Ejercicio planteado

Con este método determinar cual es el dato que más se repite y las veces que lo hace.

Metodo 2

El ejercicio anterior se puede optimizar en el punto 2 de los pasos genéricos teniendo en

cuenta lo siguiente:

El ejercicio anterior utiliza dos índices para recorrer el vector A I y J

Con el Indice I se tiene el dato que se va a analizar si ya se conto o no.

Con el Indice J se recorre el vector A a partir de la posición I+1 para encontrar elementos
iguales y contarlo

En conclusión por cada dato indicado por I se tiene que recorrer el vector con J a partir de I,
haciendo varios recorridos sobre el vector.

Este proceso se lo puede optimizar, realizando un solo recorrido del vector A de la siguiente
forma:
Aquí se va a utilizar un vector contador, es decir, cada uno de los campos del vector va a
ser un contador
Para este ejercicio se van a tener dos vectores, uno que va a cumplir la misma función del
vector CONTADOS del ejercicio anterior es decir, va a llenar el dato que aparece para ser
contado llamado DNR (Datos No Repetidos)
El segundo vector va a llevar un contador de los datos, que van apareciendo llamado CON.

Vector uno con los datos no repetidos denominado DNR

Vector dos son los datos de la cuenta denominado CON

Con los que se tendría en el modelo mental lo siguiente tres arreglos;

A
4 7 4 5 7 6 2 2 7 5 4 6

0 1 2 3 4 5 6 7 8 9 10 11
I I I I I I I I I I I

Si los datos son los anteriores, los arreglos DNR y CON van a quedar de la siguiente forma:
X
0
DNR
 4 7 5 6 2

0 1 2 3 4

J J j

CON
3 3 2 2 2

0 1 2 3 4
X X X X X
J J

Estos se llenaron de la siguiente forma:

Se tienen dos momentos:
Momento 1
Dato de A no se ha comenzado a contar lo que implica que no está en DNR
El vector DNR se va a llenar cada vez que llega un nuevo valor del vector A y CON se va a
llenar con 1, (cada vez que un nuevo dato llega a DNR, se coloca 1 en CON en la posición
correspondiente), indicando que inicia la cuenta del dato presente en DNR.
Momento 2
Dato de A si está en DNR
Cuando el dato de A ya ha aparecido al menos una vez, este ya se encuentra en DNR,
significa que ya inicio la cuenta en el vector CON, por lo que, este dato se debe contar,
incrementado en 1 el vector CON en la posición correspondiente.

La correspondencia es importante tenerla presente porque la posición del dato en DNR va a

coincidir con la posición de la cuenta del dato en CON, asi que cuando el valor del vector A
se encuentra en DNR la posición donde se encontró es la misma que la posición donde se
encuentra el contador en el vector CON. Y se lo incrementa así:

CON(J)<-CON(J)+1

En esta caso J es la posición donde se encontró el dato en DNR

Los pasos genéricos son los siguientes:

Definir variables
1. Leer Vector A
2. Recorrer el vector A y por cada dato realizar lo siguiente
Buscar el dato de A en el vector DNR
Si no esta
Llenar el dato en el vector DNR
Colocar 1 en el vector CON en la posición correspondiente
SI está
Incrementar el elemento de CON en 1 correspondiente con el
del vector DNR ( en la posición donde se encontró)
3. Mostrar vectores DNR y CON

Algunas iteraciones son

A
4 7 4 5 7 6 2 2 7 5 4 6

0 1 2 3 4 5 6 7 8 9 10 11
I I I I I I I

DNR
4 7 5 6 2

0 1 2 3 4

CON
2 2 1 1 1

0 1 2 3 4

Después de la iteración 7 es decir que I es 6 se tiene lo siguiente:

Hasta el momento 4,7,5,6 y 2 elementos del vector A no se encontraban en el vector DNR

Por lo que se llenan en DNR y se coloca 1 en el vector CON en la posición correspondiente:

Esto se llena con las siguiente instrucciones

DNR (X)  A(I)

CON(X)  1
X X+1

Ahora que pasa con el 4 que es el que quiere entrar

Se busca 4 en el vector DNR y se encuentra en la posición 0 por lo que ya no se llena en

DNR, pero se incrementa el elemento que esta ubicado en CON en la posición
correspondiente (J) al de DNR. Esto se hace con la siguiente instrucción

CON(J)  CON(J) + 1

Donde el índice J permite recorrer el vector DNR para buscar el dato del vector A, como
DNR y CON son correspondientes, y J apunta al contador correspondiente del dato en DNR,
el cual se incrementa en 1, por lo el vector queda con la siguiente información.

CON
2 1

0 1 2 3 4

Cuando se termina de recorrer el vector A se tiene en DNR y CON la siguiente información:

A
4 7 4 5 7 6 2 2 7 5 4 6

0 1 2 3 4 5 6 7 8 9 10 11
I I I I I I I I I I I I

DNR
 4 7 5 6 2

0 1 2 3 4
X X X X X
J

CON
3 3 2 2 2

0 1 2 3 4
X X X X X

Observe que X es un índice que controla los vectores DNR y CON

El algoritmo es el siguiente

Algoritmo datosRepetidosMetodo2
// Definicion de variables
Definir A,DNR,CON,I,J,B,X,N como entero

Leer N

Dimension A(N),DNR(N),CON(N)

Para I<- 0 hasta N-1

Leer A(I)
Fin para

I <- 0
X<-0
Mientras (I<=N-1) hacer // Recorre es vector A para contar
// Busca el dato A(I) en el vector DNR
B<-0
J<-0
Mientras (J <= X-1 & B=0) hacer
Si ( A(I) = DNR(J) )
Entonces
B<- 1
Sino
J<- J+ 1
Fin si
Fin mientras
Si (B=0)
Entonces // Si no se encuentra lo llenar en DNR y coloca 1 en CON
DNR(X) <- A(I)
CON(X) <- 1
X<- X+ 1
Sino // Incrementa CON en 1 en la posición correspondiente J
CON(J) <- CON(J) + 1
Fin si
I<-I+1
Fin mientras
// Muestra los datos contados
Para I<- 0 hasta X-1
 Escribir "dato ", DNR(I)," ", CON(I) , "Veces"
Fin para

FinAlgoritmo

Programa en lenguaje Python

#Formar vector sin repetidos a partir de otro vector

a=[]
con=[]
dnr
n=int(input('Cantidad de elementos de la lista uno '))
# leer lista uno
for i in range(n):
[Link](int(input(f' Digitar valor ( {i} ) = ')))

x=0
i=0
nc=0
while i<n:
#buscar dato a[i] en dnr
b=0
j=0

while j<x and b==0:

if a[i]==dnr[j]:
b=1
else:
j=j+1

if b==0:
[Link](a[i])
x=x+1
[Link](1)
else:
con[j]=con[j]+1
i=i+1
for i in range(len(con))
print('dato ',dnr[i], ' veces ',con[i])

Ejercicio planteado
Utilizar el método anterior para encontrar el dato que más se repite y las veces que lo hace
El ejercicio anterior obtiene dos vectores con y dnr, para lo cual se va a sacar el dato mayor
almacenado en con y su posición, con la posición, que es correspondiente se obtiene el dato
que más se repite:

mayor=con[0]
pos=0
for i in range(1,len(con)):
if con[i]>mayor:
 mayor=con[i]
pos=i
print('dato más repetido',dnr[pos],'veces ',con[pos])

en pos se encuentra el dato mayor por lo que se sabe que dnr[pos] está el dato que más se
repite y en con[pos] las veces que lo hace.

El programa que obtiene el que más se repite es el siguiente:

#Formar vector sin repetidos a partir de otro vector

a=[]
con=[]
dnr
n=int(input('Cantidad de elementos de la lista uno '))
# leer lista uno
for i in range(n):
[Link](int(input(f' Digitar valor ( {i} ) = ')))

x=0
i=0
nc=0
while i<n:
#buscar dato a[i] en dnr
b=0
j=0

while j<x and b==0:

if a[i]==dnr[j]:
b=1
else:
j=j+1

if b==0:
[Link](a[i])
x=x+1
[Link](1)
else:
con[j]=con[j]+1
i=i+1
for i in range(len(con))
print('dato ',dnr[i], ' veces ',con[i])

mayor=con[0]
pos=0
for i in range(1,len(con)):
if con[i]>mayor:
mayor=con[i]
pos=i
print('dato más repetido',dnr[pos],'veces ',con[pos])
El ejercicio anterior saca el primer mayor que se encuentre, porque si hay varios datos que se
repiten igualmente, no lo tiene en cuenta.

Ejercicio 3.

Leer una serie de N datos numéricos en un vector, varios de ellos repetidos y determinar las
veces que se repiten cada uno de estos y mostrarlos en forma descendente por la cantidad
de veces que se repiten.

Este ejercicio permite ordenar vectores que están relacionados. El ordenamiento se va a

realizar en un vector y como son correspondientes, los cambios que se hagan en un vector
tiene que realizarse en el otro.

El ejercicio anterior sirve para realizar este ejercicio.

El ejercicio anterior permitió obtener las veces que se repiten cada uno y estableció con el
ejemplo planteado el siguiente resultado mental

Modelo mental

a. Especificamos los datos ejemplo para el ejercicio

1 4 7 2 5 7 6 4 2 7 6 7 6

b. determinamos a partir de estos datos el resultado que esperamos.

1 está 1 vez
4 está 2 veces
7 está 4 veces
2 está 2 veces
5 está 1 veces
6 está 3 veces

Esto sería con el ejercicio anteriormente planteado

Pero el resultado esperado es el siguiente:

1 7 está 4 veces
4 6 está 3 veces
7 4 está 2 veces
2 2 está 2 veces
5 1 está 1 veces
6 5 está 1 veces

Es decir, está organizado en forma descendente por el número de veces que se repite cada
dato.

Esto determina que la información para poderse organizar debe estar en memoria, por lo que
el algoritmo anterior sirve, ya que la información quedaría almacenada en los vectores DNR y
CON de la siguiente forma
A
1 4 7 2 5 7 6 4 2 7 6 7 6

0 1 2 3 4 5 6 7 8 9 10 11 12
I I I I I I I I I I I I I

DNR
1 4 7 2 5 6

0 1 2 3 4 6
X X X X X X

CON
1 2 4 2 1 3

0 1 2 3 4 6
X X X X X X

Para que la información salga como se solicita se debe ordenar el vector CON y hacer los
cambios correspondientes en el vector DNR ya que los dos están relacionados, de lo contrario
la correspondencia se dañaría. Por lo que este ordenamiento implicaría realizar lo siguiente:

I<- 0
Mientras (I<=X-2) haga
J<- I+1
May <- CON(I)
POS <- I
Mientras (J<= X-1) haga
Si (CON(J)>May)
Entonces
May<- CON(J)
Pos <- J
Fin si
J<-J+1
Fin mientras
Aux<-CON(Pos)
CON(Pos)<-CON(I)
CON(I)<-Aux
// Intercambia también las posiciones de DNR por correspondencia
Aux<-DNR(Pos)
DNR(Pos)<-DNR(I)
DNR(I)<-Aux
I<- I+1
Fin mientras

Con esto, los dos vectores quedan así:

DNR
7 6 2 4 5 1

0 1 2 3 4 6

CON
4 3 2 2 1 1
 0 1 2 3 4 6

Con el vector CON ordenado y DNR con la información correspondiente se puede mostrar la
información con el siguiente código:

I 0
Mientras ( I <= X) haga
Escribir(DNR(I),” “,CON(I), “ Veces”)
I  I+1
Fin mientras

El ejercicio completo queda:

Algoritmo datosRepetidosMetodo2
// Definicion de variables
Definir A,DNR,CON,I,J,B,X,N como entero

// Leer Vector
Leer N
Para I<- 0 hasta N-1
Leer A(I)
Fin para
X<- 0
I<- 0
Mientras (I<=N-1) hacer
B<- 0
J<- 0
Mientras (J <= X-1 & B=0) hacer
Si ( A(I) = CON (J) )
Entonces
B<- 1
Sino
J<- J+ 1
Fin si
Fin mientras
Si (B=0)
Entonces
DNR(X) <- A(I)
CON (X) <- 1
X<- X+ 1
Sino
CON(J) <- CON(J) + 1
Fin si
I<-I+1
Fin mientras
I<- 0
Mientras (I<=X-2) hacer
J<- I+1
May <- CON(I)
POS <- I
Mientras (J<= X-1) hacer
 Si (CON(J)>May)
Entonces
May<- CON(J)
Pos <- J
Fin si
J<-J+1
Fin mientras
Aux<-CON(Pos)
CON(Pos)<-CON(I)
CON(I)<-Aux

Aux<-DNR(Pos)
DNR(Pos)<-DNR(I)
DNR(I)<-Aux
I<- I+1
Fin mientras
I<- 0
Mientras ( I <= X-1) haga
Escribir(DNR(I),’ ‘,CON(I), ‘ Veces’)
I <- I+1
Fin mientras
Fin

El ejercicio anterior hace el ordenamiento en forma descendente del vector CON, de tal forma
que los mayores van a quedar en las primeras posiciones y los menores en las últimas, los
valores de los contadores deben corresponder a los valores de los números en el vector DNR

#Determinar la repetición de los datos de un vector ordenado

a=[]
con=[]
dnr
n=int(input('Cantidad de elementos de la lista uno '))
# leer lista uno
for i in range(n):
[Link](int(input(f' Digitar valor ( {i} ) = ')))

x=0
i=0
nc=0
while i<n:
#buscar dato a[i] en dnr
b=0
j=0

while j<x and b==0:

if a[i]==dnr[j]:
b=1
else:
j=j+1

if b==0:
 [Link](a[i])
x=x+1
[Link](1)
else:
con[j]=con[j]+1
i=i+1

i=0
while i<=len(con)-2:
j=i+1
may=a[i]
pos=i
while j<= len(con)-1:
if con[j]>may:
may=con[i]
pos=i
j=j+1
aux=a[i]
con[i]=con[pos]
con[pos]=aux
#para mantener relación
aux=dnr[i]
dnr[i]= dnr[pos]
dnr[pos]=aux

i=i+1
for i in range(len(con))
print('dato ',dnr[i], ' veces ',con[i])

Con el ordenamiento de estos vectores, se puede obtener el mayor y el menor

Mayor en la posición 0 de dnr y con respectivamente, y el menor valor en la última

posición.

Ahora si se quiere sacar los datos que más se repiten, se hace un rompimiento de control con
el dato en la posición 0. Al ejercicio anterior se le agrega al final las siguientes instrucciones:

i=0;
while con[0]==con[i]:
print(‘\n\ndato mas repetido =’, dnr[i], ‘ Veces ‘,con[i])
i=i+1
}

Los siguientes ejercicios trabajan con vectores ordenados.

Ejercicio

Se tiene un vector con datos numérico ordenados, insertar un nuevo dato en la posición que
le corresponde de manera tal que siga ordenado.
Antes
A
2 7 15 20 30 40 45 50

0 1 2 3 4 6 7 8
I I I I I pos

A
2 7 15 20 30 40 40 45 50

0 1 2 3 4 6 7 8 9
I I I I I posj J

J=N-1;
Mientras j>=pos
A[j+1]=A[j]
J=j-1
Fin mientras
A[pos]=dato
N=N+1

Dato a insertar
Dato
35

Después

A
2 7 15 20 30 35 40 45 50

0 1 2 3 4 5 6 7 8
Pos

Que acciones se realizan para llegar al después.

Leer vector A ordenado

Leer dato a insertar
Buscar posición del dato en A que le corresponde
Abrir espacio en la posición
Insertar dato e incrementar en 1 la cantidad de datos de A
Mostrar vector

Como se busca la posición del dato en el vector ordenado

Se aprovecha de que está ordenado. Como está ordenado se mueve en el vector comparando
el dato con cada posición, mientras el dato sea mayor que el dato del vector, seguirá
avanzando hasta que haya uno que sea mayor o igual y deje de buscar. Se debe guardar la
posición del que fue mayor o igual, porque en esta posición es donde va a insertarse el dato.
Como se hace:

Forma 1

Leer vector ordenado

Leer Dato
I<-0
B<-0
Mientras (I <=N-1 & B=0) Hacer
Si (A(I) >= dato) Entonces
Pos<-I
B<-1
Sino
I<-I+1
Fin si
Fin Mientras
Si ( B = 0) Entonces
Pos <-N
Fin si

De lo anterior se concluye que si B=0 se adiciona el dato al final del vector, no se inserta, si
B=1 entonces hay que abrir espacio para llenar el dato.

Abrir espacio para llenar dato

Abrir el espacio se aplicaría solo si la bandera B=1, e implica correr todos los datos una
posición después de la posición encontrada, esto es:

La posición para el 35 es la posición 5, valor que queda en la variable pos

A
2 7 15 20 30 40 40 45 50

0 1 2 3 4 5 6 7 8
J J+1
J

Pos

A(J+1)<-A(J)

Los datos 40 45 50 deben quedar ubicados en las posiciones 6 7 8 respectivamente es

decir:

A
2 7 15 20 30 4040 40 45 50

0 1 2 3 4 5 6 7 8
Pos

Como se hace esto

Primero el vector va a crecer una posición y el tamaño debe permitirlo. (Dimension mas
grande)
Segundo, en el movimiento de datos del vector, se debe cuidar el no borrar información, para
esto se debe analizar como mover los datos. Para no perder información se debe mover los
datos con un ciclo que vaya desde el último hasta la posición pos asi:

Para J<-N-1 Hasta Pos con Paso -1

A(J+1) <- A(J)
Fin para

J<-N-1
Mientras (J>=pos) hacer
A(J+1) <- A(J)
J<-J-1
Fin mientras

Esto comienza dejando el último dato en una posición mayor, el penúltimo en la última y asi
sucesivamente, hasta llegar a pos

Esto deja el vector asi:

A
2 7 15 20 30 40 40 45 50

0 1 2 3 4 5 6 7 8
pos

Si se ubiera corrido la información desde pos con las siguientes acciones

Para J<pos Hasta N-1 con Paso 1

A(J+1) <- A(J)
Fin para

El vector quedaría así:

A
2 7 15 20 30 40 40 40 40

0 1 2 3 4 5 6 7 8
pos

Donde se borra el 45 y el 50, lo cual sería un error

Una vez abierto el espacio con el ciclo decreciente, se inserta el dato y se modifica el tamaño
del vector en 1 asi:

A(pos) <- Dato

N <- N+1

Retomamos entonces los pasos genéricos y tenemos:

Definir variables
Leer vector A
Leer dato a insertar
Buscar posición del dato en el vector A
Abrir espacio en la posición encontrada
Insertar dato en la posición encontrada e incrementar en 1 la cantidad de datos de A
Mostrar vector

Algoritmo insertarDatoVectorOrdenado
Definir A,I,Dato,B,Pos como entero
Dimension A(20)
// Leer vector
Leer N
Para I<-0 Hasta N-1 con paso 1
Leer A(I)
Fin para
// Leer dato a insertar
Leer Dato
// Buscar posición donde debe quedar
I<-0
B<-0
Mientras (I <=N-1 & B=0) Hacer
Si (A(I) >= dato) Entonces
Pos<-I
B<-1
Sino
I<-I+1
Fin si
Fin Mientras
Si ( B = 1) Entonces
Para J<-N-1 Hasta Pos con Paso -1
A(J+1) <- A(J)
Fin para
Sino
Pos <-N
Fin si
// Insertar dato en la posición pos
A(pos) <- Dato
N<-N+1
// Mostras vector
Para I<-0 Hasta N-1 con paso 1
Escribir A(I)
Fin para
Fin
En python, las listas son dinámicas, por lo que no se debe abrir espacio, solo se hace uso de la
función insert() que tiene el siguiente formato

insert(pos,objeto insertar)

Si la pos sobrepasa el tamaño de la lista lo adiciona al final.

Entonces en el programa solo se busca la posición que le corresponde para que se mantenga el
orden.

Programa en lenguaje Python

#insertar un dato en un vector ordenado

a=[]
n=int(input('Cantidad de elementos de la lista uno '))
# leer lista uno
for i in range(n):
[Link](int(input(f' Digitar valor ( {i} ) = ')))

dato=int(input('Digitar dato a insertar '))

i=0
b=0
while i<=n-1 and b==0:
if a[i]>=dato:
b=1
pos=1
else:
i=i+1
if b==1:
[Link](pos,dato)
else:
[Link](n,dato)
for i in range(len(a))
print('dato ',i, '= ',a[i])

El anterior ejercicio se lo puede optimizar en la búsqueda de la posición a insertar la cual se la

podría realizar de la siguiente forma:

I<-0
Mientras (dato > A(I) & I<=N-1) Hacer
I<-I+1
Fin Mientras

Esta forma se elimina la variable pos y la bandera, todo se lo maneja con la variable I. I,
abarca las tres situaciones, si va al inicio, no entra al ciclo (I=0), si va al final (I=N), y si va
en el medio, I determina el campo donde se debe insertar. En todos los casos I queda ubicada
en el campo donde debe llenarse.

El dato finalmente se va a llenar en la posición I

Algoritmo insertadatoVector2

Definir A,I,Dato,B como entero

Dimension A(20)
// Leer vector
Leer N
Para I<-0 Hasta N-1 con paso 1
Escribir A(I)
Fin para
// Leer dato a insertar
Leer Dato
// Buscar posición donde debe quedar el dato
I<-0
 Mientras (I<=N-1 & dato > A(I) ) Hacer
I<-I+1
Fin Mientras
Si (I<=N-1) Entonces // Abre el espacio si está al inicio o intermedio
Para J<-N-1 Hasta I con Paso -1
A(J+1) <- A(J)
Fin para
Fin si
// Insertar dato en la posición I
A(I) <- Dato
N<-N+1

// Mostras vector
Para I<-0 Hasta N-1 con paso 1
Escribir A(I)
Fin para
FinAlgoritmo

Programa en lenguaje Python

#insertar un dato en un vector ordenado

a=[]
n=int(input('Cantidad de elementos de la lista uno '))
# leer lista uno
for i in range(n):
[Link](int(input(f' Digitar valor ( {i} ) = ')))

dato=int(input('Digitar dato a insertar '))

i=0
while i<=n-1 and dato>a[i]:
i=i+1
[Link](i,dato)
for i in range(len(a))
print('dato ',i, '= ',a[i])

Ejercicios
Insertar un dato en un vector no ordenado y ordenado
Borrar un dato de un vector
Buscar un dato en un vector con búsqueda binaria
Formar un vector ordenado a partir de dos vectores ordenados con mezcla
N

Ejercicio
Se tiene un vector con datos numéricos, buscar un dato y eliminarlo.

Antes
A
2 7 15 20 40 45 50 50

0 1 2 3 4 5 6 7

Dato a eliminar
40

Después
A
2 7 15 20 40 45 50

0 1 2 3 4 5 6

Según lo anterior lo anterior, lo que se hizo es lo siguiente

Se busca el dato y su posición

A
2 7 15 20 40 45 50 50

0 1 2 3 4 5 6 7
J J+1
Pos

El dato a eliminar 40 está en la posición 4

Una vez determinada la posición del dato a borra y realizar los movimientos respectivos el
vector queda con la siguiente información.

A
2 7 15 20 40 45 50

0 1 2 3 4 5 6

Esto significó que los datos que están con verde, se corren todos una posición y el vector
queda con una posición menos.

Esto es lo que se hace mentalmente, computacionalmente los pasos genéricos son los
siguiente:

Definir Variables
Leer Vector A
Leer Dato a eliminar
Buscar dato en el vector y su posición.
Si el dato se encuentra, mover los datos desde la posición encontrada hasta el final una
posición.
Decrementar la cantidad de datos en 1
Mostrar Vector A

De los anteriores pasos, necesita claridad el movimiento de los datos lo cual se realiza de la
siguiente forma

A
2 7 15 20 30 40 45 50

0 1 2 3 4 5 6 7
Pos J
J

Se necesita un índice que inicie en la posición Pos , índice J o también puede iniciar en la
siguiente posición Pos+1. Veamos con las dos posibilidades como queda:

Iniciando J en pos, según el ejemplo se van a mover tres datos y se los representa con el
siguiente codigo

J<-Pos
Mientras ( J <= N-2) hacer
A(J) <- A(J+1)
J<- J+1
Fin mientras

El A(J) <- A(J+1)

Con ciclo para queda

Para J<-pos hasta N-2 con paso 1

A(J) <- A(J+1)
Fin para

Permite ubicarse en la posición J y traer el dato siguiente especificado por J+1.

En estos caso sirve el índice como expresión.

Esto también permite establecer que J vaya hasta N-2, porque si va hasta N-1, con el J+1 se
desbordaría el vector.

Para el ejemplo se tiene.

A
2 7 15 20 30 40 45 50

0 1 2 3 4 5 6 7
Pos
J J+1

A(J)<-A(J+1)
A
2 7 15 20 40 40 45 50

0 1 2 3 4 5 6 7
Pos
J J+1

Cuando J llega a N-2

Se tendría los siguiente

A
2 7 15 20 40 45 50 50

0 1 2 3 4 5 6 7
Pos
J J+1

Hasta aquí se tiene toda la información movida una posición, donde al final queda repetido el
50 y se lo ignora con la siguiente instrucción.

N<-N-1 y queda:

A
2 7 15 20 40 45 50

0 1 2 3 4 5 6

Iniciando J en pos+1 se tiene:

Para J<-pos+1 hasta N-1

A(J-1) <- A(J)
Fin para

Algoritmo:

Algoritmo eliminarDatoVector
// Definición de variables
Definir A, I, J, Pos, N,dato como entero

Escribir “Cantidad de datos del vector “

Leer N
Dimension A(N)

// Leer Vector
Para I <- 0 Hasta N-1
Leer A(I)
 Fin para

// Leer Dato a borrar

Escribir “ Dato a borrar “
Leer dato

// Buscar posición
B<-0
I <- 0
Mientras ( I<=N-1 & B=0 ) hacer
Si (A(I ) = dato) Entonces
B<- 1
Pos <-I
Sino
I<-I+1
Fin si
Fin mientras
// Corres posiciones del vector en pos
Si B=1 Entonces
Para J<- Pos hasta N-2 con paso 1
A(J) <- A(J+1)
Fin Para
// Disminuir tamaño
N<-N-1
Sino
Escribir “El dato no existe en el vector “
FinSi
// Mostrar vector
Para I<- Pos hasta N-1 con paso 1
Escribir A(I)
Fin Para
Fin Algoritmo

Programa en lenguaje Python

En Python, como la lista es dinámica, no existe contigüidad por lo tanto, no se deben correr
los datos de la lista para eliminarlo, se hace uso de la función remove() que requiere como
parámetro el objeto a eliminar.

Si la lista es A entonces la función se la utiliza como:

[Link](dato)

Esta función exige que el dato se encuentre para poderlo remover, de lo contrario saca error,
por lo que primero se debe determinar si existe para poderlo remover asi:

if (dato in a)==True:
[Link](dato)
else:
print(‘dato no existe en la lista’)

el programa en Python entonces queda:

#eliminar un dato de un vector
a=[]
n=int(input('Cantidad de elementos de la lista uno '))
# leer lista uno
for i in range(n):
[Link](int(input(f' Digitar valor ( {i} ) = ')))

dato=int(input('Digitar dato a eliminar '))

if (dato in a)==True:
[Link](dato)
else:
print('Dato no existe en la lista ')

for i in range(len(a))
print('dato ',i, '= ',a[i])

Ejercicio de ordenamiento

Buscar un dato dado en un vector ordenado, utilizando la búsqueda binaria.

La búsqueda binaria
Se presenta únicamente para los datos que están ordenados:
Se inicia con dos valores que indican los límites (índices ), un límite inicial y un límite final
de los datos.
Con estos límites se halla la media ((limiteInicial+LímiteFinal)/2) para obtener el dato que
está en esta posición y se compara el dato buscado con el dato que está en esta en la posición
media. Si es igual termina y muestra su posición.
Si no es igual al buscado, como los datos están ordenados, se determina en cúal de las mitades
está, comparando el dato buscado, si es mayor que el de la mitad, se elimina la mitad inferior
modificando el límite inferior, si es menor se modifica el límite superior. Al modificar los
límites, se elimina la mitad de los datos.
El proceso se repite hasta encontrar el dato o hasta que, al variar los límites, el límite inferior
es mayor que el limite superior, esto indica que el dato no se encuentra.

Ejemplo

Dato a buscar
82

A
10 15 20 22 35 47 56 74 82 87 96 107 116

0 1 2 3 4 5 6 7 8 9 10 11 12
Limite me Límite
Inferior Superior

Me=(LimiteInferior+LimiteSuperior)/2
Me = (0+12)/2 = 6

82 = 56 ?
No

En cual mitad está?

82<56 ?
No
LimiteInferior = me+1

A
74 82 87 96 107 116

7 8 9 10 11 12
Límite Límite
Inferior Superior

me = (limiteInferior+LímiteSuperior)/2 = 9

me = (7+12)/2 = 9,5, se toma la parte entera

El dato en la posición 9 es 87

82=87?
No

82<87?
Si // varía el límite superior

LimiteSuperior = me-1 = 8

A
74 82
7 8
Límite Limite
Inferior Superior

Me=(7+8)/2 = 15/2=7,5

82=74?
No
82<74?
No

limiteInferior=me+1=8

me=(8+8)/2=8

A
82

82=82?
Si

Respuesta “Dato “, datos, “se encuentra en “, me

Ahora, si el dato fuera 81

82=81?
No

82<81?
No
LimiteSuperior = me -1=8-1=7
Para el dato 81 se concluye, que el dato no se encuentra en el vector porque los el
limiteInferior es mayor que el límiteSuperior

Pasos genéricos

Definir variables
Leer vector ordenado
Leer dato a buscar
Definir limite inicial y limite final
Recorrer el vector A mientras no se encuentra el dato o hasta que el limiteFinal sea menor que
el LimiteInicial. Por cada Iteración realizar:
Calcular índice medio
Comparar dato a buscar con dato en índice medio
Si es igual cambiar bandera
Si no es igual, modificar limites (comparando)
Mostrar resultado

Para mostrar los resultados se utiliza una bandera, para indicar si está o no en el vector
Elemento computacional para determinar el índice medio (me)

me <- (limiteInferior+LimiteSuperior)/2

Aquí hay una división, por lo que me debería ser real, pero interesa que sea entero, por lo que
se utiliza en PseInt una función denominada TRUNC( ), la cual devuelve la parte entera de la
división y se la utiliza asi:

me <- TRUNC( (limiteInferior+LimiteSuperior)/2))

En lenguaje c no hay necesidad de utilizar truncamiento, tan solo la variable me, se la

define entera, y la asignación de un valor decimal a un valor entero, solo admite la parte
entera

me=(limiteInferior+limiteSuperior)/2;

Con esto se asegura que el índice me sea válido

Variables

A :Vector
N : Cantidad de datos
LimiteInferior : LímiteInferior
LimiteSuperior : Limite Superior
Me : Indice medio
B : Bandera para búsqueda
Algoritmo

Algoritmo busquedaBinaria
Definir A,me,LimiteInferior,LimiteSuperior,B como entero

Escribir “Cantidad de datos del vector “

Leer N
Dimension A(N)

// Leer datos
Para I<-0 hasta N-1 con paso 1
Leer A(I)
Fin para

// Leer dato a buscar

Escribir “Dato a buscar ”
Leer dato
// Definir limites iniciales

LimiteInferior <- 0
LimiteSuperior <- N-1
B<-0
Mientras (LimiteInferior<=LimiteSuperior & B=0 ) hacer
me <- TRUNC((LimiteInferior+LimiteSuperior)/2)
Si (A(me)=dato) Entonces
B <- 1 // El dato está en el vector y sale del ciclo
Sino
Si (dato <A(me))
Entonces
LimiteSuperior<-me-1 // Modifica el índice superior
Sino
LimiteInferior<-me+1 // Modifica el índice inferior
Fin di
Fin si
Fin mientras
Si ( b=1 ) Entonces
Escribir “Dato “, dato, “ está en posición “, me
Sino
Escribir “Dato no está en el vector “
Fin si
Fin

Programa en lenguaje Python

#Busqueda binaria en una lista ordenada

a=[]
n=int(input('Cantidad de elementos de la lista uno '))
# leer lista uno
for i in range(n):
[Link](int(input(f' Digitar valor ( {i} ) = ')))

dato=int(input('Digitar dato a buscar -> ')

limiteInferior=0
limiteSuperior=n-1
b=0
while limiteInferior<=limiteSuperior and b==0:
me=int((limiteInferior+limiteSuperior)/2)
if a[me]==dato:
b=1
else:
if dato<a[me]:
limiteSuperior=me-1
else:
limiteInferior=me+1
if b==1:
print('Dato ',dato, 'se encuentra en la posición ',me)
else:
print('Dato ',dato, 'no se encuentra en la lista ')

Ejercicio

Se tienen dos vectores ordenados, formar un tercer vector de tal forma que este quede
ordenado teniendo en cuenta el ordenamiento de los dos anteriores, esto indica que en el
vector tres no debe ser ordenado con un algoritmo de ordenamiento.
Este ordenamiento se denomina ordenamiento por mezcla.

Ejemplo

A
2 7 15 20 30 60 75

0 1 2 3 4 5 6
I I I I I I

B
5 15 25 28 38 55

0 1 2 3 4 5
J J J J J J

C
2 5 7 15 15 20 25 28 30 38 55 60 75

0 1 2 3 4 5 6 7 8 9 10 11 12
NC
El vector C es el resultado de A y de B, y se llena asi:

Se deben recorrer los dos vectores a la vez e ir comparando dato a dato para determinar cual
dato se debe llenar

2<5?
Si
Dato 2 del vector A, va al vector C y pasa al siguiente dato de A

Ahora compara

7<5?
No
Dato 5 del vector B va al vector C y pasa al siguiente dato de B

Ahora compara

7<15?
Si
Dato 7 del vector A, va al vector C y pasa al siguiente dato de A

Esto indica que los vectores A y B, deben avanzar de acuerdo a como se va presentando la
comparación, por lo que los índices se deben mover alternadamente, como se indica en los
tres datos que hasta el momento se han llenado.

Hasta este momento se tendría.

A
2 7 15 20 30 60 75

0 1 2 3 4 5 6
I I I
B
5 15 25 28 38 55

0 1 2 3 4 5
J J J

C
2 5 7 15

0 1 2 3 4 5 6 7 8 9 10 11 12
NC NC NC NC

De esta forma se sigue comparando los datos y se llenan en el vector C, en el orden en que lo
especifica la comparación y esto se lleva hasta que uno de los dos vectores llega a su fin.
En el ejmplo el vector que llega a su fin es el vector B, por lo que aún faltan llenar los datos
del vector A 60 y 75.
Los datos que faltan se los llena directamente en C
De igual forma pueden faltar elementos del vector B, los cuales se llenarían directamente.

A
2 7 15 20 30 60 75

0 1 2 3 4 5 6
I I I I I I

B
5 15 25 28 38 55

0 1 2 3 4 5
J J J J J J
C
2 5 7 15 15 20 25 28 30 38 55

0 1 2 3 4 5 6 7 8 9 10 11 12
NC

Los datos del vector C se han llenado, hasta que uno de los dos vectores A o B se acaba, en
este caso fue el vector B, por lo que faltarían llenar dos datos del vector A, los cuales se llenan
directamente, sin comparar.
Los datos que faltan de A que son 60 y 75, se los llena directamente en C
De igual forma pueden faltar elementos del vector B, los cuales se llenarían también
directamente.

En términos computacionales se tienen lo siguiente

Como recorrer los dos vectores a la vez

NC<-0
I<-0
J<-0
Mientras (I<=NA-1 & J<=NB-1) hacer

El avance de cada vector está condicionado de la siguiente forma

Si (A(I) < B(J) ) Entonces

C(NC) <- A(I) // llena un elemento del vector A y avanza en el vector
NC <- NC + 1
I<- I+1
Sino
C(NC) <- B(J) // llena un elemento del vector B y avanza en el vector
NC <- NC + 1
J<- J+1
Fin si
Los elementos se adicionan con el índice NC que a su vez es el número de elementos de C

El resto de los elementos se llenan después del ciclo mientras, el cual se termina si uno de las
condiciones simples de la condición compuesta se vuelve falsa. Se debe preguntar por una de
ellas y asi se conoce que vector se acabó. Esto es:

Si (I=NA) Entonces //faltan datos de B

Mientras (J <= NB – 1) Hacer
C(NC) <- B(J)
NC <- NC +1
 J<-J+1
Fin Mientras
Sino //faltan datos de A
Mientras (I <= NA – 1) Hacer
C(NC) <- A(I)
NC <- NC +1
I<-I+1
Fin Mientras
Fin si

Pasos genéricos

Definición de variables
[Link] vector A
2. Leer Vector B
3. Recorrer vector A y Vector B para llenar vector C
Comparar dato de A con Dato de B
Llenar el dato menor e incrementar el índice correspondiente
4. Determinar vector de datos faltantes y llenar datos del vector a C
5. Mostrar vector C

Construcción del algoritmo

Algoritmo ordenamientoPorMezcla
// Definir variables
Definir A,B,C,I,J,NA,NB,NC,X como entero

Escribir “Cantidad de datos del vector A”

Leer NA
Escribir “Cantidad de datos del vector B”
Leer NB
Dimension A(NA),B(NB),C(NA+NB)

// Leer vector A
Para I<-0 hasta NA-1
Leer A(I)
Fin para

// Leer vector B
Para J<-0 hasta NB-1
Leer B(J)
Fin para

// Recorrer los vectores A y B para llenar vector C

I<-0
J<-0
Mientras ( I<=NA-1 & J<=NB-1) hacer
Si (A(I) < B(J) ) Entonces
C(NC) <- A(I) // llena un elemento del vector A y avanza en el vector
NC <- NC + 1
I<- I+1
 Sino
C(NC) <- B(J) // llena un elemento del vector B y avanza en el vector
NC <- NC + 1
J<- J+1
Fin si
Fin mientras
// Llenar los valores faltantes de un vector
Si (I=NA) Entonces
Mientras (J <= NB – 1) Hacer
C(NC) <- B(J)
NC <- NC +1
J<-J+1
Fin Mientras
Sino
Mientras (I <= NA – 1) Hacer
C(NC) <- A(I)
NC <- NC +1
I<-I+1
Fin Mientras
Fin si
// Mostrar vector C
Para X<- 0 Hasta NC-1 con paso 1
Escribir C(X)
Fin para
Fin

Ordenamiento de dos vectores por mezcla

Programa en lenguaje Python

#Ordenamiento listas por mezcla

a=[]
b=[]
c=[]
na=int(input('Cantidad de elementos de la lista uno '))
# leer lista uno

for i in range(na):
[Link](int(input(f' Digitar valor ( {i} ) = ')))

nb=int(input('Cantidad de elementos de la lista dos '))

# leer lista uno

for i in range(nb):
[Link](int(input(f' Digitar valor ( {i} ) = ')))
#recorrer los vectores
nc=0
i=0
j=0
while i<=na-1 and j<=nb-1:
 if a[i]<b[j]:
[Link](a[i])
i=i+1
else:
[Link](b[j])
j=j+1
if i=na:
while j<=nb-1:
[Link](b[j])
j=j+1
else:
while i<=na-1:
[Link](b[i])
i=i+1
print('Vector ordenado por mezcla ')
for i in range(len(c)):
print('dato (',i, ') ->',c[i])

Ejercicio propuesto

Se tienen dos vectores ordenados ascendentemente, formar un tercer vector por mezcla con
los datos pares
Con los primos
Con los fibonacci

A
2 7 15 20 30 60 75

0 1 2 3 4 5 6
I I I I I I

B
5 15 25 28 38 55

0 1 2 3 4 5
J J J J J J

C
2 20 28 30 38 60

0 1 2 3 4 5

Ejercicio.
Se tienen dos vectores con datos numéricos, el primer vector tiene información de como
recorrer el segundo vector en rangos de datos asi:

VectorRango
Sus elementos contienen la cantidad de datos que se van a recorrer en el segundo vector datos

RANGOS
3 6 4

0 1 2
I I

DATOS
10 20 15 22 10 47 22 74 30 87 15 80 11

0 1 2 3 4 5 6 7 8 9 10 11 12
J J J J J

Formar un tercer vector con el mayor de cada rango

MAY

20 74 87

0 1 2

Este ejercicio es interesante porque permite recorrer en forma dinámica el vector datos
dependiendo del vector rango.

Formar con esto un vector con el mayor de cada rango. Lo importante es manejar los rangos
como se hace esto

El primer rango va de 0 - 2 se conoce 3 de Rango(I) y el índice 0 en J

El segundo rango va de 3-8 se conoce 6 de Rango(I) y el índice 3 en J
El tercer rango va 9 – 12 se conoce 4 de Rango(I) y el índice 9 en J

Donde J es el que va a recorrer el vector rango

Con estos valores se encuentra los valores 2, 8 y 12 en forma dinámica de tal forma que
funciones para los tres valores
J + Rango(I)-1
2 =0+3-1
J + Rango(I)-1
8 =3 +6-1
J + Rango(I)-1
12 = 9 + 4 – 1

Como se recorre los rangos del vector. J va a recorrer todas las posiciones del vector, lo que
se debe controlar es hasta donde va cada rango, para lo cual se calcula Lf, que es el limite
final de cada rango, según el ejemplo la primera vez es 2, la segunda 8 y la tercera 12.

Lf<-J+Rango(I)-1 //Lf establece el limite final de cada rango

Mayor=Datos(J)
Mientras (J<=Lf) Hacer
Acciones en el rango
J<-J+1
Fin mientras
Acciones después del rango

La llenada del vector MAY se hace como se llenaron los vectores anteriores
CM. Cantidad de datos en MAY

MAY (I) <- Mayor

Pasos genéricos

Definir variables
1. Leer Vector Rango
2. Leer Vector Datos
3. Recorrer el vector Rango y con cada dato realizar
Recorrer el vector Datos, de acuerdo al vector Rango para obtener el mayor
Llenar el mayor en el vector MAY
4. Mostrar el vector MAY

Algoritmo

Algoritmo rangosVector
Definir Datos,Rango,R,CD,CR,I,J,MAY,CM como entero
// Escribir Cantidad de datos del vector RANGO”
Leer CR
// Escribir Cantidad de datos del vector DATOS”
Leer CD
Dimension RANGO(CR),DATOS(CD),MAY(CR)
Escribir “Datos del vector RANGO”
Para I<-0 hasta CR-1 con paso 1
Leer RANGO(I)
Fin para
Escribir “Datos del vector DATOS”
Para I<-0 hasta CR-1 con paso 1
Leer DATOS(I)
Fin para
J<-0
I<-0
DM<-0
Mientras (I<=CR-1) Hacer
Lf=J+Rango(I)-1;
Mayor <- Datos(J)
Mientras ( J<=Lf) Hacer
Si (DATOS(J)>Mayor) Entonces
Mayor <- DATOS(J)
Fin si
J<-J+1
Fin mientras
MAY(I)<-Mayor

I<-I+1
 Fin mientras
// Escribir vector MAY
Para I<=0 Hasta CR-1 con paso 1
Escribir MAY(I)
Fin para
Fin

Programa en lenguaje Python

#Recorrido lista por rangos

datos=[]
rango=[]
may=[]
cr=int(input('Cantidad de datos de la lista rango '))
cd=int(input('Cantidad de elementos de la lista datos '))

# leer lista rango

for i in range(cr):
[Link](int(input(f' Digitar valor rango( {i} ) = ')))

# leer lista datos

for i in range(nb):
[Link](int(input(f' Digitar valor dato( {i} ) = ')))
i=0
j=0
while i<=cr-1:
lf=j+rango[i]-1
mayor=datos[j]
while j<=lf:
if datos[j]>mayor:
mayor=datos[j]
j=j+1
[Link](mayor)
i=i+1

print('Mayores de cada rango ')

for i in range(len(may)):
print('Rango ',i, 'Mayor ',may[i])

Ejercicio propuesto

Se tienen dos vectores con la siguiente información.

Vector Rango, donde hay unos valores primos que determinan la cantidad de datos de un
rango de datos a recorrer en el vector datos

RANGOS
3 6 4 5 2
0 1 2
I I

DATOS
10 20 15 22 10 47 22 74 87 15

0 1 2 3 4 5 6 7 9 10
J J J J J

Formar 3 vectores con el mayor, el menor y el promedio de cada rango

MAY

20 74 87

0 1 2
CR

MEN

20 74 87

0 1 2

PROM

20 74 87

0 1 2

Ejercicio de aplicación

Para un curso de la materia de Programación, de una cantidad dada de estudiantes, se hizo el

proceso de evaluación y se obtuvieron 3 calificaciones, con los siguientes ponderados
Cal 1 30%
Cal 2 30%
Cal 3 40%

Si por cada estudiante se tiene la siguiente información

Codigo del Estudiante
Calificación 1
Calificación 2
Calificación 3

Realizar un programa que permita encontrar la siguiente información.

Listado de los estudiantes con sus Calificaciones y su nota final, ordenado de mayor a menor
según la nota final.

Promedio de calificaciones
Cantidad de estudiantes que aprobaron la materia
Cantidad de estudiantes que perdieron la materia

Estudiantes con mayor calificación

Estudiantes con menor calificación

Ejemplo

CE
8

Cod Est N1 N2 N3 Nf
0 1 3 3,5 4 3,5 = 3*,3+3,5*,3+4*,4
1 2 4 4,5 4,5 4,3
2 3 2,5 3,5 3 3
3 4 5 4 5 4,6
4 5 2,5 3 3 2,8
5 6 3 3 2 2,6
6 7 5 4 5 4,6
7 8 3 3 2 2,6

Ordenar

Cod Est N1 N2 N3 Nf
4 5 4 5 4,6
7 5 4 5 4,6
2 4 4,5 4,5 4,3
1 3 3,5 4 3,5
3 2,5 3,5 3 3
5 2,5 3 3 2,8
6 3 3 2 2,6
8 3 3 2 2,6

Mostrar lista

Promedio (SNf/CE)

Estudiantes con mayor calificación

Estudiantes con menor calificación

Pasos genéricos

Definir variables
Leer Datos de los estudiantes
Calcular nota definitiva
Ordenar definitiva y realizar cambios correspondientes
Obtener listado de notas
Obtener estadísticas

Algoritmo calilficacionesCurso
// Definicion de variables

Definir CodEst,CE como enteros

Definir N1,N2,N3,NF como real
Escribir “Cantidad de estudiantes “
Leer CE
Dimension CodEst(CE),N1(CE), N2(CE), N3(CE), NF(CE)

//Leer información estudiante

Para i<-0 hasta CE-1

Escribir “Código Estudante “
Leer CodEst(i)
Escribir “Calificacion 1”
Leer N1(i)
Escribir “Calificacion 2”
Leer N2(i)
Escribir “Calificacion 3”
Leer N3(i)
Fin Para

//Calcular información definitiva

Para i<-0 hasta CE-1
NF(i) <- N1(i)*,3+N2(i)*,3+N3(i)*,4
Fin para

// Ordenar definitiva y establecer correspondencia

Para i<-0 hasta CE-2

Para j<-i+1 hasta CE-1
Si (NF(j) > NF(i) ) Entonces
calaux<- NF(i)
NF(i)<-NF(j)
NF(j)<-calaux

// garantizar correspondencia
calaux<- N1(i)
N1(i)<-N1(j)
N1(j)<-calaux

calaux<- N2(i)
N2(i)<-N2(j)
N2(j)<-calaux

calaux<- N3(i)
N3(i)<-N3(j)
N3(j)<-calaux

codaux<- CodEst(i)
CodEst(i)<- CodEst(j)
CodEst(j)<-calaux
Fin para
 Fin para
//Mostrar resultados
Escribir “Informe final Estudiantes “
Para i<-0 hasta CE-1
Escribir “Cod Estudiante “,CodEst(i), “ N1 “,N1(i), “ N2 “,N2(i), “ N3 “,N3(i), “
Nota final “,NF(i)
Fin para
ceg<-0
cep<-0
sum<-0
Para i<-0 hasta CE-1
Si NF(i) >= 3 Entonces
ceg<-ceg+1
Sino
cep<-cep+1
Fin si
sum<-sum+NF(i)
Fin para
prom<-sum/CE
Escribir “Cantidad de estudiantes que ganaron “,ceg
Escribir “Cantidad de estudiantes que perdieron “,cep
Escribir “promedio calificaciones “,prom
Escribir “Estudiantes con nota mayor “
i<-0
j<-0
Mientras NF(0)=NF(j) hacer
Escribir “Estudiante “,CodEst(i), “Calificacion “,NF(i)
j<-j+1
Fin Mientras

Escribir “Estudiantes con nota menor “

j<-CE-1
Mientras NF(CE-1)=NF(j) hacer
Escribir “Estudiante “,CodEst(i), “Calificacion “,NF(i)
j<-j-1
Fin Mientras

Fin

Programa en lenguaje Python

#Ejercicio aplicación Calificaciones curso programacion

codest=[]
n1=[]
n2=[]
n3=[]
nf=[]

ce=int(input('Cantidad de estudiantes '))

#leer calificaciones
for i in range(ce):
[Link](int(input(' Codigo estudiante = ')))
[Link](int(input(' Calificacion 1 = ')))
[Link](int(input(' Calificacion 2 = ')))
[Link](int(input(' Calificacion 3 = ')))
#calcular definitiva
for i in range(ce):
[Link](n1[i]*0,3+n2[i]*0,3+n3[i]*0,4)

#ordenar calificaciones descendente

for i in range(ce-2):
for j in range(i+1,ce-1)
if nf[j]>nf[i]:
calaux=nf[i]
nf[i]=nf[j]
nf[i]= calaux

#guardar correspondencia
calaux =n1[i]
n1[i]=n1[j]
n1[i]= calaux

calaux =n2[i]
n2[i]=n2[j]
n2[i]= calaux

calaux =n3[i]
n3[i]=n3[j]
n3[i]= calaux

codaux =codest[i]
codest[i]= codest[j]
codest[i]= codaux

#mostrar resultados
print('INFORME ESTUDIANTES ')
for i in range(ce):
Print('Codigo estudiante ',codest[i],' N1 ',n1[i], ' N2 ',n2[i],
'N3 ',n3[i], ' Final ',nf[i])

#Elaborar estadísticas

ceg=0
cep=0
sum=0

for i in range(ce):
if nf[i]>=3:
ceg=ceg+1
 else:
cep=cep+1
sum=sum+nf[i]

prom=sum/ce;

print('Resultados finales')
print('Cantidad de estudiantes que ganaron ->',ceg)
print('Cantidad de estudiantes que perdieron -> ',cep)
print('Promedio de calificaciones ->',prom)
print('Estudiantes con nota mayor ',nf[0])
j=0
while nf[0]==nf[j]:
print('Estudiante ',codest[j])
j=j+1

print('Estudiantes con nota menor ',nf[ce-1])

j=ce-1
while nf[ce-1]==nf[j]:
print('Estudiante ',codest[j])
j=j-1