für’s erst Mal rumprobieren hats Spass gemacht. Weil ich gerade dieses herrliche Video über Natur und Algorithmen gesehen habe (http://vimeo.com/9953368), hier ein ein simples Programm um die Fibonacci Reihe zu berechnen:

MOV A 0 ;initial Wer for Register A
MOV B 1 ; initial Wer for Register B
PUSH A ; zeige A (0)
LBL fib ; setze Sprungmarke
ADD A B ; addiere A und B (0 + 1, 1 +1, 1 + 2, 2 + 3 …)
PUSH A ; zeige A (1, 2, 3, 5, 8, 13 …)
MOV $0 A ; Wert von Register A, in welchem die Berechnung aus A + B steht, merken
MOV A B ; Wert von B nach A schieben
MOV B $0 ; das Ergebnis aus der Berechnung A + B, welches in $0 steht, nach B schreiben
CMP B 100 ; Abbruchbedingung der Schleife
JAE end ; wenn der vergleich false ergibt, sprich wenn B > 100 ist, zu Sprungmarke end springen
JMP fib ; ansonsten wieder zu Sprungmarke fib und weiter rechnen
LBL end ; setze Sprungmarke end
HLT ; Programm beenden

Das Programm von Ramon ist aber schon spannender

Cheers

Andy

auch ein schönes Programm, das ein praktisches Problem löst :).

MOV $0, 2 ; Bandbreite in MBit/s eintragen
MOV $1, 10 ; Groesse der Datei in X eintragen
MOV $2, 1 ; X, Masseinheit, fuer Datei (0 = Kilobyte, 1 = Megabyte, 2 = Gigabyte) eintragen
MOV $3, 0 ; Resultat
MOV $11, 8192 ; Ein Kilobyte in Bit
MOV $12, 8388608 ; Ein Megabyte in Bit
MOV $13, 8589934592 ; Ein Gigabyte in Bit
CMP $2, 1; Masseinheit mit 1 vergleichen
JA giga ; wenn groesser 1, dann Giga
JE mega ; wenn gleich 1, dann Mega. Sonst Kilo (optimaler Fall)
MUL $1, $11 ; Rechne Datenmenge (Kilo) nach Bit um
JMP calc
LBL giga
MUL $1, $13 ; Rechne Datenmenge (Giga) nach Bit um
JMP calc
LBL mega
MUL $1, $12 ; Rechne Datenmenge (Mega) nach Bit um
JMP calc
LBL calc
MUL $0, 1024000 ; Rechne Bandbreite in Bit um
DIV $1, $0 ; Berechne Uebertragunszeit (Menge durch Geschwindigkeit)
PUSH $1 ; Resultat (in Sekunden) auf den Stack legen

vielen Dank für die beiden Einsendungen schon mal :). Die Programme laufen fehlerfrei durch, machen den beschriebenen Job und sind auch noch ausführlich kommentiert. Großartig :). Ich drücke euch schon mal den Daumen fürs Gewinnen (und freue mich natürlich trotzdem auf weitere spannende Einsendungen ;)).

MOV A 19 ; Laden des Werts für n (im Beispiel 19)
MOV B 8 ; Laden des Werts für k (im Beispiel
CMP A B ; A und B vergleichen,
JBE ende ; falls A kleiner ist ans Ende springe
MOV $1 A ; A in $1 speichern
SUB $1 B ; B von $1 abziehen
CMP $1 B ; Vergleichen von $1 und B
JAE b_kleiner ; Wenn B kleiner ist, kann der Schritt übersprungen werden
MOV B $1 ; Falls nicht, speichere den kleineren Wert ($1) in B *
LBL b_kleiner
MOV $0 A ; Dann A und B in in $0 und $1 speichern
MOV $1 B
LBL iteration
DEC A ; In jedem Durchgang die Werte in A und B dekrementieren
DEC B
MUL $0 A ; und mit $0 und $1 multiplizieren
MUL $1 B
CMP B 1 ; wenn B == 1 ist, ist das Spiel (fast) zu Ende
JA iteration
DIV $0 $1 ; Die Werte werden noch dividiert und anschließend steht in $0 das Ergebnis
MOV $1 0 ; $1 wird noch aufgeräumt
LBL ende

*Grund: (n über k) ist identisch zu (n über n-k) und hier fällt die Wahl auf den kürzeren Weg

Lustiges Spielzeug, der virtuelle Prozessor

Schönen Gruß und danke für die nette Idee,
Flo

MOV A 5 ; Falultät von 5 (hier austauschen)
MOV B 1 ; B initialisieren mit 1
LBL fak ; Fakultäts Sprungmarke
CMP A 1 : Schauen ob er schon fertig ist mit der Berechnung
JA runfak; Wenn nicht berechne weiter
HLT ; Programm beenden (Ergebnis liegt in B)
LBL runfak; Berechnung
MUL B A ; Multiplikation von A und B
DEC A ; A –
JMP fak ; Fuehre die rekursion weiter

hoffentlich klappts ! Ich wäre am Apache Buch sehr interessiert

Danke und Gruß
Steffen