Ejercicio_26.s

# Lenguajes de Interfaz - Actividad 26
# Ordenamiento por selección
# Alumno: Gómez Aguilar Jared Emmanuel  
# Número de Control: 22210309  
# Python y Ensamblador
# Algoritmos de ordenamiento

# ---------------------------------------------
/*
def selection_sort(arr):
    for i in range(len(arr)):
        min_idx = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]

*/
# ----------------------------------------------

// Gómez Aguilar Jared Emmanuel
// 22210309
.data
    msg1:    .ascii "Los elementos del arreglo son: 45, 23, 78, 12, 67, 34, 89, 9\n"
    len1 = . - msg1
    msgOrd:  .ascii "El arreglo ordenado es: "
    lenOrd = . - msgOrd
    array:   .quad 45, 23, 78, 12, 67, 34, 89, 9
    buffer:  .skip 20        // Buffer para convertir número a string
    space:   .ascii " "
    newline: .ascii "\n"

.text
.global _start

_start:
    // Mostrar los elementos del arreglo original
    mov x0, #1              // stdout
    ldr x1, =msg1          // mensaje
    mov x2, len1           // longitud
    mov x8, #64            // syscall write
    svc #0

    // Inicializar para ordenamiento por selección
    ldr x0, =array         // Dirección base del arreglo
    mov x1, #8             // Tamaño del arreglo
    
    // Llamar a la función de ordenamiento por selección
    bl selection_sort

    // Mostrar mensaje "El arreglo ordenado es: "
    mov x0, #1
    ldr x1, =msgOrd
    mov x2, lenOrd
    mov x8, #64
    svc #0

    // Mostrar el arreglo ordenado
    ldr x0, =array
    mov x1, #8
    bl print_array

    // Salir del programa
    mov x0, #0
    mov x8, #93
    svc #0

selection_sort:
    // Guardar registros
    stp x29, x30, [sp, #-16]!
    mov x29, sp
    
    mov x2, #0                  // i = 0
outer_loop:
    cmp x2, x1                  // Comparar i con tamaño
    bge sort_end               // Si i >= tamaño, terminar
    
    mov x3, x2                  // min_idx = i
    mov x4, x2                  // j = i
    add x4, x4, #1             // j = i + 1

find_min_loop:
    cmp x4, x1                  // Comparar j con tamaño
    bge swap_min               // Si j >= tamaño, hacer intercambio
    
    // Cargar elementos para comparar
    ldr x5, [x0, x3, lsl #3]   // array[min_idx]
    ldr x6, [x0, x4, lsl #3]   // array[j]
    
    // Comparar elementos
    cmp x6, x5                 // Comparar array[j] con array[min_idx]
    bge next_element          // Si array[j] >= array[min_idx], siguiente elemento
    mov x3, x4                 // Actualizar min_idx = j

next_element:
    add x4, x4, #1             // j++
    b find_min_loop

swap_min:
    // Si min_idx != i, hacer intercambio
    cmp x3, x2
    beq next_iteration
    
    // Intercambiar elementos
    ldr x5, [x0, x2, lsl #3]   // temp = array[i]
    ldr x6, [x0, x3, lsl #3]   // array[min_idx]
    str x6, [x0, x2, lsl #3]   // array[i] = array[min_idx]
    str x5, [x0, x3, lsl #3]   // array[min_idx] = temp

next_iteration:
    add x2, x2, #1             // i++
    b outer_loop

sort_end:
    ldp x29, x30, [sp], #16
    ret

print_array:
    // Guardar registros
    stp x29, x30, [sp, #-16]!
    mov x29, sp
    
    mov x19, x0                // Guardar dirección del array
    mov x20, x1                // Guardar tamaño
    mov x21, #0                // Índice actual

print_loop:
    cmp x21, x20
    bge print_end
    
    // Convertir número actual a string
    ldr x0, [x19, x21, lsl #3]
    ldr x1, =buffer
    bl numero_a_string
    
    // Imprimir número
    mov x0, #1
    ldr x1, =buffer
    mov x8, #64
    svc #0
    
    // Imprimir espacio
    mov x0, #1
    ldr x1, =space
    mov x2, #1
    mov x8, #64
    svc #0
    
    add x21, x21, #1
    b print_loop

print_end:
    // Imprimir nueva línea
    mov x0, #1
    ldr x1, =newline
    mov x2, #1
    mov x8, #64
    svc #0
    
    ldp x29, x30, [sp], #16
    ret

numero_a_string:
    // x0 = número a convertir
    // x1 = dirección del buffer
    mov x2, #10            // Divisor
    mov x3, x1             // Guardar inicio del buffer
    
convert_loop:
    udiv x4, x0, x2        // x4 = x0 / 10
    msub x5, x4, x2, x0    // x5 = x0 - (x4 * 10) = residuo
    add x5, x5, #'0'       // Convertir a ASCII
    strb w5, [x1], #1      // Guardar dígito y avanzar
    mov x0, x4             // Preparar para siguiente división
    cbnz x0, convert_loop  // Continuar si el cociente no es cero

    // Invertir los caracteres
    mov x4, x3             // x4 = inicio
    sub x5, x1, #1         // x5 = fin
reverse_loop:
    cmp x4, x5
    bge reverse_done
    ldrb w6, [x4]
    ldrb w7, [x5]
    strb w7, [x4], #1
    strb w6, [x5], #-1
    b reverse_loop

reverse_done:
    sub x0, x1, x3         // Calcular longitud
    mov x2, x0             // Guardar longitud para syscall write
    ret


ASCIINEMA REC
https://asciinema.org/a/690705