Here is my second attempt to right somewhat offbeat algorithm for
division of number, neither it is generic nor code perfect, yet it has
potential to create a generic & efficient code for division.
Code is python which attempt to divide 378 by 24
Code (Python):
## AUTHOR:Sangram Desai ##
## AUTHOR EMAIL:sangram2681@gmail.com ##
## Purpose: Division of to decimal number ##
## FILE PATH : C:\Users\sangr\OneDrive\Documents\Algorithm ##
## Command: python3 .\divideMe.py ##
from collections import defaultdict
from fractions import Fraction
import math
decimalDivident: int = 378
decimalDivisor: int = 24
#tableBound
tableLowerBound=decimalDivisor
tableBaseLowerBound =decimalDivisor
tableUpperBound=decimalDivident
#divisionBound
divisionLowerBound=0
divisionUpperBound=decimalDivident
intermediateResult =0
divisionBaseLowerBound=0
#variables for intermediate manipulation
currentIterationNumber=1
counter=1
#multiplier
multiplier =0
swapMultiplier =0
cumulativeMultiplier =0
interval =0
totalExpectedIteration=5
isLoopBroken=False
isExactDivision =False
def getMultiplier(currentIterationNumber,multiplier,counter,divisionBaseLowerBound):
if currentIterationNumber ==1:
return 10
elif currentIterationNumber ==2:
return counter
elif currentIterationNumber ==3:
return 1 + Fraction(counter, 10)
elif currentIterationNumber ==4:
return Fraction((divisionBaseLowerBound + Fraction(counter, 10)),10)
elif currentIterationNumber ==5:
return Fraction((divisionBaseLowerBound + Fraction(counter, 100)),10)
else:
return -1
def getCumulativeMultiplier(currentIterationNumber,multiplier,counter,divisionBaseLowerBound):
if currentIterationNumber ==1:
return 10 ** counter
elif currentIterationNumber ==2:
return counter * 10
elif currentIterationNumber ==3:
return (1 + Fraction(counter, 10))*10
elif currentIterationNumber ==4:
return divisionBaseLowerBound + Fraction(counter, 10)
elif currentIterationNumber ==5:
return divisionBaseLowerBound + Fraction(counter, 100)
else:
return -1
def getIntermediateResult(currentIterationNumber,multiplier,tableLowerBound,tableBaseLowerBound,counter,decimalDivisor):
if currentIterationNumber ==1:
return tableLowerBound * multiplier
elif currentIterationNumber ==2:
return tableLowerBound * multiplier
elif currentIterationNumber ==3:
return tableBaseLowerBound * multiplier
elif currentIterationNumber ==4:
return tableBaseLowerBound + Fraction( counter * decimalDivisor , 10)
elif currentIterationNumber ==5:
return tableBaseLowerBound + Fraction( counter * decimalDivisor , 100)
else:
return -1
print(f"------------------Starting To Find {float(decimalDivident)}/{float(decimalDivisor)}-----------------------")
while True:
print(f"\n>>>>>>>>>>>>>>>> Maximuim No Of Allowed Iteration Are : {float(totalExpectedIteration)} <<<<<<<<<<<<<<<<<<<")
print(f"############# Loop Variable Status ###############################")
print(f"\t\tIteration={float(currentIterationNumber)},counter={float(counter)}")
print(f"\t\tdivisionLowerBound={float(divisionLowerBound)} divisionUpperBound={float(divisionUpperBound)}")
print(f"\t\ttableLowerBound={float(tableLowerBound)} tableUpperBound={float(tableUpperBound)}")
print(f"\t\tswapMultiplier={float(swapMultiplier)} multiplier={float(multiplier)},cumulativeMultiplier={float(cumulativeMultiplier)}")
print(f"\t\tintermediateResult={float(intermediateResult)}")
print(f"############# Loop Variable Status ###############################")
#OUTPUT FORMATTING LINE BREAK
print(f"\n")
print(f"############# Iteration - {float(currentIterationNumber)} Started ###############################")
print(f"\t^^^^^^^^^^^^^^^^^^^^ Counter - {float(counter)} Started ^^^^^^^^^^^^^^^^^^^^^")
swapMultiplier = cumulativeMultiplier
cumulativeMultiplier = getCumulativeMultiplier(currentIterationNumber,1,counter,divisionBaseLowerBound)
multiplier = getMultiplier(currentIterationNumber,1,counter,divisionBaseLowerBound)
print(f"\t\tMultiplier updated from {float(swapMultiplier)} to {float(cumulativeMultiplier)}")
print(f"\t\t <><><>tableLowerBound= {float(tableLowerBound)},tableBaseLowerBound={float(tableBaseLowerBound)} ,multiplier= {float(multiplier)},cumulativeMultiplier={float(cumulativeMultiplier)}")
if multiplier < 0:
print(f"############# INVALID MULTIPLIER FOUND ###############################")
break
else:
#intermediateResult = tableLowerBound * multiplier
intermediateResult = getIntermediateResult(currentIterationNumber,multiplier,tableLowerBound,tableBaseLowerBound,counter,decimalDivisor)
print(f"\n[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[")
print(f"\t\t Loop Variable Just After getting intermediateResult")
print(f"\t\tdivisionLowerBound={float(divisionLowerBound)} divisionUpperBound={float(divisionUpperBound)}")
print(f"\t\ttableLowerBound={float(tableLowerBound)} tableUpperBound={float(tableUpperBound)}")
print(f"\t\tIntermediate Result={float(intermediateResult)} and Decimal Divident={float(decimalDivident)}")
print(f"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\n")
#Core Logic
if intermediateResult < decimalDivident:
print(f"\t\tEntered If Part of Core Decision Logic")
print(f"\t\t#Updating Table Lower Bound from {float(tableLowerBound)} to {float(intermediateResult)}")
print(f"\t\t# multiplier={float(multiplier)} cumulativeMultiplier={float(cumulativeMultiplier)}")
tableLowerBound = intermediateResult
#lower bound
if cumulativeMultiplier > divisionLowerBound:
print(f"\t\t# Updating Division Lower Bound from {float(divisionLowerBound)} to {float(cumulativeMultiplier)}")
divisionLowerBound = cumulativeMultiplier
counter=counter+1
elif intermediateResult == decimalDivident:
print(f"\t\tEntered Else If Part of Core Decision Logic")
counter = counter +1
swapMultiplier = cumulativeMultiplier
divisionBaseLowerBound = divisionLowerBound #required
multiplier = getMultiplier(currentIterationNumber,1,counter,divisionBaseLowerBound)
cumulativeMultiplier = getCumulativeMultiplier(currentIterationNumber,1,counter,divisionBaseLowerBound)
divisionLowerBound = cumulativeMultiplier
tableUpperBound =intermediateResult
tableBaseLowerBound = tableLowerBound
tableLowerBound = intermediateResult
print(f"\t\t# multiplier={float(multiplier)},cumulativeMultiplier={float(cumulativeMultiplier)} ,divisionUpperBound={float(divisionUpperBound)}")
print(f"\t\tdivisionLowerBound={float(divisionLowerBound)} divisionUpperBound={float(divisionUpperBound)}")
print(f"\t\ttableLowerBound={float(tableLowerBound)} tableUpperBound={float(tableUpperBound)}")
print(f"\t\tIntermediate Result={float(intermediateResult)} and Decimal Divident={float(decimalDivident)}")
isExactDivision=True
isLoopBroken =True
else:
print(f"\t\tEntered Else Part of Core Decision Logic")
print(f"\t\t# Updating Table Upper Bound from {float(tableUpperBound)} to {float(intermediateResult)}")
divisionBaseLowerBound = divisionLowerBound #required
tableUpperBound =intermediateResult
tableBaseLowerBound = tableLowerBound
#upper bound
if multiplier < divisionUpperBound:
print(f"\t\t# Updating Division Upper Bound from {float(divisionUpperBound)} to {float(cumulativeMultiplier)}")
print(f"\t\t# cumulativeMultiplier={float(cumulativeMultiplier)}")
divisionUpperBound = cumulativeMultiplier
print(f"\t************************Counter - {float(counter)} Ended ***************************\n")
counter=counter+1
if isExactDivision ==False:
print(f"\n\t^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^")
print(f"\t\t# Current Lower Bound & Upper Bound Status for Division & Table")
print(f"\t\tdivisionLowerBound={float(divisionLowerBound)} divisionUpperBound={float(divisionUpperBound)}")
print(f"\t\ttableLowerBound={float(tableLowerBound)} tableUpperBound={float(tableUpperBound)}")
print(f"\t\tIntermediate Result={float(intermediateResult)} and Decimal Divident={float(decimalDivident)}")
print(f"\t^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n")
if isLoopBroken == True:
print(f"<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<RESULT>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(f"##################isExactDivision = {isExactDivision}###################")
if isExactDivision == False:
print(f"{float(decimalDivident)} lies between {float(tableLowerBound)} and {float(tableUpperBound)}")
print(f"Division {float(intermediateResult)} lies between {float(divisionLowerBound)} and {float(divisionUpperBound)}")
elif isExactDivision == True:
print(f"{float(decimalDivident)} lies between {float(tableLowerBound)} and {float(tableUpperBound)}")
print(f"Division {float(intermediateResult)} equals {float(divisionLowerBound)}")
break
else:
#total allowed iterations
if intermediateResult >= decimalDivident:
#starting next iteration
print(f"############# Iteration - {float(currentIterationNumber)} Ended ###############################")
print(f"############# totalExpectedIteration={float(totalExpectedIteration)} and currentIterationNumber={float(currentIterationNumber)}###############################")
if totalExpectedIteration > currentIterationNumber:
print(f">>>>>>>>>>>>>>>>AFTER {float(currentIterationNumber)} iteration<<<<<<<<<<<<<")
print(f"{float(decimalDivident)} lies between {float(tableLowerBound)} and {float(tableUpperBound)}")
print(f"Division {float(decimalDivident)}/{float(decimalDivisor)} lies between {float(divisionLowerBound)} and {float(divisionUpperBound)}")
currentIterationNumber = currentIterationNumber +1
counter =1
print(f">>>>>>>>>>>>>>>> Iteration Incremented To {float(currentIterationNumber)} & Counter to {float(counter)} <<<<<<<<<<<<<<<")
multiplier = getMultiplier(currentIterationNumber,1,counter,divisionLowerBound)
intermediateResult = getIntermediateResult(currentIterationNumber,multiplier,tableLowerBound,tableBaseLowerBound,counter,decimalDivisor)
else:
print(f"\n>>>>>>>>>>>>>>>>Maximuim No Of Allowed Iteration Reached<<<<<<<<<<<<<<<<<<<")
print(f"------------------After {float(totalExpectedIteration)} iterations Reached To End of Program for {float(decimalDivident)}/{float(decimalDivisor)}-----------------------")
isLoopBroken = True
print(f"\n\n################# Infinite Loop Has Broken #################################\n")
I have not yet finetuned code but it works for 378/24 division.
Happy Coding!
