ABBUC e.V. Forum

Janko und ich haben uns gerade kurz ausgetauscht über die Möglichkeit eines 50- bzw 75% igen Wertes einer Zahl in Assembler.
In einem Spiel kann es ja vorkommen, daß ein bestimmter Wert zu 75% erreicht werden muss, damit es dann entsprechend z.B. in einen nächsten Level weitergehen kann.

50 % muss man wohl hier nicht erklären... aber wie ist es mit 75%?

erster Ansatz:
ok... das geht doch schneller
Hier die Lösung von ChatGPT:
Die KI ist gut... aber Brain ist noch besser:
Zunächst lassen wir mal CLC oder SEC weg, das kürzt sich eh komplett raus und ist am Ende für einen z.B. 75% Vergleich völlig irrelevant.
Hier der schnellste Code:

korrigiert mich bitte falls ich falsch liege.

Wert=192 = %1100 0000
LSR Wert => %0110 0000
ADC #%1100 0000

%0110 0000
%1100 0000 +
=========
%0010 0000 C=1
LSR
%0001 0000 C=0
d16 ist nicht 75% von d192

oder mache ich einen Denkfehler?

Ja das muss man natürlich berücksichtigen... bei höheren Werten kommt man über 255 und dann wird es problematisch.
Der 3. Ansatz funktioniert wohl nur korrekt bei Werten bis 170
so müsste es dann klappen

.
Hallo Leute

Würde 100% - (50%x50%=25%) funktionieren?

Tschüß

Mathy

Hey Mathy... klar doch. Und wenn du dir den ersten Ansatz genau anschaust, dann wirst du sehen, daß der genau so funktioniert.
Zunächst wird 2x halbiert mit LSR, der 25% Wert in Temp zwischengespeichert und dann vom 100%-Wert abgezogen.
Super Lösung, aber etwas langsamer als die anderen Ansätze.

Dr. Irata hat geschrieben: ↑

29.05.2025 15:05

Code: Alles auswählen

LDA Wert
LSR
CLC
ADC Wert
ROR
STA Wert75Prozent

so müsste es dann klappen

Das CLC kann noch weg. Das sorgt dafür, das 0.5 abgerundet wird. Ohne wird es aufgerundet. Man kann sich streiten, was "das Richtige" hier ist, da ja insbesondere das ROR wieder abrundet. Also behaupte ich mal, OHNE ist es schneller und sogar präziser.

... ne das CLC muss m.E. leider drin bleiben, da man sonst evt. mit LSR ein Carry setzt und mit ADC das dann fälschlich addiert...

Dr. Irata hat geschrieben: ↑

29.05.2025 22:51

... ne das CLC muss m.E. leider drin bleiben, da man sonst evt. mit LSR ein Carry setzt und mit ADC das dann fälschlich addiert...

Ja, genau DAS ist auch der Plan. Du berechnest ja (x + x/2)/2. MIT dem CLC wird x/2 abgerundet. OHNE wird es aufgerundet. Das letzte /2 rundet dann wieder ab.
D.h. MIT CLC rundest Du 2 mal ab, OHNE einmal auf, einmal ab.

Einigen wir uns ersteinmal darauf, dass das nur bei ungeradem x eine Rolle spielt ,weil sonst das Carry immer 0 ist, ja?

DANN würde es genau dann einen Unterschied machen, wenn die erste Summe mit Abrunden UNGERADE ist, und mit Aufrunden gerade (nur DANN ist ja die zweite Summe größer), weil anderenfalls wird der Unterschied ja durch das folgende /2 wieder entfernt.

Also, z.B:

(9 + 9 /v/ 2) /v/ 2 = (9+4) /v/ 2 = 6
(9 + 9 /^/ 2) /v/ 2 = (9 + 4 + 1) /v/ 2 = 7

9. * .75 = 6.75

Also ist das Ergebnis OHNE clc genauer.

Ok, war jetzt kein richtiger Beweis, aber "man sieht die Tendenz"

(X+X+X)>>2

atarixle hat geschrieben: ↑

31.05.2025 08:41

(X+X+X)>>2

Das ist die ChatGPT Variante, da gibt es halt recht schnell einen Überlauf.

ja CLC kann weg, da es irrelevant in diesem Fall ist!

RhoSigma hat geschrieben: ↑

31.05.2025 09:04

atarixle hat geschrieben: ↑

31.05.2025 08:41

(X+X+X)>>2

Das ist die ChatGPT Variante, da gibt es halt recht schnell einen Überlauf.

Nee, das ist mir als erstes in den Sinn gekommen.
Bei Programmieraufgaben frage ich ChatGPT schon lange nicht mehr. Höchstens noch zu bash-scripts.
Da ich kein Assembler kann, habe ich es in C gepostet.

X×3/4=75% von X ... das braucht einen größeren Wertebereich, ist aber ausreichend genau bei Ganzzahlen und kommt mit Addition und Schieben aus.

X/4×3=75% von X ... wäre mir zu ungenau (in BASIC), aber durch den kleinen Wertebereich besser für 8-Bit-Assembler.

Hmm ((X<<1)+X)>>2 geht doch ...

Geht dann nicht auch ((X>>1)+X)>>1 ? Aber das ist es bestimmt, was ganz oben schon in Assembler steht, oder?

also oben steh im kürzesten Code folgendes:

Nimm den Wert und teile ihn durch 2 (Befehl LSR) = 50%
Addiere dann mit dem Ursprungswert (100%+50% = 150%)
Teile wieder durch 2 (Befehl ROR) = 75%

Hab mir gerade nochmal den Assemnlercode ganz oben durchgelesen, es ist genau der gleiche Gedankengang wie in meinem Post. Nur ohne KI Power

Dr. Irata hat geschrieben: ↑

31.05.2025 20:21

also oben steh im kürzesten Code folgendes:

Nimm den Wert und teile ihn durch 2 (Befehl LSR) = 50%
Addiere dann mit dem Ursprungswert (100%+50% = 150%)
Teile wieder durch 2 (Befehl ROR) = 75%

also das ist ohne KI Power und kürzer als die von der KI