Вычисление значения между квадратами из двух целых чисел

Question

Создайте функцию, которая принимает положительное число и вернет 2 целых числа, чтобы число находилось между квадратами двух целых чисел. Он возвращает одно и то же целое число дважды, если число является квадратом целого числа.

def sqApprox(num): 
    i = 0 
    minsq = 0      # set lower bound 
    maxsq = 0      # set upper bound 
    while i <= num:     # set 'while' termination condition 
     if i * i <= num and i >= minsq: # complete inequality condition 
      minsq = i 

     if i * i > num and i >= maxsq: # complete inequality condition 
      maxsq = i 
     i = i + 1     # update i so that 'while' will terminate 
    return (minsq, maxsq) 

Answer 1

import math 

def func(x): 
    return math.floor(math.sqrt(x)), math.ceil(math.sqrt(x)) 

Answer 2

FWIW, делая поиск перебором, как это очень неэффективный способ аппроксимации квадратных корней. Но я думаю, что это разумное упражнение, если вы просто учитесь делать циклы.

Основная проблема с вашим кодом заключается в том, что вы продолжаете цикл после того, как нашли решение. Вы также делаете некоторые ненужные тесты. Вот исправленная версия вашего кода.

def sqrt_approx(num): 
    i = 0 
    minsq = 0 
    maxsq = 0 
    while i <= num: 
     if i * i <= num: 
      minsq = i 
     if i * i >= num: 
      maxsq = i 
      break 
     i = i + 1 
    return minsq, maxsq 

#Test it 
for i in range(0, 26): 
    print(i, sqrt_approx(i)) 

выход

0 (0, 0) 
1 (1, 1) 
2 (1, 2) 
3 (1, 2) 
4 (2, 2) 
5 (2, 3) 
6 (2, 3) 
7 (2, 3) 
8 (2, 3) 
9 (3, 3) 
10 (3, 4) 
11 (3, 4) 
12 (3, 4) 
13 (3, 4) 
14 (3, 4) 
15 (3, 4) 
16 (4, 4) 
17 (4, 5) 
18 (4, 5) 
19 (4, 5) 
20 (4, 5) 
21 (4, 5) 
22 (4, 5) 
23 (4, 5) 
24 (4, 5) 
25 (5, 5) 

Вот немного более эффективная версия.

def sqrt_approx(num): 
    for i in range(num+1): 
     sq = i * i 
     if sq == num: 
      return i, i 
     elif sq > num: 
      return i-1, i 

В Python 2 было бы более эффективно использовать xrange(), а не range(), особенно, если вы вызываете эту функцию с большими числами. Но, как я упоминал выше, есть много лучшие способы приближения целочисленных квадратных корней.

---

Это новая версия, которая корректно обрабатывает (неотрицательные) числа с плавающей запятой.

from math import floor 

def sqrt_approx(num): 
    fnum = int(floor(num)) 
    i = 0 
    while True: 
     if i * i <= fnum: 
      minsq = i 
     if i * i >= num: 
      maxsq = i 
      break 
     i = i + 1 
    assert minsq**2 <= num <= maxsq**2 
    return minsq, maxsq 

for i in range(17): 
    j = i 
    print j, sqrt_approx(j) 
    j = i + 0.2 
    print j, sqrt_approx(j) 

выход

0 (0, 0) 
0.2 (0, 1) 
1 (1, 1) 
1.2 (1, 2) 
2 (1, 2) 
2.2 (1, 2) 
3 (1, 2) 
3.2 (1, 2) 
4 (2, 2) 
4.2 (2, 3) 
5 (2, 3) 
5.2 (2, 3) 
6 (2, 3) 
6.2 (2, 3) 
7 (2, 3) 
7.2 (2, 3) 
8 (2, 3) 
8.2 (2, 3) 
9 (3, 3) 
9.2 (3, 4) 
10 (3, 4) 
10.2 (3, 4) 
11 (3, 4) 
11.2 (3, 4) 
12 (3, 4) 
12.2 (3, 4) 
13 (3, 4) 
13.2 (3, 4) 
14 (3, 4) 
14.2 (3, 4) 
15 (3, 4) 
15.2 (3, 4) 
16 (4, 4) 
16.2 (4, 5) 

Answer 3

Вы можете использовать dychotomy найти более быстро целочисленный квадратный корень, так как SQRT является монотонной функцией:

def sqrt_approx(n): 
    if n<=1: 
     return n,n 
    inf =1 
    sup = n 
    while sup > inf + 1: 
     guess = (inf + sup)/2 
     g2 = guess * guess 
     if g2 == n: 
      return guess, guess 
     elif g2 < n: 
      inf = guess 
     else: 
      sup = guess 
    return inf, sup 

Требуется только O (log2 (n)), чтобы найти приближение (вы найдете sqrt_approx(65535) всего за 16 шагов)