MIPS tri et tableau

Question

J'ai ce problème de devoirs. Je suis supposé écrire un programme qui fait ce qui suit:

1. Trier les lettres dans la phrase dans la séquence de classement ASCII (c'est-à-dire par ordre alphabétique). Imprime les résultats et le nombre total de caractères dans la phrase.
2. Ensuite, imprimez une liste du nombre de fois où chaque lettre est apparue dans la phrase.
3. Enfin, imprimez le nombre total de caractères différents dans la phrase.

Lorsque j'essaie de tester la première exigence, je ne reçois pas la chaîne de sortie. J'ai aussi besoin d'aide pour faire les deux autres. Je suis relativement nouveau à MIPS, et j'ai une certaine compréhension de celui-ci, mais j'ai quelques difficultés. J'ai modifié du code pour le tri de l'exemple de code que j'ai trouvé.

 .data 
length: .word 0 
buffer: .space 255 
prompt1:.asciiz "Type in a sentence: " 

after: .asciiz "\nString after: " 


    .text 


# Start of code section 

main: 
     li  $v0, 4   # Prompt user for a text string 
     la  $a0, prompt1  # address of string to print 
     syscall 
     li  $v0, 8   # Read in text string 
     la  $a0, buffer 
     li  $a1, 255 
     syscall 

     la  $t0, buffer # Read character from text string 
     lw  $t1, length 
     addu  $t0, $t0, $t1 

# Call on QuickSort 

     la  $a0, buffer  # Constant pointer to string 

     add  $a1, $a0, 0  # Pointer to left end 

     add  $a2, $a0, 25  # Pointer to right end 

     jal  QS    # The one call from main 

# Print out results 

     la  $a0, after 

     li  $v0, 4 

     syscall 

     la  $a0, buffer 

     syscall 

# End main 

     li  $v0, 10 

     syscall 


QS:  sub  $sp, $sp, 16  # \ 
     sw  $a1, 0($sp)  # \ 

     sw  $a2, 4($sp)  # > Save registers 

     sw  $t2, 8($sp)  #/ 

     sw  $ra, 12($sp)  #/and return address 

     bge  $a1, $a2, QSret # Nothing to sort 

     sub  $t3, $a1, $a0  # index i 

     sub  $t4, $a2, $a0  # index j 

     add  $t0, $t3, $t4  # t0 = i+j choose middle 

     sra  $t0, $t0, 1  # t0 = (i+j) div 2 

     add  $t0, $t0, $a0  # t0 -> A[(i+j) div 2] 

     lb  $t5, 0($t0)  # t5 = pivot value 

     lb  $t6, 0($a1)  # t6 = A[i] = left element 

     sb  $t5, 0($a1)  # Swap them so pivot 

     sb  $t6, 0($t0)  # is first element 
# 

     move $t1, $a1   # Initdially i -> first (pivot) item a1 

     add  $t2, $a2, 1  # Initially j -> just past last item a2 

     lb  $t0, 0($a1)  # Pivot value in t0 (in $t5) 

# 
loop: 
# 

i_loop: add  $t1, $t1, 1  # i=i+1; 

     lb  $t5, 0($t1)  # t5 = A[i] 

     bgt  $t0, $t5, i_loop # until pivot <= A[i] 

j_loop: sub  $t2, $t2, 1  # j=j-1; 

     lb  $t6, 0($t2)  # t6 = A[j] 

     blt  $t0, $t6, j_loop # until pivot >= A[j] 
# 

     bge  $t1, $t2, test # if i<j swap 
# 

     sb  $t6, 0($t1)  # A[i] and 

     sb  $t5, 0($t2)  # A[j] 
# 

test: blt  $t1, $t2, loop # until i >= j 
# 

     lb  $t5, 0($a1)  # swap a[a1] = pivot 

     lb  $t6, 0($t2)  # and a[j] 

     sb  $t5, 0($t2)  # now a[j] is 

     sb  $t6, 0($a1)  # in its final position 

# Done with partition 

     lw  $a1, 0($sp) 

     sub  $a2, $t2, 1 

     jal  QS    # Recursive call on left 

     add  $a1, $t2, 1 

     lw  $a2, 4($sp) 

     jal  QS    # Recursive call on right 
# 

QSret: lw  $ra, 12($sp)  # \Replace return address 

     lw  $t2, 8($sp)  # \ 

     lw  $a2, 4($sp)  # > and registers 

     lw  $a1, 0($sp)  #/
     add  $sp, $sp, 16  #/

     jr  $ra 

Answer 1

buffer: .space 255 

Cela remplit buffer avec des zéros.

li  $v0, 8   # Read in text string 
la  $a0, buffer 
li  $a1, 255 
syscall 

Je ne sais pas quel environnement que vous utilisez, mais cela fonctionne généralement comme fgets() en C, donc si vous entrez hello, votre tampon finira comme:

+-----+-----+-----+-----+-----+-----+-----+-----+ more +-----+ 
| 'h' | 'e' | 'l' | 'l' | 'o' |'\n' | 0 | 0 |..zeroes...| 0 | 
+-----+-----+-----+-----+-----+-----+-----+-----+   +-----+ 

Le le code juste après cela ne semble pas faire quelque chose d'utile:

la  $t0, buffer # Read character from text string 
lw  $t1, length 
addu  $t0, $t0, $t1 

mais length n'a jamais été écrite et $t0 n'est pas utilisé à nouveau (jusqu'à ce qu'il soit écrasé à l'intérieur QS).

L'appel à QS passe une valeur fixe dans $a2 (25 - pourquoi?). En supposant que la routine QS fonctionne réellement comme annoncé: si votre chaîne d'origine est courte, certains des octets zéro dans le tampon seront inclus dans la plage qui est triée, et finira donc au début du tampon - la plage qui obtient triés ressemblera à quelque chose comme ceci:

+-----+ more +-----+-----+-----+-----+-----+-----+-----+-----+ 
| 0 |..zeroes...| 0 | 0 |'\n' | 'e' | 'h' | 'l' | 'l' | 'o' | 
+-----+   +-----+-----+-----+-----+-----+-----+-----+-----+ 

-à-dire si la plage qui obtient triée inclut tous les zéro octets, le premier octet du résultat sera zéro, et donc vous imprimera une chaîne vide.

Partie 2: une fois que vous avez une chaîne correctement triée, cela devrait être simple, car toutes les occurrences de chaque caractère sont adjacentes. Il suffit de marcher le long de la chaîne, et de considérer si chaque personnage est le même que le précédent, ou différent.

Partie 3: juste besoin d'un compteur supplémentaire tout en faisant le travail pour la partie 2.