def reverseNumber(n: int) -> int:
reversed_num = 0
while n > 0:
remainder = n % 10
reversed_num = reversed_num * 10 + remainder
n //= 10 # Floor division
return reversed_num
def create2DimensionalMatrix(rows: int, cols: int, default_value=0) -> list:
return [[default_value for _ in range(cols)] for _ in range(rows)]
def valueOfMatrix(valueMatrix: list) -> float:
returnValue:float=0
for i, row in enumerate(valueMatrix):
for j, value in enumerate(row):
returnValue = returnValue + valueMatrix[i][j]
return returnValue
decimalDividend: int = 918
decimalDivisor: int = 139
decimalDividendRevered: int = reverseNumber(decimalDividend)
decimalDivisorRevered: int = reverseNumber(decimalDivisor)
decimalDividendConstitutent:list=[]
decimalDivisorConstitutent:list=[]
while decimalDividendRevered > 0:
decimalDividendConstitutent.append(decimalDividendRevered%10)
decimalDividendRevered = int(decimalDividendRevered/10)
while decimalDivisorRevered > 0:
decimalDivisorConstitutent.append(decimalDivisorRevered%10)
decimalDivisorRevered = int(decimalDivisorRevered/10)
print(f"% Broken Dividend Decimal Into Constitutent Digits:'{decimalDividendConstitutent}'")
print(f"% Broken Divisor Decimal Into Constitutent Digits:'{decimalDivisorConstitutent}'")
decimalDividendConstitutentReversedList:list = decimalDividendConstitutent[::-1]
decimalDivisorConstitutentReversedList:list = decimalDivisorConstitutent[::-1]
numberOfDigitsInDecimalDividendReveredList:int = len(decimalDividendConstitutentReversedList)
numberOfDigitsInDecimalDivisorReveredList:int = len(decimalDivisorConstitutentReversedList)
divisionMatrix:list = create2DimensionalMatrix(numberOfDigitsInDecimalDividendReveredList,numberOfDigitsInDecimalDivisorReveredList)
remainderMatrix:list = create2DimensionalMatrix(numberOfDigitsInDecimalDividendReveredList,numberOfDigitsInDecimalDivisorReveredList)
valueMatrix:list = create2DimensionalMatrix(numberOfDigitsInDecimalDividendReveredList,numberOfDigitsInDecimalDivisorReveredList)
print(f"No Of Constitutent Digits In Dividend:'{numberOfDigitsInDecimalDividendReveredList}'")
print(f"No Of Constitutent Digits In Divisor: '{numberOfDigitsInDecimalDivisorReveredList}'")
print(f"Nexted Loop Starts Here")
division:int =0
reminder:int =0
k:int =0
valueDecimalFactor:float=0
valueDecimalDividerFactor:float=0
signFactor:int=0
borrowFactor:int=1
twoDimensionalMatrixRowCursorPlaceValue:int =0
twoDimensionalMatrixColumnCursorPlaceValue:int =0
dividentPlaceValue:int = 0
divisorPlaceValue:int = 0
# Assuming lists are of equal length
for i in reversed(range(len(decimalDividendConstitutentReversedList))):
for j in reversed(range(len(decimalDivisorConstitutentReversedList))):
print(f"------Iteration Start------")
print(f"Nexted Loop Cursor Position:")
print(f"i :{i}")
print(f"j :{j}")
print(f"abs(j-2) :{abs(j-2)}")
print(f"abs(i-2) :{abs(i-2)}")
twoDimensionalMatrixRowCursorPlaceValue =numberOfDigitsInDecimalDividendReveredList- i -1
twoDimensionalMatrixColumnCursorPlaceValue =numberOfDigitsInDecimalDivisorReveredList - j -1
if i < j: # Skip loop
print(f"# Skipping Iteration")
continue
print(f"# Decimal Cursored Dividend Digit: {decimalDividendConstitutentReversedList[i]},Cursor At Decimal Index {i}")
print(f"# Decimal Cursored Divisor Digit: {decimalDivisorConstitutentReversedList[j]},Cursor At Decimal Index {j}")
placeValueDividendConstituentReversedListCursoredDigit = decimalDividendConstitutentReversedList[i] * (10 ** i)
placeValueDivisorConstituentReversedListCursoredDigit = decimalDivisorConstitutentReversedList[j] * (10 ** j)
print(f"# Place Value Divisor Constituent Reversed List Cursored Digit: {placeValueDivisorConstituentReversedListCursoredDigit}")
print(f"# Place Value Dividend Constituent Reversed List Cursored Digit: {placeValueDividendConstituentReversedListCursoredDigit}")
# if placeValueDivisorConstituentReversedListCursoredDigit > placeValueDividendConstituentReversedListCursoredDigit : # Skip loop
# print(f"# Skipping Iteration")
# continue
if abs(j-2) < abs(i-2): #col index less than row index
print(f"## Skipping Iteration")
continue
if(decimalDivisorConstitutentReversedList[j] > decimalDividendConstitutentReversedList[i]):
borrowFactor = -1
else:
borrowFactor = 1
division = borrowFactor * placeValueDividendConstituentReversedListCursoredDigit/placeValueDivisorConstituentReversedListCursoredDigit
reminder = placeValueDividendConstituentReversedListCursoredDigit % placeValueDivisorConstituentReversedListCursoredDigit
print(f"## Dividend Constituent Digit Revered List Cursored Digit: {decimalDividendConstitutentReversedList[i]},Occurs At Decimal Index {i},Place Value {placeValueDividendConstituentReversedListCursoredDigit}")
print(f"## Divisor Constituent Digit Revered List Cursored Digit: {decimalDivisorConstitutentReversedList[j]},Occurs At Decimal Index {j},Place Value {placeValueDivisorConstituentReversedListCursoredDigit}")
print(f"### Division:{division}")
print(f"### Reminder:{reminder}")
print(f"###Division Matrix Row Cursor Index:{twoDimensionalMatrixRowCursorPlaceValue}")
print(f"### Division Matrix Column Cursor Index:{twoDimensionalMatrixColumnCursorPlaceValue}")
divisionMatrix [twoDimensionalMatrixRowCursorPlaceValue][twoDimensionalMatrixColumnCursorPlaceValue] = division
remainderMatrix [twoDimensionalMatrixRowCursorPlaceValue][twoDimensionalMatrixColumnCursorPlaceValue] = reminder
dividentCursoredDigitPlaceValue =10 ** (len(str(placeValueDividendConstituentReversedListCursoredDigit))-1)
divisorCursoredDigitPlaceValue =10 ** (len(str(placeValueDivisorConstituentReversedListCursoredDigit))-1)
valueDecimalFactor = (dividentCursoredDigitPlaceValue/divisorCursoredDigitPlaceValue)
print(f"### Divident Cursored Digit Place Value:{dividentCursoredDigitPlaceValue}")
print(f"### Divisor Cursored Digit Place Value:{divisorCursoredDigitPlaceValue}")
print(f"### Value Cursored Digit Place Value:{valueDecimalFactor}")
print(f"numberOfDigitsInDecimalDividendReveredList:{numberOfDigitsInDecimalDividendReveredList}")
k= i+j-4
print(f"k:{k}")
signFactor = (-1)**abs(k)
print(f"signFactor:{signFactor}")
valueDecimalDividerFactor = signFactor * (10 ** abs(k))
print(f"[*]: valueDecimalDividerFactor:{valueDecimalDividerFactor}")
if i+1 == numberOfDigitsInDecimalDividendReveredList and j == 0:
print(f"i inside:{i}")
print(f"j inside:{j}")
valueMatrix [twoDimensionalMatrixRowCursorPlaceValue][twoDimensionalMatrixColumnCursorPlaceValue] = division * 2 / (valueDecimalDividerFactor*10)
else:
valueMatrix [twoDimensionalMatrixRowCursorPlaceValue][twoDimensionalMatrixColumnCursorPlaceValue] = division / valueDecimalDividerFactor
print(f"Divident Cursored Digit Place Value: {dividentCursoredDigitPlaceValue}")
print(f"Divisor Cursored Digit Place Value: {divisorCursoredDigitPlaceValue}")
#valueMatrix [twoDimensionalMatrixRowCursorPlaceValue][twoDimensionalMatrixColumnCursorPlaceValue] = division * ((10 ** j)/(10 ** i))
print(f"------Iteration Ends------")
valueOfDivision:float = valueOfMatrix(valueMatrix)
print(f"#### Division Matrix:'{divisionMatrix}'")
print(f"#### Value Matrix:'{valueMatrix}'")
print(f"#### Value Of Division:'{valueOfDivision}'")
