numbers - हरण - सम संख्या परिभाषा




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

451069 तक अहस्ताक्षरित इनट्स के लिए यह काम करता है, जैसा कि यहां समझाया गया है :

def hundreds_digit(u): return mod10(div100(u))

def div100(u): return div10(div10(u))
def mod10(u):  return u - mul10(div10(u))
def mul10(u):  return ((u << 2) + u) << 1

def div10(u):
    Q = ((u >> 1) + u) >> 1  # Q = u*0.11
    Q = ((Q >> 4) + Q)       # Q = u*0.110011
    Q = ((Q >> 8) + Q) >> 3  # Q = u*0.00011001100110011
    return Q

# Alternatively:
#   def div100(u): return (u * 0xa3d7) >> 22
# though that'd only work for 16-bit u values.
# Or you could construct shifts and adds along the lines of div10(),
# but I didn't go to the trouble.

इसे जांचना:

>>> hundreds_digit(123456)
4
>>> hundreds_digit(123956)
9

मुझे आश्चर्य होगा अगर यह तेज है, हालांकि। शायद आपको अपनी समस्या पर पुनर्विचार करना चाहिए।

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

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

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


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

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


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

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 के लिए बिटवायर कार्रवाई के लिए जा रहे हैं।


बेस -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

बस समय व्यतीत करते हुए उत्तर के आधार पर यहां लिखे, इसलिए मैंने सोचा कि मैं हिस्सा लेगा।

यह ब्रैनन के उत्तर पर आधारित है, लेकिन आपको एक समय में एक से अधिक अंक प्राप्त करने देता है। मेरे मामले में मैं इसका उपयोग उस आशय में सहेजा गया दिनांक और समय से भागों को निकालने के लिए करता हूं जहां अंक yyyymmddhhnnssm_s प्रारूप में होते हैं।

public static int GetDigits(this int number, int highestDigit, int numDigits)
{
    return (number / (int)Math.Pow(10, highestDigit - numDigits)) % (int)Math.Pow(10, numDigits);
}

मैंने इसे एक एक्सटेंशन बना दिया है, हो सकता है कि आप ऐसा न करें, लेकिन यहां नमूना उपयोग किया गया है:

int i = 20010607;
string year = i.GetDigits(8,4).ToString();
string month = i.GetDigits(4,2).ToString();
string day = i.GetDigits(2,2).ToString();

परिणाम:

वर्ष = 2001

महीने = 6

दिन = 7


मान = (संख्या% (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);
}

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

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);

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