2010-09-29 18 views

उत्तर

4

एक छोटी सी नकारात्मक संख्या और मामले को संभालने के लिए जहां इनपुट शून्य है मुश्किल:

int length(int n) 
{ 
    int len = 0; 
    if (n < 0) { len = 1; n = -n; } 
    while (n > 9) { 
     n /= 10; 
     len++; 
    } 
    return len+1; 
} 
+0

+1। कल्पना अंकों की गणना करना था, इसलिए ऋणात्मक मूल्यों के लिए लेन को अलग से सेट करने की आवश्यकता नहीं है। लेन 1 में प्रवेश कर सकते हैं और लेन लौट सकते हैं। –

6

ऐसा कोई समारोह सी ++ पुस्तकालय में उपलब्ध है। हालांकि आप सादगी के लिए std::stringstream का उपयोग कर सकते हैं।

इसे आज़माएं (नकारात्मक संख्याओं को भी संभालती है)।

int a =-12345,x; 
    x = std::abs(a) 
    std::stringstream s; 
    s << x; 
    std::cout<<s.str().size(); 
+1

स्थानीयकरण और फैक्टरिंग अच्छी हैं: 'x = a <0? -a: ए; ', लेकिन मैं एक्स को डुबो दूंगा और उस अभिव्यक्ति को सीधे स्ट्रीम में डाल दूंगा। बहुत सी ++, लेकिन बहुत हेवीवेट। –

2

आपको इसे 10 तक विभाजित रखना होगा (माना जाता है कि यह एक पूर्णांक है)। आप ऐसा इसलिए करते हैं क्योंकि प्रत्येक बार जब लूप पुनरावृत्त होता है तो आप एक अंक हटा देते हैं।

की तर्ज पर

कुछ:

int number; 
int digits; 
while (number > 0) 
{ 
    digits++; 
    number /= 10; 
} 

आप शायद बनाने के लिए करना होगा कि संख्या शून्य के साथ शुरू नहीं है।

2
int intlen(float num) { 
    int cnt = 0; 
    while(num >= 1) { 
     num = num/10; 
     cnt++; 
    } 
    return cnt; 
} 
+0

संख्या 0 में 0 अंक हैं? – dreamlax

+0

नकारात्मक संख्या के पास कोई अंक नहीं है? – dreamlax

10

सकारात्मक संख्या के लिए, log10 का उपयोग करें:

int a = 1234; 
int len = static_cast<int>(log10(a)+1.); 

आप पूरी तरह से करने की जरूरत है:

int length(int a) 
{ 
    int b = abs(a); 
    if (b == 0) return 1; 
    return static_cast<int>(log10(b)+1.); 
} 
कि कहा के साथ

, यह द्वारा बार-बार विभाजन करने के लिए एक बेहतर विकल्प हो सकता है अभ्यास में 10।

int length(int a) 
{ 
    int b = 0; 
    for (a = abs(a); a != 0; b++, a /= 10) continue; 
    return b; 
} 
+1

सवाल उठता है, मानक मानक कार्यान्वयन की अनुमति देता है जहां कहता है 'लॉग 10 (10) '0.9 99 99 99 999 लौटाता है ...? मैं बस इतना नहीं जानता (या भरोसा करने के लिए लागू करने के लिए भरोसा करता हूं क्योंकि वे जो भी हार्डवेयर करते हैं, वे करते हैं), इसलिए मैं गणितीय रूप से सुरुचिपूर्ण होने के बावजूद अंक-दर-अंक int दृष्टिकोण को पसंद करता हूं। विचार? –

+0

यह 1 से कम अनुमानित है - यानी। आपके 1234 उदाहरण के लिए, यह 3 लौटाता है। साथ ही, यह संकलित नहीं होता है (कम से कम वीसी ++ के तहत) क्योंकि लॉग 10 पर कॉल संदिग्ध है - आपको स्पष्ट रूप से पहले दो बार int को डालना होगा। और मुझे लगता है कि आप बी के बजाय लॉग 10 में बी पास करना चाहते थे? – Peter

+0

आप एक से दूर हैं। लॉग 10 (5) 0.6989700 है ... जब आप इसे वापस int में डाल देते हैं, तो आपको 0. '5' निश्चित रूप से शून्य अंकों से अधिक मिलता है। इसके अलावा, आप पेट (ए) लेते हैं और इसे बी में डालते हैं, लेकिन फिर आगे बढ़ें और – SingleNegationElimination

7

आप शायद मतलब है कि आप एक स्ट्रिंग अजगर में एक पूर्णांक के बजाय संख्या से युक्त है:

>>> i = 123456789 
>>> len(i) 
Traceback (most recent call last): 
    File "<console>", line 1, in <module> 
TypeError: object of type 'int' has no len() 
>>> len(str(i)) 
9 

यदि यह भी ग में मामला है ++ यह एक स्ट्रिंग का उपयोग की लंबाई को खोजने के लिए आसान है:

my_str_value.length() 

या एक सी स्ट्रिंग strlen

0

यहाँ प्रयोग करने के लिए एक littl है ई उदाहरण:

int numberDigits(int n) { 
    char buffer[100]; 
    itoa(n,buffer,10); 
    int len=0; 
    while (buffer[len]!=0) { len++; } 
    return len; 
} 
+0

वैकल्पिक विकल्प के रूप में लिस्टिंग। किसी भी अग्रणी '-' छोड़ना चाहिए। Strlen() से बचने के बावजूद, केवल atoi() अन्य div-by-10 समाधानों की तुलना में धीमी होने के लिए सुनिश्चित है .... –

+0

यह एक मुद्दा होगा यदि गति उसके आवेदन में बहुत संवेदनशील है। –

5

हम्म ... अजगर:

>>> len(5) 

Traceback (most recent call last): 
    File "<pyshell#45>", line 1, in <module> 
    len(5) 
TypeError: object of type 'int' has no len() 

नहीं है कि तुम क्या चाहते थे?

अच्छी तरह से, मान लें कि आपके पास एक वास्तविक पूर्णांक है। लॉग बेस 10 आपको बताएगा कि आप संख्यात्मक रूप से क्या जानना चाहते हैं, यह है कि yournumber == pow(10, digits), तो log10(yournumber) == digits! दुर्भाग्यवश, यदि आपकी संख्या 10 की सटीक शक्ति नहीं है, तो आपके पास सौदा करने के लिए एक अंश भाग होगा। हालांकि, floor() फ़ंक्शन के साथ सौदा करने में काफी आसान है, जो बस नीचे घूमता है। नकारात्मक संख्याओं से सावधान रहें, क्योंकि गैर-सकारात्मक मूल्यों के लिए वास्तविक संख्या में लॉगरिदम अनिर्धारित हैं।

#include <iostream> 
#include <math.h> 

int main() 
{ 
    std::cout << floor(log10(5))+1 << std::endl; 
    std::cout << floor(log10(30))+1 << std::endl; 
    std::cout << floor(log10(2000))+1 << std::endl; 
    std::cout << floor(log10(16000))+1 << std::endl; 
} 

हमें 1 जोड़ना होगा क्योंकि 1 से 10 तक अभी भी 10 है, इसलिए हम एक से दूर हैं। एक्सपोनेंट में एक जोड़ें और आपके पास अंक हैं!

+0

उत्कृष्ट स्पष्टीकरण।+1 मेरे उत्तर की टिप्पणियों में उठाए गए फ्लोटिंग पॉइंट के साथ संभावित सटीक मुद्दों के बारे में आप कैसा महसूस करते हैं? – JoshD

+0

@ जोश डी: ठीक है, 'लॉग 10 (एक्स)' गैर-पॉजिटिव एक्स के लिए अपरिभाषित है, लेकिन उस मुद्दे से अलग, यह हमेशा सही होगा। ध्यान दें कि 'लॉग 10 (10.0) 'बिल्कुल 1.0 है। उस की मंजिल 1 है, 1 + 1 दो है। – SingleNegationElimination

0

पल कि अजगर में len() एक दृश्य में आइटमों की संख्या और एक पूर्णांक में अंकों की नहीं संख्या दिखाता है के लिए की अनदेखी करते हुए यहां विभाजन के बिना एक पूर्णांक में अंकों की संख्या गिनती करने के लिए एक समारोह है (ताकि यह होना चाहिए विभाजन का उपयोग करने वाले समान समाधानों से बहुत तेज हो)।

int number_of_digits(int value) 
{ 
    int count = 0; 
    int i = 1; 

    if (value < 0) 
    { 
     value *= -1; 
    } 

    while (i < value) 
    { 
     count++; 
     i *= 10; 
    } 

    if (count > 0) 
    { 
     return count; 
    } 
    else 
    { 
     return 1; 
    } 
} 

अतिरिक्त गति के लिए, आप भी गुणा दस से कुछ बिट twiddling से बदल सकते हैं:

i = ((i << 2) + i) << 1; 

(बिट स्थानांतरण शांत है, लेकिन गुणा आपके CPU कर सकते हैं "मुक्त" हो सकता है कुछ अन्य अप्रयुक्त गुणा इकाई पर गुणा पाइपलाइन - आधुनिक प्रोसेसर सौंदर्य की बात है)। सावधानीपूर्वक, तेज़ दृष्टिकोण के लिए

संबंधित मुद्दे