数値が完全な平方であるかどうかを確認するにはどうすればよいですか？

今のところ、速度は問題ではありません。

浮動小数点計算（、、math.sqrt(x)またはx**0.5）に依存する場合の問題は、それが正確であるかどうかを実際に確認できないことです（十分に大きい整数の場合x、正確ではなく、オーバーフローする可能性さえあります）。幸いなことに（急いでいない場合;-)次のような多くの純粋な整数アプローチがあります...：

def is_square(apositiveint):
  x = apositiveint // 2
  seen = set([x])
  while x * x != apositiveint:
    x = (x + (apositiveint // x)) // 2
    if x in seen: return False
    seen.add(x)
  return True

for i in range(110, 130):
   print i, is_square(i)

ヒント：平方根の「バビロニアアルゴリズム」に基づいています。ウィキペディアを参照してください。それはありませんあなたが;-)計算が完了するまで進行するのに十分なメモリを持っている任意の正の数のために仕事を。

編集：例を見てみましょう...

x = 12345678987654321234567 ** 2

for i in range(x, x+2):
   print i, is_square(i)

これは、必要に応じて（そして妥当な時間内にも;-)印刷します。

152415789666209426002111556165263283035677489 True
152415789666209426002111556165263283035677490 False

彼らはこの簡単な例で正しく動作させる、あなたは浮動小数点中間結果に基づいて解決策を提案する前に、してください-それはないこと、（計算SQRTは少しオフになっている場合には、あなただけのいくつかの余分なチェックが必要）ハードだけで取ります少し注意してください。

そして、x**7あなたが得る問題を回避するための賢い方法を試してみてください、

OverflowError: long int too large to convert to float

もちろん、数が増え続けるにつれて、あなたはますます賢くなる必要があります。

もちろん、急いでいる場合はgmpyを使用しますが、明らかに偏見があります;-)。

>>> import gmpy
>>> gmpy.is_square(x**7)
1
>>> gmpy.is_square(x**7 + 1)
0

ええ、私は知っています、それは浮気のように感じるのはとても簡単です（私が一般的にPythonに対して感じる方法です;-）-賢さはまったくなく、完璧な直接性と単純さ（そして、gmpyの場合は非常に速い） ;-）..。

ニュートン法を使用して、最も近い整数の平方根にすばやく焦点を合わせ、それを2乗して、それが自分の数であるかどうかを確認します。isqrtを参照してください。

Python≥3.8にはがありmath.isqrtます。古いバージョンのPythonを使用している場合は、ここで" def isqrt(n)"実装を探してください。

import math

def is_square(i: int) -> bool:
    return i == math.isqrt(i) ** 2

浮動小数点計算（平方根を計算するこれらの方法など）を処理するときに正確な比較に依存することは決してできないため、エラーが発生しにくい実装になります。

import math

def is_square(integer):
    root = math.sqrt(integer)
    return integer == int(root + 0.5) ** 2

想像integerです9。math.sqrt(9)である可能性がありますが3.0、2.99999またはのようなものである可能性もある3.00001ため、結果をすぐに二乗することは信頼できません。それintがフロア値をとることを知っているので、0.5最初にフロート値を増やすことは、探しfloatている数値に近い数値を表すのに十分な解像度がまだある範囲内にいる場合に、探している値を取得することを意味します。

興味があれば、数学スタックエクスチェンジでの同様の質問「平方根を抽出するよりも速く完全な正方形を検出する」に対する純粋数学の回答があります。

私自身のisSquare（n）の実装は最善ではないかもしれませんが、私はそれが好きです。数学理論、デジタル計算、Pythonプログラミングの研究に数か月かかり、他の貢献者と自分を比較するなどして、この方法で実際にクリックしました。私はそのシンプルさと効率が好きです。私はよく見たことがありません。あなたの考えを教えてください。

def isSquare(n):
    ## Trivial checks
    if type(n) != int:  ## integer
        return False
    if n < 0:      ## positivity
        return False
    if n == 0:      ## 0 pass
        return True

    ## Reduction by powers of 4 with bit-logic
    while n&3 == 0:    
        n=n>>2

    ## Simple bit-logic test. All perfect squares, in binary,
    ## end in 001, when powers of 4 are factored out.
    if n&7 != 1:
        return False

    if n==1:
        return True  ## is power of 4, or even power of 2


    ## Simple modulo equivalency test
    c = n%10
    if c in {3, 7}:
        return False  ## Not 1,4,5,6,9 in mod 10
    if n % 7 in {3, 5, 6}:
        return False  ## Not 1,2,4 mod 7
    if n % 9 in {2,3,5,6,8}:
        return False  
    if n % 13 in {2,5,6,7,8,11}:
        return False  

    ## Other patterns
    if c == 5:  ## if it ends in a 5
        if (n//10)%10 != 2:
            return False    ## then it must end in 25
        if (n//100)%10 not in {0,2,6}: 
            return False    ## and in 025, 225, or 625
        if (n//100)%10 == 6:
            if (n//1000)%10 not in {0,5}:
                return False    ## that is, 0625 or 5625
    else:
        if (n//10)%4 != 0:
            return False    ## (4k)*10 + (1,9)


    ## Babylonian Algorithm. Finding the integer square root.
    ## Root extraction.
    s = (len(str(n))-1) // 2
    x = (10**s) * 4

    A = {x, n}
    while x * x != n:
        x = (x + (n // x)) >> 1
        if x in A:
            return False
        A.add(x)
    return True

かなり簡単です。まず、整数があり、正の整数があることを確認します。そうでなければ意味がありません。0をTrueとしてスリップさせます（必要な場合、または次のブロックは無限ループです）。

コードの次のブロックは、ビットシフトおよびビット論理演算を使用して、非常に高速なサブアルゴリズムで4の累乗を体系的に削除します。最終的に、元のnのisSquareは見つかりませんが、可能であれば4の累乗で縮小されたk <nのisSquareが見つかります。これにより、使用している数値のサイズが小さくなり、バビロニア法が実際に高速化されますが、他のチェックも高速になります。

コードの3番目のブロックは、単純なブールビット論理テストを実行します。完全な平方の最下位の3桁（2進数）は001です。常に。とにかく、すでに説明されている4の累乗から生じる先行ゼロを除いてください。テストに失敗した場合は、正方形ではないことがすぐにわかります。それが通過した場合、あなたは確信が持てません。

また、テスト値が1になった場合、テスト番号は元々4の累乗であり、おそらく1自体も含まれます。

3番目のブロックと同様に、4番目のブロックは単純なモジュラス演算子を使用して10進数で1桁の値をテストし、前のテストをすり抜ける値をキャッチする傾向があります。また、mod 7、mod 8、mod 9、およびmod13のテスト。

コードの5番目のブロックは、よく知られている完全な正方形のパターンのいくつかをチェックします。1または9で終わる番号の前には、4の倍数が付きます。また、5で終わる番号は、5625、0625、225、または025で終わる必要があります。他の番号も含めましたが、冗長であるか、実際には使用されていないことに気付きました。

最後に、コードの6番目のブロックは、トップアンサーであるAlexMartelliの回答に非常によく似ています。基本的に、古代のバビロニアアルゴリズムを使用して平方根を見つけますが、浮動小数点を無視して整数値に制限します。速度とテスト可能な値の大きさの拡張の両方で行われます。時間がはるかに短いため、リストの代わりにセットを使用し、2で割る代わりにビットシフトを使用し、初期開始値をはるかに効率的に賢く選択しました。

ちなみに、私はAlex Martelliが推奨するテスト番号と、次のように桁違いに大きいいくつかの番号をテストしました。

x=1000199838770766116385386300483414671297203029840113913153824086810909168246772838680374612768821282446322068401699727842499994541063844393713189701844134801239504543830737724442006577672181059194558045164589783791764790043104263404683317158624270845302200548606715007310112016456397357027095564872551184907513312382763025454118825703090010401842892088063527451562032322039937924274426211671442740679624285180817682659081248396873230975882215128049713559849427311798959652681930663843994067353808298002406164092996533923220683447265882968239141724624870704231013642255563984374257471112743917655991279898690480703935007493906644744151022265929975993911186879561257100479593516979735117799410600147341193819147290056586421994333004992422258618475766549646258761885662783430625 ** 2
for i in range(x, x+2):
    print(i, isSquare(i))

次の結果を出力しました。

1000399717477066534083185452789672211951514938424998708930175541558932213310056978758103599452364409903384901149641614494249195605016959576235097480592396214296565598519295693079257885246632306201885850365687426564365813280963724310434494316592041592681626416195491751015907716210235352495422858432792668507052756279908951163972960239286719854867504108121432187033786444937064356645218196398775923710931242852937602515835035177768967470757847368349565128635934683294155947532322786360581473152034468071184081729335560769488880138928479829695277968766082973795720937033019047838250608170693879209655321034310764422462828792636246742456408134706264621790736361118589122797268261542115823201538743148116654378511916000714911467547209475246784887830649309238110794938892491396597873160778553131774466638923135932135417900066903068192088883207721545109720968467560224268563643820599665232314256575428214983451466488658896488012211237139254674708538347237589290497713613898546363590044902791724541048198769085430459186735166233549186115282574626012296888817453914112423361525305960060329430234696000121420787598967383958525670258016851764034555105019265380321048686563527396844220047826436035333266263375049097675787975100014823583097518824871586828195368306649956481108708929669583308777347960115138098217676704862934389659753628861667169905594181756523762369645897154232744410732552956489694024357481100742138381514396851789639339362228442689184910464071202445106084939268067445115601375050153663645294106475257440167535462278022649865332161044187890625 True
1000399717477066534083185452789672211951514938424998708930175541558932213310056978758103599452364409903384901149641614494249195605016959576235097480592396214296565598519295693079257885246632306201885850365687426564365813280963724310434494316592041592681626416195491751015907716210235352495422858432792668507052756279908951163972960239286719854867504108121432187033786444937064356645218196398775923710931242852937602515835035177768967470757847368349565128635934683294155947532322786360581473152034468071184081729335560769488880138928479829695277968766082973795720937033019047838250608170693879209655321034310764422462828792636246742456408134706264621790736361118589122797268261542115823201538743148116654378511916000714911467547209475246784887830649309238110794938892491396597873160778553131774466638923135932135417900066903068192088883207721545109720968467560224268563643820599665232314256575428214983451466488658896488012211237139254674708538347237589290497713613898546363590044902791724541048198769085430459186735166233549186115282574626012296888817453914112423361525305960060329430234696000121420787598967383958525670258016851764034555105019265380321048686563527396844220047826436035333266263375049097675787975100014823583097518824871586828195368306649956481108708929669583308777347960115138098217676704862934389659753628861667169905594181756523762369645897154232744410732552956489694024357481100742138381514396851789639339362228442689184910464071202445106084939268067445115601375050153663645294106475257440167535462278022649865332161044187890626 False

そしてそれは0.33秒でこれをしました。

私の意見では、私のアルゴリズムはAlex Martelliのアルゴリズムと同じように機能しますが、そのすべての利点がありますが、次の累乗によるテスト数のサイズの削減は言うまでもなく、多くの時間を節約する非常に効率的な単純テスト拒否の利点があります。 4、これにより、速度、効率、精度、およびテスト可能な数値のサイズが向上します。おそらく、Python以外の実装では特にそうです。

バビロニア語のルート抽出が実装される前に、すべての整数の約99％が非正方形として拒否され、2/3の時間でバビロニア語が整数を拒否します。そして、これらのテストはプロセスを大幅にスピードアップしませんが、4のすべての累乗を実際に分割することにより、すべてのテスト数を奇数に減らします。、バビロニアのテストが加速されます。

時間比較テストを行いました。100万から1000万までのすべての整数を連続してテストしました。バビロニアの方法だけを使用すると（特別に調整された最初の推測で）、Surface 3は平均165秒かかりました（100％の精度で）。私のアルゴリズム（バビロニア語を除く）の論理テストだけを使用すると、127秒かかり、完全な正方形を誤って拒否することなく、すべての整数の99％を非正方形として拒否しました。合格した整数のうち、完全な平方（はるかに高い密度）は3％のみでした。論理テストとバビロニア語ルート抽出の両方を採用する上記の完全なアルゴリズムを使用すると、100％の精度が得られ、テストはわずか14秒で完了します。最初の1億個の整数は、テストに約2分45秒かかります。

編集：私はさらに時間を短縮することができました。これで、0から1億の整数を1分40秒でテストできます。データ型と陽性をチェックするのに多くの時間が無駄になります。最初の2つのチェックを削除し、実験を1分短縮しました。ネガとフロートが完全な正方形ではないことをユーザーが十分に理解していると想定する必要があります。

import math

def is_square(n):
    sqrt = math.sqrt(n)
    return (sqrt - int(sqrt)) == 0

完全な平方は、2つの等しい整数の積として表現できる数です。math.sqrt(number)を返しますfloat。int(math.sqrt(number))結果をにキャストしintます。

たとえば、平方根が3のような整数の場合、math.sqrt(number) - int(math.sqrt(number))0になり、ifステートメントはになりますFalse。平方根が3.2のような実数だった場合、True「完全な平方ではありません」と出力されます。

152415789666209426002111556165263283035677490などの大きな非正方形の場合は失敗します。

私の答えは：

def is_square(x):
    return x**.5 % 1 == 0

基本的に平方根を実行し、次に1を法として整数部分を削除し、結果が0のTrue場合は戻り、それ以外の場合はを返しFalseます。この場合、xは任意の大きな数値にすることができますが、Pythonが処理できる最大浮動小数点数ほど大きくはありません：1.7976931348623157e + 308

152415789666209426002111556165263283035677490などの大きな非正方形の場合は正しくありません。

これは、decimalモジュールを使用して任意の精度の平方根を取得し、「正確さ」を簡単にチェックすることで解決できます。

import math
from decimal import localcontext, Context, Inexact

def is_perfect_square(x):
    # If you want to allow negative squares, then set x = abs(x) instead
    if x < 0:
        return False

    # Create localized, default context so flags and traps unset
    with localcontext(Context()) as ctx:
        # Set a precision sufficient to represent x exactly; `x or 1` avoids
        # math domain error for log10 when x is 0
        ctx.prec = math.ceil(math.log10(x or 1)) + 1  # Wrap ceil call in int() on Py2
        # Compute integer square root; don't even store result, just setting flags
        ctx.sqrt(x).to_integral_exact()
        # If previous line couldn't represent square root as exact int, sets Inexact flag
        return not ctx.flags[Inexact]

本当に大きな価値のあるデモンストレーションの場合：

# I just kept mashing the numpad for awhile :-)
>>> base = 100009991439393999999393939398348438492389402490289028439083249803434098349083490340934903498034098390834980349083490384903843908309390282930823940230932490340983098349032098324908324098339779438974879480379380439748093874970843479280329708324970832497804329783429874329873429870234987234978034297804329782349783249873249870234987034298703249780349783497832497823497823497803429780324
>>> sqr = base ** 2
>>> sqr ** 0.5  # Too large to use floating point math
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OverflowError: int too large to convert to float

>>> is_perfect_power(sqr)
True
>>> is_perfect_power(sqr-1)
False
>>> is_perfect_power(sqr+1)
False

テストする値のサイズを大きくすると、最終的にはかなり遅くなります（200,000ビットの正方形の場合は1秒近くかかります）が、より中程度の数値（たとえば、20,000ビット）の場合は、人間が気付くよりも高速です。個々の値（私のマシンでは約33ミリ秒）。しかし、速度はあなたの主な関心事ではなかったので、これはPythonの標準ライブラリでそれを行うための良い方法です。

もちろん、使用gmpy2してテストする方がはるかに高速ですgmpy2.mpz(x).is_square()が、サードパーティのパッケージが適切でない場合は、上記の方法で十分に機能します。

上記の例のいくつかのわずかなバリエーションを別のスレッドに投稿し（完全な正方形を見つける）、興味がある場合に備えて、ここに投稿したもののわずかなバリエーションを含めると思いました（一時変数としてnsqrtを使用）/使用する：

import math

def is_square(n):
  if not (isinstance(n, int) and (n >= 0)):
    return False 
  else:
    nsqrt = math.sqrt(n)
    return nsqrt == math.trunc(nsqrt)

152415789666209426002111556165263283035677490などの大きな非正方形の場合は正しくありません。

これは私の方法です：

def is_square(n) -> bool:
    return int(n**0.5)**2 == int(n)

数の平方根を取ります。整数に変換します。正方形を取ります。数が等しい場合、それは完全な正方形です。そうでない場合はそうではありません。

152415789666209426002111556165263283035677489などの大きな正方形には正しくありません。

丸められた平方根を二分探索することができます。結果を二乗して、元の値と一致するかどうかを確認します。

FogleBirdsの回答の方がおそらく良いでしょう。ただし、浮動小数点演算は概算であるため、このアプローチを失敗させる可能性があるので注意してください。原則として、たとえば精度が失われたために、完全な平方より1つ大きい整数から誤検知が発生する可能性があります。

平方根で割った残りの係数（余り）が0の場合、それは完全な平方です。

def is_square(num: int) -> bool:
    return num % math.sqrt(num) == 0

私はこれを1000までの完全な正方形のリストと照合しました。

1. 番号の長さを決定します。
2. デルタを取る0.000000000000 ....... 000001
3. （sqrt（x））^ 2-xがデルタよりも大きい/等しい/小さいかどうかを確認し、デルタエラーに基づいて決定します。

この応答は、あなたが述べた質問には関係しませんが、あなたが投稿したコードに見られる暗黙の質問、つまり「何かが整数かどうかを確認する方法」に関係します。

一般的にその質問に答える最初の答えは「しないでください！」です。そして、Pythonでは、タイプチェックは通常正しいことではないのは事実です。

ただし、これらのまれな例外については、数値の文字列表現で小数点を探す代わりに、isinstance関数を使用する必要があります。

>>> isinstance(5,int)
True
>>> isinstance(5.0,int)
False

もちろん、これは値ではなく変数に適用されます。値が整数であるかどうかを判断したい場合は、次のようにします。

>>> x=5.0
>>> round(x) == x
True

しかし、他の誰もが詳細に説明しているように、この種のもののほとんどのおもちゃ以外の例で考慮すべき浮動小数点の問題があります。

範囲をループして、完全な平方ではないすべての数値に対して何かを実行したい場合は、次のように実行できます。

def non_squares(upper):
    next_square = 0
    diff = 1
    for i in range(0, upper):
        if i == next_square:
            next_square += diff
            diff += 2
            continue
        yield i

完全な平方であるすべての数に対して何かをしたい場合、ジェネレーターはさらに簡単です。

(n * n for n in range(upper))

これは機能し、非常に単純だと思います。

import math

def is_square(num):
    sqrt = math.sqrt(num)
    return sqrt == int(sqrt)

152415789666209426002111556165263283035677490などの大きな非正方形の場合は正しくありません。

@AlexMartelliのソリューションの変形 set

いつx in seenですかTrue：

• ほとんどの場合、それは例えば、添加最後である1022は、生成xのを配列511、256、129、68、41、32、31、31。
• （すなわち、完全な正方形の前任者のための）いくつかの場合において、それは例えば、1023は511、256、129、68、41、生成、追加最後から2番目の一つである32、31、32。

したがって、電流xが前の電流以上になるとすぐに停止するだけで十分です。

def is_square(n):
    assert n > 1
    previous = n
    x = n // 2
    while x * x != n:
        x = (x + (n // x)) // 2
        if x >= previous:
            return False
        previous = x
    return True

x = 12345678987654321234567 ** 2
assert not is_square(x-1)
assert is_square(x)
assert not is_square(x+1)

1 <n <10 ** 7でテストされた元のアルゴリズムとの同等性。同じ間隔で、このわずかに単純なバリアントは約1.4倍高速です。

a=int(input('enter any number'))
flag=0
for i in range(1,a):
    if a==i*i:
        print(a,'is perfect square number')
        flag=1
        break
if flag==1:
    pass
else:
    print(a,'is not perfect square number')

アイデアは、i = 1からfloor（sqrt（n））までループを実行し、それを2乗するとnになるかどうかを確認することです。

bool isPerfectSquare(int n) 
{ 
    for (int i = 1; i * i <= n; i++) { 

        // If (i * i = n) 
        if ((n % i == 0) && (n / i == i)) { 
            return true; 
        } 
    } 
    return false; 
} 

import math

def is_square(n):
    sqrt = math.sqrt(n)
    return sqrt == int(sqrt)

152415789666209426002111556165263283035677490などの大きな非正方形の場合は失敗します。