📌 Demostración: Contar cuántas “a” existen en una cadena de texto en ARM64 Assembly

💻 Lenguajes de Interfaz en TECNM Campus ITT
👨‍💻 Autor: Alejandro Suarez Sandoval
📅 Fecha: 2025/04/07

🎯 Descripción

Este programa cuenta cuántas letras “a” tiene una cadena de texto.
La implementación se realiza en:

✅ Assembly ARM64 para RaspbianOS en Raspberry Pi

🔧 Compilación en Raspberry Pi (ARM64)

as contar_a.s -o contar_a.o  
ld contar_a.o -o contar_a  

▶️ Ejecución

./contar_a

👀 Código fuente

🔗 Código fuente en Gist: Programa 8 Contar cuantas “a” existen en una cadena de texto Código Assembly ARM64 para RaspbianOS

/*
 ______  ____               ____  __ __      
/\  _  \/\  _`\   /'\_/`\  /'___\/\ \\ \     
\ \ \L\ \ \ \L\ \/\      \/\ \__/\ \ \\ \    
 \ \  __ \ \ ,  /\ \ \__\ \ \  _``\ \ \\ \_  
  \ \ \/\ \ \ \\ \\ \ \_/\ \ \ \L\ \ \__ ,__\
   \ \_\ \_\ \_\ \_\ \_\\ \_\ \____/\/_/\_\_/
    \/_/\/_/\/_/\/ /\/_/ \/_/\/___/    \/_/  
                                             
♡ ∩_∩ 
(„• ֊ •„)♡
|￣U U￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣|
| • Lenguajes de Interfaz en TECNM Campus ITT                                    |
| • Autor: Alejandro Suarez Sandoval                                             |
| • Fecha: 2025/04/07                                                            |
| • Descripción: Programa que cuenta cuantas letras "a"                          |
|   hay en una cadena en Python y Assembly ARM64 para RaspbianOS.                |
| • Demostración:                                                                |
|   https://asciinema.org/a/712758                                               |
| • Compilación (Raspberry Pi ARM64):                                            |
|     as contar_a.s -o contar_a.o                                                |
|     ld contar_a.o -o contar_a                                                  |
| • Ejecución: ./contar_a                                                        |
￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣

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

# Cadena de ejemplo
cadena = "overwatch es el mejor juego del mundo"

# Inicializar el contador de letras 'a'
contador = 0

# Recorrer la cadena
for caracter in cadena:
    if caracter == 'a':  # Comparar con 'a'
        contador += 1  # Incrementar el contador

# Imprimir el resultado
print(f"La cantidad de letras 'a' es: {contador}")

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

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

    .global _start       // Punto de entrada del programa
    .align 2

_start:
    // Inicializar el puntero a la cadena
    ADR     X0, cadena
    MOV     X1, #0       // Inicializar contador a 0

loop:
    LDRB    W2, [X0], #1 // Cargar un byte y avanzar el puntero
    CMP     W2, #0       // Verificar si es el fin de la cadena
    B.EQ    imprimir     // Si es 0, ir a imprimir resultado
    
    CMP     W2, #'a'     // Comparar con 'a'
    B.NE    no_es_a      // Si no es 'a', saltar
    ADD     X1, X1, #1   // Incrementar contador de 'a'

no_es_a:
    B       loop         // Volver al ciclo

imprimir:
    // Convertir el número a ASCII para imprimir
    ADR     X0, buffer   // Cargar dirección del buffer
    ADD     X0, X0, #19  // Moverse al final del buffer
    MOV     X2, #0       // Terminar string con nulo
    STRB    W2, [X0]
    SUB     X0, X0, #1   // Retroceder una posición

    MOV     X2, #10      // Base 10 para la conversión
    MOV     X3, X1       // Copiar el contador a X3

convertir_digito:
    UDIV    X4, X3, X2   // X4 = X3 / 10
    MSUB    X5, X4, X2, X3 // X5 = X3 - (X4 * 10) = X3 % 10
    ADD     W5, W5, #'0' // Convertir a ASCII
    STRB    W5, [X0], #-1 // Guardar en buffer y retroceder
    MOV     X3, X4       // X3 = X3 / 10
    CMP     X3, #0       // Si X3 != 0, continuar
    B.NE    convertir_digito

    // Ajustar X0 para apuntar al primer dígito
    ADD     X0, X0, #1

    // Imprimir la cadena original
    MOV     X8, #64      // Syscall write
    MOV     X0, #1       // File descriptor 1 = STDOUT
    ADR     X1, cadena   // Puntero a la cadena
    MOV     X2, #54      // Longitud de la cadena (ajustar según sea necesario)
    SVC     #0

    // Imprimir mensaje de resultado
    MOV     X8, #64      // Syscall write
    MOV     X0, #1       // File descriptor 1 = STDOUT
    ADR     X1, msg      // Puntero al mensaje
    MOV     X2, #21      // Longitud del mensaje
    SVC     #0

    // Imprimir el resultado
    MOV     X8, #64      // Syscall write
    MOV     X0, #1       // File descriptor 1 = STDOUT
    ADR     X1, buffer   // Puntero al buffer ajustado con el primer dígito
    ADR     X2, buffer   // Calcular longitud restando las direcciones
    ADD     X2, X2, #20
    SUB     X2, X2, X1
    SVC     #0

    // Imprimir un salto de línea
    MOV     X8, #64      // Syscall write
    MOV     X0, #1       // File descriptor 1 = STDOUT
    ADR     X1, newline  // Puntero al salto de línea
    MOV     X2, #1       // Longitud 1
    SVC     #0

    // Terminar programa con código de salida 0
    MOV     X0, #0       // Código de salida 0
    MOV     X8, #93      // Syscall exit
    SVC     #0           // Llamada al sistema

    .data
cadena:
    .asciz  "Overwatch es un juego genial"    // Cadena de ejemplo
msg:
    .asciz  "\nNúmero de letras a: "
newline:
    .asciz  "\n"
buffer:
    .space  20           // Buffer para la conversión del número