Question

I'm learning how to write loops in Python 3+ but need help in solving this function with another function:

def babylonian_square_root(N, estimate, precision):
new_estimate = (estimate + (N / estimate)) / 2
# I need to complete this using this function close_enough().

def close_enough(x, y, maximum_allowable_difference):
''' Returns True if x and y are within maximum_allowable_difference of each other. '''
# Note: "maximum" implies that we should use <= , but for this to work mathematically we need to use < .
# So the difference might be positive or negative, right?
# There are three ways to do this:

# 1. Use the built-in function abs() to get the absolute value of (x - y):
return abs(x - y) < maximum_allowable_difference

# 2.Check BOTH (x - y) AND (y - x):
return (x - y) < maximum_allowable_difference and (y - x) < maximum_allowable_difference

# 3. Shorten the inequality into chained comparisons:
return -maximum_allowable_difference < (x - y) < maximum_allowable_difference

# All three of the above return statements are equivalent.
# Please note that Python is the ONLY language I have encountered
# that allows comparisons to be combined as shown in answer #3.
#
#
# ATTN: --- only one return statement is necessary, but I'm just showing you different ways of doing this.
#
#

# Fill in the missing code below using the function close_enough().

def babylonian_square_root(N, estimate, precision):
new_estimate = (estimate + (N / estimate)) / 2
# Keep looping until new_estimate and estimate are CLOSE ENOUGH (hint, hint).
# Return the last calculated estimate (i.e. new_estimate).
    ENTER MISSING CODE HERE

# To use this function we need three things:
# - N, the number of which we want to find the square root
# - estimate, our first estimate
# - precision, how precise we want our answer to be
# For example, to find the square root of 5 to within 0.01 with an initial estimate of 1 we would write:
print("Square root of 5 is", babylonian_square_root(5, 1, 0.01))

#
# Hint: If you are trying to use math.sqrt() you are going down the wrong path. Step back and rethink your plan.
#
# Examples of expected results:
# babylonian_square_root(100, 1, 0.00000001) ----> 10.0
# babylonian_square_root(100, 1, 0.0000001) ----> 10.0
# babylonian_square_root(100, 1, 0.000001) ----> 10.0
# babylonian_square_root(100, 1, 0.00001) ----> 10.0
# babylonian_square_root(100, 1, 0.0001) ----> 10.000000000139897
# babylonian_square_root(100, 1, 0.001) ----> 10.000000000139897
# babylonian_square_root(100, 1, 0.01) ----> 10.000000000139897
# babylonian_square_root(100, 1, 0.1) ----> 10.000052895642693
# babylonian_square_root(100, 1, 1) ----> 10.032578510960604
# babylonian_square_root(100, 1, 10) ----> 10.840434673026925
#
# babylonian_square_root(100, 10, 1) ----> 10.0
#
# babylonian_square_root(5, 1, 0.001) ----> 2.236067977499978
# babylonian_square_root(5, 1, 0.00000001) ----> 2.23606797749979
#
# ---------------------------------------------------------
# ---------------------------------------------------------

Answer 1

Babylonian method for square root

All text in bold is the python code make sure indentation in correct

def close_enough(x, y, maximum_allowable_difference):
   return abs(x - y) > maximum_allowable_difference
  
def babylonian_square_root(N, estimate, precision):
x = N
y = estimate
e = precision
while close_enough(x,y,e):
y = N / x
x = (x + y)/2
return x

root = float(input("Enter number to find the root for "))
estimate = float(input("Enter Estimated root "))
precision = float(input("Enter precision "))

print("The root of "+str(root)+" is "+str(babylonian_square_root(root,estimate,precision)))

OUTPUT