Tarea 3.

Programación y Algoritmos
Carlos Giovanny Encinia González
31 agosto 2021

Ejercicio 1 Figure 1: Es palindromo

Programa que verifique si un número de entrada

dado es palı́ndromo. Un palı́ndromo, es un número
o string que se lee igual en un sentido que en otro
(por ejemplo: Ana, 121. . . ). Usar una función que
regrese un numero invertido (al revés).
Firma de la función: int invert(int number)
Invert(123) → regresa 321
Impresión en terminal: “El número ### es (o En la figura (2) el usuario agrego un numero neg-
no es) palı́ndromo” ativo, este numero es invertido, si un palindromo
NOTA: No usar recursión ni arreglos. es ingresado el programa dira que es palindromo
aunque sea negativo, unicamente considerara los
digitos para dar un veredicto.

Respuesta Figure 2: Negativos

El algoritmo pide al usuario que ingrese un entero,

al inicio sugiere que el entero sea positivo, aunque
el usuario puede agregar uno negativo. Tal y como
lo pide el ejercicio el algoritmo imprime en pantalla
si el numero dado es un palı́ndromo o no, además de
imprimir el numero original y el numero invertido.
En el codigo exieten tres funciones, una lla-
mada potencia() que se usa dentro de una funcion
llamada invierte numero(), y la funcion main(), Si al final del numero existen ceros figura (3), este
la funcion que hace la magia es la funcion in- cero no se vera reflejado en el numero invertido ya
vierte numero(), la cual descompone el numero que los datos tipo numero no llevan un cero por
dado en varios digitos y dependiendo de la pocision delante.
opriginal del digito este es tranformado a la posi-
Figure 3: Ceros al final
cion que le tocaria si se invierte el numero, para
realizar esto al principio se debe de calcular el or-
den del numero que se esta leyendo, por ejemplo el
numero 300 es de un orden de 2, y con esto me re-
fiero que es necesario dividir entre 102 para obtener
el ultimo digito. En seguida se muestran algunos
resultados obtenidos con la ejecucion del programa.
En la figura (1) podemos observar que el numero
dado es un palı́ndromo.

1
 Code 1: main.c
1 // Giovanny E n c i n i a
// 30/08/2021
3 #i n c l u d e <s t d i o . h>
#d e f i n e TEN 10
5 #d e f i n e ONE 1
#d e f i n e ZERO 0
7
l o n g p o t e n c i a ( i n t number , i n t n )
9 {
/∗Una f u n c i o n para e f e c t u a r l a p o t e n c i a de un numero
11 unicamente s e l e da e l numero y l a p o t e n c i a a e l e v a r ∗/

13 int i = ZERO;
l o n g r e s u l t = ONE;
15
while ( i < n)
17 {
r e s u l t *= number ;
19 i++;
}
21
return r e s u l t ;
23 }

25 l o n g i n v i e r t e n u m e r o ( l o n g n number )
{
27
l o n g r e s u l t a d o , ten , sum = ZERO;
29 i n t i = ZERO, j = ZERO;

31 t e n = TEN;

33 // e n c u e n t r a e l numero de v e c e s que debe s e r d i v i d i d o

// por d i e z para poder l l e g a r a una unidad con e l p r i m e r d i g i t o
35 r e s u l t a d o = n number / t e n ;

37 w h i l e ( r e s u l t a d o != ZERO)
{
39 // e l u l t i m o e v e n t o e s cuando t e n hace que h a l l a d e c i m a l e s
t e n *= TEN;
41 r e s u l t a d o = n number / t e n ;
i++;
43
}
45
t e n /= TEN; // r e g r e s a a cuando t e n d e j a una unidad
47
w h i l e ( j <= i )

2
49 {
r e s u l t a d o = n number / t e n ; // o b t e n e r l o s d i g i t o s
51 // n number e s e l r e s t o d e s p u e s de o b t e n e r e l d i g i t o
// ahora t e n debe s e r menor e j . a n t e s e r a n c e n t e n a s ,
53 // ahora d e c e n a s l a s que s e obtendran
n number %= t e n ;
55
t e n /= TEN;
57 // cada uno de l o s d i j i t o s m u l t i p l i c a l o s por l a p o t e n c i a
// c o r r e s p o n d i e n t e de d i e z
59 // de t a l manera que s e e vayan i n v i e r t i e n d o l o s numeros
sum += r e s u l t a d o * p o t e n c i a (TEN, j++) ;
61 }

63 // a l f i n a l s o l o nos f a l t a a g r e g a r l a unidad l a c u a l s e r a
// e l u l t i m o numero n number
65 // que e s e l r e s u l t a d o d e l modulo d e l numero o r i g i n a l e n t r e
// l a p o t e n c i a mas grande que d e j a
67 // l a unidad y a s i s e i n v i e r t e e l numero
sum += n number * p o t e n c i a (TEN, j ) ;
69
r e t u r n sum ;
71 }

73 i n t main ( )
{
75 l o n g number , i n v e r t i d o ;

77 p r i n t f ( ” \ t \ t I n g r e s e un numero p o s i t i v o \n” ) ;
s c a n f ( ”%l d ” , &number ) ;
79 i n v e r t i d o = i n v i e r t e n u m e r o ( number ) ;
p r i n t f ( ” \n\ t E l numero e s %l d \n” , number ) ;
81 p r i n t f ( ” \ t E l numero i n v e r t i d o e s %l d \n” , i n v e r t i d o ) ;

83 i f ( number == i n v e r t i d o )
{
85 p r i n t f ( ” \ t%l d e s palindromo \n” , number ) ;
}
87 else
{
89 p r i n t f ( ” \tNo e s palindromo u . u\n” ) ;
}
91
r e t u r n ZERO;
93 }

3
Ejercicio 2 Figure 4: Lenando con push()

Escribe un programa que implemente la estructura

de datos Stack usando un arreglo de enteros. Se
puede asumir que la capacidad máxima del Stack
es de 10 enteros. El arreglo se puede definir glob-
almente y se implementaran las funciones push y
pop:

void push(int)

int pop( )

Simula 10 operaciones e imprime en terminal el

estado interno del Stack.

Respuesta

El algoritmo no necesita que el usuario introduzca

datos, únicamente se muestra como cambia el es- Figure 5: Vaciando con pop()
tado de un stack al realizar ciertas operaciones. Las
operaciones que están disponibles son is empty(),
is full(), push() y pop(). La manera en que se tra-
baja el arreglo es usando dos variables globales muy
importantes, que son los datos actuales dentro del
stack denotados por n y el array donde se guarda
el stack.

Si se quiere realizar un push pero el stack ya

esta lleno, mandara un mensaje a la salida de datos
standard diciendo que es imposible dicha operación
en ese momento figura (6), algo similar sucede si se
quiere hacer pop y el stack esta vació. Tambien se Figure 6: Stack lleno
agrego una función que imprime los datos del stack
y el numero de datos que existen en el.

En las figuras (4) y (5) se muestran algunas op-

eraciones realizadas para primero llenar el arreglo
y después hacer pop a algunos elementos. Despues
de la imagenes se muestra el codigo del programa.

4
 Code 2: main.c
1 // Giovanny E n c i n i a
// 30/08/2021
3 #i n c l u d e <s t d i o . h>
#d e f i n e ZERO 0
5 #d e f i n e ONE 1
#d e f i n e SIZE 10
7 #d e f i n e LEN( a ) ( s i z e o f ( a ) / s i z e o f ( a [ZERO ] ) )

9 v o i d push ( i n t ) ;
i n t pop ( v o i d ) ;
11 v o i d imprime ( v o i d ) ;
i n t i s f u l l ( void ) ;
13 i n t is empty ( void ) ;

15 i n t a [ SIZE ] ;
i n t n = ZERO; // s e r v i r a para c o n t r o l a r e l s t a c k
17
i n t i s f u l l ( void )
19 {
/∗ Comprueba que e l s t a c k e s t a v a c i o ,
21 e s t o con ayuda de l a
v a r i a b l e g l o b a l n∗/
23
i f ( n == SIZE )
25 {
r e t u r n ONE; // v e r d a d e r o
27 }
else
29 {
r e t u r n ZERO; // f a l s o
31 }
}
33
i n t is empty ( void )
35 {
/∗ Comprueba que e l s t a c k e s t e l l e n o ,
37 e s t o con ayuda de l a
v a r i a b l e g l o b a l n∗/
39
i f ( n == ZERO)
41 {
r e t u r n ONE;
43 }
else
45 {
r e t u r n ZERO;
47 }
}

5
49
v o i d push ( i n t number )
51 {
i f (! i s f u l l ())
53 {
a [ n ] = number ;
55 n++; // a c t u a l i z a e l e s t a d o d e l s t a c k
}
57 else
{
59 p r i n t f ( ” \ t \ t E l a r r e g l o ya e s t a \
l l e n o , i m p o s i b l e h a c e r push \n” ) ;
61 }

63 }

65 i n t pop ( v o i d )
{
67 i n t number ;
i f ( ! is empty ( ) )
69 {
number = a [ n - ONE ] ;
71 n -= ONE; // a c t u a l i z a e l e s t a d o d e l s t a c k
}
73 else
{
75 p r i n t f ( ” \ t \ t E l a r r e g l o ya e s t a \
v a c i o i m p o s i b l e h a c e r pop , r e g r e s a r a 0\n” ) ;
77 r e t u r n ZERO;
}
79
r e t u r n number ;
81 }

83 v o i d imprime ( v o i d )
{
85 i n t i = ZERO;

87 p r i n t f ( ” \ t \ t E l s t a c k t i e n e %d \
e l e m e n t o s : \ n\ t \ t ” , n ) ;
89
while ( i < n)
91 {
p r i n t f ( ”%d ” , a [ i ] ) ;
93 i++;
}
95
p r i n t f ( ” \n\n” ) ;
97 }

6
99 i n t main ( v o i d )
{
101 i n t i = ZERO;

103 w h i l e ( i < SIZE + ONE)

{
105 p r i n t f ( ” \ t \ tpush a l v a l o r %d\n” , i * 3 ) ;
push ( i * 3 ) ;
107 imprime ( ) ;
i++;
109 }

111 p r i n t f ( ” \ t \ tpop a l v a l o r %d\n” , pop ( ) ) ;

imprime ( ) ;
113 p r i n t f ( ” \ t \ tpop a l v a l o r %d\n” , pop ( ) ) ;
p r i n t f ( ” \ t \ tpop a l v a l o r %d\n” , pop ( ) ) ;
115 p r i n t f ( ” \ t \ tpop a l v a l o r %d\n” , pop ( ) ) ;
push ( i++) ;
117 imprime ( ) ;

119 r e t u r n ZERO;

121 }

7
Ejercicio 3 Figure 7: Primera versión

Escribe una función que reciba un arreglo de en-

teros y que calcule el producto acumulado para
cada entrada usando
Y
a[i] = a[j]
j6=i

Se espera que la complejidad del algoritmo sea lin-

eal O(n). Se puede asumir que la longitud máxima
del arreglo será 50.
Firma de la función: products(int a[ ], int prod-
ucts[ ]) Imprime en terminal el arreglo original y el
arreglo de productos.
NOTA: El martes 31 de agosto estudiaremos fun-
ciones con argumentos de tipo arreglo.

Respuesta

Se hicieron dos versiones del algoritmo, al principio

creı́ que solamente se deberı́a de obtener el pro-
ducto acumulado del arreglo para cada elemento,
por ejemplo para el arreglo [1, 2, 3, 4] el resultado
seria [1, 2, 6, 12] figura (7). Entonces este programa
que también sera entregado, pide al usuario la can-
tidad de elementos que tendrá el arreglo (máximo
de 50) y comienza a realizar el producto como se
mostró anteriormente. Al final imprime el arreglo
entregado y el arreglo con el producto acumulado. Figure 8: Segunda versión
La segunda versión al final me hizo mas sentido
ya que mencionaba que i 6= j, esta versión también
pide el numero de elementos del arreglo y después
empieza a leer cada elemento, al terminar multi-
plica todo los elementos exceptuando el elemento
cuyo ı́ndice en el arreglo original es el mismo que
en el que se guardara. Se toman tres casos distin-
tos, el primer caso es donde todos los elementos son
distintos de cero figura (8), el segundo es donde solo
existe un cero figura (9), y el tercero es donde hay
mas de un cero figura (10). Cuando existe un cero,
el ı́ndice donde esta el elemento cero tendrá el valor
de la multiplicación de cada uno de los elementos,
y los demás espacios en el arreglo serán cero. El
primer caso es trivial y en el segundo caso todos
los elementos son ceros.

8
 Figure 9: Segunda versión un cero

Figure 10: Segunda versión mas de un cero

9
 Code 3: version1.c
1 #i n c l u d e <s t d i o . h>
#d e f i n e ZERO 0
3 #d e f i n e ONE 1
#d e f i n e SIZE 50
5
void products ( i n t [ ] , i n t [ ] , i n t lenght ) ;
7 void p r i n t a r r a y ( i n t a [ ] , i n t lenght ) ;

9 void p r i n t a r r a y ( i n t ar [ ] , i n t lenght )
{
11 /∗ f u n c i o n que umprime e l a r r e g l o ∗/
int i = 0;
13
p r i n t f ( ”\ t \ t ” ) ;
15 while ( i < lenght )
{
17 p r i n t f ( ”%d ” , a r [ i++ ] ) ;
}
19
p r i n t f ( ” \n\n” ) ;
21 }

23 void products ( i n t a [ ] , i n t product [ ] , i n t lenght )

{
25 int i = 0;

27 // e l p r i m e r e l e m e n t o de p r o d u c t e s e l
// p r i m e r e l e m e n t o de a
29 product [ i ] = a [ i ] ;
i++;
31
while ( i < lenght )
33 {
// e l e l e m e n t o a n t e r i o r de prod
35 // por e l e l e m e n t o e q u i de a
p r o d u c t [ i ] = p r o d u c t [ i - ONE] * a [ i ] ;
37 i++;
}
39
p r i n t f ( ” \ t \ t E l a r r e g l o o r i g i n a l e s : \ n” ) ;
41 print array (a , lenght ) ;
p r i n t f (\
43 ”\ t \ t E l a r r e g l o con p r o d u c t o acumulado e s : \ n” ) ;
p r i n t a r r a y ( product , l e n g h t ) ;
45 }

47 i n t main ( )
{

10
49 i n t a [ SIZE ] , tamanio , p r o d u c t [ SIZE ] , i = 0 ;

51 p r i n t f ( ” \ t \ tCuantos e l e m e n t o s t e n d r a \
e l a r r e g l o ( maximo 5 0 ) ? \ n” ) ;
53 s c a n f ( ” %d” , &tamanio ) ;

55 w h i l e ( i < tamanio )
{
57 p r i n t f ( ” Agregue e l e l e m e n t o %d\n” , i ) ;
s c a n f ( ” %d” , &a [ i++ ] ) ;
59 }

61 p r o d u c t s ( a , product , i ) ;

63 r e t u r n ZERO;
}

Code 4: version2.c
#i n c l u d e <s t d i o . h>
2 #d e f i n e SIZE 50
#d e f i n e ZERO 0
4 #d e f i n e ONE 1

6 int read array ( int [ ] ) ;

void p r i n t a r r a y ( i n t [ ] , i n t ) ;
8 i n t producto ( i n t [ ] , int , i n t ) ;
void products ( i n t [ ] , i n t [ ] , \
10 int );

12 int read array ( int a [ ] )

{
14 i n t i = 0 , number ;

16 p r i n t f ( ” \ t \ t I n g r e s e e l numero \
de e l e m e n t o s maximo 50\n\ t \ t ” ) ;
18 s c a n f ( ” %d” , &number ) ;

20 w h i l e ( i < number )
{
22 p r i n t f ( ”\ t \ t I \
n g r e s e e l e l e m e n t o %d\n\ t \ t ” , i ) ;
24 s c a n f ( ” %d” , &a [ i++ ] ) ;
}
26

28 r e t u r n number ;
}
30
void p r i n t a r r a y ( i n t a [ ] , i n t length )

11
32 {

34 int i = 0;

36 p r i n t f ( ”\ t \ t ” ) ;
while ( i < length )
38 {
p r i n t f ( ”%d ” , a [ i++ ] ) ;
40 }
p r i n t f ( ” \n\n” ) ;
42 }

44 i n t p r o d u c t o ( i n t a [ ] , i n t index , i n t l e n g t h )
{
46 /∗ R e a l i z a e l p r o d u c t o de cada uno de l o s
e l e m e n t o s d e l a r r e g l o ∗/
48
i n t i = ZERO, pro = ONE;
50
while ( i < length )
52 {
i f ( i == i n d e x )
54 {
i++;
56 continue ;
}
58
pro *= a [ i++ ] ;
60 }

62 r e t u r n pro ;
}
64
void products ( i n t a [ ] , i n t product [ ] , \
66 int length )
{
68 /∗ Asigna e l p r o d u c t o d e l a r e g l o
a un e l e m e n t o d e l nuevo a r r e g l o
70 evitando e l elemento i del
a r r e g l o o r i g i n a l ∗/
72
i n t i = ZERO, prod = ONE;
74 i n t count = ZERO, i n d e x ;
int activate index ;
76
// c u a n t s a c u a n t o s c e r o s
78 // hay en e l a r r e g l o
while ( i < length )
80 {
i f ( a [ i ] == ZERO)

12
82 {
count++;
84 index = i ;
}
86
i++;
88 }

90 s w i t c h ( count )
{
92 c a s e ZERO: // no hay c e r o s
a c t i v a t e i n d e x = ZERO;
94 // menos uno e s para poder
// m u l t i p l i c a r t o d o s l o s e l e m e n t o s
96 prod = p r o d u c t o ( a , -ONE, l e n g t h ) ;
break ;
98 c a s e ONE: // hay un c e r o
// p r o d u c t o que t e n d r a e l e l e m e n t o
100 // con c e r o
// ademas que s e a c t i v a en e l i f
102 // s i hay v a l o r
activate index = \
104 p r o d u c t o ( a , index , l e n g t h ) ;
prod = ZERO;
106 break ;
default :
108 a c t i v a t e i n d e x = ZERO;
prod = ZERO;
110 }

112 i = ZERO;

114 while ( i < length )

{
116 // e x i s t e s o l o un 0
i f ( activate index )
118 {

120 i f ( i == i n d e x )
{
122 product [ i ] = a c t i v a t e i n d e x ;
}
124 else
{
126 p r o d u c t [ i ] = ZERO;
}
128
}
130 else
{

13
132 // e x i s t e mas de un 0
i f ( prod == ZERO)
134 {
p r o d u c t [ i ] = ZERO;
136 }
// no e x i s t e ningun 0
138 else
{
140 p r o d u c t [ i ] = prod / a [ i ] ;
}
142
}
144
i++;
146 }

148 }

150
i n t main ( )
152 {
i n t a [ SIZE ] , b [ SIZE ] , l 1 ;
154
// l e e y o b t i e n e #e l e m e n t o s
156 l 1 = read array (a ) ;
// o b t i e n e a r r e g l o p r o d u c t o s
158 products (a , b , l 1 ) ;
p r i n t f ( ” \n\ t \ t E l a r r e g l o \
160 o r i g i n a l e s : \ n” ) ;
print array (a , l 1 );
162 p r i n t f ( ” \ t \ t E l a r r e g l o con \
o r o d u c t o s e s : \ n” ) ;
164 print array (b , l 1 ) ;

166 r e t u r n ZERO;
}

14
Ejercicio 4 Figure 11: Primer arreglo

Escribe una función que reciba dos arreglos de en-

teros ordenados en forma no decreciente, y combine
dichos arreglos en un solo arreglo también ordenado
en forma no decreciente.

Firma de la función: void merge(int a1[], int n1,

int a2[], int n2, int result[], int n3)

Se puede asumir que la longitud máxima de los

arreglos a1 y a2 será 20, n1 y n2 representa el
número de elementos en dichos arreglos.
Figure 12: Segundo arreglo

Respuesta

El algoritmo pide al usuario elementos de dos ar-

reglos, estos datos deben de ser del tipo entero,
podemos observar en la figura (11) y (12). como
es que se muestra en pantalla la petición, es im-
portante remarcar que el arreglo que se da debe de
estar en un orden no decreciente, este concepto lo
he tomado como que puede ser un arreglo desorde-
nado o un arreglo ordenado de manera creciente, si
esto no se cumple lanza un mensaje como el de la Figure 13: Imprime/Merge
figura (15) y se termina el programa.

Una vez que se entregan los datos, el algoritmo

procede a realizar el merge a los dos arreglos y de-
spués imprime en pantalla el nuevo arreglo. Por
ultimo se le pregunta al usuario si quiere que el
arreglo este ordenado estrictamente de manera cre-
ciente, si este oprime 1 en teclado el arreglo se or-
dena y después se imprime el resultado como en
la figura (14). La manera en que se comprueba
que un arreglo es verdaderamente no decreciente, es
primero ordenando una copia del verdadero arreglo
de manera decreciente, este despues se compara con Figure 14: Opción ordenar
el original, y si es igual, entonces se rechaza figura
(15). El mismo algoritmo de ordenamiento se uti-
liza al final cuando el usuario decide ordenar el ar-
reglo de manera creciente. El algoritmo que se uti-
liza es ”merge sort”.

15
Figure 15: Entrada decreciente

16
 Code 5: main.c
1 // Giovanny E n c i n i a
// 31/08/2021
3 #i n c l u d e <s t d i o . h>
#i n c l u d e ” f u n c t i o n s . h”
5 #d e f i n e ZERO 0
#d e f i n e ONE 1
7 #d e f i n e SIZE 20

9 i n t main ( )
{
11 i n t a [ SIZE ] , b [ SIZE ] , c [ SIZE + SIZE ] ;
i n t a c [ SIZE ] , b c [ SIZE ] ;
13 i n t tamanio 1 , tamanio 2 ;
char option ;
15
p r i n t f ( ” \ t \ t ∗∗∗∗ Primer a r r e g l o ∗∗∗∗\ n” ) ;
17 tamanio 1 = w r i t e c o p i a c o m p r u e b a ( a , a c ) ;

19 i f ( ! tamanio 1 )
r e t u r n ZERO;
21
p r i n t f ( ” \ t \ t ∗∗∗∗ Segundo a r r e g l o ∗∗∗∗\ n” ) ;
23 tamanio 2 = w r i t e c o p i a c o m p r u e b a ( b , b c ) ;

25 i f ( ! tamanio 2 )
r e t u r n ZERO;
27
p r i n t f ( ” \ t \ t E l a r r e g l o a [ ] e s \n” ) ;
29 p r i n t a r r a y ( a , tamanio 1 ) ;

31 p r i n t f ( ” \ t \ t E l a r r e g l o b [ ] e s \n” ) ;
p r i n t a r r a y ( b , tamanio 2 ) ;
33

35 merge ( a , tamanio 1 , b , \
tamanio 2 , c , tamanio 1+tamanio 2 ) ;
37
p r i n t f ( ” \ t \ t E l a r r e g l o merge e s : \n” ) ;
39 p r i n t a r r a y ( c , tamanio 1 + tamanio 2 ) ;

41 p r i n t f ( ” \ t \ tDesea o r d e n a r en \
orden c r e c i e n t e ? ( s i : 1 , no : o t h e r ) \ n\ t \ t ” ) ;
43 s c a n f ( ” %c ” , &o p t i o n ) ;

45 i f ( o p t i o n == ’ 1 ’ )
{
47 m e r g e s o r t ( c , ZERO, \
tamanio 1 + tamanio 2 - ONE, ONE) ;

17
49 p r i n t f ( ” \ t \ t E l a r r e g l o ordenado e s \n” ) ;
p r i n t a r r a y ( c , tamanio 1+tamanio 2 ) ;
51 }

53 r e t u r n ZERO;
}

Code 6: functions.h
#i f n d e f FUNCTIONS
2 #d e f i n e FUNCTIONS

4 void merge sort ( i n t [ ] , int , int , i n t ) ;

v o i d merge ( i n t [ ] , i n t , i n t [ ] , \
6 int , int [ ] , int ) ;
v o i d merge ( i n t [ ] , i n t , i n t , i n t , i n t ) ;
8 void p r i n t a r r a y ( i n t [ ] , i n t ) ;
int leer arreglo ( int [ ] ) ;
10 void copy array ( i n t [ ] , i n t [ ] , i n t ) ;
int write copia comprueba ( int a [ ] , int a c [ ] ) ;
12
#e n d i f // FUNCTIONS

Code 7: fucntions.c
1 // Giovanny E n c i n i a
// 31/08/2021
3 #i n c l u d e <s t d i o . h>
#d e f i n e ZERO 0
5 #d e f i n e ONE 1
#d e f i n e SIZE 20
7
v o i d merge ( i n t a [ ] , i n t l 1 , i n t b [ ] , \
9 int l 2 , int c [ ] , int l 3 )
{
11 /∗ Junta dos a r r e g l o s en un nuevo a r r e g l o ∗/

13 i n t i = ZERO, j = ZERO, k = ZERO;

15 while ( i < l 1 )
{
17 c [ k ] = a [ i++ ] ;
k++;
19 }

21 while ( j < l 2)
{
23 c [ k ] = b [ j++ ] ;
k++;

18
25 }

27 }

29 v o i d merge ( i n t a [ ] , i n t l e f t , i n t mid , i n t r i g h t , i n t o r d e r )
{
31 /∗ Es e l pado merge d e l a l g o r i t m o merge s o r t ∗/

33 i n t l 1 , r 1 , k , i = ZERO, j = ZERO;

35 l 1 = mid - l e f t + ONE;
r 1 = r i g h t - mid ;
37 // A r r e g l o s que nos ayudan a almacenar
// d i v i s i o n e s d e l o r i g i n a l
39 i n t L [ l 1 ] , R[ r 1 ] ;

41 while ( i < l 1 )
{
43 // n u e s t r o punto de r e f e r e n c i a
// s i e m p r e e s l e f t , e s t e cambia
45 // conforme avanza l a r e c u r s i v i d a d
L[ i ] = a [ l e f t + i ] ;
47 i++;
}
49
while ( j < r 1 )
51 {
R[ j ] = a [ mid + j + ONE ] ;
53 j++;
}
55
i = j = ZERO;
57 k = left ;

59 w h i l e ( i < l 1 && j < r 1 )

{
61 // o d e r 1 c r e c i e n t e
// 0 d e c r e c i e n t e
63 i f ( o r d e r ? ( L [ i ] < R[ j ] ) : (L [ i ] > R[ j ] ) )
{
65 a [ k ] = L [ i++ ] ;
}
67 else
{
69 a [ k ] = R[ j++ ] ;
}
71
k++;
73 }

19
75 // pueden haber s o b r a d o d a t o s
// s i n ordenar , a s i que s e l l e n a
77 // con e l s o b r e n t e
while ( i < l 1 )
79 {
a [ k ] = L [ i++ ] ;
81 k++;
}
83
while ( j < r 1 )
85 {
a [ k ] = R[ j++ ] ;
87 k++;
}
89
}
91
void merge sort ( i n t a [ ] , i n t l e f t , i n t right , i n t order )
93 {
/∗ a l g o r i t m o merge s o r t ∗/
95
i n t mid ;
97
i f ( l e f t < right )
99 {
// buscamos e l punto medio
101 mid = l e f t + ( r i g h t - l e f t ) / 2 ;

103 // r e c u r s d i v i d a d a l a p r i m e r a mitad
m e r g e s o r t ( a , l e f t , mid , o r d e r ) ;
105 // segunda mitad
m e r g e s o r t ( a , mid + ONE, r i g h t , o r d e r ) ;
107 // r e a l i z a merge a l a s m i t a d e s
merge ( a , l e f t , mid , r i g h t , o r d e r ) ;
109 }

111 }

113 void p r i n t a r r a y ( i n t a [ ] , i n t s i z e )
{
115 i n t i = ZERO;

117 p r i n t f ( ”\ t \ t ” ) ;
while ( i < s i z e )
119 {
p r i n t f ( ”%d ” , a [ i++ ] ) ;
121 }

123 p r i n t f ( ” \n” ) ;
}

20
125
int l e e r a r r e g l o ( int array [ ] )
127 {
/∗ Lee cada uno de l o s e l e m e n t o s
129 que t e n d r a e l a r r e g l o
e l tamanio maximo e s de 20 e l e m e n t o s ∗/
131
i n t tamanio , i = ZERO;
133
p r i n t f ( ” \ t \ tCuantos e l e m e n t o s t e n d r a \
135 e l a r r e g l o ( maximo 2 0 ) ? \ n\ t \ t ” ) ;
s c a n f ( ” %d” , &tamanio ) ;
137
w h i l e ( i < tamanio )
139 {
p r i n t f ( ” \ t \ tAgregue e l e l e m e n t o %d\n\ t \ t ” , i ) ;
141 s c a n f ( ” %d” , &a r r a y [ i++ ] ) ;
}
143
p r i n t f ( ” \n\n” ) ;
145
r e t u r n tamanio ;
147 }

149 i n t compare ( i n t a [ ] , i n t b [ ] , i n t tamanio )

{
151 /∗Compara cada e l e m e n t o de l o s a r r e g l o s
y r e g r e s a 1 s i son i n g u a l e s ambos a r r e g l o s
153 0 s i son d i s t i n t o s ∗/

155 i n t i = ZERO;

157 w h i l e ( i < tamanio )

{
159 i f ( a [ i ] != b [ i ] )
{
161 r e t u r n ZERO;
}
163
i++;
165 }

167 r e t u r n ONE;
}
169
v o i d c o p y a r r a y ( i n t a [ ] , i n t copy [ ] , i n t s i z e )
171 {
/∗ Copia e l e m e n t o s a un nuevo a r r e g l o ∗/
173
i n t i = ZERO;

21
175
while ( i < s i z e )
177 {
copy [ i ] = a [ i ] ;
179 i++;
}
181
}
183
int write copia comprueba ( int a [ ] , int a c [ ] )
185 {
i n t tamanio ;
187
p r i n t f ( ” \ t \ tAgregue l o s \
189 e l e m e n t o s d e l a r r e g l o \n” ) ;
tamanio = l e e r a r r e g l o ( a ) ;
191 c o p y a r r a y ( a , a c , tamanio ) ;
m e r g e s o r t ( a c , ZERO, tamanio - ONE, ZERO) ;
193
// comprueba que no e s t e en orden d e c r e c i e n t e
195 i f ( compare ( a , a c , tamanio ) )
{
197 p r i n t f ( ” \ t \ tAgregue un a r r e g l o \
que no e s t e en orden d e c r e c i e n t e \n” ) ;
199
r e t u r n ZERO;
201 }

203 r e t u r n tamanio ;
}

22