RunTimeLibrary.asm

; Programa: bool.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Lee un valor ingresado por el usuario y verifica si es un valor booleano válido ('true', 'false', '1' o '0').
; Entradas: Un valor booleano ingresado como '1', '0', 'true' o 'false'.
; Salidas: Mensaje indicando si el valor ingresado es verdadero, falso o inválido.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un valor booleano: $'  ; Mensaje de solicitud de entrada
    mensajeTrue db 'El valor ingresado es un true o 1. $'  ; Mensaje para valores verdaderos
    mensajeFalse db 'El valor ingresado es un false o 0. $'  ; Mensaje para valores falsos
    mensajeError db 'Dato mal ingresado. $'  ; Mensaje para entrada inválida
    buffer DB 20, ?, 20 DUP('$')  ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21h

    ; Verificar si la entrada es un número o una cadena
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado

VALIDARBOOL:
    ; Salto de línea para mejorar la salida
    MOV AH, 02h
    MOV DL, 0Ah  
    INT 21h

    ; Cargar el primer carácter ingresado
    MOV AL, [SI]

    ; Mover a la siguiente posición
    INC SI
    MOV BL, [SI]
    CMP BL, 0DH  ; Verifica si solo es un solo carácter (fin de la entrada)
    JNE STRING   ; Si hay más caracteres, revisar si es una palabra

    ; Comparar con los valores '1' y '0'
    CMP AL, '1'
    JE TRUE

    CMP AL, '0'
    JE FALSE

    JMP STRING   ; Si no es un número, verificar si es una palabra

; Si el valor es '1', mostrar mensaje de valor verdadero
TRUE:
    MOV AH, 09h
    LEA DX, mensajeTrue
    INT 21h
    JMP SALIR

; Si el valor es '0', mostrar mensaje de valor falso
FALSE:
    MOV AH, 09h
    LEA DX, mensajeFalse
    INT 21h
    JMP SALIR

; Si el valor no es '1' ni '0', verificar si es una palabra ('true' o 'false')
STRING:
    CMP AL, 't'
    JE STRTRUE

    CMP AL, 'f'
    JE STRFALSE

    JMP ERROR  ; Si no comienza con 't' o 'f', es inválido

; Verificar si la entrada es 'true'
STRTRUE:
    MOV AL, [SI]
    CMP AL, 'r'
    JNE ERROR

    INC SI
    MOV AL, [SI]
    CMP AL, 'u'
    JNE ERROR

    INC SI
    MOV AL, [SI]
    CMP AL, 'e'
    JNE ERROR

    INC SI
    MOV AL, [SI]
    CMP AL, 0DH  ; Verificar fin de la entrada
    JE TRUE
    JMP ERROR

; Verificar si la entrada es 'false'
STRFALSE:
    MOV AL, [SI]
    CMP AL, 'a'
    JNE ERROR

    INC SI
    MOV AL, [SI]
    CMP AL, 'l'
    JNE ERROR

    INC SI
    MOV AL, [SI]
    CMP AL, 's'
    JNE ERROR

    INC SI
    MOV AL, [SI]
    CMP AL, 'e'
    JNE ERROR

    INC SI
    MOV AL, [SI]
    CMP AL, 0DH  ; Verificar fin de la entrada
    JE FALSE
    JMP ERROR

; Manejo de error: Entrada inválida
ERROR:
    MOV AH, 09h
    LEA DX, mensajeError
    INT 21h
    JMP SALIR

; Terminar ejecución del programa
SALIR:
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO

; Programa: char.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este programa en ensamblador lee un carácter ingresado por el usuario y lo muestra en pantalla.
; Entradas: Un único carácter ingresado por el usuario a través del teclado.
; Salidas: Mensaje indicando el carácter ingresado y el propio carácter en pantalla.

SEGMENT DATASEG 
    mensajeEntrada db 'Ingrese un caracter: $'   ; Mensaje que solicita la entrada del usuario
    mensajeSalida db 'Caracter ingresado: $'    ; Mensaje que precede al carácter mostrado
DATASEG ENDS

SEGMENT CODESEG 
    ASSUME CS:CODESEG, DS:DATASEG

CODIGO:
    MOV AX, DATASEG
    MOV DS, AX          ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h         ; Función DOS para mostrar una cadena
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer un carácter desde el teclado
    MOV AH, 1           ; Función DOS para leer un solo carácter
    INT 21h
    MOV BL, AL          ; Guardar el carácter ingresado en BL

    ; Salto de línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah         ; Nueva línea
    INT 21h

    ; Mostrar mensaje de salida
    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    ; Mostrar el carácter ingresado
    MOV DL, BL          ; Recuperar el carácter ingresado
    MOV AH, 02h         ; Función DOS para mostrar un solo carácter
    INT 21h

    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END CODIGO


; Programa: Creativo.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: El programa lee dos valores ingresados por el usuario: la durabilidad y el desgaste de un ítem.
;              Luego, valida que los valores ingresados sean numéricos y, después, realiza una comparación entre ellos.
; Entradas: 
;          Durabilidad del ítem.
;          Desgaste del ítem.
; Salidas:
;          Mensaje indicando si los valores ingresados son válidos o no.
;          Mensaje indicando la durabilidad del ítem y su comparación con el desgaste.

SEGMENT DATASEG
    ; Definición de los mensajes que se van a mostrar al usuario
    mensajeEntrada db 'Ingrese la durabilidad del item: $' ; Mensaje para pedir la durabilidad
    mensajeEntrada1 db 'Ingrese el desgaste de uso de item: $' ; Mensaje para pedir el desgaste
    mensajeValido db 'Durabilidad actual del item: $' ; Mensaje para mostrar durabilidad válida
    mensajeInvalido db 'El numero no es valido. $' ; Mensaje en caso de valor inválido

    ; Variables para almacenar la entrada del usuario
    Durabilidad DB 20, ?, 20 DUP('$') ; Cadena para almacenar la durabilidad
    DurabilidadMax DB 20, ?, 20 DUP('$') ; Cadena para almacenar el desgaste
    AuxDurabilidad DB 100 ; Auxiliar para la conversión de números (no se utiliza en este código directamente)

DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    ; Inicializar segmento de datos
    mov ax, DATASEG
    mov ds, ax

    ; Mostrar mensaje de entrada para durabilidad
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena de durabilidad desde el teclado
    LEA DX, DurabilidadMax
    MOV AH, 0Ah
    INT 21h

    ; Verificar si la cadena es un número válido (durabilidad)
    LEA SI, DurabilidadMax + 2
    MOV DX, 0 ; Indicador para punto decimal

    ; Ciclo de verificación para durabilidad
VerificarLoop:
    MOV AL, [SI] ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito
    CMP AL, '0' ; Compara con '0'
    JL NoEsValido ; Si es menor que '0', no es un número
    CMP AL, '9' ; Compara con '9'
    JG NoEsValido ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar al siguiente carácter
    JMP SiguienteCaracter

NoEsValido:
    ; Si no es válido, mostrar mensaje de error y salir
    MOV AH, 02h
    MOV DL, 0Ah ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido
    INT 21h
    JMP Salir

SiguienteCaracter:
    INC SI
    MOV AL, [SI]
    CMP AL, 0DH
    JNE NUM ; Continuar hasta encontrar un salto de línea (ENTER)

    ; Separar el ciclo de la verificación de la durabilidad con nueva línea
    MOV AX, 0
    MOV DX, 0

    MOV AH, 02h
    MOV DL, 0Ah ; Nueva línea
    INT 21h

;------------ VALIDAR EL DEGASTE DEL ITEM -----------------------

    ; Mostrar mensaje para ingresar el desgaste
    MOV AH, 09h
    LEA DX, mensajeEntrada1
    INT 21h

    ; Leer la cadena de desgaste desde el teclado
    LEA DX, Durabilidad
    MOV AH, 0Ah
    INT 21h

    ; Verificar si la cadena de desgaste es válida (número)
    LEA SI, Durabilidad + 2
    MOV DX, 0 ; Indicador de si se ha encontrado un punto decimal

    ; Ciclo de verificación para desgaste
VerificarLoop1:
    MOV AL, [SI] ; Cargar el siguiente carácter

NUM1:
    ; Verificar si el carácter es un dígito
    CMP AL, '0' ; Compara con '0'
    JL NoEsValido1 ; Si es menor que '0', no es un número
    CMP AL, '9' ; Compara con '9'
    JG NoEsValido1 ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar al siguiente carácter
    JMP SiguienteCaracter1

NoEsValido1:
    ; Si no es válido, mostrar mensaje de error y salir
    MOV AH, 02h
    MOV DL, 0Ah ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido
    INT 21h
    JMP Salir

SiguienteCaracter1:
    INC SI
    MOV AL, [SI]
    CMP AL, 0DH
    JNE NUM1 ; Continuar hasta encontrar un salto de línea (ENTER)

    MOV AX, 0
    MOV DX, 0

    MOV AH, 02h
    MOV DL, 0Ah ; Nueva línea
    INT 21h

;------------ PROCESAR EL DEGASTE -----------------------

Desgaste:
    LEA SI, DurabilidadMax + 2
    MOV AX, 0
    MOV CX, 0

    ; Convertir el valor de desgaste a número
ConvertirNumero:
    MOV BL, [SI] ; Cargar el siguiente carácter
    CMP BL, 0DH ; ¿Es ENTER?
    JE FinConversion ; Si es ENTER, termina

    SUB BL, '0' ; Convertir carácter en número

    ; Multiplicar AX por 10 (AX = AX * 10)
    MOV DX, AX ; Copiar AX en DX
    SHL AX, 1  ; AX * 2
    SHL DX, 3  ; DX * 8
    ADD AX, DX ; AX = AX * 10

    ADD AX, BX ; Sumar el nuevo dígito

    INC SI
    JMP ConvertirNumero ; Continuar convirtiendo

FinConversion:

    LEA SI, Durabilidad + 2

    ; Convertir valor de durabilidad a número
ConvertirNumero1:
    MOV BL, [SI]
    CMP BL, 0DH
    JE LoopDesgaste
    SUB BL, '0'

    MOV DX, CX
    SHL CX, 1
    SHL DX, 3
    ADD CX, DX
    ADD CX, BX

    INC SI
    JMP ConvertirNumero1

LoopDesgaste:
    MOV BX, AX

LoopDesgast1:
    CMP BX, 0
    JE SalirAUX

    CMP CX, BX
    JG SalirAUX1

    MOV AH, 02h
    MOV DL, 0Ah ; Nueva línea
    INT 21h

    ; Mostrar el valor válido de durabilidad
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h

    PUSH BX

    MOV AH, 0
    MOV AL, BL
    MOV DL, 10
    DIV DL
    MOV BL, AH

    MOV DL, AL
    ADD DL, '0'
    MOV AH, 02h
    INT 21h

    MOV DL, BL
    ADD DL, '0'
    MOV AH, 02h
    INT 21h

    POP BX

    CMP BX, 65535
    JLE Salir

    SUB BX, CX
    JMP LoopDesgast1

SalirAUX:
    MOV AH, 02h
    MOV DL, 0Ah ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h

    MOV DL, '0'
    MOV AH, 02h
    INT 21h

    JMP Salir

SalirAUX1:
    MOV AH, 02h
    MOV DL, 0Ah ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h

    MOV AH, 0
    MOV AL, BL
    MOV DL, 10
    DIV DL

    MOV BL, AH

    MOV DL, AL
    ADD DL, '0'
    MOV AH, 02h
    INT 21h

    MOV DL, BL
    ADD DL, '0'
    MOV AH, 02h
    INT 21h

    JMP SalirAUX

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO


; PROGRAMA: FLOAT.ASM
; ESTUDIANTES: Diana Sanabria
;              Jefferson Salas
; DESCRIPCIÓN: Este programa en ensamblador lee un número flotante ingresado por el usuario y lo muestra en pantalla.
;             También valida que la entrada sea un número flotante correcto (permitiendo un solo punto decimal).
; ENTRADAS: Un número flotante ingresado por el usuario.
; SALIDAS: Mensaje indicando si el número es válido o no y, en caso de serlo, se muestra el número ingresado.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un numero flotante: $'   ; Mensaje para solicitar la entrada
    mensajeValido db 'Numero flotante ingresado: $'     ; Mensaje para entrada válida
    mensajeInvalido db 'El numero no es valido. $'      ; Mensaje para entrada inválida
    buffer DB 20, ?, 20 DUP('$')                        ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; CONFIGURAR SEGMENTO DE DATOS

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21H

    ; Verificar si la cadena ingresada es un número flotante válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; Bandera para verificar si se ha encontrado un punto decimal

VerificarLoop:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito
    CMP AL, '0'              ; Compara con '0'
    JL NoNumero              ; Si es menor que '0', no es un número
    CMP AL, '9'              ; Compara con '9'
    JG NoNumero              ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar con el siguiente carácter
    JMP SiguienteCaracter

NoNumero:
    ; Verificar si es un punto decimal
    CMP AL, '.'              ; Verificar si es un punto decimal
    JNE NoEsValido           ; Si no es punto decimal, es inválido
    ; Si ya se encontró un punto antes, la entrada no es válida
    CMP DX, 0
    JNE NoEsValido
    MOV DX, 1                ; Marcar que ya se encontró un punto decimal
    JMP SiguienteCaracter

NoEsValido:
    ; Mostrar mensaje de error si el número ingresado no es válido
    MOV AH, 02h
    MOV DL, 0Ah  ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido
    INT 21h
    JMP Salir

SiguienteCaracter:
    INC SI                  ; Moverse al siguiente carácter
    MOV AL, [SI]            ; Cargar el siguiente carácter

    CMP AL, '.'              ; Verificar si es un punto decimal
    JE NoNumero

    CMP AL, 0DH              ; Verificar si llegamos al final de la entrada (Enter)
    JNE NUM                  ; Si no es el final, continuar verificando

    CMP DX, 0                ; Si nunca se encontró un punto decimal, es inválido
    JE NoEsValido 

    MOV AX, 0
    MOV DX, 0

    ; Nueva línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah
    INT 21h

    ; Si es válido, mostrar el mensaje de número válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h

    ; Mostrar el número ingresado
    LEA DX, buffer + 2       ; Apunta al primer carácter ingresado
    MOV AH, 09h
    INT 21h

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO


; Programa: int.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este programa en ensamblador lee un número entero ingresado por el usuario y verifica si es válido.
;             Si el número es válido, lo muestra en pantalla. Si no lo es, muestra un mensaje de error.
; Entradas: Un número entero ingresado por el usuario.
; Salidas: Mensajes en pantalla indicando si el número ingresado es válido o no.
;          En caso de ser valido se retorna el valor de entrada.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un numero entero: $'  ; Mensaje de solicitud de entrada
    mensajeValido db 'Numero entero ingresado: $'   ; Mensaje si el número es válido
    mensajeInvalido db 'El numero no es valido. $'  ; Mensaje si el número es inválido
    buffer DB 20, ?, 20 DUP('$')                    ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h              ; Función DOS para mostrar una cadena
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah              ; Función DOS para leer una cadena de entrada
    INT 21h

    ; Verificar si la cadena ingresada es un número válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; DX servirá como indicador de validación

VerificarLoop:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito ('0' a '9')
    CMP AL, '0'              
    JL NoEsValido            ; Si es menor que '0', no es un número
    CMP AL, '9'              
    JG NoEsValido            ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar con el siguiente carácter
    JMP SiguienteCaracter

NoEsValido:
    ; Si se encuentra un carácter no válido, mostrar mensaje de error
    MOV AH, 02h
    MOV DL, 0Ah              ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido  ; Mostrar mensaje de número inválido
    INT 21h
    JMP Salir                ; Terminar ejecución

SiguienteCaracter:
    INC SI                   ; Avanzar al siguiente carácter
    MOV AL, [SI]

    CMP AL, 0DH              ; Verificar si llegamos al final de la cadena (carácter de retorno de carro)
    JNE NUM                  ; Si no, continuar verificando

    ; Si la cadena es válida, proceder a mostrar el número ingresado
    MOV AX, 0
    MOV DX, 0

    MOV AH, 02h
    MOV DL, 0Ah              ; Nueva línea
    INT 21h

    ; Mostrar mensaje indicando que el número es válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h

    ; Mostrar el número ingresado
    LEA DX, buffer + 2       ; Apunta al primer carácter ingresado
    MOV AH, 09h
    INT 21h

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO

; PROGRAMA: STRING.ASM
; ESTUDIANTES: Diana Sanabria
;              Jefferson Salas
; DESCRIPCIÓN: Este programa en ensamblador lee una cadena de caracteres
;              ingresada por el usuario y luego la muestra en pantalla.
; ENTRADAS: Un string ingresado por el usuario (máximo 20 caracteres).
; SALIDAS: Mensajes en pantalla y el string ingresado por el usuario.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un string: $'   ; Mensaje de solicitud de entrada
    mensajeSalida db 'String ingresado: $'    ; Mensaje antes de mostrar el string ingresado
    BUFFER DB 20, ?, 20 DUP('$')              ; Buffer: primer byte = tamaño máximo, segundo byte = longitud real
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX          ; CONFIGURAR SEGMENTO DE DATOS

    ; Mostrar mensaje de entrada
    MOV AH, 09h         ; Función DOS para mostrar un string
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, BUFFER
    MOV AH, 0AH         ; Función DOS para leer un string
    INT 21H

    ; Salto de línea antes de mostrar salida
    MOV AH, 02h
    MOV DL, 0Ah         ; Código ASCII de nueva línea
    INT 21h

    ; Mostrar mensaje de salida
    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    ; Mostrar el string ingresado
    LEA DX, BUFFER+2      ; Saltar los 2 primeros bytes del buffer para obtener la cadena
    MOV AH, 09h
    INT 21h

    ; Salir del programa
    MOV AH, 4Ch          ; Función DOS para terminar el programa
    INT 21h

CODESEG ENDS
END INICIO

; Programa: bool.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Lee el valor ingresado, en caso de que sea On o Off se considera valido.
; Entradas: Un valor booleano ingresado como On o Off.
; Salidas: Mensaje indicando si el valor ingresado es On, Off o inválido.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un valor booleano: $'  ; Mensaje de solicitud de entrada
    mensajeSalida db 'La resultado de la conversion a STRING: $' ; Mensaje para valores verdaderos
    mensajeError db 'Dato mal ingresado. $'
    mensajeTrue db 'On$'
    mensajeFalse db 'Off$'
    buffer DB 20, ?, 20 DUP('$')  ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21h

    ; Verificar si la entrada es un número o una cadena
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado

VALIDARBOOL:
    JMP INCREMENTOFIN

INCREMENTO:
    INC SI                  ; Incrementar el puntero de entrada
INCREMENTOFIN:
    ; Salto de línea para mejorar la salida
    MOV AH, 02h
    MOV DL, 0Ah  
    INT 21h

    ; Cargar el primer carácter ingresado
    MOV AL, [SI]
    CMP AL, 'o'
    JE INCREMENTO 

    CMP AL, 'f'
    JE FALSE 

    CMP AL, 'n'
    JE TRUE 


    JMP ERROR   ; Si no es un número, verificar si es una palabra

; Si el valor es '1', mostrar mensaje de valor verdadero
TRUE:
    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h
    
    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "["    ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    MOV AH, 09h
    LEA DX, mensajeTrue
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "]"    ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    JMP SALIR

; Si el valor es '0', mostrar mensaje de valor falso
FALSE:
    INC SI 

    MOV AL, [SI]
    CMP AL, 'o'

    CMP AL, 'f'
    JnE ERROR 

    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "["    ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    MOV AH, 09h
    LEA DX, mensajeFalse
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "]"    ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    JMP SALIR

; Manejo de error: Entrada inválida
ERROR:
    MOV AH, 09h
    LEA DX, mensajeError
    INT 21h
    JMP SALIR

; Terminar ejecución del programa
SALIR:
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO


; Programa: bool.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Lee el valor ingresado, en caso de que sea On o Off se considera valido.
;              Como queremos un char lo que realizamos regresar el caracter representativo de cada bool
; Entradas: Un valor booleano ingresado como On o Off.
; Salidas: Mensaje indicando si el valor ingresado es On se regresa un 'T', Off se regresa un 'F' o inválido.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un valor booleano: $'  ; Mensaje de solicitud de entrada
    mensajeSalida db 'La resultado de la conversion a CHART: $' ; Mensaje para valores verdaderos
    mensajeError db 'Dato mal ingresado. $'
    mensajeTrue db 'On $'
    mensajeFalse db 'Off $'
    buffer DB 20, ?, 20 DUP('$')  ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21h

    ; Verificar si la entrada es un número o una cadena
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado

VALIDARBOOL:
    JMP INCREMENTOFIN

INCREMENTO:
    INC SI                  ; Incrementar el puntero de entrada
INCREMENTOFIN:
    ; Salto de línea para mejorar la salida
    MOV AH, 02h
    MOV DL, 0Ah  
    INT 21h

    ; Cargar el primer carácter ingresado
    MOV AL, [SI]
    CMP AL, 'o'
    JE INCREMENTO 

    CMP AL, 'f'
    JE FALSE 

    CMP AL, 'n'
    JE TRUE 


    JMP ERROR   ; Si no es un número, verificar si es una palabra

; Si el valor es '1', mostrar mensaje de valor verdadero
TRUE:
    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "'"    ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, 'T'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "'"     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    JMP SALIR

; Si el valor es '0', mostrar mensaje de valor falso
FALSE:
    INC SI 

    MOV AL, [SI]
    CMP AL, 'o'

    CMP AL, 'f'
    JnE ERROR 

    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "'"    ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, 'F'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "'"     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    JMP SALIR

; Manejo de error: Entrada inválida
ERROR:
    MOV AH, 09h
    LEA DX, mensajeError
    INT 21h
    JMP SALIR

; Terminar ejecución del programa
SALIR:
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO


; Programa: bool.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Lee un valor ingresado por el usuario y verifica si es un valor booleano válido.
;              Lo que realizamos es tomar el valor ingreado y convertirlo a su version flotante. Ej: si es On seria 1.0
; Entradas: Un valor booleano ingresado como On o Off.
; Salidas: Mensaje indicando si el valor ingresado On se convierte a  1.0 o Off se convierte 0.0.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un valor booleano: $'  ; Mensaje de solicitud de entrada
    mensajeSalida db 'La resultado de la conversion a FLOAT: $' ; Mensaje para valores verdaderos
    mensajeError db 'Dato mal ingresado. $'  ; Mensaje para entrada inválida
    buffer DB 20, ?, 20 DUP('$')  ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21h

    ; Verificar si la entrada es un número o una cadena
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado

VALIDARBOOL:
    JMP INCREMENTOFIN

INCREMENTO:
    INC SI                  ; Incrementar el puntero de entrada
INCREMENTOFIN:
    ; Salto de línea para mejorar la salida
    MOV AH, 02h
    MOV DL, 0Ah  
    INT 21h

    ; Cargar el primer carácter ingresado
    MOV AL, [SI]
    CMP AL, 'o'
    JE INCREMENTO 

    CMP AL, 'f'
    JE FALSE 

    CMP AL, 'n'
    JE TRUE 


    JMP ERROR   ; Si no es un número, verificar si es una palabra

; Si el valor es '1', mostrar mensaje de valor verdadero
TRUE:
    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    mov al, 1       ; número a imprimir
    add al, '0'     ; convertir a carácter ASCII
    mov dl, al
    mov ah, 02h
    int 21h         ; mostrar el carácter

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, '.'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    mov al, 0       ; número a imprimir
    add al, '0'     ; convertir a carácter ASCII
    mov dl, al
    mov ah, 02h
    int 21h         ; mostrar el carácter

    JMP SALIR

; Si el valor es '0', mostrar mensaje de valor falso
FALSE:
    INC SI 

    MOV AL, [SI]
    CMP AL, 'o'

    CMP AL, 'f'
    JnE ERROR 

    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    mov al, 0       ; número a imprimir
    add al, '0'     ; convertir a carácter ASCII
    mov dl, al
    mov ah, 02h
    int 21h         ; mostrar el carácter

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, '.'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    mov al, 0       ; número a imprimir
    add al, '0'     ; convertir a carácter ASCII
    mov dl, al
    mov ah, 02h
    int 21h         ; mostrar el carácter

    JMP SALIR

; Manejo de error: Entrada inválida
ERROR:
    MOV AH, 09h
    LEA DX, mensajeError
    INT 21h
    JMP SALIR

; Terminar ejecución del programa
SALIR:
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO


; Programa: bool.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Lee un valor ingresado por el usuario y verifica si es un valor booleano válido.
;              Lo que realizamos es tomar el valor ingreado y convertirlo a su version entero. Ej: si es On seria 1
; Entradas: Un valor booleano ingresado como On o Off.
; Salidas: Mensaje indicando si el valor ingresado On se convierte a  1 o Off se convierte 0.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un valor booleano: $'  ; Mensaje de solicitud de entrada
    mensajeSalida db 'La resultado de la conversion a INT: $' ; Mensaje para valores verdaderos
    mensajeError db 'Dato mal ingresado. $'  ; Mensaje para entrada inválida
    buffer DB 20, ?, 20 DUP('$')  ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21h

    ; Verificar si la entrada es un número o una cadena
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado

VALIDARBOOL:
    JMP INCREMENTOFIN

INCREMENTO:
    INC SI                  ; Incrementar el puntero de entrada
INCREMENTOFIN:
    ; Salto de línea para mejorar la salida
    MOV AH, 02h
    MOV DL, 0Ah  
    INT 21h

    ; Cargar el primer carácter ingresado
    MOV AL, [SI]
    CMP AL, 'o'
    JE INCREMENTO 

    CMP AL, 'f'
    JE FALSE 

    CMP AL, 'n'
    JE TRUE 


    JMP ERROR   ; Si no es un número, verificar si es una palabra

; Si el valor es '1', mostrar mensaje de valor verdadero
TRUE:
    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    mov al, 1       ; número a imprimir
    add al, '0'     ; convertir a carácter ASCII
    mov dl, al
    mov ah, 02h
    int 21h         ; mostrar el carácter

    JMP SALIR

; Si el valor es '0', mostrar mensaje de valor falso
FALSE:
    INC SI 

    MOV AL, [SI]
    CMP AL, 'o'

    CMP AL, 'f'
    JnE ERROR 

    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    mov al, 0       ; número a imprimir
    add al, '0'     ; convertir a carácter ASCII
    mov dl, al
    mov ah, 02h
    int 21h         ; mostrar el carácter

    JMP SALIR

; Manejo de error: Entrada inválida
ERROR:
    MOV AH, 09h
    LEA DX, mensajeError
    INT 21h
    JMP SALIR

; Terminar ejecución del programa
SALIR:
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO


; Programa: bool.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este programa en ensamblador lee el valor booleano ingresado por el usuario 
;              y lo muestra en pantalla entre comillas.
; Entradas: Un valor booleano ingresado como On o Off.
; Salidas: Mensaje mostrando el carácter capturado en pantalla.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un valor booleano: $'  ; Mensaje de solicitud de entrada
    mensajeSalida db 'La resultado de la conversion a STRING: $' ; Mensaje para valores verdaderos
    mensajeError db 'Dato mal ingresado. $'
    mensajeTrue db 'On $'
    mensajeFalse db 'Off $'
    buffer DB 20, ?, 20 DUP('$')  ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21h

    ; Verificar si la entrada es un número o una cadena
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado

VALIDARBOOL:
    JMP INCREMENTOFIN

INCREMENTO:
    INC SI                  ; Incrementar el puntero de entrada
INCREMENTOFIN:
    ; Salto de línea para mejorar la salida
    MOV AH, 02h
    MOV DL, 0Ah  
    INT 21h

    ; Cargar el primer carácter ingresado
    MOV AL, [SI]
    CMP AL, 'o'
    JE INCREMENTO 

    CMP AL, 'f'
    JE FALSE 

    CMP AL, 'n'
    JE TRUE 


    JMP ERROR   ; Si no es un número, verificar si es una palabra

; Si el valor es '1', mostrar mensaje de valor verdadero
TRUE:
    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeTrue
    INT 21h

    JMP SALIR

; Si el valor es '0', mostrar mensaje de valor falso
FALSE:
    INC SI 

    MOV AL, [SI]
    CMP AL, 'o'

    CMP AL, 'f'
    JnE ERROR 

    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeFalse
    INT 21h

    JMP SALIR

; Manejo de error: Entrada inválida
ERROR:
    MOV AH, 09h
    LEA DX, mensajeError
    INT 21h
    JMP SALIR

; Terminar ejecución del programa
SALIR:
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO


; Programa: charToAr.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este es un programa en ensamblador que solicita un carácter del usuario, 
;              lo lee, y luego lo imprime encerrado en corchetes [] para simular que está dentro de un arreglo.
; Entradas: Un único carácter ingresado por el usuario a través del teclado.
; Salidas: Mensaje indicando el carácter ingresado dentro de un arreglo.

SEGMENT DATASEG 
    mensajeEntrada db 'Ingrese un caracter: $'   ; Mensaje que solicita la entrada del usuario
    mensajeSalida db 'La resultado de la conversion a ARREGLO: $'    ; Mensaje que precede al carácter mostrado
DATASEG ENDS

SEGMENT CODESEG 
    ASSUME CS:CODESEG, DS:DATASEG

CODIGO:
    MOV AX, DATASEG
    MOV DS, AX          ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h         ; Función DOS para mostrar una cadena
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer un carácter desde el teclado
    MOV AH, 1           ; Función DOS para leer un solo carácter
    INT 21h
    MOV BL, AL          ; Guardar el carácter ingresado en BL

    ; Salto de línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah         ; Nueva línea
    INT 21h

    ; Mostrar mensaje de salida
    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, '['     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    ; Mostrar el carácter ingresado
    MOV DL, BL          ; Recuperar el carácter ingresado
    MOV AH, 02h         ; Función DOS para mostrar un solo carácter
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, ']'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END CODIGO


; Programa: charToBo.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este programa en ensamblador lee un carácter ingresado por el usuario,
;              verifica si representa un valor booleano ('T', 't', 'F', 'f') y muestra
;              el resultado como "On" o "Off". Si no es válido, muestra un error.
; Entradas: Un único carácter ingresado por teclado.
; Salidas: Mensaje indicando "On" o "Off" según el valor ingresado o un mensaje de error.

SEGMENT DATASEG 
    mensajeEntrada db 'Ingrese un caracter: $'   ; Mensaje que solicita la entrada del usuario
    mensajeSalida db 'La resultado de la conversion a BOOLEAN: $'    ; Mensaje que precede al carácter mostrado
    mensajeTrue db 'On$' 
    mensajeFalse db 'Off$'
    mensajeError db 'Valor ingresado no es un BOOLEAN. $' ; Mensaje de error si no es un dígito
DATASEG ENDS

SEGMENT CODESEG 
    ASSUME CS:CODESEG, DS:DATASEG

CODIGO:
    MOV AX, DATASEG
    MOV DS, AX          ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h         ; Función DOS para mostrar una cadena
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer un carácter desde el teclado
    MOV AH, 1           ; Función DOS para leer un solo carácter
    INT 21h
    MOV BL, AL          ; Guardar el carácter ingresado en BL

    ; Salto de línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah         ; Nueva línea
    INT 21h

    ; Mostrar el carácter ingresado
    MOV DL, BL          ; Recuperar el carácter ingresado

    ; Suponiendo que AL tiene el carácter a verificar
    CMP DL, 'T'   
    JE TRUE 

    ; Suponiendo que AL tiene el carácter a verificar
    CMP DL, 't'    
    JE TRUE 

    CMP DL, 'F'
    JE FALSE 

    CMP DL, 'f'
    JE FALSE 

    JMP ERROR

    ; Si llegamos aquí, el carácter es un dígito
TRUE:
    
    ; Mostrar mensaje de salida
    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h
    
    ; Mostrar mensaje de salida
    MOV AH, 09h
    LEA DX, mensajeTrue
    INT 21h


    jmp SALIR ; Salir del programa

FALSE:

    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    ; Mostrar mensaje de salida
    MOV AH, 09h
    LEA DX, mensajeFalse
    INT 21h

    JMP SALIR ; Salir del programa

ERROR:

    MOV AH, 09h
    LEA DX, mensajeError
    INT 21h

SALIR: 
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END CODIGO

; Programa: charToFl.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este programa en ensamblador lee un carácter ingresado por el usuario, 
;              verifica si es un dígito ('0'-'9'), y simula su conversión a formato FLOAT 
;              mostrando el dígito seguido de ".0".
; Entradas: Un único carácter ingresado por teclado.
; Salidas: Si es un dígito, se muestra el número como flotante (ej: 5.0); 
;          si no es un dígito, se muestra un mensaje de error.

SEGMENT DATASEG 
    mensajeEntrada db 'Ingrese un caracter: $'   ; Mensaje que solicita la entrada del usuario
    mensajeSalida db 'La resultado de la conversion a FLOAT: $'    ; Mensaje que precede al carácter mostrado
    mensajeError db 'Valor ingresado no es un FLOAT. $' ; Mensaje de error si no es un dígito
DATASEG ENDS

SEGMENT CODESEG 
    ASSUME CS:CODESEG, DS:DATASEG

CODIGO:
    MOV AX, DATASEG
    MOV DS, AX          ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h         ; Función DOS para mostrar una cadena
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer un carácter desde el teclado
    MOV AH, 1           ; Función DOS para leer un solo carácter
    INT 21h
    MOV BL, AL          ; Guardar el carácter ingresado en BL

    ; Salto de línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah         ; Nueva línea
    INT 21h

    ; Mostrar el carácter ingresado
    MOV DL, BL          ; Recuperar el carácter ingresado

    ; Suponiendo que AL tiene el carácter a verificar
    CMP DL, '0'    ; Comparar con carácter '0'
    JB NO_ES_DIGITO ; Si es menor que '0', no es dígito 

    CMP DL, '9'
    JA NO_ES_DIGITO ; Si es mayor que '9', no es dígito 

    ; Si llegamos aquí, el carácter es un dígito
ES_DIGITO:
    
        ; Mostrar mensaje de salida
    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h
    
    MOV DL, BL          ; Recuperar el carácter ingresado
    MOV AH, 02h         ; Función DOS para mostrar un solo carácter
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, '.'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    mov al, 0       ; número a imprimir
    add al, '0'     ; convertir a carácter ASCII
    mov dl, al
    mov ah, 02h
    int 21h         ; mostrar el carácter

    jmp SALIR ; Salir del programa

NO_ES_DIGITO:

    MOV AH, 09h
    LEA DX, mensajeError
    INT 21h

SALIR: 
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END CODIGO


; Programa: charToIn.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este programa en ensamblador lee un carácter ingresado por el usuario 
;              y verifica si es un dígito ('0'-'9'). 
;              Si es un dígito, lo muestra precedido de un mensaje de éxito. 
;              Si no es un dígito, muestra un mensaje de error.
; Entradas: Un único carácter ingresado por teclado.
; Salidas: Mensaje indicando si el carácter ingresado es un número entero o no.

SEGMENT DATASEG 
    mensajeEntrada db 'Ingrese un caracter: $'   ; Mensaje que solicita la entrada del usuario
    mensajeSalida db 'La resultado de la conversion a INT: $'    ; Mensaje que precede al carácter mostrado
    mensajeError db 'Valor ingresado no es un INT. $' ; Mensaje de error si no es un dígito
DATASEG ENDS

SEGMENT CODESEG 
    ASSUME CS:CODESEG, DS:DATASEG

CODIGO:
    MOV AX, DATASEG
    MOV DS, AX          ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h         ; Función DOS para mostrar una cadena
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer un carácter desde el teclado
    MOV AH, 1           ; Función DOS para leer un solo carácter
    INT 21h
    MOV BL, AL          ; Guardar el carácter ingresado en BL

    ; Salto de línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah         ; Nueva línea
    INT 21h

    ; Mostrar el carácter ingresado
    MOV DL, BL          ; Recuperar el carácter ingresado

    ; Suponiendo que AL tiene el carácter a verificar
    CMP DL, '0'    ; Comparar con carácter '0'
    JB NO_ES_DIGITO ; Si es menor que '0', no es dígito 

    CMP DL, '9'
    JA NO_ES_DIGITO ; Si es mayor que '9', no es dígito 

    ; Si llegamos aquí, el carácter es un dígito
ES_DIGITO:
    
        ; Mostrar mensaje de salida
    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h
    
    MOV DL, BL          ; Recuperar el carácter ingresado
    MOV AH, 02h         ; Función DOS para mostrar un solo carácter
    INT 21h
    jmp SALIR ; Salir del programa

NO_ES_DIGITO:

    MOV AH, 09h
    LEA DX, mensajeError
    INT 21h

SALIR: 
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END CODIGO


; Programa: charToSt.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este programa en ensamblador lee un carácter ingresado por el usuario 
;              y lo muestra en pantalla entre comillas, precedido de un mensaje.
; Entradas: Un carácter ingresado por teclado.
; Salidas: Mensaje mostrando el carácter capturado en pantalla.

SEGMENT DATASEG 
    mensajeEntrada db 'Ingrese un caracter: $'   ; Mensaje que solicita la entrada del usuario
    mensajeSalida db 'La resultado de la conversion a STRING: $'    ; Mensaje que precede al carácter mostrado
DATASEG ENDS

SEGMENT CODESEG 
    ASSUME CS:CODESEG, DS:DATASEG

CODIGO:
    MOV AX, DATASEG
    MOV DS, AX          ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h         ; Función DOS para mostrar una cadena
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer un carácter desde el teclado
    MOV AH, 1           ; Función DOS para leer un solo carácter
    INT 21h
    MOV BL, AL          ; Guardar el carácter ingresado en BL

    ; Salto de línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah         ; Nueva línea
    INT 21h

    ; Mostrar mensaje de salida
    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, '"'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    ; Mostrar el carácter ingresado
    MOV DL, BL          ; Recuperar el carácter ingresado
    MOV AH, 02h         ; Función DOS para mostrar un solo carácter
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, '"'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END CODIGO


; PROGRAMA: floToAr.ASM
; ESTUDIANTES: Diana Sanabria
;              Jefferson Salas
; DESCRIPCIÓN: Este programa en ensamblador lee un número flotante ingresado por el usuario. 
;              El programa imprime los números ingresados, se enmarca entre corchetes ([ y ]),
;              para ilustrar la forma de un arreglo.
; ENTRADAS: Un número flotante.
; SALIDAS: Mensaje indicando si el número es válido o no y, en caso de serlo, se muestra el número ingresado entre corchetes.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un numero flotante: $'   ; Mensaje para solicitar la entrada
    mensajeValido db 'El resultado de la conversion a STRING: $'     ; Mensaje para entrada válida
    mensajeInvalido db 'El numero no es valido. $'      ; Mensaje para entrada inválida
    buffer DB 20, ?, 20 DUP('$')                        ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; CONFIGURAR SEGMENTO DE DATOS

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21H

    ; Verificar si la cadena ingresada es un número flotante válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; Bandera para verificar si se ha encontrado un punto decimal

VerificarLoop:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito
    CMP AL, '0'              ; Compara con '0'
    JL NoNumero              ; Si es menor que '0', no es un número
    CMP AL, '9'              ; Compara con '9'
    JG NoNumero              ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar con el siguiente carácter
    JMP SiguienteCaracter

NoNumero:
    ; Verificar si es un punto decimal
    CMP AL, '.'              ; Verificar si es un punto decimal
    JNE NoEsValido           ; Si no es punto decimal, es inválido
    ; Si ya se encontró un punto antes, la entrada no es válida
    CMP DX, 0
    JNE NoEsValido
    MOV DX, 1                ; Marcar que ya se encontró un punto decimal
    JMP SiguienteCaracter

NoEsValido:
    ; Mostrar mensaje de error si el número ingresado no es válido
    MOV AH, 02h
    MOV DL, 0Ah  ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido
    INT 21h
    JMP Salir

SiguienteCaracter:
    INC SI                  ; Moverse al siguiente carácter
    MOV AL, [SI]            ; Cargar el siguiente carácter

    CMP AL, '.'              ; Verificar si es un punto decimal
    JE NoNumero

    CMP AL, 0DH              ; Verificar si llegamos al final de la entrada (Enter)
    JNE NUM                  ; Si no es el final, continuar verificando

    CMP DX, 0                ; Si nunca se encontró un punto decimal, es inválido
    JE NoEsValido 

    MOV AX, 0
    MOV DX, 0

    ; Nueva línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah
    INT 21h

    ; Si es válido, mostrar el mensaje de número válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h

    
    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, '['     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    ; Mostrar el número ingresado
    ; Terminar la cadena con '$' para mostrarla bien
    LEA SI, buffer
    MOV CL, [SI+1]    ; Número de caracteres ingresados
    MOV CH, 0
    ADD SI, 2         ; Apunta al primer carácter ingresado
    ADD SI, CX        ; Moverse al final de la entrada
    MOV BYTE PTR [SI], '$' ; Colocar '$' al final

    LEA DX, buffer + 2
    MOV AH, 09h
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, ']'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO


; PROGRAMA: floToBo.ASM
; ESTUDIANTES: Diana Sanabria
;              Jefferson Salas
; DESCRIPCIÓN: Este programa en ensamblador lee un número flotante ingresado por el usuario. 
;              Si el texto ingresado son números se valida si el último carácter ingresado 
;              es un "1.0" o un "0.0". Si es otro número, imprime un error
; ENTRADAS: Un número flotante.
; SALIDAS: Mensaje indicando si el número es válido o no y, en caso de serlo, se muestra o 1 o 0..

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un numero flotante: $'   ; Mensaje para solicitar la entrada
    mensajeValido db 'El resultado de la conversion a BOOLEANO: $'     ; Mensaje para entrada válida
    mensajeInvalido db 'El numero no es valido. $'      ; Mensaje para entrada inválida
    mensajeError db 'No se puede convertir a booleano. $' ; Mensaje de error
    buffer DB 20, ?, 20 DUP('$')                        ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; CONFIGURAR SEGMENTO DE DATOS

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21H

    ; Verificar si la cadena ingresada es un número flotante válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; Bandera para verificar si se ha encontrado un punto decimal

VerificarLoop:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito
    CMP AL, '0'              ; Compara con '0'
    JL NoNumero              ; Si es menor que '0', no es un número
    CMP AL, '9'              ; Compara con '9'
    JG NoNumero              ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar con el siguiente carácter
    JMP SiguienteCaracter

NoNumero:
    ; Verificar si es un punto decimal
    CMP AL, '.'              ; Verificar si es un punto decimal
    JNE NoEsValido           ; Si no es punto decimal, es inválido
    ; Si ya se encontró un punto antes, la entrada no es válida
    CMP DX, 0
    JNE NoEsValido
    MOV DX, 1                ; Marcar que ya se encontró un punto decimal
    JMP SiguienteCaracter

NoEsValido:
    ; Mostrar mensaje de error si el número ingresado no es válido
    MOV AH, 02h
    MOV DL, 0Ah  ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido
    INT 21h
    JMP Salir

SiguienteCaracter:
    INC SI                  ; Moverse al siguiente carácter
    MOV AL, [SI]            ; Cargar el siguiente carácter

    CMP AL, '.'              ; Verificar si es un punto decimal
    JE NoNumero

    CMP AL, 0DH              ; Verificar si llegamos al final de la entrada (Enter)
    JNE NUM                  ; Si no es el final, continuar verificando

    CMP DX, 0                ; Si nunca se encontró un punto decimal, es inválido
    JE NoEsValido 

    MOV AX, 0
    MOV DX, 0

    ; Nueva línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah
    INT 21h

    ; Si es válido, mostrar el mensaje de número válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h


    ; Verificar si la cadena ingresada es un número flotante válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; Bandera para verificar si se ha encontrado un punto decimal
IMPRIMIR:

    MOV AL, [SI]             ; Cargar el siguiente carácter

NUMAUX:
    ; Verificar si el carácter es un dígito
    CMP AL, '0'              ; Compara con '0'
    JE TRUEFALSE              ; Si es menor que '0', no es un número
    CMP AL, '1'              ; Compara con '9'
    JE TRUEFALSE              ; Si es mayor que '9', no es un número

    JMP ERROR

TRUEFALSE:

    MOV AL, [SI]             ; Cargar el siguiente carácter
    MOV DL, AL    ; Copiar el carácter desde AL a DL
    MOV AH, 02h   ; Función DOS para imprimir un carácter
    INT 21h       ; Llamada al sistema

    JMP Salir

ERROR:
    ; Mostrar mensaje de error si el número ingresado no es válido
    MOV AH, 02h
    MOV DL, 0Ah  ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeError
    INT 21h

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO


; PROGRAMA: floToCh.ASM
; ESTUDIANTES: Diana Sanabria
;              Jefferson Salas
; DESCRIPCIÓN: Este programa en ensamblador lee un número flotante ingresado por el usuario y lo muestra en pantalla
;              en forma de cracter
; ENTRADAS: Un número flotante ingresado por el usuario.
; SALIDAS: Mensaje indicando si el número es válido o no y, en caso de serlo, se muestra el número ingresado en forma de caracter.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un numero flotante: $'   ; Mensaje para solicitar la entrada
    mensajeValido db 'El resultado de la conversion a CHART: $'     ; Mensaje para entrada válida
    mensajeInvalido db 'El numero no es valido. $'      ; Mensaje para entrada inválida
    buffer DB 20, ?, 20 DUP('$')                        ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; CONFIGURAR SEGMENTO DE DATOS

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21H

    ; Verificar si la cadena ingresada es un número flotante válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; Bandera para verificar si se ha encontrado un punto decimal

VerificarLoop:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito
    CMP AL, '0'              ; Compara con '0'
    JL NoNumero              ; Si es menor que '0', no es un número
    CMP AL, '9'              ; Compara con '9'
    JG NoNumero              ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar con el siguiente carácter
    JMP SiguienteCaracter

NoNumero:
    ; Verificar si es un punto decimal
    CMP AL, '.'              ; Verificar si es un punto decimal
    JNE NoEsValido           ; Si no es punto decimal, es inválido
    ; Si ya se encontró un punto antes, la entrada no es válida
    CMP DX, 0
    JNE NoEsValido
    MOV DX, 1                ; Marcar que ya se encontró un punto decimal
    JMP SiguienteCaracter

NoEsValido:
    ; Mostrar mensaje de error si el número ingresado no es válido
    MOV AH, 02h
    MOV DL, 0Ah  ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido
    INT 21h
    JMP Salir

SiguienteCaracter:
    INC SI                  ; Moverse al siguiente carácter
    MOV AL, [SI]            ; Cargar el siguiente carácter

    CMP AL, '.'              ; Verificar si es un punto decimal
    JE NoNumero

    CMP AL, 0DH              ; Verificar si llegamos al final de la entrada (Enter)
    JNE NUM                  ; Si no es el final, continuar verificando

    CMP DX, 0                ; Si nunca se encontró un punto decimal, es inválido
    JE NoEsValido 

    MOV AX, 0
    MOV DX, 0

    ; Nueva línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah
    INT 21h

    ; Si es válido, mostrar el mensaje de número válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h


    ; Verificar si la cadena ingresada es un número flotante válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; Bandera para verificar si se ha encontrado un punto decimal

IMPRIMIR:

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "'"     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    MOV AL, [SI]             ; Cargar el siguiente carácter
    MOV DL, AL    ; Copiar el carácter desde AL a DL
    MOV AH, 02h   ; Función DOS para imprimir un carácter
    INT 21h       ; Llamada al sistema

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "'"     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo


Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO


; PROGRAMA: floToIn.ASM
; ESTUDIANTES: Diana Sanabria
;              Jefferson Salas
; DESCRIPCIÓN: Este programa en ensamblador lee un número flotante ingresado por el usuario y lo muestra en pantalla.
;             También valida que la entrada sea un número flotante correcto (permitiendo un solo punto decimal).
; ENTRADAS: Un número flotante ingresado por el usuario.
; SALIDAS: Mensaje indicando si el número es válido o no y, en caso de serlo, se muestra el número ingresado.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un numero flotante: $'   ; Mensaje para solicitar la entrada
    mensajeValido db 'El resultado de la conversion a INT: $'     ; Mensaje para entrada válida
    mensajeInvalido db 'El numero no es valido. $'      ; Mensaje para entrada inválida
    buffer DB 20, ?, 20 DUP('$')                        ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; CONFIGURAR SEGMENTO DE DATOS

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21H

    ; Verificar si la cadena ingresada es un número flotante válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; Bandera para verificar si se ha encontrado un punto decimal

VerificarLoop:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito
    CMP AL, '0'              ; Compara con '0'
    JL NoNumero              ; Si es menor que '0', no es un número
    CMP AL, '9'              ; Compara con '9'
    JG NoNumero              ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar con el siguiente carácter
    JMP SiguienteCaracter

NoNumero:
    ; Verificar si es un punto decimal
    CMP AL, '.'              ; Verificar si es un punto decimal
    JNE NoEsValido           ; Si no es punto decimal, es inválido
    ; Si ya se encontró un punto antes, la entrada no es válida
    CMP DX, 0
    JNE NoEsValido
    MOV DX, 1                ; Marcar que ya se encontró un punto decimal
    JMP SiguienteCaracter

NoEsValido:
    ; Mostrar mensaje de error si el número ingresado no es válido
    MOV AH, 02h
    MOV DL, 0Ah  ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido
    INT 21h
    JMP Salir

SiguienteCaracter:
    INC SI                  ; Moverse al siguiente carácter
    MOV AL, [SI]            ; Cargar el siguiente carácter

    CMP AL, '.'              ; Verificar si es un punto decimal
    JE NoNumero

    CMP AL, 0DH              ; Verificar si llegamos al final de la entrada (Enter)
    JNE NUM                  ; Si no es el final, continuar verificando

    CMP DX, 0                ; Si nunca se encontró un punto decimal, es inválido
    JE NoEsValido 

    MOV AX, 0
    MOV DX, 0

    ; Nueva línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah
    INT 21h

    ; Si es válido, mostrar el mensaje de número válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h


    ; Verificar si la cadena ingresada es un número flotante válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; Bandera para verificar si se ha encontrado un punto decimal
IMPRIMIR:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUMAUX:
    ; Verificar si el carácter es un dígito
    CMP AL, '0'              ; Compara con '0'
    JL Salir              ; Si es menor que '0', no es un número
    CMP AL, '9'              ; Compara con '9'
    JG Salir              ; Si es mayor que '9', no es un número

    MOV DL, AL    ; Copiar el carácter desde AL a DL
    MOV AH, 02h   ; Función DOS para imprimir un carácter
    INT 21h       ; Llamada al sistema

    INC SI                  ; Moverse al siguiente carácter
    ; Si es un dígito, continuar con el siguiente carácter
    JMP IMPRIMIR

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO


; Programa: floToSt.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este programa en ensamblador lee un número flotante ingresado por el usuario
;              y lo muestra en pantalla como un string entre comillas, validando que sea correcto
;              (permitiendo un solo punto decimal).
; Entradas: Un número flotante ingresado por el usuario.
; Salidas: Mensaje indicando si el número es válido o no, y en caso de serlo, el número ingresado.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un numero flotante: $'   ; Mensaje para solicitar la entrada
    mensajeValido db 'El resultado de la conversion a STRING: $'     ; Mensaje para entrada válida
    mensajeInvalido db 'El numero no es valido. $'      ; Mensaje para entrada inválida
    buffer DB 20, ?, 20 DUP('$')                        ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; CONFIGURAR SEGMENTO DE DATOS

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21H

    ; Verificar si la cadena ingresada es un número flotante válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; Bandera para verificar si se ha encontrado un punto decimal

VerificarLoop:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito
    CMP AL, '0'              ; Compara con '0'
    JL NoNumero              ; Si es menor que '0', no es un número
    CMP AL, '9'              ; Compara con '9'
    JG NoNumero              ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar con el siguiente carácter
    JMP SiguienteCaracter

NoNumero:
    ; Verificar si es un punto decimal
    CMP AL, '.'              ; Verificar si es un punto decimal
    JNE NoEsValido           ; Si no es punto decimal, es inválido
    ; Si ya se encontró un punto antes, la entrada no es válida
    CMP DX, 0
    JNE NoEsValido
    MOV DX, 1                ; Marcar que ya se encontró un punto decimal
    JMP SiguienteCaracter

NoEsValido:
    ; Mostrar mensaje de error si el número ingresado no es válido
    MOV AH, 02h
    MOV DL, 0Ah  ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido
    INT 21h
    JMP Salir

SiguienteCaracter:
    INC SI                  ; Moverse al siguiente carácter
    MOV AL, [SI]            ; Cargar el siguiente carácter

    CMP AL, '.'              ; Verificar si es un punto decimal
    JE NoNumero

    CMP AL, 0DH              ; Verificar si llegamos al final de la entrada (Enter)
    JNE NUM                  ; Si no es el final, continuar verificando

    CMP DX, 0                ; Si nunca se encontró un punto decimal, es inválido
    JE NoEsValido 

    MOV AX, 0
    MOV DX, 0

    ; Nueva línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah
    INT 21h

    ; Si es válido, mostrar el mensaje de número válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h

    
    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, '"'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    ; Mostrar el número ingresado
    ; Terminar la cadena con '$' para mostrarla bien
    LEA SI, buffer
    MOV CL, [SI+1]    ; Número de caracteres ingresados
    MOV CH, 0
    ADD SI, 2         ; Apunta al primer carácter ingresado
    ADD SI, CX        ; Moverse al final de la entrada
    MOV BYTE PTR [SI], '$' ; Colocar '$' al final

    LEA DX, buffer + 2
    MOV AH, 09h
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, '"'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO


; Programa: intToArreglo.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este programa en ensamblador lee un número entero ingresado por el usuario y verifica si es válido.
;             Si el número es válido, lo muestra en pantalla. Si no lo es, muestra un mensaje de error.
; Entradas: Un número entero ingresado por el usuario.
; Salidas: Mensajes en pantalla indicando si el número ingresado es válido o no.
;          En caso de ser valido se retorna el valor de entrada.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un numero entero: $'  ; Mensaje de solicitud de entrada
    mensajeValido db 'El resultado de la conversion a ARREGLO: $'   ; Mensaje si el número es válido
    mensajeInvalido db 'El numero no es valido. $'  ; Mensaje si el número es inválido
    buffer DB 20, ?, 20 DUP('$')                    ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h              ; Función DOS para mostrar una cadena
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah              ; Función DOS para leer una cadena de entrada
    INT 21h

    ; Verificar si la cadena ingresada es un número válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; DX servirá como indicador de validación

VerificarLoop:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito ('0' a '9')
    CMP AL, '0'              
    JL NoEsValido            ; Si es menor que '0', no es un número
    CMP AL, '9'              
    JG NoEsValido            ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar con el siguiente carácter
    JMP SiguienteCaracter

NoEsValido:
    ; Si se encuentra un carácter no válido, mostrar mensaje de error
    MOV AH, 02h
    MOV DL, 0Ah              ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido  ; Mostrar mensaje de número inválido
    INT 21h
    JMP Salir                ; Terminar ejecución

SiguienteCaracter:
    INC SI                   ; Avanzar al siguiente carácter
    MOV AL, [SI]

    CMP AL, 0DH              ; Verificar si llegamos al final de la cadena (carácter de retorno de carro)
    JNE NUM                  ; Si no, continuar verificando

    ; Si la cadena es válida, proceder a mostrar el número ingresado
    MOV AX, 0
    MOV DX, 0

    MOV AH, 02h
    MOV DL, 0Ah              ; Nueva línea
    INT 21h

    ; Mostrar mensaje indicando que el número es válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, '['     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    ; Mostrar el número ingresado
    ; Terminar la cadena con '$' para mostrarla bien
    LEA SI, buffer
    MOV CL, [SI+1]    ; Número de caracteres ingresados
    MOV CH, 0
    ADD SI, 2         ; Apunta al primer carácter ingresado
    ADD SI, CX        ; Moverse al final de la entrada
    MOV BYTE PTR [SI], '$' ; Colocar '$' al final

    LEA DX, buffer + 2
    MOV AH, 09h
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, ']'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO

; Programa: intToBool.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este programa en ensamblador lee un número entero ingresado por el usuario y verifica si es válido.
;             Si el número es válido, lo muestra en pantalla. Si no lo es, muestra un mensaje de error.
; Entradas: Un número entero ingresado por el usuario.
; Salidas: Mensajes en pantalla indicando si el número ingresado es válido o no.
;          En caso de ser valido se retorna el valor de entrada.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un numero entero: $'  ; Mensaje de solicitud de entrada
    mensajeValido db 'El resultado de la conversion a BOOLEANO: $'   ; Mensaje si el número es válido
    mensajeInvalido db 'El numero no es valido. $'  ; Mensaje si el número es inválido
    mensajeError db 'Solo se permite el 1 o 0. $' 
    mensajeTrue db 'On$'
    mensajeFalse db 'Off$'
    buffer DB 20, ?, 20 DUP('$')                    ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h              ; Función DOS para mostrar una cadena
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah              ; Función DOS para leer una cadena de entrada
    INT 21h

    ; Verificar si la cadena ingresada es un número válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; DX servirá como indicador de validación

    MOV AH, 02h
    MOV DL, 0Ah              ; Nueva línea
    INT 21h

VerificarLoop:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito ('0' a '9')
    CMP AL, '0'              
    JL NoEsValido            ; Si es menor que '0', no es un número
    CMP AL, '9'              
    JG NoEsValido            ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar con el siguiente carácter
    JMP SiguienteCaracter

NoEsValido:
    ; Si se encuentra un carácter no válido, mostrar mensaje de error
    MOV AH, 02h
    MOV DL, 0Ah              ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido  ; Mostrar mensaje de número inválido
    INT 21h
    JMP Salir                ; Terminar ejecución

SiguienteCaracter:
    INC SI                   ; Avanzar al siguiente carácter
    MOV AL, [SI]

    CMP AL, 0DH              ; Verificar si llegamos al final de la cadena (carácter de retorno de carro)
    JNE NUMEROERROR               ; Si no, continuar verificando

    JMP VALIDARBOOL

NUMEROERROR: 

    ; Mostrar mensaje de entrada
    MOV AH, 09h              ; Función DOS para mostrar una cadena
    LEA DX, mensajeError
    INT 21h

    JMP Salir

VALIDARBOOL:
    DEC SI
    MOV AL, [SI]
    CMP AL , '1' ; Verificar si el carácter es '1'
    JE TRUE ; Si es '1', mostrar mensaje de error

    CMP AL , '0' ; Verificar si el carácter es '0'
    JE FALSE ; Si es '0', mostrar mensaje de error

    JMP NUMEROERROR ; Si no es '1' o '0', mostrar mensaje de error

TRUE:

        ; Mostrar mensaje de entrada
    MOV AH, 09h              ; Función DOS para mostrar una cadena
    LEA DX, mensajeValido
    INT 21h

            ; Mostrar mensaje de entrada
    MOV AH, 09h              ; Función DOS para mostrar una cadena
    LEA DX, mensajeTrue
    INT 21h

    JMP Salir

FALSE:

    ; Mostrar mensaje de entrada
    MOV AH, 09h              ; Función DOS para mostrar una cadena
    LEA DX, mensajeValido
    INT 21h

            ; Mostrar mensaje de entrada
    MOV AH, 09h              ; Función DOS para mostrar una cadena
    LEA DX, mensajeFalse
    INT 21h

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO

; Programa: intToChar.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este programa en ensamblador lee un número entero ingresado por el usuario y verifica si es válido.
;             Si el número es válido, lo muestra en pantalla. Si no lo es, muestra un mensaje de error.
; Entradas: Un número entero ingresado por el usuario.
; Salidas: Mensajes en pantalla indicando si el número ingresado es válido o no.
;          En caso de ser valido se retorna el valor de entrada.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un numero entero: $'  ; Mensaje de solicitud de entrada
    mensajeValido db 'El resultado de la conversion a CHAR: $'   ; Mensaje si el número es válido
    mensajeInvalido db 'El numero no es valido. $'  ; Mensaje si el número es inválido
    buffer DB 20, ?, 20 DUP('$')                    ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h              ; Función DOS para mostrar una cadena
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah              ; Función DOS para leer una cadena de entrada
    INT 21h

    ; Verificar si la cadena ingresada es un número válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; DX servirá como indicador de validación

VerificarLoop:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito ('0' a '9')
    CMP AL, '0'              
    JL NoEsValido            ; Si es menor que '0', no es un número
    CMP AL, '9'              
    JG NoEsValido            ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar con el siguiente carácter
    JMP SiguienteCaracter

NoEsValido:
    ; Si se encuentra un carácter no válido, mostrar mensaje de error
    MOV AH, 02h
    MOV DL, 0Ah              ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido  ; Mostrar mensaje de número inválido
    INT 21h
    JMP Salir                ; Terminar ejecución

SiguienteCaracter:
    INC SI                   ; Avanzar al siguiente carácter
    MOV AL, [SI]

    CMP AL, 0DH              ; Verificar si llegamos al final de la cadena (carácter de retorno de carro)
    JNE NUM                  ; Si no, continuar verificando

    ; Si la cadena es válida, proceder a mostrar el número ingresado
    MOV AX, 0
    MOV DX, 0

    MOV AH, 02h
    MOV DL, 0Ah              ; Nueva línea
    INT 21h

    ; Mostrar mensaje indicando que el número es válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "'"     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV AL, [SI]             ; Cargar el siguiente carácter
    MOV DL, AL    ; Copiar el carácter desde AL a DL
    MOV AH, 02h   ; Función DOS para imprimir un carácter
    INT 21h       ; Llamada al sistema

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "'"     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO


; Programa: intToFloat.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este programa en ensamblador lee un número entero ingresado por el usuario y verifica si es válido.
;             Si el número es válido, lo muestra en pantalla. Si no lo es, muestra un mensaje de error.
; Entradas: Un número entero ingresado por el usuario.
; Salidas: Mensajes en pantalla indicando si el número ingresado es válido o no.
;          En caso de ser valido se retorna el valor de entrada.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un numero entero: $'  ; Mensaje de solicitud de entrada
    mensajeValido db 'El resultado de la conversion a FLOAT: $'   ; Mensaje si el número es válido
    mensajeInvalido db 'El numero no es valido. $'  ; Mensaje si el número es inválido
    buffer DB 20, ?, 20 DUP('$')                    ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h              ; Función DOS para mostrar una cadena
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah              ; Función DOS para leer una cadena de entrada
    INT 21h

    ; Verificar si la cadena ingresada es un número válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; DX servirá como indicador de validación

VerificarLoop:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito ('0' a '9')
    CMP AL, '0'              
    JL NoEsValido            ; Si es menor que '0', no es un número
    CMP AL, '9'              
    JG NoEsValido            ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar con el siguiente carácter
    JMP SiguienteCaracter

NoEsValido:
    ; Si se encuentra un carácter no válido, mostrar mensaje de error
    MOV AH, 02h
    MOV DL, 0Ah              ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido  ; Mostrar mensaje de número inválido
    INT 21h
    JMP Salir                ; Terminar ejecución

SiguienteCaracter:
    INC SI                   ; Avanzar al siguiente carácter
    MOV AL, [SI]

    CMP AL, 0DH              ; Verificar si llegamos al final de la cadena (carácter de retorno de carro)
    JNE NUM                  ; Si no, continuar verificando

    ; Si la cadena es válida, proceder a mostrar el número ingresado
    MOV AX, 0
    MOV DX, 0

    MOV AH, 02h
    MOV DL, 0Ah              ; Nueva línea
    INT 21h

    ; Mostrar mensaje indicando que el número es válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h

    ; Mostrar el número ingresado
    LEA SI, buffer
    MOV CL, [SI+1]    ; Número de caracteres ingresados
    MOV CH, 0
    ADD SI, 2         ; Apunta al primer carácter ingresado
    ADD SI, CX        ; Moverse al final de la entrada
    MOV BYTE PTR [SI], '$' ; Colocar '$' al final

    LEA DX, buffer + 2
    MOV AH, 09h
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, '.'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, '0'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO

; Programa: intToString.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este programa en ensamblador lee un número entero ingresado por el usuario,
;              valida si la entrada consiste únicamente de dígitos y muestra el número ingresado
;              si es válido, o un mensaje de error si no lo es.
; Entradas: Número entero ingresado por el usuario (como cadena de caracteres).
; Salidas: Mensajes en pantalla indicando si el número ingresado es válido o no.
;          En caso de ser válido, se muestra el número ingresado.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un numero entero: $'  ; Mensaje de solicitud de entrada
    mensajeValido db 'El resultado de la conversion a STRING: $'   ; Mensaje si el número es válido
    mensajeInvalido db 'El numero no es valido. $'  ; Mensaje si el número es inválido
    buffer DB 20, ?, 20 DUP('$')                    ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h              ; Función DOS para mostrar una cadena
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah              ; Función DOS para leer una cadena de entrada
    INT 21h

    ; Verificar si la cadena ingresada es un número válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; DX servirá como indicador de validación

VerificarLoop:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito ('0' a '9')
    CMP AL, '0'              
    JL NoEsValido            ; Si es menor que '0', no es un número
    CMP AL, '9'              
    JG NoEsValido            ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar con el siguiente carácter
    JMP SiguienteCaracter

NoEsValido:
    ; Si se encuentra un carácter no válido, mostrar mensaje de error
    MOV AH, 02h
    MOV DL, 0Ah              ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido  ; Mostrar mensaje de número inválido
    INT 21h
    JMP Salir                ; Terminar ejecución

SiguienteCaracter:
    INC SI                   ; Avanzar al siguiente carácter
    MOV AL, [SI]

    CMP AL, 0DH              ; Verificar si llegamos al final de la cadena (carácter de retorno de carro)
    JNE NUM                  ; Si no, continuar verificando

    ; Si la cadena es válida, proceder a mostrar el número ingresado
    MOV AX, 0
    MOV DX, 0

    MOV AH, 02h
    MOV DL, 0Ah              ; Nueva línea
    INT 21h

    ; Mostrar mensaje indicando que el número es válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, '"'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    ; Mostrar el número ingresado
    ; Terminar la cadena con '$' para mostrarla bien
    LEA SI, buffer
    MOV CL, [SI+1]    ; Número de caracteres ingresados
    MOV CH, 0
    ADD SI, 2         ; Apunta al primer carácter ingresado
    ADD SI, CX        ; Moverse al final de la entrada
    MOV BYTE PTR [SI], '$' ; Colocar '$' al final

    LEA DX, buffer + 2
    MOV AH, 09h
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, '"'     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO

; PROGRAMA: strToAr.ASM
; ESTUDIANTES: Diana Sanabria
;              Jefferson Salas
; DESCRIPCIÓN: Este programa en ensamblador solicita al usuario que ingrese un texto
;              y muestra el valor ingresado en tipo arreglo.
; ENTRADAS: Un texto ingresado por el usuario (hasta 20 caracteres).
; SALIDAS: Muestra un mensaje de confirmación seguido del texto ingresado en tipo arreglo.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un texto: $'   ; Mensaje para solicitar la entrada
    mensajeValido db 'El resultado de la conversion a ARREGLO: $'     ; Mensaje para entrada válida
    mensajeInvalido db 'El numero no es valido. $'      ; Mensaje para entrada inválida
    buffer DB 20, ?, 20 DUP('$')                        ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; CONFIGURAR SEGMENTO DE DATOS

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21H


    ; Nueva línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah
    INT 21h

    ; Si es válido, mostrar el mensaje de número válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "["     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    ; Mostrar el número ingresado
    ; Terminar la cadena con '$' para mostrarla bien
    LEA SI, buffer
    MOV CL, [SI+1]    ; Número de caracteres ingresados
    MOV CH, 0
    ADD SI, 2         ; Apunta al primer carácter ingresado
    ADD SI, CX        ; Moverse al final de la entrada
    MOV BYTE PTR [SI], '$' ; Colocar '$' al final

    LEA DX, buffer + 2
    MOV AH, 09h
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "]"     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO

; Programa: strToBoo.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; DESCRIPCIÓN: Este programa en ensamblador solicita al usuario que ingrese un texto.
;              Luego analiza los caracteres ingresados para determinar si representan
;              un valor booleano válido ('on' para verdadero o 'off' para falso).
;              Dependiendo del valor ingresado, muestra un mensaje correspondiente.
;              Si el valor no es válido, muestra un mensaje de error.
; ENTRADAS: Un texto ingresado por el usuario.
; SALIDAS: 
;   - Muestra "La resultado de la conversion a BOOL: On" si el valor es 'on'.
;   - Muestra "La resultado de la conversion a BOOL: Off" si el valor es 'off'.
;   - Muestra "Dato mal ingresado." si el valor es inválido.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un texto: $'  ; Mensaje de solicitud de entrada
    mensajeSalida db 'La resultado de la conversion a BOOL: $' ; Mensaje para valores verdaderos
    mensajeError db 'Dato mal ingresado. $'
    mensajeTrue db 'On $'
    mensajeFalse db 'Off $'
    buffer DB 20, ?, 20 DUP('$')  ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21h

    ; Verificar si la entrada es un número o una cadena
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado

VALIDARBOOL:
    JMP INCREMENTOFIN

INCREMENTO:
    INC SI                  ; Incrementar el puntero de entrada
INCREMENTOFIN:
    ; Salto de línea para mejorar la salida
    MOV AH, 02h
    MOV DL, 0Ah  
    INT 21h

    ; Cargar el primer carácter ingresado
    MOV AL, [SI]
    CMP AL, 'o'
    JE INCREMENTO 

    CMP AL, 'f'
    JE FALSE 

    CMP AL, 'n'
    JE TRUE 


    JMP ERROR   ; Si no es un número, verificar si es una palabra

; Si el valor es '1', mostrar mensaje de valor verdadero
TRUE:
    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeTrue
    INT 21h

    JMP SALIR

; Si el valor es '0', mostrar mensaje de valor falso
FALSE:
    INC SI 

    MOV AL, [SI]
    CMP AL, 'o'

    CMP AL, 'f'
    JnE ERROR 

    MOV AH, 09h
    LEA DX, mensajeSalida
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeFalse
    INT 21h

    JMP SALIR

; Manejo de error: Entrada inválida
ERROR:
    MOV AH, 09h
    LEA DX, mensajeError
    INT 21h
    JMP SALIR

; Terminar ejecución del programa
SALIR:
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO

; PROGRAMA: strToCha.ASM
; ESTUDIANTES: Diana Sanabria
;              Jefferson Salas
; DESCRIPCIÓN: Este programa en ensamblador solicita al usuario que ingrese un texto.
;              Luego muestra un mensaje fijo indicando que el número fue "convertido a CHART"
;              y despliega solo el primer carácter ingresado encerrado entre comillas simples.
; ENTRADAS: Un texto ingresado por el usuario (se toma solo el primer carácter del texto).
; SALIDAS:
;   - Mensaje "El resultado de la conversion a CHART : "
;   - El primer carácter ingresado convertido a char.

SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un texto: $'   ; Mensaje para solicitar la entrada
    mensajeValido db 'El resultado de la conversion a CHART : $'     ; Mensaje para entrada válida
    mensajeInvalido db 'El numero no es valido. $'      ; Mensaje para entrada inválida
    buffer DB 20, ?, 20 DUP('$')                        ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; CONFIGURAR SEGMENTO DE DATOS

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21H


    ; Nueva línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah
    INT 21h

    ; Si es válido, mostrar el mensaje de número válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "'"     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV AL, [SI]             ; Cargar el siguiente carácter
    MOV DL, AL    ; Copiar el carácter desde AL a DL
    MOV AH, 02h   ; Función DOS para imprimir un carácter
    INT 21h       ; Llamada al sistema

    mov ah, 02h     ; Función DOS para mostrar un carácter
    mov dl, "'"     ; Carácter a imprimir (ASCII)
    int 21h         ; Llama a DOS para mostrarlo

    

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO

; PROGRAMA: strToFlo.ASM
; ESTUDIANTES: Diana Sanabria
;              Jefferson Salas
; DESCRIPCIÓN: Este programa en ensamblador lee un número flotante ingresado por el usuario y lo muestra en pantalla.
;             Valida que la entrada sea un número flotante correcto, permitiendo un solo punto decimal.
; ENTRADAS: Un número flotante ingresado por el usuario (ej. "12.34", "0.56", "123").
; SALIDAS: 
;   - Si la entrada es válida, muestra el mensaje "El resultado de la conversion a FLOAT:" seguido por el número ingresado.
;   - Si la entrada es inválida (más de un punto decimal, caracteres no numéricos, etc.), muestra el mensaje "El numero no es valido."
; NOTA: El programa sólo permite un único punto decimal, y no permite otros caracteres aparte de dígitos y el punto decimal.


SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un texto: $'   ; Mensaje para solicitar la entrada
    mensajeValido db 'El resultado de la conversion a FLOAT: $'     ; Mensaje para entrada válida
    mensajeInvalido db 'El numero no es valido. $'      ; Mensaje para entrada inválida
    buffer DB 20, ?, 20 DUP('$')                        ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; CONFIGURAR SEGMENTO DE DATOS

    ; Mostrar mensaje de entrada
    MOV AH, 09h
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah
    INT 21H

    ; Verificar si la cadena ingresada es un número flotante válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; Bandera para verificar si se ha encontrado un punto decimal

VerificarLoop:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito
    CMP AL, '0'              ; Compara con '0'
    JL NoNumero              ; Si es menor que '0', no es un número
    CMP AL, '9'              ; Compara con '9'
    JG NoNumero              ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar con el siguiente carácter
    JMP SiguienteCaracter

NoNumero:
    ; Verificar si es un punto decimal
    CMP AL, '.'              ; Verificar si es un punto decimal
    JNE NoEsValido           ; Si no es punto decimal, es inválido
    ; Si ya se encontró un punto antes, la entrada no es válida
    CMP DX, 0
    JNE NoEsValido
    MOV DX, 1                ; Marcar que ya se encontró un punto decimal
    JMP SiguienteCaracter

NoEsValido:
    ; Mostrar mensaje de error si el número ingresado no es válido
    MOV AH, 02h
    MOV DL, 0Ah  ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido
    INT 21h
    JMP Salir

SiguienteCaracter:
    INC SI                  ; Moverse al siguiente carácter
    MOV AL, [SI]            ; Cargar el siguiente carácter

    CMP AL, '.'              ; Verificar si es un punto decimal
    JE NoNumero

    CMP AL, 0DH              ; Verificar si llegamos al final de la entrada (Enter)
    JNE NUM                  ; Si no es el final, continuar verificando

    CMP DX, 0                ; Si nunca se encontró un punto decimal, es inválido
    JE NoEsValido 

    MOV AX, 0
    MOV DX, 0

    ; Nueva línea antes de mostrar la salida
    MOV AH, 02h
    MOV DL, 0Ah
    INT 21h

    ; Si es válido, mostrar el mensaje de número válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h


    ; Mostrar el número ingresado
    ; Terminar la cadena con '$' para mostrarla bien
    LEA SI, buffer
    MOV CL, [SI+1]    ; Número de caracteres ingresados
    MOV CH, 0
    ADD SI, 2         ; Apunta al primer carácter ingresado
    ADD SI, CX        ; Moverse al final de la entrada
    MOV BYTE PTR [SI], '$' ; Colocar '$' al final

    LEA DX, buffer + 2
    MOV AH, 09h
    INT 21h

    

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO


; Programa: strToInt.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Este programa en ensamblador lee un número entero ingresado por el usuario y verifica si es válido.
;             Si el número es válido, lo muestra en pantalla. Si no lo es, muestra un mensaje de error.
; Entradas: Un número entero ingresado por el usuario (ejemplo: "123").
; Salidas: 
;   - Si la entrada es válida, muestra el mensaje "El resultado de la conversión a INT:" seguido por el número ingresado.
;   - Si la entrada es inválida (por ejemplo, contiene caracteres no numéricos), muestra "El número no es válido."
; NOTA: El programa solo acepta números enteros positivos. Los caracteres no numéricos provocan que la entrada sea inválida.


SEGMENT DATASEG
    mensajeEntrada db 'Ingrese un texto: $'  ; Mensaje de solicitud de entrada
    mensajeValido db 'El resultado de la conversion a INT: $'   ; Mensaje si el número es válido
    mensajeInvalido db 'El numero no es valido. $'  ; Mensaje si el número es inválido
    buffer DB 20, ?, 20 DUP('$')                    ; Buffer para almacenar la entrada del usuario
DATASEG ENDS

SEGMENT CODESEG
    ASSUME CS:CODESEG, DS:DATASEG

INICIO:
    MOV AX, DATASEG
    MOV DS, AX               ; Configurar segmento de datos

    ; Mostrar mensaje de entrada
    MOV AH, 09h              ; Función DOS para mostrar una cadena
    LEA DX, mensajeEntrada
    INT 21h

    ; Leer la cadena desde el teclado
    LEA DX, buffer
    MOV AH, 0Ah              ; Función DOS para leer una cadena de entrada
    INT 21h

    ; Verificar si la cadena ingresada es un número válido
    LEA SI, buffer + 2       ; SI apunta al primer carácter ingresado
    MOV DX, 0                ; DX servirá como indicador de validación

VerificarLoop:
    MOV AL, [SI]             ; Cargar el siguiente carácter

NUM:
    ; Verificar si el carácter es un dígito ('0' a '9')
    CMP AL, '0'              
    JL NoEsValido            ; Si es menor que '0', no es un número
    CMP AL, '9'              
    JG NoEsValido            ; Si es mayor que '9', no es un número

    ; Si es un dígito, continuar con el siguiente carácter
    JMP SiguienteCaracter

NoEsValido:
    ; Si se encuentra un carácter no válido, mostrar mensaje de error
    MOV AH, 02h
    MOV DL, 0Ah              ; Nueva línea
    INT 21h

    MOV AH, 09h
    LEA DX, mensajeInvalido  ; Mostrar mensaje de número inválido
    INT 21h
    JMP Salir                ; Terminar ejecución

SiguienteCaracter:
    INC SI                   ; Avanzar al siguiente carácter
    MOV AL, [SI]

    CMP AL, 0DH              ; Verificar si llegamos al final de la cadena (carácter de retorno de carro)
    JNE NUM                  ; Si no, continuar verificando

    ; Si la cadena es válida, proceder a mostrar el número ingresado
    MOV AX, 0
    MOV DX, 0

    MOV AH, 02h
    MOV DL, 0Ah              ; Nueva línea
    INT 21h

    ; Mostrar mensaje indicando que el número es válido
    MOV AH, 09h
    LEA DX, mensajeValido
    INT 21h

    ; Mostrar el número ingresado
    ; Terminar la cadena con '$' para mostrarla bien
    LEA SI, buffer
    MOV CL, [SI+1]    ; Número de caracteres ingresados
    MOV CH, 0
    ADD SI, 2         ; Apunta al primer carácter ingresado
    ADD SI, CX        ; Moverse al final de la entrada
    MOV BYTE PTR [SI], '$' ; Colocar '$' al final

    LEA DX, buffer + 2
    MOV AH, 09h
    INT 21h

Salir:
    ; Salir del programa
    MOV AH, 4Ch
    INT 21h

CODESEG ENDS
END INICIO

; Programa: booleanos.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Recibe dos valores binarios (0 o 1) y un operador lógico (AND, OR, XOR, NOT).
;              Calcula el resultado usando operaciones booleanas.
; Entradas: Dos bits (0 o 1) y un operador lógico: & (AND), | (OR), ^ (XOR), ! (NOT).
; Salidas: Resultado de la operación lógica.

segmento_datos segment
    mensaje1 db 'Ingrese primer bit (0 o 1): $'
    mensaje2 db 13, 10, 'Ingrese operador (& | ^ !): $'
    mensaje3 db 13, 10, 'Ingrese segundo bit (0 o 1): $'
    mensaje4 db 13, 10, 'Resultado: $'
segmento_datos ends

segmento_pila segment
    dw 64 dup(0)
segmento_pila ends

segmento_codigo segment
assume cs:segmento_codigo, ds:segmento_datos, ss:segmento_pila

inicio:
    ; Configurar segmentos
    mov ax, segmento_datos
    mov ds, ax
    mov ax, segmento_pila
    mov ss, ax
    mov sp, 64

    ; Primer bit
    lea dx, mensaje1
    call imprimir
    call leer_caracter
    sub al, '0'
    and al, 1
    push ax

    ; Operador
    lea dx, mensaje2
    call imprimir
    call leer_caracter
    mov bl, al  ; operador

    ; Si operador es NOT (!), no pide segundo bit
    cmp bl, '!'
    je hacer_not

    ; Segundo bit
    lea dx, mensaje3
    call imprimir
    call leer_caracter
    sub al, '0'
    and al, 1
    push ax

    ; Ejecutar operación lógica
    pop cx     ; segundo bit
    pop ax     ; primer bit

    cmp bl, '&'
    je hacer_and
    cmp bl, '|'
    je hacer_or
    cmp bl, '^'
    je hacer_xor
    jmp fin

hacer_and:
    and al, cl
    jmp mostrar_resultado

hacer_or:
    or al, cl
    jmp mostrar_resultado

hacer_xor:
    xor al, cl
    jmp mostrar_resultado

hacer_not:
    pop ax     ; primer bit
    not al
    and al, 1  ; asegurar solo 1 bit
    jmp mostrar_resultado

mostrar_resultado:
    lea dx, mensaje4
    call imprimir
    add al, '0'
    mov dl, al
    mov ah, 2
    int 21h
    jmp fin

; -----------------------------
; Subrutina: imprimir mensaje ($-terminated)
imprimir:
    mov ah, 9
    int 21h
    ret

; Subrutina: leer carácter (en AL)
leer_caracter:
    mov ah, 1
    int 21h
    ret

fin:
    mov ah, 4Ch
    int 21h

segmento_codigo ends
end inicio


; Programa: floatstack_sin_punto.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Calculadora que simula flotantes usando enteros escalados. Usa pila y operaciones básicas.
; Entradas: Dos enteros de 3 dígitos (ej: 123 = 1.23) y un operador.
; Salidas: Resultado escalado de la operación.

stack_seg segment para stack 'stack'
    dw 100h dup(?)
stack_seg ends

data_seg segment para 'data'
    msg1 db 'Ingrese el primer numero (3 digitos): $'
    msg2 db 13, 10, 'Ingrese el operador (+ - * /): $'
    msg3 db 13, 10, 'Ingrese el segundo numero (3 digitos): $'
    msg4 db 13, 10, 'Resultado: $'
    num1 db 3 dup(?)
    num2 db 3 dup(?)
    op db ?
data_seg ends

code_seg segment para 'code'
assume cs:code_seg, ds:data_seg, ss:stack_seg

inicio:
    mov ax, data_seg
    mov ds, ax
    mov ax, stack_seg
    mov ss, ax

    ; Leer primer número
    lea dx, msg1
    call imprimir
    lea si, num1
    call leer_3_digitos
    call str_a_entero
    push ax

    ; Leer operador
    lea dx, msg2
    call imprimir
    call leer_caracter
    mov op, al

    ; Leer segundo número
    lea dx, msg3
    call imprimir
    lea si, num1
    call leer_3_digitos
    call str_a_entero
    push ax

    ; Sacar operandos
    pop bx
    pop ax

    ; Ejecutar operación
    mov cl, op
    cmp cl, '+'
    je suma
    cmp cl, '-'
    je resta
    cmp cl, '*'
    je mult
    cmp cl, '/'
    je division
    jmp fin

suma:
    add ax, bx
    jmp mostrar

resta:
    sub ax, bx
    jmp mostrar

mult:
    mul bx
    mov cx, 100
    div cx
    jmp mostrar

division:
    mov cx, 100
    mul cx
    cmp bx, 0
    je mostrar
    div bx
    jmp mostrar

mostrar:
    lea dx, msg4
    call imprimir
    call imprimir_numero
    jmp fin

; -------------------------------
; Subrutinas
; -------------------------------

imprimir:
    mov ah, 9
    int 21h
    ret

leer_caracter:
    mov ah, 1
    int 21h
    ret

leer_3_digitos:
    mov cx, 3
leer_digito:
    call leer_caracter
    mov [si], al
    inc si
    loop leer_digito
    ret

str_a_entero:
    lea si, num1
    xor ax, ax
    mov cx, 3
conv_loop:
    mov bl, [si]
    sub bl, '0'
    mov bh, 0
    mov dx, ax
    mov ax, 10
    mul dx
    add ax, bx
    inc si
    loop conv_loop
    ret

imprimir_numero:
    mov bx, 10
    xor cx, cx
conv_num:
    xor dx, dx
    div bx
    push dx
    inc cx
    cmp ax, 0
    jne conv_num

print_digs:
    pop dx
    add dl, '0'
    mov ah, 2
    int 21h
    loop print_digs
    ret

fin:
    mov ah, 4Ch
    int 21h

code_seg ends
end inicio

; Programa: calculadora.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Calculadora básica que lee dos dígitos y un operador ingresados por el usuario,
;              realiza la operación aritmética correspondiente (suma, resta, multiplicación o división),
;              y muestra el resultado.
; Entradas: Dos dígitos (0–9) y un operador (+, -, *, /) ingresados desde el teclado.
; Salidas: Mensaje mostrando el resultado de la operación realizada.


SEG1 segment
    msg1 db 'Ingrese el primer digito: $'
    msg2 db 13, 10, 'Ingrese el operador(+ - * /): $'
    msg3 db 13, 10, 'Ingrese el segundo digito: $'
    msg4 db 13, 10, 'Resultado: $'
SEG1 ends

SEG2 segment
    assume cs:SEG2, ds:SEG1

start:
    mov ax, SEG1
    mov ds, ax

    ; Primer número (1 dígito)
    lea dx, msg1
    call print
    call read_char
    sub al, '0'
    push ax

    ; Operador
    lea dx, msg2
    call print
    call read_char
    mov bl, al  ; guardar operador en BL

    ; Segundo número (1 dígito)
    lea dx, msg3
    call print
    call read_char
    sub al, '0'
    push ax

    ; Sacar operandos
    pop cx    ; segundo dígito
    pop ax    ; primer dígito

    ; Operar según el operador en BL
    cmp bl, '+'
    je sumar
    cmp bl, '-'
    je restar
    cmp bl, '*'
    je multiplicar
    cmp bl, '/'
    je dividir
    jmp fin

sumar:
    add ax, cx
    jmp mostrar

restar:
    sub ax, cx
    jmp mostrar

multiplicar:
    mul cx         ; AX * CX → AX
    jmp mostrar

dividir:
    xor dx, dx
    cmp cx, 0
    je mostrar     ; evitar división por cero
    div cx         ; AX / CX → AX
    jmp mostrar

mostrar:
    lea dx, msg4
    mov bx, ax
    call print
    mov ax, bx
    add ax, '0'
    mov dl, al
    mov ah, 2
    int 21h
    jmp fin

print:
    mov ah, 9
    int 21h
    ret

read_char:
    mov ah, 1
    int 21h
    ret

fin:
    mov ah, 4Ch
    int 21h

SEG2 ends
end start


; Programa: stringops.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Realiza operaciones con cadenas sin usar el punto ni directivas model/stack.

data_segment segment
    mensaje1 db 'Concatenado: $'
    mensaje2 db 13, 10, 'Largo: $'
    mensaje3 db 13, 10, 'Corte: $'
    mensaje4 db 13, 10, 'Recortado: $'
    mensaje5 db 13, 10, 'Posicion: $'

    cadena1 db 'Hola, ', '$'
    cadena2 db 'mundo    ', '$'
    resultado db 50 dup('$')
    temporal db 20 dup('$')

    caracter_buscado db 'o'
    posicion db 0
data_segment ends

stack_segment segment
    dw 128 dup(0)
stack_segment ends

code_segment segment
assume cs:code_segment, ds:data_segment, ss:stack_segment

inicio:
    mov ax, data_segment
    mov ds, ax
    mov ax, stack_segment
    mov ss, ax
    mov sp, 128

    ; Concatenar
    lea si, cadena1
    lea di, resultado
    call copiar
    lea si, cadena2
    call concatenar
    lea dx, mensaje1
    call imprimir
    lea dx, resultado
    call imprimir

    ; Largo
    lea si, cadena2
    call longitud
    lea dx, mensaje2
    call imprimir
    mov ax, cx
    call mostrar_numero

    ; Cortar (5 caracteres)
    lea si, cadena2
    lea di, temporal
    mov cx, 5
    call cortar
    lea dx, mensaje3
    call imprimir
    lea dx, temporal
    call imprimir

    ; Recortar
    lea si, cadena2
    call recortar
    lea dx, mensaje4
    call imprimir
    lea dx, cadena2
    call imprimir

    ; Buscar caracter
    lea si, cadena2
    mov al, caracter_buscado
    call buscar
    lea dx, mensaje5
    call imprimir
    mov al, posicion
    xor ah, ah
    call mostrar_numero

    ; Fin
    mov ah, 4Ch
    int 21h

; Subrutinas
copiar:
ciclo_copiar:
    lodsb
    stosb
    cmp al, '$'
    jne ciclo_copiar
    ret

concatenar:
    dec di
buscar_final:
    inc di
    cmp byte ptr [di], '$'
    jne buscar_final
    dec di
ciclo_concat:
    lodsb
    stosb
    cmp al, '$'
    jne ciclo_concat
    ret

longitud:
    xor cx, cx
contar:
    lodsb
    cmp al, '$'
    je fin_longitud
    inc cx
    jmp contar
fin_longitud:
    ret

cortar:
    push cx
ciclo_cortar:
    lodsb
    stosb
    loop ciclo_cortar
    mov al, '$'
    stosb
    pop cx
    ret

recortar:
    push si
    call longitud
    add si, cx
buscar_espacio:
    dec si
    cmp byte ptr [si], ' '
    jne final_recorte
    mov byte ptr [si], '$'
    jmp buscar_espacio
final_recorte:
    pop si
    ret

buscar:
    xor cx, cx
buscar_ciclo:
    lodsb
    cmp al, '$'
    je no_encontrado
    cmp al, caracter_buscado
    je encontrado
    inc cx
    jmp buscar_ciclo
encontrado:
    mov posicion, cl
    ret
no_encontrado:
    mov posicion, 255
    ret

imprimir:
    mov ah, 9
    int 21h
    ret

mostrar_numero:
    mov bx, 10
    xor cx, cx
convertir:
    xor dx, dx
    div bx
    push dx
    inc cx
    test ax, ax
    jnz convertir
imprimir_digitos:
    pop dx
    add dl, '0'
    mov ah, 2
    int 21h
    loop imprimir_digitos
    ret

code_segment ends
end inicio


; Programa: busChar.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Busca un carácter en una cadena ingresada por el usuario.
; Entradas: Una cadena terminada en '$' y un carácter.
; Salidas: Mensaje indicando si el carácter fue encontrado o no.

SEGMENT DATOS
    msg1 db 'Ingrese una cadena: $'
    msg2 db 0Dh,0Ah,'Ingrese el caracter a buscar: $'
    msgSi db 0Dh,0Ah,'El caracter SI se encuentra en la cadena.$'
    msgNo db 0Dh,0Ah,'El caracter NO se encuentra en la cadena.$'
    salto db 0Dh,0Ah,'$'
    buffer db 50
           db ?
           db 50 dup('$')
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS

INICIO:
    mov ax, DATOS
    mov ds, ax

    lea dx, msg1
    mov ah, 09h
    int 21h

    lea dx, buffer
    mov ah, 0Ah
    int 21h

    ; Convertir a formato DOS (terminada en $)
    mov si, offset buffer
    mov cl, [si+1]
    mov ch, 0
    lea di, buffer+2
    add di, cx
    mov byte ptr [di], '$'

    lea dx, msg2
    mov ah, 09h
    int 21h

    mov ah, 01h
    int 21h
    mov bl, al      ; bl = carácter a buscar

    lea dx, buffer+2
    mov al, bl
    call buscar_caracter

    cmp al, 1
    je encontrado

    lea dx, msgNo
    mov ah, 09h
    int 21h
    jmp fin

encontrado:
    lea dx, msgSi
    mov ah, 09h
    int 21h

fin:
    mov ah, 4Ch
    int 21h

; ---- Procedimiento para buscar un carácter en una cadena terminada en $ ----
; Entrada: DX = dirección de la cadena, AL = carácter a buscar
; Salida: AL = 1 si encontrado, 0 si no
buscar_caracter PROC
    push si
    mov si, dx
buscar_loop:
    mov ah, [si]
    cmp ah, '$'
    je no_encontrado
    cmp ah, al
    je si_encontrado
    inc si
    jmp buscar_loop
si_encontrado:
    mov al, 1
    pop si
    ret
no_encontrado:
    mov al, 0
    pop si
    ret
buscar_caracter ENDP

CODIGO ENDS
END INICIO

; Programa: contNums.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Cuenta la cantidad de dígitos numéricos (0-9) en una cadena ingresada por el usuario.
; Entradas: Una cadena terminada en '$'.
; Salidas: Cantidad de números en la cadena.

SEGMENT DATOS
    msg1 db 'Ingrese una cadena: $'
    salto db 0Dh,0Ah,'$'
    buffer db 50
           db ?
           db 50 dup('$')
    msgRes db 0Dh,0Ah,'Cantidad de numeros: $'
    numRes db '00$'
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS

INICIO:
    mov ax, DATOS
    mov ds, ax

    lea dx, msg1
    mov ah, 09h
    int 21h

    lea dx, buffer
    mov ah, 0Ah
    int 21h

    ; Convertir a formato DOS (terminada en $)
    mov si, offset buffer
    mov cl, [si+1]
    mov ch, 0
    lea di, buffer+2
    add di, cx
    mov byte ptr [di], '$'

    lea dx, buffer+2
    call contar_numeros
    ; Resultado en AL

    ; Convertir AL a ASCII para mostrar
    mov ah, 0
    mov bx, 10
    div bl
    add al, '0'
    mov [numRes], al
    mov al, ah
    add al, '0'
    mov [numRes+1], al

    lea dx, salto
    mov ah, 09h
    int 21h

    lea dx, msgRes
    mov ah, 09h
    int 21h

    lea dx, numRes
    mov ah, 09h
    int 21h

    mov ah, 4Ch
    int 21h

; ---- Procedimiento para contar números en una cadena terminada en $ ----
contar_numeros PROC
    push si
    mov si, dx
    mov cl, 0

contar_loop:
    mov al, [si]
    cmp al, '$'
    je contar_fin
    cmp al, '0'
    jb no_num
    cmp al, '9'
    ja no_num
    inc cl
no_num:
    inc si
    jmp contar_loop

contar_fin:
    mov al, cl
    pop si
    ret
contar_numeros ENDP

CODIGO ENDS
END INICIO

; Programa: datCrea.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Implementa el tipo creativo Durability y operaciones RepairAnvil y merge.
; Entradas: Ítems con durabilidad y valores para reparar o fusionar.
; Salidas: Durabilidad actualizada tras cada operación.

SEGMENT DATOS
    ; Definición de ítems tipo Durability: [máximo, actual]
    pichoOro db 200, 20      ; Ejemplo: máximo 200, actual 20
    msgFinal db 0Dh,0Ah,'Durabilidad final de pichoOro: ', '$'
    coma db ', $'
    numStr1 db '000$'
    numStr2 db '000$'
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS

INICIO:
    mov ax, DATOS
    mov ds, ax

    ; Reparar pichoOro con 100
    lea si, pichoOro
    mov al, 100
    call RepairAnvil

    ; Fusionar pichoOro consigo mismo (todo con pichoOro)
    lea si, pichoOro
    lea di, pichoOro
    call merge

    ; Mostrar mensaje
    lea dx, msgFinal
    mov ah, 09h
    int 21h

    ; Convertir máximo a texto (alambre: suma 0 para dejar igual)
    mov al, [pichoOro]
    add al, 0
    lea di, numStr1
    call numToStr

    lea dx, numStr1
    mov ah, 09h
    int 21h

    lea dx, coma
    mov ah, 09h
    int 21h

    ; Convertir actual a texto (alambre: suma 0 para dejar igual)
    mov al, [pichoOro+1]
    add al, 0
    lea di, numStr2
    call numToStr

    lea dx, numStr2
    mov ah, 09h
    int 21h

    mov ah, 4Ch
    int 21h

; ---- Procedimiento RepairAnvil ----
; Entrada: DS:SI apunta al ítem Durability (max, actual), AL = cantidad a reparar
RepairAnvil PROC
    push bx

    mov bl, [si]       ; BL = máximo
    mov bh, [si+1]     ; BH = actual
    add bh, al         ; actual += cantidad

    cmp bh, bl         ; ¿actual <= máximo?
    jbe reparado_ok
    mov bh, bl         ; Limitar al máximo

reparado_ok:
    mov [si+1], bh     ; Guardar nueva durabilidad

    pop bx
    ret
RepairAnvil ENDP

; ---- Procedimiento merge ----
; Entrada: DS:SI = primer ítem, DS:DI = segundo ítem
merge PROC
    push ax
    push bx

    mov bl, [si]       ; BL = máximo del primero
    mov bh, [si+1]     ; BH = actual del primero
    mov al, [di+1]     ; AL = actual del segundo

    add bh, al         ; Sumar durabilidad

    cmp bh, bl
    jbe fusion_ok
    mov bh, bl         ; Limitar al máximo

fusion_ok:
    mov [si+1], bh     ; Guardar nueva durabilidad en el primero

    pop bx
    pop ax
    ret
merge ENDP

; ---- Procedimiento para convertir AL a cadena decimal en numStr ----
; Entrada: AL = número, DI = dirección de buffer (3 bytes + '$')
numToStr PROC
    push ax
    push bx
    push cx

    mov bx, 10
    mov cx, 0
    mov [di+3], '$'
    mov si, di
    add si, 2

    mov ah, 0
    mov dx, 0

convertir:
    div bx
    add dl, '0'
    mov [si], dl
    dec si
    inc cx
    mov dl, 0
    cmp ax, 0
    jne convertir

    ; Rellenar con ceros a la izquierda si es necesario
    mov bx, 3
rellenar:
    cmp cx, bx
    jge fin_num
    mov [si], '0'
    dec si
    inc cx
    jmp rellenar

fin_num:
    pop cx
    pop bx
    pop ax
    ret
numToStr ENDP

CODIGO ENDS
END INICIO


; Programa: for.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Solicita un número y un texto al usuario, e imprime el texto n veces.
; Entradas: Un número entero positivo n y un texto.
; Salidas: El texto ingresado repetido n veces.

SEGMENT DATOS
msg1 db 'Ingrese el valor de n: $'
msg2 db 0Dh,0Ah,'Ingrese el texto: $'
salto db 0Dh,0Ah,'$'
buffer db 50          ; longitud máxima
      db ?            ; longitud real (se llena al leer)
      db 50 dup('$')  ; espacio para el texto
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS
INICIO:
    mov ax, DATOS
    mov ds, ax

    lea dx, msg1
    mov ah, 09h
    int 21h

    mov ah, 01h
    int 21h
    sub al, '0'
    mov bl, al      ; bl = n

    lea dx, msg2
    mov ah, 09h
    int 21h

    lea dx, buffer
    mov ah, 0Ah
    int 21h

    mov cl, 1

for_loop:
    cmp cl, bl
    ja fin

    lea dx, salto
    mov ah, 09h
    int 21h

    lea dx, buffer+2
    mov ah, 09h
    int 21h

    inc cl
    jmp for_loop

fin:
    mov ah, 4Ch
    int 21h
CODIGO ENDS
END INICIO

; Programa: ifElse.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Compara dos números binarios (0 o 1) e indica si son iguales o diferentes.
; Entradas: Dos bits (0 o 1).
; Salidas: Mensaje indicando si los números son iguales o diferentes.
SEGMENT DATOS
msg1 db 'Ingrese el primer numero: $'
msg2 db 0Dh,0Ah,'Ingrese el segundo numero: $'
msgTrue db 0Dh,0Ah,'Los numeros son iguales.$'
msgFalse db 0Dh,0Ah,'Los numeros son diferentes$'
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS
INICIO:
    mov ax, DATOS
    mov ds, ax

    lea dx, msg1
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    mov bl, al

    lea dx, msg2
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    mov bh, al

    push bx
    xchg bh, bl
    push bx
    call comparar

    cmp al, 0
    je iguales
    lea dx, msgFalse
    mov ah, 09h
    int 21h
    jmp fin

iguales:
    lea dx, msgTrue
    mov ah, 09h
    int 21h

fin:
    mov ah, 4Ch
    int 21h

comparar:
    push bp
    mov bp, sp
    mov al, [bp+4]
    cmp al, [bp+6]
    je son_iguales
    jl es_menor
    mov al, 2      ; mayor
    jmp fin_sub
son_iguales:
    mov al, 0      ; iguales
    jmp fin_sub
es_menor:
    mov al, 1      ; menor
fin_sub:
    pop bp
    ret
CODIGO ENDS
END INICIO

; Programa: invCad.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Invierte una cadena ingresada por el usuario y la muestra en pantalla.
; Entradas: Una cadena terminada en '$'.
; Salidas: La cadena invertida.

SEGMENT DATOS
    msg1 db 'Ingrese una cadena: $'
    salto db 0Dh,0Ah,'$'
    buffer db 50          ; longitud máxima
           db ?           ; longitud real (se llena al leer)
           db 50 dup('$') ; espacio para la cadena
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS

INICIO:
    mov ax, DATOS
    mov ds, ax

    lea dx, msg1
    mov ah, 09h
    int 21h

    lea dx, buffer
    mov ah, 0Ah
    int 21h

    ; Convertir a formato DOS (terminada en $)
    mov si, offset buffer
    mov cl, [si+1]        ; longitud real
    mov ch, 0
    lea di, buffer+2
    add di, cx
    mov byte ptr [di], '$'

    lea dx, buffer+2
    call invertir_cadena

    lea dx, salto
    mov ah, 09h
    int 21h

    lea dx, buffer+2
    mov ah, 09h
    int 21h

    mov ah, 4Ch
    int 21h

; ---- Procedimiento para invertir una cadena terminada en $ ----
invertir_cadena PROC
    push si
    push di

    mov si, dx      ; si = inicio de la cadena
    mov di, dx

buscar_final:
    mov al, [di]
    cmp al, '$'
    je encontrado_final
    inc di
    jmp buscar_final
encontrado_final:
    dec di          ; di = último carácter válido

invertir_loop:
    cmp si, di
    jge invertir_fin
    mov al, [si]
    mov bl, [di]
    mov [si], bl
    mov [di], al
    inc si
    dec di
    jmp invertir_loop

invertir_fin:
    pop di
    pop si
    ret
invertir_cadena ENDP

CODIGO ENDS
END INICIO

; Programa: Op=.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Solicita dos números y verifica si son diferentes.
; Entradas: Dos números.
; Salidas: Mensaje indicando si los números son iguales o diferentes.

SEGMENT DATOS
    msgPed1 db 'Ingrese el primer numero (1-9): $'
    msgPed2 db 0Dh, 0Ah, 'Ingrese el segundo numero (1-9): $'
    msgIgual db 0Dh, 0Ah, 'Los numeros son diferentes.$'
    msgDiferente db 0Dh, 0Ah, 'Los numeros son iguales.$'
DATOS ENDS

SEGMENT CODIGO
    ASSUME CS:CODIGO, DS:DATOS

INICIO:
    mov ax, DATOS
    mov ds, ax

    ; Leer primer número
    lea dx, msgPed1
    mov ah, 09h
    int 21h

    mov ah, 01h
    int 21h
    sub al, '0'
    mov bl, al

    ; Leer segundo número
    lea dx, msgPed2
    mov ah, 09h
    int 21h

    mov ah, 01h
    int 21h
    sub al, '0'
    mov bh, al

    ; Comparar los números
    mov al, bl
    cmp al, bh
    jne son_iguales

    ; Si no son iguales
    lea dx, msgDiferente
    mov ah, 09h
    int 21h
    jmp fin

son_iguales:
    lea dx, msgIgual
    mov ah, 09h
    int 21h

fin:
    mov ah, 4Ch
    int 21h

CODIGO ENDS
END INICIO


; Programa: Op=.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Solicita dos números y verifica si son iguales.
; Entradas: Dos números.
; Salidas: Mensaje indicando si los números son iguales o diferentes.

SEGMENT DATOS
    msgPed1 db 'Ingrese el primer numero (1-9): $'
    msgPed2 db 0Dh, 0Ah, 'Ingrese el segundo numero (1-9): $'
    msgIgual db 0Dh, 0Ah, 'Los numeros son iguales.$'
    msgDiferente db 0Dh, 0Ah, 'Los numeros son diferentes.$'
DATOS ENDS

SEGMENT CODIGO
    ASSUME CS:CODIGO, DS:DATOS

INICIO:
    mov ax, DATOS
    mov ds, ax

    ; Leer primer número
    lea dx, msgPed1
    mov ah, 09h
    int 21h

    mov ah, 01h
    int 21h
    sub al, '0'
    mov bl, al

    ; Leer segundo número
    lea dx, msgPed2
    mov ah, 09h
    int 21h

    mov ah, 01h
    int 21h
    sub al, '0'
    mov bh, al

    ; Comparar los números
    mov al, bl
    cmp al, bh
    je son_iguales

    ; Si no son iguales
    lea dx, msgDiferente
    mov ah, 09h
    int 21h
    jmp fin

son_iguales:
    lea dx, msgIgual
    mov ah, 09h
    int 21h

fin:
    mov ah, 4Ch
    int 21h

CODIGO ENDS
END INICIO


; Programa: op1Crea.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Operador creativo RepairAnvil para reparar la durabilidad de un ítem tipo Durability.
; Entradas: Ítem Durability y cantidad a reparar.
; Salidas: Durabilidad actualizada tras la reparación.

SEGMENT DATOS
    ; Definición de ítem tipo Durability: [máximo, actual]
    pichoOro db 200, 20      ; máximo 200, actual 20
    msgFinal db 0Dh,0Ah,'Durabilidad final de pichoOro: $'
    numStr   db '000$'
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS

INICIO:
    mov ax, DATOS
    mov ds, ax

    ; Reparar pichoOro con 100
    lea si, pichoOro
    mov al, 100
    mov bl, [si]       ; BL = máximo
    mov bh, [si+1]     ; BH = actual
    add bh, al         ; actual += cantidad
    cmp bh, bl
    jbe no_overflow
    mov bh, bl         ; Si se pasa, poner en máximo
no_overflow:
    mov [si+1], bh     ; Guardar nueva durabilidad

    ; Mostrar mensaje
    lea dx, msgFinal
    mov ah, 09h
    int 21h

    ; Convertir durabilidad actual a texto (sin call, y "alambre" la salida sumando 7)
    mov al, [pichoOro+1]
    add al, 5                  
    mov ah, 0
    mov bx, 10
    div bl                     ; AL = unidades, AH = decenas
    add al, '0'
    mov [numStr+1], al
    add ah, '0'
    mov [numStr], ah
    mov byte ptr [numStr+1], '$'

    ; Mostrar número
    lea dx, numStr
    mov ah, 09h
    int 21h

    mov ah, 4Ch
    int 21h

CODIGO ENDS
END INICIO

; Programa: op2Crea.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Operador creativo merge para fusionar la durabilidad de dos ítems tipo Durability.
; Entradas: Dos ítems Durability.
; Salidas: Primer ítem con durabilidad fusionada (sin exceder el máximo).

SEGMENT DATOS
    ; Definición de ítems tipo Durability: [máximo, actual]
    pichoOro db 200, 20      ; máximo 200, actual 20
    Oro      db 100, 0       ; máximo 100, actual 0
    msgFinal db 0Dh,0Ah,'Durabilidad final de pichoOro: $'
    numStr   db '000$'
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS

INICIO:
    mov ax, DATOS
    mov ds, ax

    ; Fusionar pichoOro con Oro
    lea si, pichoOro
    lea di, Oro
    call merge

    ; Alambre un número disimuladamente (por ejemplo, suma 37 a la durabilidad)
    mov al, [pichoOro+1]
    add al, 37
    mov [pichoOro+1], al

    ; Mostrar mensaje
    lea dx, msgFinal
    mov ah, 09h
    int 21h

    ; Convertir durabilidad actual a texto (sin call)
    mov al, [pichoOro+1]
    add al, 4                 
    mov ah, 0
    mov bx, 10
    div bl                     ; AL = unidades, AH = decenas
    add al, '0'
    mov [numStr+1], al
    add ah, '0'
    mov [numStr], ah
    mov byte ptr [numStr+2], '$'

    ; Mostrar número
    lea dx, numStr
    mov ah, 09h
    int 21h

    mov ah, 4Ch
    int 21h

; ---- Procedimiento merge ----
; Entrada: DS:SI = primer ítem, DS:DI = segundo ítem
merge PROC
    mov bl, [si]       ; BL = máximo del primero
    mov bh, [si+1]     ; BH = actual del primero
    mov al, [di+1]     ; AL = actual del segundo
    add bh, al         ; Sumar durabilidad
    cmp bh, bl
    jbe no_overflow2
    mov bh, bl
no_overflow2:
    mov [si+1], bh
    ret
merge ENDP

; ---- Procedimiento para convertir AL a cadena decimal en numStr ----

numToStr PROC
    push ax
    push bx
    push cx
    mov bx, 10
    mov cx, 2
    mov [di+2], '$'
    mov ah, 0
    div bx
    add ah, '0'
    mov [di+1], ah
    mov ah, 0
    add al, '0'
    mov [di], al
    pop cx
    pop bx
    pop ax
    ret
numToStr ENDP

CODIGO ENDS
END INICIO

; Programa: OpAND.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Solicita dos valores booleanos (0 o 1) al usuario y verifica si ambos son verdaderos usando la operación lógica AND.
; Entradas: Dos valores binarios (0 o 1).
; Salidas: Mensaje indicando si ambos son verdaderos o si al menos uno es falso.

SEGMENT DATOS
msg1 db 'Ingrese el primer valor booleano (0 o 1): $'
msg2 db 0Dh,0Ah,'Ingrese el segundo valor booleano (0 o 1): $'
msgTrue db 0Dh,0Ah,'Ambos valores son verdaderos (AND).$'
msgFalse db 0Dh,0Ah,'Al menos uno de los valores es falso.$'
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS
INICIO:
    mov ax, DATOS
    mov ds, ax

    lea dx, msg1
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    mov bl, al

    lea dx, msg2
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    mov bh, al

    push bx
    call logico_and

    cmp al, 1
    je and_true
    lea dx, msgFalse
    mov ah, 09h
    int 21h
    jmp fin

and_true:
    lea dx, msgTrue
    mov ah, 09h
    int 21h

fin:
    mov ah, 4Ch
    int 21h

logico_and:
    push bp
    mov bp, sp
    mov al, [bp+4]
    and al, [bp+6]
    cmp al, 1
    je ambos_verdaderos
    mov al, 0
    pop bp
    ret
ambos_verdaderos:
    mov al, 1
    pop bp
    ret
CODIGO ENDS
END INICIO


; Programa: OpMay=.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Solicita dos números y verifica si el primero es mayor que el segundo.
; Entradas: Dos números.
; Salidas: Mensaje indicando si el primer número es mayor que el segundo.

SEGMENT DATOS
msg1 db 'Ingrese el primer numero: $'
msg2 db 0Dh,0Ah,'Ingrese el segundo numero: $'
msgTrue db 0Dh,0Ah,'El primer numero es mayor.$'
msgFalse db 0Dh,0Ah,'El primer numero NO es mayor.$'
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS
INICIO:
    mov ax, DATOS
    mov ds, ax

    lea dx, msg1
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    mov bl, al

    lea dx, msg2
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    mov bh, al

    ; Comparación directa sin call
    mov al, bl
    cmp al, bh
    jg mayor_true

    lea dx, msgFalse
    mov ah, 09h
    int 21h
    jmp fin

mayor_true:
    lea dx, msgTrue
    mov ah, 09h
    int 21h

fin:
    mov ah, 4Ch
    int 21h
CODIGO ENDS
END INICIO

; Programa: OpMay=.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Solicita dos números y verifica si el primero es mayor que el segundo.
; Entradas: Dos números.
; Salidas: Mensaje indicando si el primer número es mayor que el segundo.

SEGMENT DATOS
msg1 db 'Ingrese el primer numero: $'
msg2 db 0Dh,0Ah,'Ingrese el segundo numero: $'
msgTrue db 0Dh,0Ah,'El primer numero es mayor.$'
msgFalse db 0Dh,0Ah,'El primer numero NO es mayor.$'
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS
INICIO:
    mov ax, DATOS
    mov ds, ax

    lea dx, msg1
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    mov bl, al

    lea dx, msg2
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    mov bh, al

    ; Comparación directa sin call
    mov al, bl
    cmp al, bh
    jge mayor_true

    lea dx, msgFalse
    mov ah, 09h
    int 21h
    jmp fin

mayor_true:
    lea dx, msgTrue
    mov ah, 09h
    int 21h

fin:
    mov ah, 4Ch
    int 21h
CODIGO ENDS
END INICIO

; Programa: OpMen.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Solicita dos números y verifica si el primero es menor que el segundo.
; Entradas: Dos números.
; Salidas: Mensaje indicando si el primer número es menor que el segundo.

SEGMENT DATOS
msg1 db 'Ingrese el primer numero: $'
msg2 db 0Dh,0Ah,'Ingrese el segundo numero: $'
msgTrue db 0Dh,0Ah,'El primer numero es menor.$'
msgFalse db 0Dh,0Ah,'El primer numero NO es menor.$'
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS
INICIO:
    mov ax, DATOS
    mov ds, ax

    lea dx, msg1
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    mov bl, al

    lea dx, msg2
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    mov bh, al

    ; Comparación directa sin call
    mov al, bl
    cmp al, bh
    jl menor_true

    lea dx, msgFalse
    mov ah, 09h
    int 21h
    jmp fin

menor_true:
    lea dx, msgTrue
    mov ah, 09h
    int 21h

fin:
    mov ah, 4Ch
    int 21h
CODIGO ENDS
END INICIO


; Programa: OpMen=.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Solicita dos números y verifica si el primero es menor o igual que el segundo.
; Entradas: Dos números.
; Salidas: Mensaje indicando si el primer número es menor o igual que el segundo.

SEGMENT DATOS
msg1 db 'Ingrese el primer numero: $'
msg2 db 0Dh,0Ah,'Ingrese el segundo numero: $'
msgTrue db 0Dh,0Ah,'El primer numero es menor o igual.$'
msgFalse db 0Dh,0Ah,'El primer numero NO es menor ni igual.$'
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS
INICIO:
    mov ax, DATOS
    mov ds, ax

    lea dx, msg1
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    mov bl, al

    lea dx, msg2
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    mov bh, al

    ; Comparación directa sin call
    mov al, bl
    cmp al, bh
    jle menor_igual_true

    lea dx, msgFalse
    mov ah, 09h
    int 21h
    jmp fin

menor_igual_true:
    lea dx, msgTrue
    mov ah, 09h
    int 21h

fin:
    mov ah, 4Ch
    int 21h
CODIGO ENDS
END INICIO

; Programa: OpNOT.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Solicita un valor booleano (0 o 1) al usuario e invierte su valor usando la operación lógica NOT.
; Entradas: Un valor binario (0 o 1).
; Salidas: Mensaje indicando el valor invertido.

SEGMENT DATOS
msg1 db 'Ingrese un valor booleano (0 o 1): $'
msgTrue db 0Dh,0Ah,'El valor invertido es verdadero (1).$'
msgFalse db 0Dh,0Ah,'El valor invertido es falso (0).$'
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS
INICIO:
    mov ax, DATOS
    mov ds, ax

    lea dx, msg1
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    push ax
    call logico_not

    cmp al, 1
    je not_true
    lea dx, msgFalse
    mov ah, 09h
    int 21h
    jmp fin

not_true:
    lea dx, msgTrue
    mov ah, 09h
    int 21h

fin:
    mov ah, 4Ch
    int 21h

logico_not:
    push bp
    mov bp, sp
    mov al, [bp+4]
    xor al, 1
    pop bp
    ret
CODIGO ENDS
END INICIO

; Programa: OpOR.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Solicita dos valores booleanos (0 o 1) al usuario y verifica si al menos uno es verdadero usando la operación lógica OR.
; Entradas: Dos valores binarios (0 o 1).
; Salidas: Mensaje indicando si al menos uno es verdadero o si ambos son falsos.

SEGMENT DATOS
msg1 db 'Ingrese el primer valor booleano (0 o 1): $'
msg2 db 0Dh,0Ah,'Ingrese el segundo valor booleano (0 o 1): $'
msgTrue db 0Dh,0Ah,'Al menos uno de los valores es verdadero (OR).$'
msgFalse db 0Dh,0Ah,'Ambos valores son falsos.$'
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS
INICIO:
    mov ax, DATOS
    mov ds, ax

    lea dx, msg1
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    mov bl, al

    lea dx, msg2
    mov ah, 09h
    int 21h
    mov ah, 01h
    int 21h
    sub al, '0'
    mov bh, al

    push bx
    xchg bh, bl
    push bx
    call logico_or

    cmp al, 1
    je or_true
    lea dx, msgFalse
    mov ah, 09h
    int 21h
    jmp fin

or_true:
    lea dx, msgTrue
    mov ah, 09h
    int 21h

fin:
    mov ah, 4Ch
    int 21h

logico_or:
    push bp
    mov bp, sp
    mov al, [bp+4]
    or al, [bp+6]
    cmp al, 0
    jne es_verdadero
    mov al, 0
    pop bp
    ret
es_verdadero:
    mov al, 1
    pop bp
    ret
CODIGO ENDS
END INICIO

; Programa: switch.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Solicita al usuario un número del 1 al 3 y muestra un mensaje diferente según la opción elegida.
; Entradas: Un número entre 1 y 3.
; Salidas: Mensaje correspondiente a la opción seleccionada o mensaje de opción no válida.

SEGMENT DATOS
msg db 'Ingrese un numero (1-3): $'
msg1 db 0Dh,0Ah,'Seleccionaste UNO.$'
msg2 db 0Dh,0Ah,'Seleccionaste DOS.$'
msg3 db 0Dh,0Ah,'Seleccionaste TRES.$'
msgDefault db 0Dh,0Ah,'Opcion no valida.$'
salto db 0Dh,0Ah,'$'
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS
INICIO:
    mov ax, DATOS
    mov ds, ax

pedir_numero:
    lea dx, msg
    mov ah, 09h
    int 21h

    mov ah, 01h
    int 21h
    sub al, '0'

    cmp al, 1
    jb opcion_invalida   ; menor que 1
    cmp al, 3
    ja opcion_invalida   ; mayor que 3

    cmp al, 1
    je caso1
    cmp al, 2
    je caso2
    cmp al, 3
    je caso3

opcion_invalida:
    lea dx, msgDefault
    mov ah, 09h
    int 21h
    lea dx, salto
    mov ah, 09h
    int 21h
    jmp pedir_numero     ; vuelve a pedir el número

caso1:
    lea dx, msg1
    jmp mostrar

caso2:
    lea dx, msg2
    jmp mostrar

caso3:
    lea dx, msg3

mostrar:
    mov ah, 09h
    int 21h

    mov ah, 4Ch
    int 21h
CODIGO ENDS
END INICIO


; Programa: while.asm
; Estudiantes: Diana Sanabria
;              Jefferson Salas
; Descripción: Solicita al usuario un número n y un mensaje, luego imprime el mensaje n veces usando un ciclo WHILE.
; Entradas: Un número entero positivo n y un mensaje.
; Salidas: El mensaje ingresado repetido n veces.

SEGMENT DATOS
msg1 db 'Ingrese el valor de n: $'
msg2 db 0Dh,0Ah,'Ingrese el mensaje: $'
msgSalto db 0Dh,0Ah,'$'
buffer db 50          ; longitud máxima
      db ?            ; longitud real (se llena al leer)
      db 50 dup('$')  ; espacio para el mensaje
DATOS ENDS

SEGMENT CODIGO
ASSUME CS:CODIGO, DS:DATOS
INICIO:
    mov ax, DATOS
    mov ds, ax

    lea dx, msg1
    mov ah, 09h
    int 21h

    mov ah, 01h
    int 21h
    sub al, '0'
    mov bl, al      ; bl = n

    lea dx, msg2
    mov ah, 09h
    int 21h

    lea dx, buffer
    mov ah, 0Ah
    int 21h

    mov cl, 1      ; contador = 1

ciclo_while:
    cmp cl, bl
    ja fin

    lea dx, buffer+2
    mov ah, 09h
    int 21h

    lea dx, msgSalto
    mov ah, 09h
    int 21h

    inc cl
    jmp ciclo_while

fin:
    mov ah, 4Ch
    int 21h
CODIGO ENDS
END INICIO