Division using Matrix a failed attempt

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}'")