मैं एक संख्या में कुल अंकों की संख्या कैसे प्राप्त कर सकता हूं?

114

मैं C # में किसी संख्या के कुल अंकों की संख्या कैसे प्राप्त कर सकता हूं? उदाहरण के लिए, संख्या 887979789 में 9 अंक हैं।

c#  math  numbers 
— जल्दबाजी
स्रोत
6
उपयोग करने की कोशिश करें। अगर यह काम नहीं करता है तो गति को पहले एक स्ट्रिंग में परिवर्तित करें
— Breezer
मान लें कि x = 887979789; x.ToString () गणना ()।; आपको वह देगा।
— nPcomp
2
— s --unıɐ ɐ qɐp

जवाबों:

174

एक स्ट्रिंग में परिवर्तित किए बिना आप कोशिश कर सकते हैं:

Math.Ceiling(Math.Log10(n));

Ysap की टिप्पणी के बाद सुधार:

Math.Floor(Math.Log10(n) + 1);
— स्टीव
स्रोत
10
मुझे डर है सीविल (log10 (10)) = छत (1) = 1, और 2 नहीं जैसा कि इस प्रश्न के लिए होना चाहिए!
— ysap
3
धन्यवाद, यह एक अच्छा तरीका है। हालाँकि यह इंट काउंट = 0 से कोई तेज़ नहीं है; do {गिनती ++; } जबकि ((i / = 10)> = 1); :(
— पुतर्डो बोरेटो
3
यदि आपकी संख्या सीमा में नकारात्मक शामिल हैं, तो आपको Math.Floor (Math.Log10 (Math.Abs ​​(n)) + 1) का उपयोग करने की आवश्यकता होगी;
— mrcrowl
1
खैर अगर nहै 0तो बस लौट सकते हैं 1:) बहुत संभाल ऋणात्मक मानों बस की जगह nके साथ Math.Abs(n)।
— उमैर
3
@ कंप्यूटर बोराटो: मेरा प्रदर्शन परीक्षण वास्तव में यह दर्शाता है कि अंकों की संख्या <5 होने पर आपका तरीका तेज है। पास।, स्टीव का गणित। क्लोअर तेज है।
— स्टैक 247
83

इसे इस्तेमाल करे: 

myint.ToString().Length

क्या वह काम करता है ?

— Andiih
स्रोत
25
यह इंगित करने के लायक है कि यदि आप नकारात्मक संख्याओं के साथ काम कर रहे हैं तो आप इस पद्धति की समस्याओं में भाग लेंगे। (और स्पष्ट रूप से दशमलव, लेकिन उदाहरण के एक का उपयोग करता है int, इसलिए मुझे लगता है कि कोई मुद्दा नहीं है।)
— कोड़ी ग्रे
2
@Krythic स्ट्रिंग आवंटन .NET की दुनिया में नया क्रेज है।
— नवफाल
1
नया? मुश्किल से। मैं 2010 में वापस स्ट्रिंग का आवंटन कर रहा था। क्या एक ट्रेंड सेटर था। जबरदस्त हंसी। हालांकि आप सही हैं। यह गंदा है!
— एंडीएच
3
@Krythic यह 1980 का दशक नहीं है, आपके कंप्यूटर में एक ऑपरेशन की अवधि के लिए 10 वर्ण स्ट्रिंग को मेमोरी में सहेजने के लिए पर्याप्त RAM है।
— MrLore
2
@ अधिक सरल अनुप्रयोगों में यह सच हो सकता है, लेकिन खेल के विकास की दुनिया में, यह पूरी तरह से अलग जानवर है।
— क्रिएथिक
48

समाधान

निम्नलिखित एक्सटेंशन विधियों में से कोई भी कार्य करेगा। वे सभी माइनस साइन को एक अंक के रूप में मानते हैं, और सभी संभावित इनपुट मानों के लिए सही ढंग से काम करते हैं। वे .NET फ्रेमवर्क और .NET कोर के लिए भी काम करते हैं। हालांकि, प्लेटफ़ॉर्म / फ्रेमवर्क की आपकी पसंद के आधार पर प्रासंगिक प्रदर्शन अंतर (नीचे चर्चा की गई) हैं।

Int32 संस्करण:

public static class Int32Extensions
{
    // IF-CHAIN:
    public static int Digits_IfChain(this int n)
    {
        if (n >= 0)
        {
            if (n < 10) return 1;
            if (n < 100) return 2;
            if (n < 1000) return 3;
            if (n < 10000) return 4;
            if (n < 100000) return 5;
            if (n < 1000000) return 6;
            if (n < 10000000) return 7;
            if (n < 100000000) return 8;
            if (n < 1000000000) return 9;
            return 10;
        }
        else
        {
            if (n > -10) return 2;
            if (n > -100) return 3;
            if (n > -1000) return 4;
            if (n > -10000) return 5;
            if (n > -100000) return 6;
            if (n > -1000000) return 7;
            if (n > -10000000) return 8;
            if (n > -100000000) return 9;
            if (n > -1000000000) return 10;
            return 11;
        }
    }

    // USING LOG10:
    public static int Digits_Log10(this int n) =>
        n == 0 ? 1 : (n > 0 ? 1 : 2) + (int)Math.Log10(Math.Abs((double)n));

    // WHILE LOOP:
    public static int Digits_While(this int n)
    {
        int digits = n < 0 ? 2 : 1;
        while ((n /= 10) != 0) ++digits;
        return digits;
    }

    // STRING CONVERSION:
    public static int Digits_String(this int n) =>
        n.ToString().Length;
}

Int64 संस्करण:

public static class Int64Extensions
{
    // IF-CHAIN:
    public static int Digits_IfChain(this long n)
    {
        if (n >= 0)
        {
            if (n < 10L) return 1;
            if (n < 100L) return 2;
            if (n < 1000L) return 3;
            if (n < 10000L) return 4;
            if (n < 100000L) return 5;
            if (n < 1000000L) return 6;
            if (n < 10000000L) return 7;
            if (n < 100000000L) return 8;
            if (n < 1000000000L) return 9;
            if (n < 10000000000L) return 10;
            if (n < 100000000000L) return 11;
            if (n < 1000000000000L) return 12;
            if (n < 10000000000000L) return 13;
            if (n < 100000000000000L) return 14;
            if (n < 1000000000000000L) return 15;
            if (n < 10000000000000000L) return 16;
            if (n < 100000000000000000L) return 17;
            if (n < 1000000000000000000L) return 18;
            return 19;
        }
        else
        {
            if (n > -10L) return 2;
            if (n > -100L) return 3;
            if (n > -1000L) return 4;
            if (n > -10000L) return 5;
            if (n > -100000L) return 6;
            if (n > -1000000L) return 7;
            if (n > -10000000L) return 8;
            if (n > -100000000L) return 9;
            if (n > -1000000000L) return 10;
            if (n > -10000000000L) return 11;
            if (n > -100000000000L) return 12;
            if (n > -1000000000000L) return 13;
            if (n > -10000000000000L) return 14;
            if (n > -100000000000000L) return 15;
            if (n > -1000000000000000L) return 16;
            if (n > -10000000000000000L) return 17;
            if (n > -100000000000000000L) return 18;
            if (n > -1000000000000000000L) return 19;
            return 20;
        }
    }

    // USING LOG10:
    public static int Digits_Log10(this long n) =>
        n == 0L ? 1 : (n > 0L ? 1 : 2) + (int)Math.Log10(Math.Abs((double)n));

    // WHILE LOOP:
    public static int Digits_While(this long n)
    {
        int digits = n < 0 ? 2 : 1;
        while ((n /= 10L) != 0L) ++digits;
        return digits;
    }

    // STRING CONVERSION:
    public static int Digits_String(this long n) =>
        n.ToString().Length;
}

विचार-विमर्श

यह जवाब दोनों के लिए प्रदर्शन किया परीक्षण भी शामिल है Int32और Int64प्रकार, की एक सरणी का उपयोग कर 100.000.000बेतरतीब ढंग से नमूना int/ longसंख्या। परीक्षणों को निष्पादित करने से पहले यादृच्छिक डेटासेट को एक सरणी में पूर्व-संसाधित किया जाता है।

4 अलग तरीकों के बीच संगति परीक्षण भी मार डाला गया के लिए MinValue, नकारात्मक सीमा मामलों, -1, 0, 1, सकारात्मक सीमा मामलों, MaxValueऔर भी पूरे यादृच्छिक डेटासेट के लिए। उपरोक्त प्रदान किए गए तरीकों के लिए कोई संगतता परीक्षण विफल नहीं होता है, LOG10 विधि के लिए EXCEPT (यह बाद में चर्चा की गई है)।

परीक्षणों को निष्पादित किया गया .NET Framework 4.7.2और .NET Core 2.2; के लिए x86और x64प्लेटफार्मों, एक 64-बिट इंटेल प्रोसेसर मशीन पर, साथ Windows 10, और साथ VS2017 v.15.9.17। निम्नलिखित 4 मामलों का प्रदर्शन परिणामों पर समान प्रभाव पड़ता है:

.NET फ्रेमवर्क (x86)

  • Platform = x86

  • Platform = AnyCPU, Prefer 32-bitपरियोजना सेटिंग्स में जाँच की है

.NET फ्रेमवर्क (x64)

  • Platform = x64

  • Platform = AnyCPU, Prefer 32-bitपरियोजना सेटिंग्स में अनियंत्रित है

.NET कोर (x86)

  • "C:\Program Files (x86)\dotnet\dotnet.exe" bin\Release\netcoreapp2.2\ConsoleApp.dll

  • "C:\Program Files (x86)\dotnet\dotnet.exe" bin\x86\Release\netcoreapp2.2\ConsoleApp.dll

.NET कोर (x64)

  • "C:\Program Files\dotnet\dotnet.exe" bin\Release\netcoreapp2.2\ConsoleApp.dll

  • "C:\Program Files\dotnet\dotnet.exe" bin\x64\Release\netcoreapp2.2\ConsoleApp.dll

परिणाम

नीचे दिए गए प्रदर्शन परीक्षण एक पूर्णांक मानों की विस्तृत श्रृंखला के बीच मूल्यों का एक समान वितरण पैदा कर सकते हैं। इसका मतलब यह है कि अंकों की एक बड़ी संख्या के साथ मूल्यों का परीक्षण करने की बहुत अधिक संभावना है। वास्तविक जीवन परिदृश्यों में, अधिकांश मूल्य छोटे हो सकते हैं, इसलिए IF-CHAIN ​​को और भी बेहतर प्रदर्शन करना चाहिए। इसके अलावा, प्रोसेसर आपके डेटासेट के अनुसार IF-CHAIN ​​निर्णयों को कैश और ऑप्टिमाइज़ करेगा।

के रूप में @AlanSingfield टिप्पणी अनुभाग में बताया, LOG10 पद्धति के लिए एक कास्टिंग के साथ तय किया जा सकता था doubleअंदर Math.Abs()मामले के लिए जब इनपुट मूल्य है int.MinValueया long.MinValue।

इस प्रश्न को संपादित करने से पहले मेरे द्वारा लागू किए गए प्रारंभिक प्रदर्शन परीक्षणों के बारे में (यह पहले से ही एक मिलियन बार संपादित किया जाना था), @ GyörgyKőszeg द्वारा निर्दिष्ट एक विशिष्ट मामला था , जिसमें IF-CHAIN ​​विधि LOG10 विधि की तुलना में धीमी गति से कार्य करती है।

यह अभी भी होता है, हालांकि @AlanSingfield द्वारा बताए गए मुद्दे के लिए तय होने के बाद अंतर की मात्रा बहुत कम हो गई । doubleजब इनपुट मान बिलकुल ठीक होता है तो यह फिक्स (एक कास्ट को जोड़ते हुए ) एक संगणना त्रुटि का कारण बनता है -999999999999999999: 20इसके बजाय LOG10 विधि वापस आती है 19। लॉग 10 विधि ifमें इनपुट मान शून्य होने पर केस के लिए एक गार्ड भी होना चाहिए ।

LOG10 विधि सभी मूल्यों के लिए काम करने के लिए काफी पेचीदा है, जिसका मतलब है कि आपको इससे बचना चाहिए। अगर किसी को नीचे दिए गए सभी संगतता परीक्षणों के लिए इसे सही तरीके से काम करने का तरीका मिल जाए, तो कृपया एक टिप्पणी पोस्ट करें!

WHILE विधि को हाल ही में रिफलेक्ट किया गया संस्करण भी मिला है जो तेज है, लेकिन यह अभी भी धीमा है Platform = x86(मुझे इसका कारण नहीं पता चल सका, अब तक)।

STRING विधि लगातार धीमी है: यह लालच से बिना कुछ लिए बहुत अधिक मेमोरी आवंटित करता है। दिलचस्प बात यह है कि, .NET कोर में, स्ट्रिंग फ्रेमवर्क .NET फ्रेमवर्क की तुलना में बहुत तेज लगता है। जानकार अच्छा लगा।

IF-CHAIN ​​विधि को 99.99% मामलों में अन्य सभी तरीकों से बेहतर प्रदर्शन करना चाहिए; और, मेरी व्यक्तिगत राय में, आपका सबसे अच्छा विकल्प है (LOG10 विधि को सही ढंग से काम करने के लिए आवश्यक सभी समायोजन पर विचार करना, और अन्य दो तरीकों का बुरा प्रदर्शन)।

अंत में, परिणाम हैं:

यहां छवि विवरण दर्ज करें

चूँकि ये परिणाम हार्डवेयर-निर्भर हैं, इसलिए मैं आपके कंप्यूटर पर नीचे दिए गए प्रदर्शन परीक्षणों को चलाने की सलाह देता हूँ अगर आपको वास्तव में आपके विशिष्ट मामले में 100% सुनिश्चित होना चाहिए।

टेस्ट कोड

नीचे प्रदर्शन परीक्षण के लिए कोड है, और स्थिरता परीक्षण भी। उसी कोड का उपयोग .NET फ्रेमवर्क और .NET कोर दोनों के लिए किया जाता है।

using System;
using System.Diagnostics;

namespace NumberOfDigits
{
    // Performance Tests:
    class Program
    {
        private static void Main(string[] args)
        {
            Console.WriteLine("\r\n.NET Core");

            RunTests_Int32();
            RunTests_Int64();
        }

        // Int32 Performance Tests:
        private static void RunTests_Int32()
        {
            Console.WriteLine("\r\nInt32");

            const int size = 100000000;
            int[] samples = new int[size];
            Random random = new Random((int)DateTime.Now.Ticks);
            for (int i = 0; i < size; ++i)
                samples[i] = random.Next(int.MinValue, int.MaxValue);

            Stopwatch sw1 = new Stopwatch();
            sw1.Start();
            for (int i = 0; i < size; ++i) samples[i].Digits_IfChain();
            sw1.Stop();
            Console.WriteLine($"IfChain: {sw1.ElapsedMilliseconds} ms");

            Stopwatch sw2 = new Stopwatch();
            sw2.Start();
            for (int i = 0; i < size; ++i) samples[i].Digits_Log10();
            sw2.Stop();
            Console.WriteLine($"Log10: {sw2.ElapsedMilliseconds} ms");

            Stopwatch sw3 = new Stopwatch();
            sw3.Start();
            for (int i = 0; i < size; ++i) samples[i].Digits_While();
            sw3.Stop();
            Console.WriteLine($"While: {sw3.ElapsedMilliseconds} ms");

            Stopwatch sw4 = new Stopwatch();
            sw4.Start();
            for (int i = 0; i < size; ++i) samples[i].Digits_String();
            sw4.Stop();
            Console.WriteLine($"String: {sw4.ElapsedMilliseconds} ms");


            // Start of consistency tests:
            Console.WriteLine("Running consistency tests...");
            bool isConsistent = true;

            // Consistency test on random set:
            for (int i = 0; i < samples.Length; ++i)
            {
                int s = samples[i];
                int a = s.Digits_IfChain();
                int b = s.Digits_Log10();
                int c = s.Digits_While();
                int d = s.Digits_String();
                if (a != b || c != d || a != c)
                {
                    Console.WriteLine($"Digits({s}): IfChain={a} Log10={b} While={c} String={d}");
                    isConsistent = false;
                    break;
                }
            }

            // Consistency test of special values:
            samples = new int[]
            {
                0,
                int.MinValue, -1000000000, -999999999, -100000000, -99999999, -10000000, -9999999, -1000000, -999999, -100000, -99999, -10000, -9999, -1000, -999, -100, -99, -10, -9, - 1,
                int.MaxValue, 1000000000, 999999999, 100000000, 99999999, 10000000, 9999999, 1000000, 999999, 100000, 99999, 10000, 9999, 1000, 999, 100, 99, 10, 9,  1,
            };
            for (int i = 0; i < samples.Length; ++i)
            {
                int s = samples[i];
                int a = s.Digits_IfChain();
                int b = s.Digits_Log10();
                int c = s.Digits_While();
                int d = s.Digits_String();
                if (a != b || c != d || a != c)
                {
                    Console.WriteLine($"Digits({s}): IfChain={a} Log10={b} While={c} String={d}");
                    isConsistent = false;
                    break;
                }
            }

            // Consistency test result:
            if (isConsistent)
                Console.WriteLine("Consistency tests are OK");
        }

        // Int64 Performance Tests:
        private static void RunTests_Int64()
        {
            Console.WriteLine("\r\nInt64");

            const int size = 100000000;
            long[] samples = new long[size];
            Random random = new Random((int)DateTime.Now.Ticks);
            for (int i = 0; i < size; ++i)
                samples[i] = Math.Sign(random.Next(-1, 1)) * (long)(random.NextDouble() * long.MaxValue);

            Stopwatch sw1 = new Stopwatch();
            sw1.Start();
            for (int i = 0; i < size; ++i) samples[i].Digits_IfChain();
            sw1.Stop();
            Console.WriteLine($"IfChain: {sw1.ElapsedMilliseconds} ms");

            Stopwatch sw2 = new Stopwatch();
            sw2.Start();
            for (int i = 0; i < size; ++i) samples[i].Digits_Log10();
            sw2.Stop();
            Console.WriteLine($"Log10: {sw2.ElapsedMilliseconds} ms");

            Stopwatch sw3 = new Stopwatch();
            sw3.Start();
            for (int i = 0; i < size; ++i) samples[i].Digits_While();
            sw3.Stop();
            Console.WriteLine($"While: {sw3.ElapsedMilliseconds} ms");

            Stopwatch sw4 = new Stopwatch();
            sw4.Start();
            for (int i = 0; i < size; ++i) samples[i].Digits_String();
            sw4.Stop();
            Console.WriteLine($"String: {sw4.ElapsedMilliseconds} ms");

            // Start of consistency tests:
            Console.WriteLine("Running consistency tests...");
            bool isConsistent = true;

            // Consistency test on random set:
            for (int i = 0; i < samples.Length; ++i)
            {
                long s = samples[i];
                int a = s.Digits_IfChain();
                int b = s.Digits_Log10();
                int c = s.Digits_While();
                int d = s.Digits_String();
                if (a != b || c != d || a != c)
                {
                    Console.WriteLine($"Digits({s}): IfChain={a} Log10={b} While={c} String={d}");
                    isConsistent = false;
                    break;
                }
            }

            // Consistency test of special values:
            samples = new long[] 
            {
                0,
                long.MinValue, -1000000000000000000, -999999999999999999, -100000000000000000, -99999999999999999, -10000000000000000, -9999999999999999, -1000000000000000, -999999999999999, -100000000000000, -99999999999999, -10000000000000, -9999999999999, -1000000000000, -999999999999, -100000000000, -99999999999, -10000000000, -9999999999, -1000000000, -999999999, -100000000, -99999999, -10000000, -9999999, -1000000, -999999, -100000, -99999, -10000, -9999, -1000, -999, -100, -99, -10, -9, - 1,
                long.MaxValue, 1000000000000000000, 999999999999999999, 100000000000000000, 99999999999999999, 10000000000000000, 9999999999999999, 1000000000000000, 999999999999999, 100000000000000, 99999999999999, 10000000000000, 9999999999999, 1000000000000, 999999999999, 100000000000, 99999999999, 10000000000, 9999999999, 1000000000, 999999999, 100000000, 99999999, 10000000, 9999999, 1000000, 999999, 100000, 99999, 10000, 9999, 1000, 999, 100, 99, 10, 9,  1,
            };
            for (int i = 0; i < samples.Length; ++i)
            {
                long s = samples[i];
                int a = s.Digits_IfChain();
                int b = s.Digits_Log10();
                int c = s.Digits_While();
                int d = s.Digits_String();
                if (a != b || c != d || a != c)
                {
                    Console.WriteLine($"Digits({s}): IfChain={a} Log10={b} While={c} String={d}");
                    isConsistent = false;
                    break;
                }
            }

            // Consistency test result:
            if (isConsistent)
                Console.WriteLine("Consistency tests are OK");
        }
    }
}
— sɐunıɔ ןɐ qɐp
स्रोत
4
मुझे यह समाधान पसंद है, यह मैथ्स ट्रिक्स की तुलना में बहुत अधिक पठनीय है और गति खुद के लिए बोलती है, यश।
— मृलूर
3
इसे समाधान के रूप में चिह्नित क्यों नहीं किया गया है? प्रदर्शन मायने रखता है और यह सबसे व्यापक जवाब लगता है।
— मार्टिन डे जोंग
दिलचस्प है, मुझे अलग परिणाम मिलते हैं । यादृच्छिक मूल्यों के लिए Log10 और जानवर बल लगभग समान हैं लेकिन long.MaxValueLog10 के लिए काफी बेहतर है। या यह सिर्फ .NET कोर में है?
— गियोगी कोज़ेग
@ GyörgyKőszeg: मैंने Int64 के लिए परीक्षण जोड़े हैं। कृपया ध्यान रखें कि विभिन्न डेटासेट के लिए परीक्षण Int32और Int64उत्पन्न करते हैं, जो यह समझा सकते हैं कि कुछ मामलों में Int64तेजी से क्यों बढ़ गया Int32। हालांकि, Int32परीक्षण के भीतर और Int64परीक्षण के भीतर अलग-अलग गणना विधियों का परीक्षण करते समय डेटासेट नहीं बदले जाते हैं। अब .NET कोर के बारे में, मुझे संदेह है कि गणित पुस्तकालय में कोई जादू अनुकूलन है जो इन परिणामों को बदल देगा, लेकिन मैं इसके बारे में और अधिक सुनना पसंद करूंगा (मेरा जवाब पहले से ही बहुत बड़ा है, शायद एसओ में सबसे बड़ा;;;
— sunı19 ɐ qɐp
@ GyörgyKőszeg: इसके अलावा, निम्न-स्तर का प्रदर्शन खानों में बहुत मुश्किल है। मैं आमतौर पर हो सके, आसान कोड रखना पसंद करते हैं (मैं सरल पसंद forसे अधिक छोरों enumerations, मैं पूर्व प्रक्रिया यादृच्छिक डेटासेट, और जेनरिक, कार्य, के उपयोग से बचने Function<>, Action<>, या किसी भी काले बॉक्स्ड माप रूपरेखा)। संक्षेप में, इसे सरल रखें। मैं सभी अनावश्यक अनुप्रयोगों (स्काइप, विंडोज डिफेंडर, एंटी-वायरस, क्रोम, माइक्रोसॉफ्ट ऑफिस कैश आदि को अक्षम करता हूं) को भी मारता हूं।
— s --unıɐ ɐ qɐp
13

सीधे सी # नहीं है, लेकिन सूत्र है: n = floor(log10(x)+1)

— ysap
स्रोत
2
log10 (0) है -इनफिनिटी
— एलेक्स क्लॉस
2
@ क्लॉस - log10 (0) वास्तव में अपरिभाषित है। लेकिन, आप सही हैं कि यह एक विशेष मामला है जिसके लिए अलग से परीक्षण और उपचार की आवश्यकता होती है। यह किसी भी गैर सकारात्मक पूर्णांक संख्या के लिए भी सही है। स्टीव के जवाब के लिए टिप्पणियां देखें।
— ysap
@ysap: लॉग 10 सही ढंग से काम करने के लिए काफी मुश्किल है। क्या आपके पास इस बारे में कोई विचार है कि सभी संभावित इनपुट मूल्यों के लिए इसे सही तरीके से कैसे लागू किया जाए?
— s --unıɐ ןɐ qɐp
@ s @unıɐ ןɐ qɐp - log10ज्यादातर मामलों में एक पुस्तकालय समारोह है। आप इसे खुद क्यों लागू करना चाहते हैं, और किन मुद्दों पर आपका सामना होता है? log10(x) = log2(x) / log2(10), या आम तौर पर logA(x) = logB(x) / logB(A)।
— ysap
मैं फिर Log10(0)से लॉग 10 को लागू करने का मतलब नहीं था, मेरा मतलब है -इनफिनिटी। जब तक आप Math.Abs()Log10 के मान को पास करने से पहले उपयोग नहीं करते हैं, तब तक Log10 का उपयोग ऋणात्मक संख्याओं के अंकों की गणना के लिए नहीं किया जा सकता है । लेकिन तब Math.Abs(int.MinValue)एक अपवाद ( long.MinValueInt64 के मामले में भी) फेंकता है । यदि हम Log10 में इसे पास करने से पहले संख्या को दोगुना कर देते हैं, तो यह -999999999999999999(Int64 के मामले में) को छोड़कर लगभग सभी संख्याओं के लिए काम करता है । क्या आप अंकों की संख्या की गणना के लिए कोई सूत्र जानते हैं जो log10 का उपयोग करता है और इनपुट के रूप में किसी भी int32 या int64 मान को स्वीकार करता है और केवल वैध मानों को आउटपुट करता है?
— s --unıɐ ןɐ qɐp
9

यहां पहले से ही दिए गए उत्तर अहस्ताक्षरित पूर्णांक के लिए काम करते हैं, लेकिन मुझे दशमलव और युगल से अंकों की संख्या प्राप्त करने के लिए अच्छा समाधान नहीं मिला है।

public static int Length(double number)
{
    number = Math.Abs(number);
    int length = 1;
    while ((number /= 10) >= 1)
        length++;
    return length;
}
//number of digits in 0 = 1,
//number of digits in 22.1 = 2,
//number of digits in -23 = 2

आप से इनपुट प्रकार बदल सकते हैं doubleकरने के लिए decimalकरता है, तो परिशुद्धता मायने रखती है, लेकिन दशमलव भी एक सीमा होती है।

— nawfal
स्रोत
7

स्टीव का उत्तर सही है , लेकिन यह 1 से कम पूर्णांकों के लिए काम नहीं करता है।

यहां एक अद्यतन संस्करण जो नकारात्मक कार्य करता है:

int digits = n == 0 ? 1 : Math.Floor(Math.Log10(Math.Abs(n)) + 1)
— पैट्रिक हॉफमैन
स्रोत
आपको कास्टिंग काउंट याद आ रहा है:digits = n == 0 ? 1 : (int)Math.Floor(Math.Log10(Math.Abs(n)) + 1);
— sɐunıןɐ ɐ q Junp
मैंने इसे बिना स्टेटमेंट के किया: अंक = (int) Math.Floor (Math.Abs ​​(Math.Log10 (Math.Abs) (n))) + 1)
— KOLRH
जब यह एक अपवाद फेंकता है n = int.MinValue।
— s --unıɐ ןɐ qɐp
5

पुनरावर्ती का उपयोग करना (कभी-कभी साक्षात्कारों में पूछा जाता है)

public int CountDigits(int number)
{
    // In case of negative numbers
    number = Math.Abs(number);

    if (number >= 10)
        return CountDigits(number / 10) + 1;
    return 1;
 }
1
जब यह एक अपवाद फेंकता है number = int.MinValue।
— s --unıɐ ןɐ qɐp
4 
static void Main(string[] args)
{
    long blah = 20948230498204;
    Console.WriteLine(blah.ToString().Length);
}
— weloytty
स्रोत
2
नकारात्मक से सावधान रहें: -1= 2
— MrLore
2

यहां बाइनरी खोज का उपयोग करके कार्यान्वयन किया गया है। इंट 32 पर अब तक का सबसे तेज लग रहा है।

Int64 कार्यान्वयन को पाठक के लिए एक अभ्यास के रूप में छोड़ दिया गया है (!)

मैंने पेड़ की हार्ड-कोडिंग के बजाय Array.BinarySearch का उपयोग करने की कोशिश की, लेकिन वह लगभग आधी गति थी।

संपादित करें: अधिक मेमोरी का उपयोग करने की कीमत पर एक खोज तालिका बाइनरी खोज की तुलना में बहुत तेज है। वास्तविक रूप से मैं शायद बाइनरी खोज एक का उपयोग उत्पादन में करूंगा, लुकअप टेबल एक गति प्राप्त करने के लिए बहुत अधिक जटिलता है जो कि सॉफ्टवेयर के अन्य भागों द्वारा ओवरशैड किए जाने की संभावना है।

Lookup-Table: 439 ms
Binary-Search: 1069 ms
If-Chain: 1409 ms
Log10: 1145 ms
While: 1768 ms
String: 5153 ms

लुकअप तालिका संस्करण:

static byte[] _0000llll = new byte[0x10000];
static byte[] _FFFFllll = new byte[0x10001];
static sbyte[] _hhhhXXXXdigits = new sbyte[0x10000];

// Special cases where the high DWORD is not enough information to find out how
// many digits.
static ushort[] _lowordSplits = new ushort[12];
static sbyte[] _lowordSplitDigitsLT = new sbyte[12];
static sbyte[] _lowordSplitDigitsGE = new sbyte[12];

static Int32Extensions()
{
    // Simple lookup tables for number of digits where value is 
    //    0000xxxx (0 .. 65535)
    // or FFFFxxxx (-1 .. -65536)
    precomputePositiveLo16();
    precomputeNegativeLo16();

    // Hiword is a little more complex
    precomputeHiwordDigits();
}

private static void precomputeHiwordDigits()
{
    int b = 0;

    for(int hhhh = 0; hhhh <= 0xFFFF; hhhh++)
    {
        // For hiword hhhh, calculate integer value for loword of 0000 and FFFF.
        int hhhh0000 = (unchecked(hhhh * 0x10000));  // wrap around on negatives
        int hhhhFFFF = hhhh0000 + 0xFFFF;

        // How many decimal digits for each?
        int digits0000 = hhhh0000.Digits_IfChain();
        int digitsFFFF = hhhhFFFF.Digits_IfChain();

        // If same number of decimal digits, we know that when we see that hiword
        // we don't have to look at the loword to know the right answer.
        if(digits0000 == digitsFFFF)
        {
            _hhhhXXXXdigits[hhhh] = (sbyte)digits0000;
        }
        else
        {
            bool negative = hhhh >= 0x8000;

            // Calculate 10, 100, 1000, 10000 etc
            int tenToThePower = (int)Math.Pow(10, (negative ? digits0000 : digitsFFFF) - 1);

            // Calculate the loword of the 10^n value.
            ushort lowordSplit = unchecked((ushort)tenToThePower);
            if(negative)
                lowordSplit = unchecked((ushort)(2 + (ushort)~lowordSplit));

            // Store the split point and digits into these arrays
            _lowordSplits[b] = lowordSplit;
            _lowordSplitDigitsLT[b] = (sbyte)digits0000;
            _lowordSplitDigitsGE[b] = (sbyte)digitsFFFF;

            // Store the minus of the array index into the digits lookup. We look for
            // minus values and use these to trigger using the split points logic.
            _hhhhXXXXdigits[hhhh] = (sbyte)(-b);
            b++;
        }
    }
}

private static void precomputePositiveLo16()
{
    for(int i = 0; i <= 9; i++)
        _0000llll[i] = 1;

    for(int i = 10; i <= 99; i++)
        _0000llll[i] = 2;

    for(int i = 100; i <= 999; i++)
        _0000llll[i] = 3;

    for(int i = 1000; i <= 9999; i++)
        _0000llll[i] = 4;

    for(int i = 10000; i <= 65535; i++)
        _0000llll[i] = 5;
}

private static void precomputeNegativeLo16()
{
    for(int i = 0; i <= 9; i++)
        _FFFFllll[65536 - i] = 1;

    for(int i = 10; i <= 99; i++)
        _FFFFllll[65536 - i] = 2;

    for(int i = 100; i <= 999; i++)
        _FFFFllll[65536 - i] = 3;

    for(int i = 1000; i <= 9999; i++)
        _FFFFllll[65536 - i] = 4;

    for(int i = 10000; i <= 65535; i++)
        _FFFFllll[65536 - i] = 5;
}



public static int Digits_LookupTable(this int n)
{
    // Split input into low word and high word.
    ushort l = unchecked((ushort)n);
    ushort h = unchecked((ushort)(n >> 16));

    // If the hiword is 0000 or FFFF we have precomputed tables for these.
    if(h == 0x0000)
    {
        return _0000llll[l];
    }
    else if(h == 0xFFFF)
    {
        return _FFFFllll[l];
    }

    // In most cases the hiword will tell us the number of decimal digits.
    sbyte digits = _hhhhXXXXdigits[h];

    // We put a positive number in this lookup table when
    // hhhh0000 .. hhhhFFFF all have the same number of decimal digits.
    if(digits > 0)
        return digits;

    // Where the answer is different for hhhh0000 to hhhhFFFF, we need to
    // look up in a separate array to tell us at what loword the change occurs.
    var splitIndex = (sbyte)(-digits);

    ushort lowordSplit = _lowordSplits[splitIndex];

    // Pick the correct answer from the relevant array, depending whether
    // our loword is lower than the split point or greater/equal. Note that for
    // negative numbers, the loword is LOWER for MORE decimal digits.
    if(l < lowordSplit)
        return _lowordSplitDigitsLT[splitIndex];
    else
        return _lowordSplitDigitsGE[splitIndex];
}

द्विआधारी खोज संस्करण

        public static int Digits_BinarySearch(this int n)
        {
            if(n >= 0)
            {
                if(n <= 9999) // 0 .. 9999
                {
                    if(n <= 99) // 0 .. 99
                    {
                        return (n <= 9) ? 1 : 2;
                    }
                    else // 100 .. 9999
                    {
                        return (n <= 999) ? 3 : 4;
                    }
                }
                else // 10000 .. int.MaxValue
                {
                    if(n <= 9_999_999) // 10000 .. 9,999,999
                    {
                        if(n <= 99_999)
                            return 5;
                        else if(n <= 999_999)
                            return 6;
                        else
                            return 7;
                    }
                    else // 10,000,000 .. int.MaxValue
                    {
                        if(n <= 99_999_999)
                            return 8;
                        else if(n <= 999_999_999)
                            return 9;
                        else
                            return 10;
                    }
                }
            }
            else
            {
                if(n >= -9999) // -9999 .. -1
                {
                    if(n >= -99) // -99 .. -1
                    {
                        return (n >= -9) ? 1 : 2;
                    }
                    else // -9999 .. -100
                    {
                        return (n >= -999) ? 3 : 4;
                    }
                }
                else // int.MinValue .. -10000
                {
                    if(n >= -9_999_999) // -9,999,999 .. -10000
                    {
                        if(n >= -99_999)
                            return 5;
                        else if(n >= -999_999)
                            return 6;
                        else
                            return 7;
                    }
                    else // int.MinValue .. -10,000,000 
                    {
                        if(n >= -99_999_999)
                            return 8;
                        else if(n >= -999_999_999)
                            return 9;
                        else
                            return 10;
                    }
                }
            }
        }

        Stopwatch sw0 = new Stopwatch();
        sw0.Start();
        for(int i = 0; i < size; ++i) samples[i].Digits_BinarySearch();
        sw0.Stop();
        Console.WriteLine($"Binary-Search: {sw0.ElapsedMilliseconds} ms");
— एलन सिंगफील्ड
स्रोत
बहुत दिलचस्प दृष्टिकोण। यह वास्तव में "Log10", "string.Length", और "जबकि" समान रूप से वितरित पूर्णांक मानों की तुलना में अधिक तेज़ है। वास्तविक स्थिति में, पूर्णांक मानों के वितरण पर हमेशा विचार किया जाना चाहिए, यदि श्रृंखला-जैसे समाधान। +1
— s Decunıɔ ɐ qɐp
लुकअप दृष्टिकोण उन परिदृश्यों के लिए सुपर फास्ट लगता है जहां मेमोरी एक्सेस टोंटी नहीं है। मेरा दृढ़ता से मानना ​​है कि लगातार मेमोरी एक्सेस वाले परिदृश्यों के लिए, लुकअपटेबल, अगर आपके द्वारा सुझाए गए बिनसर्च की तरह है, तो चेन-जैसे तरीकों से धीमा हो जाता है। वैसे, क्या आपके पास Int64लुकअप के लिए कार्यान्वयन है? या क्या आपको लगता है कि इसे लागू करना बहुत जटिल है? मैं बाद में पूर्ण सेट पर प्रदर्शन परीक्षण चलाना चाहता हूं।
— s --unıɐ ɐ qɐp
अरे, 64-बिट के रूप में दूर के रूप में नहीं मिला। यह सिद्धांत थोड़ा अलग होना चाहिए कि आपको हाईवे और लोर्ड के बजाय 4x स्तरों की आवश्यकता होगी। निश्चित रूप से इस बात से सहमत हैं कि वास्तविक दुनिया में, आपके सीपीयू कैश में अंतरिक्ष के लिए बहुत सी अन्य प्रतिस्पर्धी ज़रूरतें होंगी, और लुकअप के आकार को काटने में सुधार के लिए बहुत जगह है (>> 1 तब भी संख्या केवल दिमाग में आती है) । द्विआधारी खोज एक को 1,2,3,4 के बजाय 9,10,8 अंकों की ओर बायपास करके सुधारा जा सकता है - जिसे आपके यादृच्छिक रैंडम सेट का वितरण दिया गया है।
— एलन सिंगफील्ड
1

किसी संख्या को 10 से विभाजित करने पर आपको बाईं ओर सबसे अधिक अंक मिलेंगे, फिर संख्या पर एक मॉड 10 करना पहले अंक के बिना नंबर देता है और दोहराता है कि जब तक आपके पास सभी अंक नहीं हैं

— romejoe
स्रोत
0 
int i = 855865264;
int NumLen = i.ToString().Length;
— जावेद अकरम
स्रोत
2
नकारात्मक इंट के लिए विफल रहता है, और 23.00 जैसे संख्याओं के लिए। एक string.TrimStart('-')बेहतर
— नवफ़ल
0

एक विधि बनाएँ जो सभी अंकों को लौटाए, और दूसरा जो उन्हें गिनता है:

public static int GetNumberOfDigits(this long value)
{
    return value.GetDigits().Count();
}

public static IEnumerable<int> GetDigits(this long value)
{
    do
    {
        yield return (int)(value % 10);
        value /= 10;
    } while (value != 0);
}

यह इस समस्या से निपटने के दौरान मेरे लिए अधिक सहज दृष्टिकोण की तरह लगा। मैंने Log10इसकी स्पष्ट सादगी के कारण पहले विधि की कोशिश की , लेकिन इसमें कोने के मामलों और सटीक समस्याओं की एक पागल राशि है।

मैंने if-चिन को दूसरे उत्तर में देखने के लिए थोड़ा बदसूरत प्रस्तावित किया।

मुझे पता है कि यह सबसे प्रभावी तरीका नहीं है, लेकिन यह आपको अन्य उपयोगों के लिए अंकों को वापस करने के लिए दूसरा एक्सटेंशन देता है ( privateयदि आप इसे कक्षा के बाहर उपयोग करने की आवश्यकता नहीं है, तो आप इसे चिह्नित कर सकते हैं )।

ध्यान रखें कि यह नकारात्मक संकेत को अंक के रूप में नहीं मानता है।

— julealgon
स्रोत
-2

स्ट्रिंग में परिवर्तित करें और फिर आप .length विधि द्वारा अंकों की संख्या को गिन सकते हैं। पसंद:

String numberString = "855865264".toString();
int NumLen = numberString .Length;
1
एक स्ट्रिंग आवंटित करना पूरी तरह से अनावश्यक है।
— क्रिटिक
-2

यह निर्भर करता है कि आप अंकों के साथ क्या करना चाहते हैं। आप इस तरह से पिछले से शुरू होने वाले अंकों के माध्यम से पुनरावृति कर सकते हैं:

int tmp = number;
int lastDigit = 0;
do
{
    lastDigit = tmp / 10;
    doSomethingWithDigit(lastDigit);
    tmp %= 10;
} while (tmp != 0);
— मिहरन होसेपियन
स्रोत
1
तुम्हारा तर्क उलटा है। आपको %अंक प्राप्त करने के लिए उपयोग करने की आवश्यकता है , और फिर /=इसे काटने के लिए।
— जूलियागॉन
-3

मान लीजिए कि आपका प्रश्न एक इंट का संदर्भ दे रहा है, तो निम्न कार्य नकारात्मक / सकारात्मक और शून्य के लिए भी काम करता है:

Math.Floor((decimal) Math.Abs(n)).ToString().Length
— पेत्रु ज़हरिया
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.