Comment obtenir le n-ième chiffre d'un nombre entier avec bit-wise opérations?

Une application plus efficace pourrait être quelque chose comme ceci:

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

Cela permet d'économiser l'effort de convertir tous les chiffres de format de chaîne si vous voulez seulement l'un d'entre eux. Et, vous n'avez pas à allouer de l'espace pour la chaîne convertie.

Si la vitesse est un problème, vous pourriez précalculer une gamme de puissances de 10 et de l'utilisation n de l'indice dans ce tableau:

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

Comme mentionné par d'autres, ce qui est aussi proche que vous allez arriver à des opérations bit à bit pour la base 10.

Juste passé du temps à écrire ce basées sur les réponses ici, donc pensé que je voudrais partager.

Ceci est basé sur Brannon réponse, mais vous permet d'obtenir plus d'un chiffre à la fois. Dans mon cas je l'utilise pour extraire des parties de la date et l'heure enregistrées dans un int où les chiffres sont en yyyymmddhhnnssm_s format.

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

Je l'ai fait une extension, vous ne voulez pas vous, mais voici un exemple d'utilisation:

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

résultats:

année = 2001

mois = 6

jour = 7

Cela fonctionne pour les entiers non signés jusqu'à 451069, comme expliqué ici:

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.

La tester:

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

Je serais surpris si c'est plus rapide, cependant. Peut-être que vous devriez reconsidérer votre problème.

Vous pouvez essayer un bit à bit shift-gauche (pour N-1), puis lire le chiffre [0], ce qui pourrait être un assembleur approche.

123456 -> 456 -> lire le premier chiffre

Juste pour le fun, voici le C# extension de classe:

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

Utilisation:

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

à deux chiffres de la d1 et la d2 sera passé .le programme doit imprimer le n-ième Nombre est le nombre de système de composés uniquement de chiffres avec d1 et d2
format d'entrée
la première ligne contient d1
la deuxième ligne contient d2
troisième kiné contenir n
d1 n'est pas égal à d2