कैसे जांच करें कि क्या एक फ्लोट मान पूरी संख्या है

Question

मैं सबसे बड़ा क्यूब रूट खोजने की कोशिश कर रहा हूं जो कि पूरी संख्या है, जो कि 12,000 से कम है।

processing = True
n = 12000
while processing:
    n -= 1
    if n ** (1/3) == #checks to see if this has decimals or not

मुझे यकीन नहीं है कि यह कैसे जांचना है कि यह पूरी संख्या है या नहीं! मैं इसे एक स्ट्रिंग में परिवर्तित कर सकता हूं फिर अंत मानों की जांच करने के लिए अनुक्रमणिका का उपयोग कर सकता हूं और देख सकता हूं कि वे शून्य हैं या नहीं, हालांकि यह बोझिल लगता है। क्या कोई सरल तरीका है?

Comments

इससे घन रूट n -> (n * n * n <12000) से काम करना आसान हो जाएगा

— 17

Answer 1

जाँच करने के लिए कि क्या एक फ्लोट मान पूरी संख्या है, float.is_integer()विधि का उपयोग करें :

>>> (1.0).is_integer()
True
>>> (1.555).is_integer()
False

विधि को floatपायथन 2.6 में प्रकार में जोड़ा गया था ।

खाता कि अजगर 2 में, में रखना 1/3है 0(पूर्णांक ऑपरेंड के लिए फर्श विभाजन!), और चल बिन्दु अंकगणितीय अनिश्चित हो सकता है कि (क floatद्विआधारी भिन्न, का उपयोग करते हुए एक सन्निकटन है नहीं एक सटीक वास्तविक संख्या)। लेकिन आपके पाश को थोड़ा समायोजित करना यह देता है:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

जिसका अर्थ है कि 3 क्यूबेड (10648 सहित) से अधिक कुछ भी पूर्वोक्त दोष के कारण छूट गया था:

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

आपको इसके बजाय पूरे नंबर के करीब के नंबरों की जांच करनी होगी , या float()अपना नंबर खोजने के लिए उपयोग नहीं करना चाहिए। घनमूल को नीचे घुमाने की तरह 12000:

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

यदि आप पायथन 3.5 या नए का उपयोग कर रहे हैं, तो आप math.isclose()फ़ंक्शन का उपयोग यह देखने के लिए कर सकते हैं कि क्या एक फ्लोटिंग पॉइंट वैल्यू एक कॉन्फ़िगर करने योग्य मार्जिन के भीतर है:

>>> from math import isclose
>>> isclose((4**3) ** (1.0/3), 4)
True
>>> isclose(10648 ** (1.0/3), 22)
True

पुराने संस्करणों के लिए, PEP485 में उल्लिखित उस फ़ंक्शन का अनुभवहीन कार्यान्वयन (अनन्तता की जाँच करने और अनन्तता और NaN को छोड़ना )

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

Comments

अजगर को न जानकर, इस तरह के बयान से मुझे घबराहट होगी क्योंकि ऐसा लगता है कि वास्तविक दुनिया में काम करने के लिए सही गणित की आवश्यकता है।

— पीटर एम

@PeterM: विधि वास्तव में केवल तभी वापस आती है Trueजब कोई भी दशमलव न हो। ओपी के हिस्से पर अस्थायी बिंदु अंकगणित और सटीक के बारे में गलतफहमी हो सकती है, ज़ाहिर है।

— मार्टिन पीटर्स

@MartijnPieters हाँ और एक फ्लोटिंग पॉइंट गणना में एक छोटी सी पर्ची और अचानक आपके पास ये छोटे, अवांछित दशमलव जैसे 0.00000000000000000001

— पीटर एम

@PeterM: और पायथन 2 में डिफ़ॉल्ट प्रतिनिधित्व 16 अंकों का होगा; 1.0000000000000001के रूप में प्रदर्शित किया जाता है 1.0, 3 में सबसे कम स्ट्रिंग प्रतिनिधित्व जो समान मूल्य का उत्पादन करता है दिखाया गया है।

— मार्टिन पीटर्स

आपका range(12000, -1, -1)हो सकता है (imo, अधिक सफाई से) के रूप में फिर से लिखाreversed(range(12000+1))

— cs95

Answer 2

हम modulo (%) ऑपरेटर का उपयोग कर सकते हैं। यह बताता है कि जब हम x को y से विभाजित करते हैं तो कितने अवशेष हैं - जैसा कि व्यक्त करता है x % y। प्रत्येक पूरी संख्या को 1 से विभाजित करना होगा, इसलिए यदि शेष है, तो यह पूरी संख्या नहीं होनी चाहिए।

यह फ़ंक्शन एक बूलियन लौटाएगा, Trueया False, इस पर निर्भर करेगा कि क्या nपूरी संख्या है।

def is_whole(n):
    return n % 1 == 0

Answer 3

आप इसका उपयोग कर सकते हैं:

if k == int(k):
    print(str(k) + " is a whole number!")

Comments

यह बड़ी संख्या के लिए विफल रहता है जबकि .is_integer()काम करना जारी रखता है।

— jfs

आपका लिंक IMHO नहीं दिखाता है कि यह काम नहीं करता है। यह सिर्फ दिखाता है कि बड़ी तैरने से सटीकता खो जाती है। is_integerएक समान विधि ( o = (floor(x) == x) ? Py_True : Py_False;) का उपयोग करता है । लेकिन मैं मानता हूं, एक का उपयोग करना चाहिए is_integer()क्योंकि यह बहुत स्पष्ट है।

— जूरी रॉबल

हाँ। यह सिर्फ दिखाता है कि बड़ी फ्लोट सटीक खो large_float == large_intसकती है , भले ही विफल हो large_float == float(large_int)।

— 19'14

123456789012345678901234567890.0 != 123456789012345678901234567890लेकिन123456789012345678901234567890.0 == float(123456789012345678901234567890)

— 19'14

हाँ, लेकिन k = 123456789012345678901234567890.0फिर k == int(k)सही है, जो सही उत्तर है।

— जूरी रॉबल

Answer 4

आपको लूप या कुछ भी जांचने की आवश्यकता नहीं है। बस १२,००० का घनमूल लें और इसे नीचे लाएँ:

r = int(12000**(1/3.0))
print r*r*r # 10648

Comments

यह एक उचित जवाब है।

— हुग्डब्रोर्न

Answer 5

आप इसके लिए एक मोडुलो ऑपरेशन का उपयोग कर सकते हैं ।

if (n ** (1.0/3)) % 1 != 0:
    print("We have a decimal number here!")

Comments

अगर n6.2, 6.0, 6.12312412 है, तो हम सभी के पास है "We have a decimal number here!"?

— जय वोंग

@JayWong यकीन नहीं है कि आपने अपना परीक्षण कैसे लोड किया, लेकिन यह मेरी मशीन पर Python3.7 का उपयोग करके ठीक काम करता है।

— Zchpyvr

Answer 6

क्या घनमूलों का परीक्षण करना आसान नहीं होगा? 20 (20 ** 3 = 8000) से शुरू करें और 30 (30 ** 3 = 27000) तक जाएं। फिर आपको 10 से कम पूर्णांक का परीक्षण करना होगा।

for i in range(20, 30):
    print("Trying {0}".format(i))
    if i ** 3 > 12000:
        print("Maximum integral cube root less than 12000: {0}".format(i - 1))
        break

Comments

इसके अलावा, फ़्लोट्स में राउंड-ऑफ त्रुटियां होती हैं ताकि n**(1/3)पूर्णांक होने पर गणना करते समय आप संख्या को याद कर सकें । मेरे कंप्यूटर पर उदाहरण के लिए `10648 ** (1/3) = 21.999999999999996` के बजाय 22: समस्या! इस उत्तर की विधि के साथ ऐसी कोई समस्या नहीं है। मुझे लगता है कि यह गणित के दृष्टिकोण से एकमात्र सही समाधान है (अन्य समाधान पायथन-सही हैं)।

— JPG

Answer 7

कैसा रहेगा

if x%1==0:
    print "is integer"

Answer 8

उपरोक्त उत्तर कई मामलों के लिए काम करते हैं लेकिन वे कुछ याद करते हैं। निम्नलिखित को धयान मे रखते हुए:

fl = sum([0.1]*10)  # this is 0.9999999999999999, but we want to say it IS an int

एक बेंचमार्क के रूप में इसका उपयोग करते हुए, कुछ अन्य सुझावों को वह व्यवहार नहीं मिलता है जो हम चाहते हैं:

fl.is_integer() # False

fl % 1 == 0     # False

इसके बजाय कोशिश करें:

def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
    return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

def is_integer(fl):
    return isclose(fl, round(fl))

अब हमें मिलता है:

is_integer(fl)   # True

iscloseपायथन 3.5+ के साथ आता है , और अन्य पायथन के लिए आप इस अधिकतर समतुल्य परिभाषा का उपयोग कर सकते हैं (जैसा कि संबंधित PEP में उल्लिखित है )

Comments

math.fsum([0.1] * 10) == 1

— एक्यूमेनस

Answer 9

बस एक पक्ष जानकारी, is_integerआंतरिक रूप से कर रहा है:

import math
isInteger = (math.floor(x) == x)

अजगर में बिल्कुल नहीं है, लेकिन ऊपर वर्णित के रूप में cpython कार्यान्वयन लागू किया गया है।

Answer 10

सभी उत्तर अच्छे हैं लेकिन एक सुनिश्चित अग्नि विधि होगी

def whole (n):
     return (n*10)%10==0

यह फ़ंक्शन सही है, यदि यह पूरी संख्या में गलत है .... मुझे पता है कि मुझे थोड़ी देर हो गई है लेकिन यहाँ एक दिलचस्प तरीका है जो मैंने बनाया है ...

संपादित करें: जैसा कि नीचे टिप्पणी द्वारा कहा गया है, एक सस्ता समकक्ष परीक्षण होगा:

def whole(n):
    return n%1==0

Comments

यह कार्यात्मक रूप से भिन्न नहीं होना चाहिए n % 1 == 0। इस मामले में, आप दो ऑपरेशन कर रहे हैं जो एक सस्ते समकक्ष परीक्षण के लिए अधिक महंगा है।

— Zchpyvr

Answer 11

>>> def is_near_integer(n, precision=8, get_integer=False):
...     if get_integer:
...         return int(round(n, precision))
...     else:
...         return round(n) == round(n, precision)
...
>>> print(is_near_integer(10648 ** (1.0/3)))
True
>>> print(is_near_integer(10648 ** (1.0/3), get_integer=True))
22
>>> for i in [4.9, 5.1, 4.99, 5.01, 4.999, 5.001, 4.9999, 5.0001, 4.99999, 5.000
01, 4.999999, 5.000001]:
...     print(i, is_near_integer(i, 4))
...
4.9 False
5.1 False
4.99 False
5.01 False
4.999 False
5.001 False
4.9999 False
5.0001 False
4.99999 True
5.00001 True
4.999999 True
5.000001 True
>>>

Comments

यहाँ मैं कैसे एक अच्छा जवाब लिखने के लिए कुछ दिशानिर्देश हैं ? । यह प्रदान किया गया उत्तर सही हो सकता है, लेकिन यह एक स्पष्टीकरण से लाभान्वित हो सकता है। कोड केवल उत्तरों को "अच्छा" उत्तर नहीं माना जाता है। से समीक्षा ।

— ट्रेंटन मैककिनी

Answer 12

प्रयोग करके देखें:

int(val) == val

यह किसी भी अन्य तरीकों की तुलना में बहुत अधिक सटीक देगा।

Comments

क्या आप इस दावे का समर्थन करने के लिए एक उदाहरण दे सकते हैं कि "यह बहुत अधिक सटीकता देगा"? यह निराधार लगता है।

— मार्क डिकिंसन

Answer 13

आप उपयोग कर सकते हैं round मान की गणना करने के फ़ंक्शन का ।

हाँ, अजगर में बहुत से लोगों ने बताया कि जब हम एक घनमूल के मान की गणना करते हैं, तो यह आपको थोड़ी सी त्रुटि के साथ आउटपुट देगा। यह जांचने के लिए कि क्या मूल्य एक पूर्ण संख्या है, आप निम्नलिखित फ़ंक्शन का उपयोग कर सकते हैं:

def cube_integer(n):
    if round(n**(1.0/3.0))**3 == n:
        return True
    return False

लेकिन याद रखें कि int(n)इसके बराबर है math.floorऔर इस वजह से अगर आप पाते हैंint(41063625**(1.0/3.0)) आपको 345 के बजाय 344 मिलेगा।

इसलिए intविथ क्यूब जड़ों का उपयोग करते समय कृपया सावधान रहें ।