You are an adept, highly detail oriented grading assistant. Given the instructor code and rubric grade the student code. Note, it doesn't have to be an exact efficient match instead it adheres to the rubric guidelines.

Rubric:
"""
General point breakdown
Main function: 15 points
- Getting and validating inputs: 5 points
- Calling square\_root() correctly: 5 points
- Printing results correctly: 5 points
absolute\_value() function: 5 points
square\_root() function: 30 points
- Having correct two parameters: 10 points
- Looping against the difference in guesses: 10 points
- Calculating each next guess: 5 points
- Returning the best guess: 5 points
Notes:
Do take off points for poor variable names. Random unrelated names should lose 5 points. Single or two character names that don't have obvious meaning should lose 2 points.
Take off 3 points for input and/or 3 points for output messages if they don’t conform to the required messages and continue to provide feedback that more points may be lost in the future.
Minor typos should typically result in 2 points off each.
My solution uses a function to get the user input. That's not required.
Note that students will lose 40 points if they use math.sqrt() or math.pow(). Another 10 points if they use abs() or math.abs().

Specific feedback
-3, user prompt message doesn’t match the required message format. See assignment for the required message format.
-3, output messages don’t match the required message formats. See assignment for the required message format.
-50, nothing submitted for this problem.
-40, can't use math.sqrt(), math.pow(), or any related built-in math functions.
-10, have to write your own absolute\_value() function, can't use abs() or math.abs().
-5, the final estimate is supposed to be printed to 10 decimal places.
-10, do not use global scope variables (those in the top-level program) inside functions unless they are passed in as parameters.
-5, the loop in square\_root() has to use the absolute\_value() function to make sure the difference in estimates is positive.
-10, your loop in square\_root() isn't right. You have to check if the difference between the two most recent estimates is greater than the tolerance and keep looping if so.
-10, you have to use two variables to track the current estimate and the better estimate each time through the loop so that you can stop the loop when the two estimates are close enough (less than the tolerance).
-5, have to return the current best estimate, not the previous best estimate.
-10, have to return the estimate at the end of the square\_root() function, not print it out in the function.

Instructor Sample Code:
```
import sys

def get\_positive\_float(name):
 float\_val = float(input(f"Enter {name}: "))
 if float\_val <= 0:
 print(f"{name} must be positive!")
 sys.exit()
 return float\_val

def absolute\_value(x):
 if x < 0:
 return -x
 else:
 return x

def square\_root(x, tolerance):
 guess = x
 next\_guess = (x/guess + guess)/2
 while absolute\_value(guess-next\_guess) > tolerance:
 guess = next\_guess
 next\_guess = (x/guess + guess)/2
 return next\_guess

x = get\_positive\_float("x")
tolerance = get\_positive\_float("tolerance")

root = square\_root(x, tolerance)
print(f"Square root = {root:.10f}")
```

Student Code:
```

#import sys module
import sys

# getting user input for x and tolerance values
x\_value = float(input("Enter x: "))
if x\_value <= 0:
 print("x must be positive!")
 sys.exit()
 
tolerance = float(input("Enter tolerance: "))
if tolerance <= 0:
 print("tolerance must be positive!")
 sys.exit()

# defining absolute value function
def absolute\_value(diff):
 if diff < 0:
 pos\_diff = diff \* (-1)
 else:
 pos\_diff = diff
 return pos\_diff
# defining square root function
def square\_root(x\_value, tolerance):
 pos\_diff = tolerance + 1
 guess\_0 = x\_value ## (i.e. previous guess)
 guess\_1 = x\_value ## (i.e. "better" guess)
 while tolerance < pos\_diff:
 #print(f"guess\_1 = {guess\_1} and guess\_0 = {guess\_0}")
 numerator = guess\_1 + (x\_value/guess\_1)
 #print(f"numerator = {numerator}")
 guess\_1 = numerator / 2
 #print(f"better = {guess\_1}")
 diff = guess\_1 - guess\_0 
 #print(f"diff = {diff}")
 pos\_diff = absolute\_value(diff)
 #print(f"pos\_diff = {pos\_diff}")
 guess\_0 = guess\_1
 return guess\_1

# storing return value from square root function 
babylonian\_sqrt = square\_root(x\_value, tolerance)

# printing output
print(f"Square root = {babylonian\_sqrt:.10f}")
```
귀하는 능숙하고 세부 사항을 중시하는 채점 도우미입니다. 교수자 코드와 루브릭이 주어지면 학생 코드를 채점합니다. 정확히 효율적으로 일치할 필요는 없으며 루브릭 가이드라인을 준수하면 됩니다.

루브릭:
"""
일반적인 점수 분석
주요 기능: 15점
- 입력값 가져오기 및 유효성 검사: 5점
- square\_root()를 올바르게 호출합니다: 5점
- 결과를 올바르게 인쇄합니다: 5점
절대\_값() 함수: 5점
square\_root() 함수: 30점
- 두 개의 매개변수가 정확합니다: 10점
- 추측의 차이에 대해 반복합니다: 10점
- 각 다음 추측 계산: 5점
- 가장 적합한 추측 반환: 5점
참고:
잘못된 변수 이름은 감점 처리합니다. 관련 없는 임의의 이름은 5점을 감점합니다. 의미가 분명하지 않은 한 글자 또는 두 글자 이름은 2점을 감점합니다.
입력 메시지가 필수 메시지와 일치하지 않는 경우 3점, 출력 메시지가 필수 메시지와 일치하지 않는 경우 3점을 감점하고 향후 더 감점될 수 있다는 피드백을 계속 제공하세요.
사소한 오타의 경우 일반적으로 각각 2점을 감점합니다.
제 솔루션은 함수를 사용하여 사용자 입력을 받습니다. 이는 필수는 아닙니다.
학생이 math.sqrt() 또는 math.pow()를 사용하는 경우 40점이 감점됩니다. abs() 또는 math.abs()를 사용하면 10점이 감점됩니다.

구체적인 피드백
-3, 사용자 프롬프트 메시지가 필수 메시지 형식과 일치하지 않습니다. 필요한 메시지 형식은 과제를 참조하세요.
-3, 출력 메시지가 필수 메시지 형식과 일치하지 않습니다. 필요한 메시지 형식은 과제를 참조하세요.
-50, 이 문제에 대해 제출된 것이 없습니다.
-40, math.sqrt(), math.pow() 또는 관련 내장 수학 함수를 사용할 수 없습니다.
-10, 절대\_value() 함수를 직접 작성해야 하며, abs() 또는 math.abs()를 사용할 수 없습니다.
-5, 최종 예상값은 소수점 이하 10자리까지 인쇄되어야 합니다.
-10, 전역 범위 변수(최상위 프로그램에 있는 변수)는 매개 변수로 전달되지 않는 한 함수 내에서 사용할 수 없습니다.
-5, square\_root()의 루프는 절대\_value() 함수를 사용하여 추정값의 차이가 양수인지 확인해야 합니다.
-10이면 square\_root()의 루프가 올바르지 않습니다. 가장 최근의 두 추정치 간의 차이가 허용 오차보다 큰지 확인하고 큰 경우 계속 반복해야 합니다.
-10인 경우 두 변수를 사용하여 루프를 통해 매번 현재 추정치와 더 나은 추정치를 추적하여 두 추정치가 충분히 가까워지면(허용 오차보다 작으면) 루프를 중지할 수 있도록 해야 합니다.
-5, 이전 최적 추정치가 아닌 현재 최적 추정치를 반환해야 합니다.
-10의 경우, 추정값을 함수에서 출력하지 않고 square\_root() 함수의 끝에 반환해야 합니다.

강사 샘플 코드:
```
import sys

def get\_positive\_float(name):
 float\_val = float(입력(f"{이름} 입력: "))
 if float\_val <= 0:
 print(f"{이름}은 양수여야 합니다!")
 sys.exit()
 반환 float\_val

def absolute\_value(x):
 if x < 0:
 return -x
 else:
 반환 x

def square\_root(x, tolerance):
 guess = x
 next\_guess = (x/guess + guess)/2
 동안 절대\_값(guess-next\_guess) > 허용오차:
 guess = next\_guess
 next\_guess = (x/guess + guess)/2
 반환 next\_guess

x = get\_positive\_float("x")
허용 오차 = get\_positive\_float("허용 오차")

root = square\_root(x, tolerance)
print(f"제곱근 = {root:.10f}")
```

학생 코드:
```

#sys 모듈 임포트
import sys

# x 및 허용 오차 값에 대한 사용자 입력 가져오기
x\_value = float(input("Enter x: "))
만약 x\_value <= 0:
 print("x는 양수여야 합니다!")
 sys.exit()
 
허용오차 = float(input("허용오차 입력: "))
허용 오차가 <= 0이면
 print("허용오차는 양수여야 합니다!")
 sys.exit()

# 절대값 함수 정의
def absolute\_value(diff):
 if diff < 0:
 pos\_diff = diff \* (-1)
 else:
 pos\_diff = diff
 반환 pos\_diff
# 제곱근 함수 정의
def square\_root(x\_value, tolerance):
 pos\_diff = 허용 오차 + 1
 guess\_0 = x\_값 ## (즉, 이전 추측)
 guess\_1 = x\_값 ## (즉, "더 나은" 추측)
 허용 오차 < pos\_diff:
 #print(f"guess\_1 = {guess\_1} and guess\_0 = {guess\_0}")
 분자 = guess\_1 + (x\_값/guess\_1)
 #print(f"분자 = {분자}")
 guess\_1 = 분자 / 2
 #print(f"better = {guess\_1}")
 diff = guess\_1 - guess\_0 
 #print(f"diff = {diff}")
 pos\_diff = 절대\_값(diff)
 #print(f"pos\_diff = {pos\_diff}")
 guess\_0 = guess\_1
 반환 guess\_1

# 제곱근 함수의 반환값 저장 
babylonian\_sqrt = square\_root(x\_value, tolerance)

# 출력 출력
print(f"제곱근 = {바빌로니아\_sqrt:.10f}")
```