MOSTRAR EN ENSAMBLADOR LOS NÚMEROS DEL 1 AL 100 EN BASE HEXADECIMAL

CÓDIGO EN ENSAMBLADOR

page 60, 132

title Cien_Caracteres

;--------------------

pila segment para stack 'stack'

DB 12 dup ('pilapila')

pila ends

;--------------------

dato segment para 'data'

dato ends

;--------------------

codigo segment para 'code'

inicio proc far

assume cs: codigo, ds:dato, es:dato, ss:pila

push ds

sub ax, ax

push ax

mov ax, dato

mov ds, ax

mov es, ax

;-------------------- PROGRAMA PRINCIPAL -------------------

mov bl, 31h;asignacion b=1

mov cl, 41h;asignacion c=A

unidades1:; en esta etiqueta se imprimen los primeros numeros de un digito del 1 a 9

                                               mov ah,08; se lee un caracter de pantalla

                                               int 21h

                                               mov ah, 02

                                               mov dl, bl; salida en pantalla de bl (numeros del 1 al 9)

                                               int 21h

                                               mov ah, 02

                                               mov dl, 20h;salida en pantalla de espacio para separar los numeros

                                               int 21h

                                               inc bl;incremento de bl

                                               cmp bl, 39h;comparacion de bl con 9

                                               ja unidades2;salto condicional: si bl es igual a 9 salta a unidades2 para ahora imprimir de la A a la F

                                               jmp unidades1;salto incondicional a unidades 1 para continuar imprimiendo numeros

unidades2:; en esta etiqueta se imprimen los primeros numeros de un dígito  de la A a la F

                                               mov ah,08;se lee un caracter de pantalla

                                               int 21h

                                               mov ah, 02

                                               mov dl, cl; salida en pantalla de letras de la A a la F

                                               int 21h

                                               mov ah, 02

                                               mov dl, 20h;salida en pantalla de espacio para separar los numeros

                                               int 21h

                                               inc cl ;incremento de cl

                                               cmp cl, 46h; comparacion de cl con F

                                               ja decenas;salto condicional: si cl es mayor que F saltara a decenas

                                               jmp unidades2;salto incondicional a unidades2

                                               decenas:;en esta etiqueta asignamos nuevos valores a bl y cl para comezar con los numeros de dos digitos

                                               mov bl, 31h;asignamos a bl 1

                                               mov cl, 30h;asignamos  a cl 0

                                               jmp doble1;salto incondicional a doble1

incremento1:;aqui se majen las letras para los numeros de dos cifras

                                               mov cl,41h; se asigna a cl A

                                               cmp cl,46h;se compara cl con F

                                               ja incremento2;salto condicional: si cl es mayor  que F salta a incremento2

                                               jmp doble2;salto incondicional a doble2

incremento2:;aqui se controla el incremento de bl y se asigna a cl 0 para iniciar una nueva impresion de unidades

                                               mov cl,30h; asignacion a cl de 0

                                               inc bl;; se incrementa bl

                                               cmp bl,36h;se compara bl con 6

                                               je doble3;salto condicional: si bl es igual a 6 salta a doble3

                                               jmp doble1;salto incondicional  a doble1 para continuar imprimiendo numero con numero

doble1:;en esta etiqueta se muestran en pantalla numeros de dos digitos (numero con numero)

                                               mov ah,08;lee un caracter en pantalla

                                               int 21h

                                               mov ah,02

                                               mov dl, bl;se imprime en pantalla un numero(del 1 al 5)

                                               int 21h

                                               mov ah,02

                                               mov dl, cl¨;se imprime en pantalla un numero(del 0 al 9)

                                               int 21h

                                               mov ah, 02

                                               mov dl, 20h; se imprime un pantalla un espacio

                                               int 21h

                                               inc cl;incremento de cl

                                               cmp cl,39h;comparacion de cl con 9

                                               ja incremento1;salto condicional:  si cl es mayor que 9 salta a incremento1

                                               jmp doble1;salto incondicional a doble1 para continuar imprimiendo numero y numero

doble2:;en esta etiqueta se imprimen numeros de dos cifras formados por numero y letra

                                               mov ah,08;leer un caracter en pantalla

                                               int 21h

                                               mov ah,02

                                               mov dl, bl;se imprime en pantalla un numero(del 0 al 9)

                                               int 21h

                                               mov ah,02

                                               mov dl, cl;se imprime en pantalla una letra(de la A a la F)

                                   int 21h

                                               mov ah, 02

                                               mov dl, 20h;muestra en pantalla un espacio

                                               int 21h

                                               inc cl;incremento de cl

                                               cmp cl,46h;comparacion de cl con F

                                               ja incremento2;salto condicional: si cl es mayor que F salta a incremento2

                                               jmp doble2;salto incondicional a doble2 para seguir imprimiendo numero y letra

doble3:; aqui se terminan de imprimir los numeros del 60 al 64 para no llegar hasta el 6F

                                               mov ah,08;lee un caracter de la pantalla

                                               int 21h

                                               mov ah,02

                                               mov dl, bl;imprime un numero, que en esta parte siempre es 6

                                               int 21h

                                               mov ah,02

                                               mov dl, cl;imprime numeros del 0 al 4

                                               int 21h

                                               mov ah, 02

                                               mov dl, 20h; muestra en pantalla el espacio

                                               int 21h

                                               inc cl;incremento de cl

                                               cmp cl,34h;comparacion de cl con 4

                                               ja fin;salto condicional: si cl es mayor a 4 salta a fin

                                               jmp doble3;salto incondicional  a doble3 para continuar imprimendo del 60 al 64

;------------

fin:; fin del programa

                nop;no realiza accion alguna

;-------------------------- END PP -------------------------

ret

inicio endp

codigo ends

end inicio

ENSAMBLADO, ENLACE Y EJECUCIÓN USANDO TASM Y TLINK

MOSTRAR EN PANTALLA UNA FIGURA EN ENSAMBLADOR

CÓDIGO DEL PROGRAMA

page 60, 132

title figu

;--------------------

pila segment para stack 'stack'

DB 12 dup ('pilapila')

pila ends

;--------------------

dato segment para 'data'

; figu es la figura que se va a mostrar en pantalla, cada linea comienza con DB y termina con 0ah,0dh para

; salto del inea, al final de la figura va el caracter $ para indicar que termina la figura

figu DB '    \\\ ',0ah,0dh

                 DB '     \\\\\\ ',0ah,0dh

                 DB '      \(0)/ ',0ah,0dh

                 DB '     (/ \ ',0ah,0dh

                 DB '     /\  \ ',0ah,0dh

                 DB '    ///   \ ',0ah,0dh

                 DB '   ///|   | ',0ah,0dh

                 DB '  ////|   | ',0ah,0dh

                 DB ' //////   / ',0ah,0dh

                 DB '  |////  /_ ',0ah,0dh

                 DB ' /|///_ _ _/ ',0ah,0dh

                 DB '//\/|     | ',0ah,0dh

                 DB '__////____\__\_______ ',0ah,0dh

                 DB '_____________________ ',0ah,0dh

                 DB '    ||       || ',0ah,0dh

     DB '    ||       ||','$'

dato ends

;--------------------

codigo segment para 'code'

inicio proc far

assume cs: codigo, ds:dato, es:dato, ss:pila

push ds

sub ax, ax

push ax

mov ax, dato

mov ds, ax

mov es, ax

;-------------------- PROGRAMA PRINCIPAL -------------------

mov ah,09; funcion 09 envio de una cadena de caracteres en este caso es nuestra figura de nombre figu

mov dx,offset figu

int 21h

;------------

fin:;etiqueta fin

nop;no realiza instruccion

;-------------------------- END PP -------------------------

ret

inicio endp

codigo ends

end inicio

ENSAMBLADO, ENLACE Y EJECUCIÓN USANDO TASM Y TLINK

ORDENAR MIEMBROS DE FAMILIA CON EDADES USANDO MÉTODO BURBUJA Y PROPIEDAD SPLIT

Objetivo: lograr que el alumno recuerde el uso de la programación estructurada.

Desarrollo: crear un programa (consola), que solicite el nombre y las edades de tu familia, cuyo programa tendrá el siguiente formato:

Familia: apellido paterno, apellido materno.

Padre: Nombre, A. P., A.M.

Madre: Nombre, A.P., A. M.

Hijo1: Nombre, A.P., A. M.

Hijo2: Nombre, A.P., A. M.

El programa solicitará nombres y edades, no el parentesco:

Integrante #1, integrante #2, etc.

Observaciones:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace practica1_ordrnomb_1cadena_

{

    class Program

    {

        static void Main(string[] args)

        {

            // Declaracion de variables

            // Para almacenar la cadena de entrada se declara una variable de tipo string(cadena) llamada cadena

            string cadena;

            // Se declaran los arreglos para edades, nombres y los apellidos, de tamaño 4 pues solo ingresaremos

            // 4 integrantes de una familia, sólo edades será de tipo entero y los restantes de tipo string

            int[] edades = new int[4];

            string[] nombres = new string[4];

            string[] apellido_p = new string[4];

            string[] apellido_m = new string[4];

            // Se declara un arreglo para cada integrante, sin tamaño pues se llenaran posteriormente

            string[] integrante1;

            string[] integrante2;

            string[] integrante3;

            string[] integrante4;

            // Para descomponer la cadena de entrada se declara un arreglo con los posibles delimitadores en la propia cadena

            // para este programa se usará el espacio en blanco pero pueden ser comas, puntos, etc. Será de tipo char(caracter)

            char[] caracteresdelimitadores = { ' ', ',', '.', ':', '\t' };

            // Se definen las instrucciones:

            Console.WriteLine("                   BIENVENIDO");

            Console.WriteLine("Instrucciones: Inserte cada uno de los miembros de la familia,\n el formato es el siguiente:\n  NOMBRE espacio APELLIDO PATERNO espacio APELLIDO MATERNO espacio EDAD \n Ejemplo: Guadalupe Ramirez Cobos 40");

            Console.WriteLine("OPRIMA UNA TECLA PARA CONTINUAR");

            // La instrucción Console.ReadKey(); Espera a que se teclee cualquier tecla para continuar con el programa

            Console.ReadKey();

            // borramos pantalla

            Console.Clear();

            // Se comienzan a ingresar los datos:

           Console.WriteLine("Ingrese el integrante 1:");

            // Ingresaremos la cadena y la siguiente instrucción la almacenará en la variable "cadena".

            cadena = Console.ReadLine();

            // Enseguida con la propiedad Split a partir del arreglo que contiene los caracteres delimitantes separaremos en partes la cadena y se almacenaran en los arreglos antes declarados.

          integrante1 = cadena.Split(caracteresdelimitadores);

            // Se almacena el nombre del primer integrante en el arreglo nommbres en su posicón 0 y lo tomamos del arreglo integrante1 en su posición 0 pues en esa posicion se guarda el nombre.

          nombres[0] = integrante1[0];

            // Lo mismo se hace con los campos de los apellidos

          apellido_p[0] = integrante1[1];

          apellido_m[0] = integrante1[2];

            // el campo edad debe de  almacenar el campo con un tipo de dato entero por lo que es necesario convertirlo de string a entero

          edades[0]=Convert.ToInt32( integrante1[3]);

            // Limpiamos la cadena

          cadena = "";

            // Limpiamos la pantalla

          Console.Clear();

            // Realizamos lo mismo para cada integrante

          Console.WriteLine("Ingrese el integrante 2:");

          cadena = Console.ReadLine();

          integrante2 = cadena.Split(caracteresdelimitadores);

          nombres[1] = integrante2[0];

          apellido_p[1] = integrante2[1];

          apellido_m[1] = integrante2[2];

          edades[1] = Convert.ToInt32(integrante2[3]);

          cadena = "";

              Console.Clear();

            Console.WriteLine("Ingrese el integrante 3:");

          cadena = Console.ReadLine();

          integrante3 = cadena.Split(caracteresdelimitadores);

          nombres[2] = integrante3[0];

          apellido_p[2] = integrante3[1];

          apellido_m[2] = integrante3[2];

          edades[2] = Convert.ToInt32(integrante3[3]);

          cadena = "";

              Console.Clear();

          Console.WriteLine("Ingrese el integrante 4:");

          cadena = Console.ReadLine();

          integrante4 = cadena.Split(caracteresdelimitadores);

          nombres[3] = integrante4[0];

          apellido_p[3] = integrante4[1];

          apellido_m[3] = integrante4[2];

          edades[3] = Convert.ToInt32(integrante4[3]);

              Console.Clear();

              //Se declaran variables temporales para edad, nombre, apellido paterno y apellido materno.

              //la edad es de tipo entero, el nombre y apellidos son de tipo string

              int edadtemp;

              string nombretemp, apellidomtem_p, apellidotemp_m;

            //Método burbuja

            // con el método burbuja ordenaremos el arreglo que contiene las edades pues a partir de ellas definiremos quien es cada integrante

            // se compone de dos ciclos for con los cuales iremos comparando en pares las edades y ordenandolas

            for (int i = 0; i < (edades.Length - 1); i++)

            {

                for (int j = 0; j < (edades.Length - 1); j++)

                { //con el condicional if comparamos si la primera edad almacenada en el arreglo es mayor que la segunda, conforme aumente j compararemos la siguiente pareja de edades

                     // el signo > ordenará el arreglo de menor a mayor, si fuese < el arreglo se ordenará de mayor a menor

                    if (edades[j] > edades[j + 1])

                    {

                        //al cumplirse se asignará a la variable temporal para edad el valor de la segunda posicion del arreglo edades

                        //conforme se incremente el valor de j se compará la siguiente pareja de edades

                        edadtemp = edades[j];

                        //pasará lo mismo con las variables temporales para nombre y apellidos

                        nombretemp = nombres[j];

                        apellidomtem_p = apellido_p[j];

                        apellidotemp_m = apellido_m[j];

                        //enseguida se asigna al arreglo edades en su posicion j el valor de la siguiente posicion indicado como j+1

                        edades[j] = edades[j + 1];

                        //se realiza lo mismo con los arreglos de nombre y apellidos

                        nombres[j] = nombres[j + 1];

                        apellido_p[j] = apellido_p[j + 1];

                        apellido_m[j] = apellido_m[j + 1];

                        //al arreglo edades en su posición siguiente j+1 se la asignará el valor almacenado en la variable temporal

                        edades[j + 1] = edadtemp;

                        nombres[j + 1] = nombretemp;

                        apellido_p[j + 1] = apellidomtem_p;

                        apellido_m[j + 1] = apellidotemp_m;

                    }

                }

            }

            //cuando los ciclos for terminen los arreglos estarán ordenados de acuerdo a la edad de menor a mayor

            Console.WriteLine("            ESTRUCTURA DE LA FAMILIA      ");

            //como ya estan ordenadpos los arreglos y suponemos que la mayor edad es la del padre y la siguiente es de la madre tomamos

            //el apellido paterno de cada uno para mostrar el nombre de la familia

            Console.WriteLine("   Familia: " + apellido_p[3] + " " + apellido_p[2] + ".");

            //como ya tenemos la mayor edad, la cual está en la posicion 3 del arreglo y por lo tanto es la del padre y solo tomamos sus valores para mostrarlos

            Console.WriteLine("   Padre: " + nombres[3] + " " + apellido_p[3] + " " + apellido_m[3] + " su edad es: " + edades[3] + ".");

            //la edad en la posicion 2 es la madre

            Console.WriteLine("   Madre: " + nombres[2] + " " + apellido_p[2] + " " + apellido_m[2] + " su edad es: " + edades[2] + ".");

            // la posición 1 es el hijo mayor

            Console.WriteLine("   Hijo mayor: " + nombres[1] + " " + apellido_p[1] + " " + apellido_m[1] + " su edad es: " + edades[1] + ".");

            // la menor edad que es la posición 0 es el hijo menor

            Console.WriteLine("   Hijo menor: " + nombres[0] + " " + apellido_p[0] + " " + apellido_m[0] + " su edad es: " + edades[0] + ".");

          

            //detenemos la pantalla

            Console.ReadLine();

        }

    }

}