numbers हरण बिट-वार ऑपरेशंस के साथ पूर्णांक के एनएफ़ अंक कैसे प्राप्त करें?




सम संख्या परिभाषा (9)

उदाहरण। 123456, और हम दाईं ओर से तीसरा ('4') चाहते हैं।

प्रथा में विचार प्रत्येक अंक को अलग से एक्सेस करना है (यानी 6 5 4 3 2 1)।

सी / सी ++ / सी # पसंदीदा


एक और अधिक कुशल कार्यान्वयन कुछ ऐसा हो सकता है:

char nthdigit(int x, int n)
{
    while (n--) {
        x /= 10;
    }
    return (x % 10) + '0';
}

यह सभी अंकों को स्ट्रिंग फ़ॉर्मेट में परिवर्तित करने का प्रयास बचाता है यदि आप केवल उनमें से एक चाहते हैं। और, आपको परिवर्तित स्ट्रिंग के लिए स्थान आवंटित करने की आवश्यकता नहीं है।

अगर गति एक चिंता का विषय है, तो आप 10 की शक्तियों की सरणी को सटीक बना सकते हैं और इस सरणी में इंडेक्स में n का उपयोग कर सकते हैं:

char nthdigit(int x, int n)
{
    static int powersof10[] = {1, 10, 100, 1000, ...};
    return ((x / powersof10[n]) % 10) + '0';
}

जैसा कि अन्य लोगों द्वारा उल्लिखित है, यह उतना करीब है जितना आप आधार 10 के लिए बिटवायर कार्रवाई के लिए जा रहे हैं।


सी में आप निम्न की तरह कुछ कर सकते हैं, जहां n = 0 सहीतम अंक इंगित करेगा

char nthDigitFromRight(int x,int n)
{
    char str[20];
    sprintf(str,"%020d",x);
    return(str[19 - x]);
}

यदि आप सही संख्या के लिए n = 1 चाहते हैं तो [19-x] से [20-x] को बदलें


बेस -10 गणित का उपयोग करें:

class Program
{
    static void Main(string[] args)
    {
        int x = 123456;

        for (int i = 1; i <= 6; i++)
        {
            Console.WriteLine(GetDigit(x, i));
        }
    }

    static int GetDigit(int number, int digit)
    {
        return (number / (int)Math.Pow(10, digit - 1)) % 10;
    }
}

पैदा करता है:

6
5
4
3
2
1

int returndigit(int n,int d)
{
    d=d-1;
    while(d--)
    {
        n/=10;
    }
    return (n%10);
}

निम्नलिखित कोड एक नंबर में सही से 9वी अंक देगा:

public void getDigit(long n,int k){
    int i=0;
    long r =0;
    while(i<n){
        r=n%10;
        n=n/10;
        i++;
    }
    System.out.println( k + "th digit from right " + r);
 }

मस्ती के लिए, यहां सी # विस्तार वर्ग है:

public static class IntExtensions
{
    /// <summary>
    /// Returns the nth digit from an int, 
    /// where 0 is the least significant digit 
    /// and n is the most significant digit.
    /// </summary>
    public static int GetDigit(this int number, int digit)
    {
        for (int i = 0; i < digit; i++)
        {
            number /= 10;
        }
        return number % 10;
    }
}

उपयोग:

int myNumber = 12345;
int five = myNumber.GetDigit(0);
int four = myNumber.GetDigit(1);
int three = myNumber.GetDigit(2);
int two = myNumber.GetDigit(3);
int one = myNumber.GetDigit(4);
int zero = myNumber.GetDigit(5);

मान = (संख्या% (10 ^ स्थिति)) / 10 ^ (स्थिति -1)

उदाहरण:

संख्या = 23846

स्थिति = 1 -> मान = 6

स्थिति = 2 -> मूल्य = 4

स्थिति = 3 -> मूल्य = 8

ऐसा करने के लिए यहां एक साधारण उद्देश्य-सी उपयोगिता विधि है:

+ (int)digitAtPosition:(int)pos of:(int)number {

    return (number % ((int)pow(10, pos))) / (int)pow(10, pos - 1);
}

इसका कारण यह कि बिट-वार ऑपरेशंस के साथ (आसानी से) काम नहीं करेगा, यह है कि दशमलव प्रणाली का आधार (10) बाइनरी सिस्टम (2) के आधार की शक्ति नहीं है

यदि आप बेस 8 में कोडिंग कर रहे थे, तो आपके पास pow(2, 3) == 8 और तीन बिट्स के ब्लॉक के रूप में प्रत्येक अष्टक अंक को निकाल सकते हैं।

इसलिए आपको वास्तव में आधार 10 में कनवर्ट करना होगा, जो आमतौर पर स्ट्रिंग में बदलकर (स्ट्रिंग (जावा) या स्प्रिंटफ़ (सी) के रूप में परिवर्तित किया जाता है, जैसा कि दूसरों ने अपने उत्तरों में दिखाया है)।


आप थोड़ा-सा बदलाव-बाएं (N-1) के लिए कोशिश कर सकते हैं और फिर [0] पर अंकों को पढ़ सकते हैं, क्योंकि यह एक कोडर दृष्टिकोण हो सकता है

123456 -> 456 -> पहला अंक पढ़ें