The remainder is the numerator for a fraction. For example, "5/3 = 1 with a remainder of 2" (because "5 - (1*3) = 2"), so the true result would be "1 + 2/3" (or "quotient + remainder/divisor"). Note that many fractions are recurring decimals, and "1 + 2/3" would be the number 2.666666666...
The easiest way to display this is to display it as a fraction (e.g. print the remainder, the '/' sign and the divisor).
To print it as a decimal; you can repeatedly multiply "remainder/divisor" by 10 and extract the integer part. E.g. "2*10 / 3 = 6 with a remainder of 2" so you can print '6' and do it again with the new remainder, which for this example will be the same, so you'll end up printing '6' repeatedly (until you stop for some other reason - e.g. because you limited it to 3 digits). This works better for other fractions, like "1/8"; where you'd do "1*10/8 = 1 with a remainder of 2; 2*10/8 = 2 with a remainder of 4; 4*10/8 = 5 with a remainder of 0" to get the digits 1, 2 then 5.
The other problem is that this will truncate towards zero and humans prefer "round to nearest" - e.g. for "5/3" you'd end up printing "5.666" and humans would want "5.667" instead. To fix that, if you're doing 3 digits after the decimal point, you'd want to add 0.0005 to the original remainder at the beginning, and to do that with fractions it ends up being cross multiplication - e.g. "remainder/divisor + 1/2000
= (remainder*2000) / (divisor*2000) + (divisor*1) / (divisor*2000)
= (remainder*2000 + divisor*1) / (divisor*2000)
= (remainder*2000 + divisor) / (divisor*2000)".
In other words; if you do "remainder = remainder*2000 + divisor" and "divisor = divisor*2000" before converting the fraction to three decimal digits you'll get a correctly rounded result. Note: In some cases this rounding can change the integer part - e.g. the value 3.99987654321 should be displayed as "4.000" but if you're not careful you'll display "3.000" instead. Fortunately you won't have to worry about this for your case (as the divisor is always a number from 1 to 9).
In assembly; this might look like (NASM syntax, untested):
; ax = number1 = [0,9]; bx = number2 = [1,9]
div bl ;ah = remainder, al = quotient
;Do integer part
mov dl,al ;dl = quotient
call printchar ;Print the quotient
;Prepare for fractional part
shr ax,8 ;ax = remainder (from 0 to 8)
mov cx,2000
mul cx ;dx:ax = ax = remainder*2000 (from 0 to 16000)
add ax,bx ;ax = remainder*2000+divisor (from 1 to 16009)
push ax ; (1)
mov ax,bx ;ax = divisor (from 1 to 9)
mul cx ;dx:ax = ax = divisor*2000 (from 2000 to 18000)
mov bx,ax ;bx = divisor*2000 (from 2000 to 18000)
mov dl,'.'
call printchar ;Print the decimal point
pop ax ; (1)
mov cx,10
;Do the first fractional digit
mul cx ;dx:ax = (remainder*2000+divisor) * 10 (from 10 to 160090)
div bx ;ax = (remainder*2000+divisor) / (divisor*2000); dx = next_remainder (from 0 to 17999)
push dx
mov dl,al
call printchar ;Print the first factional digit
pop ax ;ax = next_remainder (from 0 to 17999)
;Do the second fractional digit
mul cx ;dx:ax = next_remainder * 10 (from 0 to 179990)
div bx ;ax = (next_remainder*10) / (divisor*2000); dx = next remainder
push dx
mov dl,al
call printchar ;Print the second factional digit
pop ax ;ax = next_remainder (from 0 to 17999)
;Do the last fractional digit
mul cx ;dx:ax = next_remainder * 10 (from 0 to 179990)
div bx ;ax = (next_remainder*10) / (divisor*2000); dx = next remainder
mov dl,al
call printchar ;Print the third factional digit
Note that it's important to keep track of variable ranges (e.g. as I have done in the comments above) to provide an assurance that there's no overflow bugs. For example, an integer value from from 10 to 180000 will not fit in 16 bits (and will not fit in a 16-bit register like AX), and we're merely lucky that the instruction set makes it easy to use a pair of registers ("DX:AX" or "highest 16 bits in DX and lowest 16 bits in AX") for those cases.
