Programa 35 Generador de anagramas dada una palabra por el usuario Código Assembly ARM64 para RaspbianOS

anagrama.s

/*
 ______  ____               ____  __ __      
/\  _  \/\  _`\   /'\_/`\  /'___\/\ \\ \     
\ \ \L\ \ \ \L\ \/\      \/\ \__/\ \ \\ \    
 \ \  __ \ \ ,  /\ \ \__\ \ \  _``\ \ \\ \_  
  \ \ \/\ \ \ \\ \\ \ \_/\ \ \ \L\ \ \__ ,__\
   \ \_\ \_\ \_\ \_\ \_\\ \_\ \____/\/_/\_\_/
    \/_/\/_/\/_/\/ /\/_/ \/_/\/___/    \/_/  
                                             
♡ ∩_∩ 
(„• ֊ •„)♡
|￣U U￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣| 
| • Lenguajes de Interfaz en TECNM Campus ITT                                 |   
| • Autor: Alejandro Suarez Sandoval                                          | 
| • Fecha: 2025/04/10                                                         | 
| • Descripción: Programa que genera todos los anagramas posibles, dada       | 
|   una palabra dada por el usuario C# y Assembly ARM64 para RaspbianOS.      | 
| • Demostración:                                                             |
|   https://asciinema.org/a/714599                                            |
| • Compilación (Raspberry Pi ARM64):                                         |  
|     as anagrama.s -o anagrama.o                                             |  
|     ld anagrama.o -o anagrama                                               |  
| • Ejecución: ./anagrama                                                     |  
￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣                                       

⠂⠄⠄⠂⠁⠁⠂⠄⠄⠂⠁⠁⠂⠄⠄⠂ ⠂⠄⠄⠂☆
═════════•°• Demostración Código en lenguaje PHP •°•═══════

<?php
function generateAnagrams($word, $start, $end, &$result) {
    if ($start == $end) {
        $result[] = implode('', $word);
    } else {
        for ($i = $start; $i <= $end; $i++) {
            [$word[$start], $word[$i]] = [$word[$i], $word[$start]];
            generateAnagrams($word, $start + 1, $end, $result);
            [$word[$start], $word[$i]] = [$word[$i], $word[$start]];
        }
    }
}

echo "Ingrese una palabra: ";
$input = trim(fgets(STDIN));

$len = strlen($input);
if ($len > 0 && $len <= 10) {
    echo "Anagramas:\n";
    $chars = str_split($input);
    $anagrams = [];
    generateAnagrams($chars, 0, count($chars) - 1, $anagrams);
    $anagrams = array_unique($anagrams);
    foreach ($anagrams as $a) {
        echo $a . "\n";
    }
}
?>


════════════════════•°• ☆ •°•══════════════════════════════
/*

/* ⠂⠄⠄⠂⠁⠁⠂⠄⠄⠂⠁⠁⠂⠄⠄⠂ ⠂⠄⠄⠂☆
═════════════•°• Código en ARM64 Assembly •°•═════════════ */

.global _start

// Garantizar alineamiento para los datos
.align 4
.section .rodata
    prompt:     .ascii "Ingrese una palabra: "
    .align 3    // Alineación de 8 bytes para quad
    prompt_len: .quad . - prompt
    newline:    .ascii "\n"

.align 4
.section .bss
    .align 4    // Alineación para buffer
    buffer:     .space 100
    .align 4    // Alineación para word
    word:       .space 100
    .align 3    // Alineación de 8 bytes para quad
    word_len:   .quad 0

.align 4
.section .text
_start:
    // Mostrar prompt
    mov x0, #1                          // fd = STDOUT
    ldr x1, =prompt                     // buffer = prompt
    ldr x2, =prompt_len                 // puntero a prompt_len
    ldr x2, [x2]                        // cargar valor de prompt_len
    mov x8, #64                         // syscall = sys_write
    svc #0

    // Leer la palabra del usuario
    mov x0, #0                          // fd = STDIN
    ldr x1, =buffer                     // buffer donde almacenar la entrada
    mov x2, #100                        // count = tamaño máximo del buffer
    mov x8, #63                         // syscall = sys_read
    svc #0

    // Guardar la longitud de la palabra (excluyendo el salto de línea)
    sub x0, x0, #1                      // Restar 1 para excluir el salto de línea
    ldr x1, =word_len                   // puntero a word_len
    str x0, [x1]                        // almacenar longitud

    // Copiar la palabra al buffer de trabajo
    mov x3, #0                          // Inicializar contador
    ldr x1, =buffer                     // dirección del buffer fuente
    ldr x2, =word                       // dirección del buffer destino
copy_loop:
    ldrb w4, [x1, x3]                   // cargar byte de buffer[i]
    cmp w4, #10                         // Comprobar si es salto de línea
    b.eq copy_done                      // Si es fin de línea, terminar copia
    strb w4, [x2, x3]                   // word[i] = buffer[i]
    add x3, x3, #1                      // i++
    b copy_loop                         // continuar bucle
copy_done:

    // Llamar a la función para generar anagramas
    ldr x0, =word                       // Puntero a la palabra
    ldr x1, =word_len                   // Puntero a longitud
    ldr x1, [x1]                        // Cargar longitud
    mov x2, #0                          // Posición inicial = 0
    bl generate_anagrams                // Llamar a función

    // Salir del programa
    mov x0, #0                          // código de salida = 0
    mov x8, #93                         // syscall = sys_exit
    svc #0

// Función recursiva para generar anagramas
// x0 = puntero a la palabra
// x1 = longitud de la palabra
// x2 = posición actual
generate_anagrams:
    // Guardar registros en la pila
    stp x29, x30, [sp, #-16]!
    stp x19, x20, [sp, #-16]!
    stp x21, x22, [sp, #-16]!
    stp x23, x24, [sp, #-16]!

    // Guardar parámetros en registros no volátiles
    mov x19, x0                         // x19 = puntero a la palabra
    mov x20, x1                         // x20 = longitud de la palabra
    mov x21, x2                         // x21 = posición actual

    // Si la posición actual es igual a la longitud de la palabra,
    // hemos completado un anagrama, imprimirlo
    cmp x21, x20
    b.ne continue_recursion
    
    // Imprimir el anagrama actual
    mov x0, #1                          // fd = STDOUT
    mov x1, x19                         // buffer = palabra
    mov x2, x20                         // count = longitud de la palabra
    mov x8, #64                         // syscall = sys_write
    svc #0
    
    // Imprimir un salto de línea
    mov x0, #1                          // fd = STDOUT
    ldr x1, =newline                    // buffer = newline
    mov x2, #1                          // count = 1
    mov x8, #64                         // syscall = sys_write
    svc #0
    
    b recursion_done

continue_recursion:
    // Generar anagramas recursivamente
    mov x22, x21                        // i = posición actual

recursion_loop:
    cmp x22, x20                        // Comparar i con la longitud
    b.ge recursion_done                 // Si i >= longitud, terminar

    // Intercambiar caracteres en posición actual e i
    ldrb w23, [x19, x21]                // w23 = palabra[posición]
    ldrb w24, [x19, x22]                // w24 = palabra[i]
    strb w24, [x19, x21]                // palabra[posición] = palabra[i]
    strb w23, [x19, x22]                // palabra[i] = palabra[posición]

    // Llamada recursiva con posición + 1
    mov x0, x19                         // puntero a la palabra
    mov x1, x20                         // longitud de la palabra
    add x2, x21, #1                     // posición + 1
    bl generate_anagrams                // llamada recursiva

    // Restaurar el intercambio (backtracking)
    ldrb w23, [x19, x21]                // w23 = palabra[posición]
    ldrb w24, [x19, x22]                // w24 = palabra[i]
    strb w24, [x19, x21]                // palabra[posición] = palabra[i]
    strb w23, [x19, x22]                // palabra[i] = palabra[posición]

    add x22, x22, #1                    // i++
    b recursion_loop                    // continuar bucle

recursion_done:
    // Restaurar registros de la pila
    ldp x23, x24, [sp], #16
    ldp x21, x22, [sp], #16
    ldp x19, x20, [sp], #16
    ldp x29, x30, [sp], #16
    ret