आप इंट (C #) में पहला अंक कैसे प्राप्त कर सकते हैं?

Question 1

C # में, int में 1st अंक प्राप्त करने का सबसे अच्छा तरीका क्या है? जिस विधि के साथ मैं आया था, वह इंट को एक स्ट्रिंग में बदलना है, स्ट्रिंग के 1 चार्ट को ढूंढना है, फिर इसे एक इंट में वापस करना है।

int start = Convert.ToInt32(curr.ToString().Substring(0, 1));

हालांकि यह काम करता है, ऐसा लगता है कि इस तरह की समस्या का एक अच्छा, सरल, गणित आधारित समाधान है। स्ट्रिंग हेरफेर क्लंकी लगता है।

संपादित करें: गति अंतर के बावजूद, एस्ट्रिंग () के बजाय मिस्ट्रिंग [0] अभी भी केवल स्ट्रिंग हेरफेर है

Question 2

ऐसे

int i = Math.Abs(386792);
while(i >= 10)
    i /= 10;

और iआप की जरूरत है क्या शामिल होगा

Question 3

मानक

सबसे पहले, आपको यह तय करना होगा कि आप "सर्वश्रेष्ठ" समाधान से क्या मतलब है, निश्चित रूप से एल्गोरिथ्म की दक्षता, इसकी पठनीयता / रखरखाव, और भविष्य में कीड़े रेंगने की संभावना को ध्यान में रखते हैं। सावधान इकाई परीक्षण आमतौर पर उन समस्याओं से बच सकते हैं, हालांकि।

मैंने इनमें से प्रत्येक उदाहरण को 10 मिलियन बार चलाया, और परिणाम मूल्य उस संख्या की संख्या है ElapsedTicksजो पारित हो गई है।

आगे की हलचल के बिना, सबसे धीमी से लेकर सबसे तेज तक एल्गोरिदम हैं:

एक स्ट्रिंग में परिवर्तित करना, पहले वर्ण लें

int firstDigit = (int)(Value.ToString()[0]) - 48;

परिणाम:

12,552,893 ticks

एक लघुगणक का उपयोग करना

int firstDigit = (int)(Value / Math.Pow(10, (int)Math.Floor(Math.Log10(Value))));

परिणाम:

9,165,089 ticks

पाशन

while (number >= 10)
    number /= 10;

परिणाम:

6,001,570 ticks

सशर्त,

int firstdigit;
if (Value < 10)
     firstdigit = Value;
else if (Value < 100)
     firstdigit = Value / 10;
else if (Value < 1000)
     firstdigit = Value / 100;
else if (Value < 10000)
     firstdigit = Value / 1000;
else if (Value < 100000)
     firstdigit = Value / 10000;
else if (Value < 1000000)
     firstdigit = Value / 100000;
else if (Value < 10000000)
     firstdigit = Value / 1000000;
else if (Value < 100000000)
     firstdigit = Value / 10000000;
else if (Value < 1000000000)
     firstdigit = Value / 100000000;
else
     firstdigit = Value / 1000000000;

परिणाम:

1,421,659 ticks

अनियंत्रित और अनुकूलित लूप

if (i >= 100000000) i /= 100000000;
if (i >= 10000) i /= 10000;
if (i >= 100) i /= 100;
if (i >= 10) i /= 10;

परिणाम:

1,399,788 ticks

ध्यान दें:

प्रत्येक परीक्षण Random.Next()अगले प्राप्त करने के लिए कहता हैint

Question 4

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

public int GetFirstDigit(int number) {
  if ( number < 10 ) {
    return number;
  }
  return GetFirstDigit ( (number - (number % 10)) / 10);
}

संपादित करें

कई लोगों ने लूप संस्करण का अनुरोध किया है

public static int GetFirstDigitLoop(int number)
{
    while (number >= 10)
    {
        number = (number - (number % 10)) / 10;
    }
    return number;
}

Question 5

सबसे अच्छा मैं आ सकता है:

int numberOfDigits = Convert.ToInt32(Math.Floor( Math.Log10( value ) ) );

int firstDigit = value / Math.Pow( 10, numberOfDigits );

Question 6

एंटोन के उत्तर पर भिन्नता:

 // cut down the number of divisions (assuming i is positive & 32 bits)
if (i >= 100000000) i /= 100000000;
if (i >= 10000) i /= 10000;
if (i >= 100) i /= 100;
if (i >= 10) i /= 10;

Question 7

int myNumber = 8383;
char firstDigit = myNumber.ToString()[0];
// char = '8'

Question 8

लेननेर्ट के समान विचार था

int start = number == 0 ? 0 : number / (int) Math.Pow(10,Math.Floor(Math.Log10(Math.Abs(number))));

यह नकारात्मक संख्याओं के साथ भी काम करता है।

Question 9

अगर आपको लगता है कि केल्टेक्स का जवाब बदसूरत है, तो इसे आज़माएं, यह वास्तव में बदसूरत है, और तेज़ भी। यह लंबाई निर्धारित करने के लिए अनियंत्रित बाइनरी खोज करता है।

 ... leading code along the same lines
/* i<10000 */
if (i >= 100){
  if (i >= 1000){
    return i/1000;
  }
  else /* i<1000 */{
    return i/100;
  }
}
else /* i<100*/ {
  if (i >= 10){
    return i/10;
  }
  else /* i<10 */{
    return i;
  }
}

पीएस मार्टिनस्टाइनर का भी यही विचार था।

Question 10

एक स्पष्ट, लेकिन धीमा, गणितीय दृष्टिकोण है:

int firstDigit = (int)(i / Math.Pow(10, (int)Math.Log10(i))));

Question 11

int temp = i;
while (temp >= 10)
{
    temp /= 10;
}

परिणाम होना temp

Question 12

मुझे पता है कि यह C # नहीं है, लेकिन यह आश्चर्यजनक है कि अजगर में "संख्या के स्ट्रिंग प्रतिनिधित्व का पहला चार्ट प्राप्त करें" तेज है!

संपादित करें : नहीं, मैंने एक गलती की, मैं फिर से इंट, सॉरी का निर्माण करना भूल गया। अनियंत्रित संस्करण यह सबसे तेज़ है।

$ cat first_digit.py
def loop(n):
    while n >= 10:
        n /= 10
    return n

def unrolled(n):
    while n >= 100000000: # yea... unlimited size int supported :)
        n /= 100000000
    if n >= 10000:
        n /= 10000
    if n >= 100:
        n /= 100
    if n >= 10:
        n /= 10
    return n

def string(n):
    return int(str(n)[0])
$ python -mtimeit -s 'from first_digit import loop as test' \
    'for n in xrange(0, 100000000, 1000): test(n)'
10 loops, best of 3: 275 msec per loop
$ python -mtimeit -s 'from first_digit import unrolled as test' \
    'for n in xrange(0, 100000000, 1000): test(n)'
10 loops, best of 3: 149 msec per loop
$ python -mtimeit -s 'from first_digit import string as test' \
    'for n in xrange(0, 100000000, 1000): test(n)'
10 loops, best of 3: 284 msec per loop
$

Question 13

मैं बस इस पुराने सवाल पर लड़खड़ाया और लगा कि एक और सुझाव देने का प्रस्ताव है क्योंकि अन्य जवाबों में से कोई भी अब तक सभी संभावित इनपुट मूल्यों के लिए सही परिणाम नहीं देता है और इसे अभी भी तेजी से बनाया जा सकता है:

public static int GetFirstDigit( int i )
{
    if( i < 0 && ( i = -i ) < 0 ) return 2;
    return ( i < 100 ) ? ( i < 1 ) ? 0 : ( i < 10 )
            ? i : i / 10 : ( i < 1000000 ) ? ( i < 10000 )
            ? ( i < 1000 ) ? i / 100 : i / 1000 : ( i < 100000 )
            ? i / 10000 : i / 100000 : ( i < 100000000 )
            ? ( i < 10000000 ) ? i / 1000000 : i / 10000000
            : ( i < 1000000000 ) ? i / 100000000 : i / 1000000000;
}

यह सभी हस्ताक्षरित पूर्णांक मानों के लिए काम करता है, -2147483648जो कि सबसे छोटा हस्ताक्षरित पूर्णांक है और इसमें सकारात्मक प्रतिपक्ष नहीं है। Math.Abs( -2147483648 )ट्रिगर करता है System.OverflowExceptionऔर - -2147483648करने के लिए गणना करता है -2147483648।

कार्यान्वयन को अब तक के दो सबसे तेज़ कार्यान्वयन के लाभों के संयोजन के रूप में देखा जा सकता है। यह एक द्विआधारी खोज का उपयोग करता है और सतही विभाजन से बचा जाता है। 100,000,000 पुनरावृत्तियों के साथ एक लूप के सूचकांक के साथ एक त्वरित बेंचमार्क दर्शाता है कि यह वर्तमान में सबसे तेज़ कार्यान्वयन से दोगुना है।

यह 2,829,581 टिक्स के बाद खत्म होता है।

तुलना के लिए मैंने वर्तमान में सबसे तेज़ कार्यान्वयन का एक सही संस्करण भी मापा, जिसमें 5,664,627 टिक लगे।

public static int GetFirstDigitX( int i )
{
    if( i < 0 && ( i = -i ) < 0 ) return 2;
    if( i >= 100000000 ) i /= 100000000;
    if( i >= 10000 ) i /= 10000;
    if( i >= 100 ) i /= 100;
    if( i >= 10 ) i /= 10;
    return i;
}

इसी सुधार के साथ स्वीकृत उत्तर के लिए मेरे कंप्यूटर पर इस परीक्षण के लिए 16,561,929 टिक्स की आवश्यकता थी ।

public static int GetFirstDigitY( int i )
{
    if( i < 0 && ( i = -i ) < 0 ) return 2;
    while( i >= 10 )
        i /= 10;
    return i;
}

इस तरह के सरल कार्य आसानी से शुद्धता के लिए सिद्ध हो सकते हैं क्योंकि वर्तमान हार्डवेयर पर सभी संभव पूर्णांक मान कुछ सेकंड से अधिक नहीं होते हैं। इसका मतलब यह है कि उन्हें असाधारण रूप से पढ़ने योग्य फैशन में लागू करना कम महत्वपूर्ण है क्योंकि बाद में कभी भी बग को अंदर ठीक करने की आवश्यकता नहीं होगी।

Question 14

बहुत सरल (और शायद काफी तेज है क्योंकि इसमें केवल तुलना और एक विभाजन शामिल है):

if(i<10)
   firstdigit = i;
else if (i<100)
   firstdigit = i/10;
else if (i<1000)
   firstdigit = i/100;
else if (i<10000)
   firstdigit = i/1000;
else if (i<100000)
   firstdigit = i/10000;
else (etc... all the way up to 1000000000)

Question 15

क्या मेरे किसी सहकर्मी के यहाँ कुछ परीक्षण हुए, और पता चला कि अधिकांश समाधान 0 से कम संख्या के लिए काम नहीं करते हैं।

  public int GetFirstDigit(int number)
    {
        number = Math.Abs(number); <- makes sure you really get the digit!

        if (number < 10)
        {
            return number;
        }
        return GetFirstDigit((number - (number % 10)) / 10);
    }

Question 16

इस कोड को प्राप्त करने के लिए नीचे दिए गए सभी उदाहरणों का उपयोग करना:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace Benfords
{
    class Program
    {
        static int FirstDigit1(int value)
        {
            return Convert.ToInt32(value.ToString().Substring(0, 1));
        }

        static int FirstDigit2(int value)
        {
            while (value >= 10) value /= 10;
            return value;
        }


        static int FirstDigit3(int value)
        {
            return (int)(value.ToString()[0]) - 48;
        }

        static int FirstDigit4(int value)
        {
            return (int)(value / Math.Pow(10, (int)Math.Floor(Math.Log10(value))));
        }

        static int FirstDigit5(int value)
        {
            if (value < 10) return value;
            if (value < 100) return value / 10;
            if (value < 1000) return value / 100;
            if (value < 10000) return value / 1000;
            if (value < 100000) return value / 10000;
            if (value < 1000000) return value / 100000;
            if (value < 10000000) return value / 1000000;
            if (value < 100000000) return value / 10000000;
            if (value < 1000000000) return value / 100000000;
            return value / 1000000000;
        }

        static int FirstDigit6(int value)
        {
            if (value >= 100000000) value /= 100000000;
            if (value >= 10000) value /= 10000;
            if (value >= 100) value /= 100;
            if (value >= 10) value /= 10;
            return value;
        }

        const int mcTests = 1000000;

        static void Main(string[] args)
        {
            Stopwatch lswWatch = new Stopwatch();
            Random lrRandom = new Random();

            int liCounter;

            lswWatch.Start();
            for (liCounter = 0; liCounter < mcTests; liCounter++)
                FirstDigit1(lrRandom.Next());
            lswWatch.Stop();
            Console.WriteLine("Test {0} = {1} ticks", 1, lswWatch.ElapsedTicks);

            lswWatch.Reset();
            lswWatch.Start();
            for (liCounter = 0; liCounter < mcTests; liCounter++)
                FirstDigit2(lrRandom.Next());
            lswWatch.Stop();
            Console.WriteLine("Test {0} = {1} ticks", 2, lswWatch.ElapsedTicks);

            lswWatch.Reset();
            lswWatch.Start();
            for (liCounter = 0; liCounter < mcTests; liCounter++)
                FirstDigit3(lrRandom.Next());
            lswWatch.Stop();
            Console.WriteLine("Test {0} = {1} ticks", 3, lswWatch.ElapsedTicks);

            lswWatch.Reset();
            lswWatch.Start();
            for (liCounter = 0; liCounter < mcTests; liCounter++)
                FirstDigit4(lrRandom.Next());
            lswWatch.Stop();
            Console.WriteLine("Test {0} = {1} ticks", 4, lswWatch.ElapsedTicks);

            lswWatch.Reset();
            lswWatch.Start();
            for (liCounter = 0; liCounter < mcTests; liCounter++)
                FirstDigit5(lrRandom.Next());
            lswWatch.Stop();
            Console.WriteLine("Test {0} = {1} ticks", 5, lswWatch.ElapsedTicks);

            lswWatch.Reset();
            lswWatch.Start();
            for (liCounter = 0; liCounter < mcTests; liCounter++)
                FirstDigit6(lrRandom.Next());
            lswWatch.Stop();
            Console.WriteLine("Test {0} = {1} ticks", 6, lswWatch.ElapsedTicks);

            Console.ReadLine();
        }
    }
}

मुझे ये परिणाम एक एएमडी एहटलॉन 64 एक्स 2 डुअल कोर 4200+ (2.2 गीगाहर्ट्ज) पर मिले:

Test 1 = 2352048 ticks
Test 2 = 614550 ticks
Test 3 = 1354784 ticks
Test 4 = 844519 ticks
Test 5 = 150021 ticks
Test 6 = 192303 ticks

लेकिन एएमडी एफएक्स 8350 आठ कोर (4.00 गीगाहर्ट्ज) पर इन्हें प्राप्त करें

Test 1 = 3917354 ticks
Test 2 = 811727 ticks
Test 3 = 2187388 ticks
Test 4 = 1790292 ticks
Test 5 = 241150 ticks
Test 6 = 227738 ticks

इसलिए विधि 5 या 6 तेज है या नहीं, यह सीपीयू पर निर्भर करता है, मैं केवल इस बात पर ध्यान दे सकता हूं क्योंकि सीपीयू के कमांड प्रोसेसर में शाखा की भविष्यवाणी नए प्रोसेसर पर अधिक स्मार्ट है, लेकिन मुझे वास्तव में यकीन नहीं है।

मेरे पास कोई इंटेल सीपीयू नहीं है, शायद कोई हमारे लिए यह परीक्षण कर सकता है?

Question 17

इसे भी जांचें:

int get1digit(Int64 myVal)
{
    string q12 = myVal.ToString()[0].ToString();
    int i = int.Parse(q12);
    return i;
}

यदि आप कई नंबर चाहते हैं तो भी अच्छा है:

int get3digit(Int64 myVal) //Int64 or whatever numerical data you have
{
    char mg1 = myVal.ToString()[0];
    char mg2 = myVal.ToString()[1];
    char mg3 = myVal.ToString()[2];
    char[] chars = { mg1, mg2, mg3 };
    string q12= new string(chars);
    int i = int.Parse(q12);
    return i;
}

Question 18

while (i > 10)
{
   i = (Int32)Math.Floor((Decimal)i / 10);
}
// i is now the first int

Question 19

गैर पुनरावृत्त सूत्र:

public static int GetHighestDigit(int num)
{
    if (num <= 0)
       return 0; 

    return (int)((double)num / Math.Pow(10f, Math.Floor(Math.Log10(num))));
}

Question 20

बस आपको एक विकल्प देने के लिए, आप बार-बार पूर्णांक को 10 से विभाजित कर सकते हैं, और शून्य पर पहुंचने के बाद एक मान को रोलबैक कर सकते हैं। चूंकि स्ट्रिंग ऑपरेशन आम तौर पर धीमा होते हैं, यह स्ट्रिंग हेरफेर की तुलना में तेज हो सकता है, लेकिन किसी भी तरह से सुरुचिपूर्ण नहीं है।

कुछ इस तरह:

while(curr>=10)
     curr /= 10;

Question 21

start = getFirstDigit(start);   
public int getFirstDigit(final int start){
    int number = Math.abs(start);
    while(number > 10){
        number /= 10;
    }
    return number;
}

या

public int getFirstDigit(final int start){
  return getFirstDigit(Math.abs(start), true);
}
private int getFirstDigit(final int start, final boolean recurse){
  if(start < 10){
    return start;
  }
  return getFirstDigit(start / 10, recurse);
}

Question 22

int start = curr;
while (start >= 10)
  start /= 10;

यह एक ToString () दृष्टिकोण से अधिक कुशल है जो आंतरिक रूप से एक समान लूप को लागू करना चाहिए और रास्ते में एक स्ट्रिंग ऑब्जेक्ट (और पार्स) का निर्माण करना होगा ...

Question 23

अंतिम अंक प्राप्त करने की बहुत आसान विधि:

int myInt = 1821;

int lastDigit = myInt - ((myInt/10)*10); // 1821 - 1820 = 1

Question 24

यह वही है जो मैं आमतौर पर करता हूं, कृपया नीचे मेरे फ़ंक्शन को देखें:

यह फ़ंक्शन आपके द्वारा उपयोग किए जा सकने वाले किसी भी स्ट्रिंग से पहली संख्या में सुधार को संशोधित कर सकता है और इस फ़ंक्शन का उपयोग कर सकता है

   public static int GetFirstNumber(this string strInsput)
    {
        int number = 0;
        string strNumber = "";
        bool bIsContNo = true;
        bool bNoOccued = false;

        try
        {
            var arry = strInsput.ToCharArray(0, strInsput.Length - 1);

            foreach (char item in arry)
            {
                if (char.IsNumber(item))
                {
                    strNumber = strNumber + item.ToString();

                    bIsContNo = true;

                    bNoOccued = true;
                }
                else
                {
                    bIsContNo = false;
                }

                if (bNoOccued && !bIsContNo)
                {
                    break;
                }


            }

            number = Convert.ToInt32(strNumber);

        }
        catch (Exception ex)
        {

            return 0;
        }

        return number;

    }

Question 25

यहां एक सरल तरीका है जिसमें लूपिंग शामिल नहीं है

int number = 1234
int firstDigit = Math.Floor(number/(Math.Pow(10, number.ToString().length - 1))

यह हमें १२३४ / गणित.पॉ। (१०, ४ - १) = १२३४ / १००० = १ देगा

Question 26

int i = 4567789;
int digit1 = int.Parse(i.ToString()[0].ToString());