Visual Studio Code :Replace a text by another using regular expression

Suppose in your Visual Studio Code, you come at situtaion where you want to

replace certain text by other but simple Find & Replace isn't

a viable option then you can use regular expression.

e.g.If we want to replace {intermediateResult} with {float(intermediateResult)}.

In visual studio code launch Find & replace,then enable regular expression (the .* icon in the Find bar)

In Find:

            \{(intermediateResult)\}

In Replace TextBox:

            {float($1)}

Explanation:

    \{ and \} match literal curly braces (escaped with backslashes).

    (intermediateResult) captures the variable name.

    $1 in the replace refers to the captured group (i.e., intermediateResult).

In general if You want to replace {abcd} to {float(abcd)} then

Again Enable "Use Regular Expression" (.* icon)

In Find TextBox:

    \{([a-zA-Z_][a-zA-Z0-9_]*)\}

Replace:

    {float($1)}

Explanation:

    \{ and \} match literal curly braces.

    ([a-zA-Z_][a-zA-Z0-9_]*) matches any valid Python identifier:

    Starts with a letter or underscore

    Followed by letters, numbers, or underscores

    $1 refers to the captured variable name.

Division of decimal Algorithm-Another attempt

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!

Division Approximation Algorithm:Initial Phase

Just for fun ,today i tried to implement code for decimal division

similar to approximation way

Here is my code:

Code (python):

        from collections import defaultdict

        import math

        decimalDivident: int = 378

        decimalDivisor: int = 24

        #array/table

        table = [0] * 10

        #intermediateResult

        intermediateResult=0

        #tableBound

        tableLowerBound=decimalDivisor

        tableUpperBound=0

        #expression params

        factor = 1

        counter=1

        #division

        divisionUpperBound=0

        divisionLowerBound=0

        interval =0

        interation =0

        while True:

            if interation ==0:

                intermediateResult = tableLowerBound * (factor * 10)

                table[counter-1]  = intermediateResult

           

                if table[counter-1] < decimalDivident:  

                    divisionLowerBound = factor *  (10 ** counter)

                    tableLowerBound = table[counter-1]

                    tableUpperBound =0

                else:

                    tableUpperBound = table[counter-1]

                    divisionUpperBound = factor * (10 ** counter)

           

                if tableUpperBound > 0:

                    if tableUpperBound == decimalDivident:

                        print(f"Division is {divisionUpperBound}")

                    elif divisionLowerBound == decimalDivident:

                        print(f"Division is {divisionLowerBound}")

                    else:

                        print(f"{decimalDivident} lies between {tableLowerBound} and {tableUpperBound}")

                        print(f"Division lies between {round(divisionLowerBound,4)} and {round(divisionUpperBound,4)}")

               

                    #first iteration ended

                    interation =interation +1

                    # reset counter & factor

                    counter=1

                    #break

                counter=counter+1

            elif interation == 1:

                interval = (tableUpperBound -tableLowerBound)/9

                intermediateResult = tableLowerBound + interval

                table[counter-1]  = intermediateResult

                if table[counter-1] < decimalDivident:  

                    divisionLowerBound = counter * 10

                    tableLowerBound = table[counter-1]

                    tableUpperBound =0

                else:

                    tableUpperBound = table[counter-1]

                    divisionUpperBound = counter * 10

                if tableUpperBound > 0:

                    # reset counter & factor

                    counter=1

                    if tableUpperBound == decimalDivident:

                        print(f"Division is {divisionUpperBound}")

                    elif divisionLowerBound == decimalDivident:

                        print(f"Division is {divisionLowerBound}")

                    else:

                        print(f"{decimalDivident} lies between {tableLowerBound} and {tableUpperBound}")

                        print(f"Division lies between {round(divisionLowerBound,4)} and {round(divisionUpperBound,4)}")

               

                    #iteration incremented

                    interation =interation +1

                else:

                    factor = factor +1

                    counter=counter+1

            elif interation == 2:

                interval = decimalDivisor

                intermediateResult = tableLowerBound + interval

                table[counter-1]  = intermediateResult

                if table[counter-1] < decimalDivident:  

                    divisionLowerBound = 10 + counter

                    tableLowerBound = table[counter-1]

                    tableUpperBound =0

                else:

                    tableUpperBound = table[counter-1]

                    divisionUpperBound = 10 + counter

                if tableUpperBound > 0:

                   

                    if tableUpperBound == decimalDivident:

                        print(f"Division is {divisionUpperBound}")

                    elif divisionLowerBound == decimalDivident:

                        print(f"Division is {divisionLowerBound}")

                    else:

                        print(f"{decimalDivident} lies between {tableLowerBound} and {tableUpperBound}")

                        print(f"Division lies between {round(divisionLowerBound,4)} and {round(divisionUpperBound,4)}")

                    #iteration incremented

                    interation =interation +1

                    # reset counter & factor

                    interval = decimalDivisor/10 #2.4

                    divisionInterval = (divisionUpperBound-divisionLowerBound)/10 # 0.1

                    counter=1

                    #break

                else:

                    factor = factor +1

                    counter=counter+1

            elif interation == 3:#360.384 | 15,16

                intermediateResult = tableLowerBound + interval

                table[counter-1]  = intermediateResult

                if table[counter-1] < decimalDivident:  

                    divisionLowerBound = divisionLowerBound + divisionInterval

                    tableLowerBound = table[counter-1]

                    tableUpperBound =0

                else:

                    tableUpperBound = table[counter-1]

                    divisionUpperBound =divisionLowerBound + divisionInterval

                if tableUpperBound > 0:

                    tableLowerBound = round(tableLowerBound)

                    tableUpperBound = round(tableUpperBound)

                    if tableUpperBound == decimalDivident:

                        print(f"Division is {divisionUpperBound}")

                    elif divisionLowerBound == decimalDivident:

                        print(f"Division is {divisionLowerBound}")

                    else:

                        print(f"{decimalDivident} lies between {tableLowerBound} and {tableUpperBound}")

                        print(f"Division lies between {round(divisionLowerBound,4)} and {round(divisionUpperBound,4)}")

               

                    #iteration incremented

                    interation =interation +1

                    interval = decimalDivisor/100 #0.24

                    divisionInterval = (divisionUpperBound-divisionLowerBound)/10 # 0.1

                    # reset counter & factor

                    counter=1

                    #break

                else:

                    factor = factor +1  

                    counter=counter+1      

            elif interation == 4:#377.379 | 15.7,16.8

                print(f"interval={round(interval,3)},divisionInterval={round(divisionInterval,3)}")

                                                                                   

                intermediateResult = tableLowerBound + interval

                table[counter-1]  = intermediateResult

                if table[counter-1] < decimalDivident:  

                    divisionLowerBound = divisionLowerBound + divisionInterval

                    tableLowerBound = table[counter-1]

                    tableUpperBound =0

                else:

                    tableUpperBound = table[counter-1]

                    divisionUpperBound =divisionLowerBound + divisionInterval

                if tableUpperBound > 0:

                    tableLowerBound = round(tableLowerBound)

                    tableUpperBound = round(tableUpperBound)

                    if tableUpperBound == decimalDivident:

                        print(f"Division is {divisionUpperBound}")

                    elif divisionLowerBound == decimalDivident:

                        print(f"Division is {divisionLowerBound}")

                    else:

                        print(f"{decimalDivident} lies between {tableLowerBound} and {tableUpperBound}")

                        print(f"Division lies between {round(divisionLowerBound,4)} and {round(divisionUpperBound,4)}")

           

                    #iteration incremented

                    interation =interation +1

                    # reset counter & factor

                    counter=1

                    #break

                else:

                    factor = factor +1  

                    counter=counter+1      

Revisiting Algorithm -- Multiplication of decimal number using matrix

Here we revisit the our algorithm to multiplyy two decimal number.

I will try to rewrite the aalgorithm as i feel previous attempt may

be successfull yet it does not appeal my senses.

Here is my new attempt,the code is in python.I am not proficient in python so

some common coding practices might be misssing,if anyone find some please let

me know in comments.

Along with intellectual honesty politeness is also virtue that let you grow in choosen

field so keep comments if any short & precise & upto point.  

Code:

        from collections import defaultdict

        import math

        decimalMultiplicand: int = 378

        decimalMultiplier: int = 250

        def decimalToArray(n):

            return [int(digit) for digit in str(n)]

        def getMultiplication(multiplicand: int, multiplier: int):

            try:

                multiplicandArray = decimalToArray(decimalMultiplicand) #378

                multiplierArray = decimalToArray(multiplier) #24

                i = len(multiplicandArray) -1

                j =  len(multiplierArray) -1

               

                k =0

                intervalSize = len(multiplicandArray)

                sum =0

                power=0

                while j >=0:

                    while i >=0:

                        intermediateResult = multiplierArray[j] * multiplicandArray[i]

                        formattedNumber = f"{intermediateResult:02}"

                        sum = sum + (intermediateResult * (10 **(power+k)))

                        i=i-1

                        k=k+1

                    i=len(multiplicandArray) -1

                    k=0

                    power =power+1

                    j=j-1

                       

                multiplication = multiplicand * multiplier

                return sum

            except Exception as e:

                print(f"An error occured:{e}")

                raise

        result =getMultiplication(decimalMultiplicand, decimalMultiplier)

        print(f"Result:{decimalMultiplicand} * {decimalMultiplier}={result}")