Problema 5:

Desarrolle un programa para imprimir un intervalo de nmeros que sean

capicas de 3 cifras.
Se pide ingresar por teclado el valor mnimo y mximo donde deben estar los
nmeros capicas comprendidos en este rango.

a) Diagrama de Flujo:

b) Cdigo en lenguaje C:
#include<stdio.h>
void main()
{
int max,min,max1,min1;
int u1,u2,d1,d2,c1,c2;
char m;
printf("Ingrese el rango maximo: \n");
scanf("%d",&max);
printf("Ingrese el rango minimo: \n");
scanf("%d",&min);
system("pause");
max1=max;
min1=min;
c1=max/100;
max=max%100;
d1=max/10;
max=max%10;
u1=max;
c2=min/100;
min=min%100;
d2=min/10;
min=min%10;
u2=min;
if (c2==u2)
{
printf("\n %d%d%d",c2,d2,u2);
do
{
min1++;
min=min1;
c2=min/100;
min=min%100;
d2=min/10;
min=min%10;
u2=min;
if(min1>max1)
{
}
else
{
if(c2==u2 && c2!=0 && u2!=0)
{printf("\n %d%d%d",c2,d2,u2);}
}
}while (c2<10 & d2<10 & u2<10);
}

else
{
do
{
min1++;
min=min1;
c2=min/100;
min=min%100;
d2=min/10;
min=min%10;
u2=min;
if(min1>max1)
{
}
else
{
if(c2==u2 && c2!=0 && u2!=0)
{printf("\n %d%d%d",c2,d2,u2);}
}
}while (c2<10 & d2<10 & u2<10);
}
}

c) Cdigo en lenguaje ensamblador:

org 100h
jmp inicio
maximo db '?','?','?'
minimo db '?','?','?'
espacio db 10,13,'$'
tex1 db 10,13,'Ingrese el valor maximo$'
tex2 db 10,13,'Ingrese el valor minimo$'
tex3 db 10,13,'Presione una tecla para comenzar$'
inicio:
mov ah,9
mov dx, offset tex1
int 21h
mov ah,9
mov dx, offset espacio
int 21h
lea si,maximo
mov cx,3
max:
mov ah,1
int 21h
mov [si],al

inc si
loop max
mov ah,9
mov dx, offset tex2
int 21h
mov ah,9
mov dx, offset espacio
int 21h
lea di,minimo
mov cx,3
min:
mov ah,1
int 21h
mov [di],al
inc di
loop min
mov ah,9
mov dx, offset espacio
int 21h
mov ah,9
mov dx, offset tex3
int 21h
mov ah,7
int 21h
mov ah,9
mov dx,offset espacio
int 21h
lea si,maximo
lea di,minimo
mov al,[di]
inc di
inc di
mov ah,[di]
cmp al,ah
je mostrar
jne ultimo
mostrar:
mov ah,9
mov dx, offset espacio
int 21h
lea di,minimo
mov cx,3

lea si,maximo
lea di,minimo
mov cx,3
control:
mov ah,[si]
mov al,[di]
cmp ah,al
jbe centenas
jne min2
centenas:
inc si
inc di
mov ah,[si]
mov al,[di]
cmp ah,al
jbe decenas
jne min2
decenas:
inc si
inc di
mov ah,[si]
mov al,[di]
cmp ah,al
jbe fin1
jne min2
loop control
min2:
lea di,minimo
min1:
mov ah,2
mov dx,[di]
int 21h
inc di
loop min1
lea di,minimo
inc di
add [di],1
mov bh,[di]
mov bl,0Ah
add bl,30h
cmp bh,bl
ja sor
jb mostrar
sor:

lea di,minimo
inc [di]
mov ah,[di]
inc di
mov [di],'0'
inc di
inc [di]
mov al,[di]
mov bl,0Ah
add bl,30h
cmp ah,bl
jae fin
un:
cmp ah,al
je mostrar
ultimo:
mov ah,9
mov dx, offset espacio
int 21h
lea di,minimo
mov cx,3
lea si,maximo
lea di,minimo
mov cx,3
control1:
mov ah,[si]
mov al,[di]
cmp ah,al
jbe centenas1
jne hulk
centenas1:
inc si
inc di
mov ah,[si]
mov al,[di]
cmp ah,al
jbe decenas1
jne hulk
decenas1:
inc si
inc di
mov ah,[si]
mov al,[di]
cmp ah,al
jbe fin1
jne hulk

loop control1
hulk:
lea di,minimo
mov bl,[di]
inc di
inc di
mov bh,[di]
cmp bh,bl
je mostrar21
min21:
lea di,minimo
mov bl,[di]
inc di
inc di
inc [di]
mov bh,[di]
cmp bh,bl
je mostrar21
jb min21
jne salto
salto:
lea di,minimo
inc di
inc di
mov [di],'0'
jmp min21
mostrar21:
lea di,minimo
mov cx,3
min12:
mov ah,2
mov dx,[di]
int 21h
inc di
loop min12
lea di,minimo
inc di
add [di],1
mov bh,[di]
mov bl,0Ah
add bl,30h
cmp bh,bl
ja sor12

jb ultimo
sor12:
lea di,minimo
inc [di]
mov ah,[di]
inc di
mov [di],'0'
inc di
inc [di]
mov al,[di]
mov bl,0Ah
add bl,30h
cmp ah,bl
jae fin
un1:
cmp ah,al
je ultimo
fin:
cmp al,bl
jae fin1
jb un
fin1:
lea si, maximo
mov ah,[si]
inc si
inc si
mov al,[si]
cmp ah,al
je sid1
jne sid
sid1:
lea si,maximo
mostrarx:
mov ah,2
mov dx,[si]
int 21h
inc si
loop mostrarx
sid:
ret

d) Resultados:
d.1) EN DFD:

d.2) Lenguaje C:

d.3) Lenguaje ensamblador:

e) Observaciones y conclusiones:
EL problema nmero 5, el cual realice en c, dfd y emu8086, fue una
programacin larga (emu8086) por la que al ingresar el dato, yo lo hice
ya separado en sus valores, el problema fue en la comparaciones que

realice fueron tantas que tuve que estar creando subrutinas en las
cuales cumplan su funcin como incrementar el valor o incrementar el
vector, pero la realizacin fue una de las tantas maneras que logr
pensar.
Se pudo haber mejorado usando el comando call, pero se necesita un
anlisis mas profundo acerca de lo que realiza cada subrutina y las
cuales cumplen una funcin y realizan un salto hacia otra subrutina, esa
es la razn por la cual si se usaba el comando call hubiera necesitado un
anlisis ms profundo.
f) Bibliografa:
El lenguaje de programacin C - Kernighan, Ritchie
Programacin en C Metodologa, algoritmos y estructura de datos Luis
Joyanes