numbers - representarse - operadores de bits java

¿Cómo obtener el dígito N-ésimo de un entero con operaciones de bits?

Question

Ejemplo. 123456, y queremos que salga el tercero de la derecha (''4'').

La idea en la práctica es acceder a cada dígito por separado (es decir, 6 5 4 3 2 1).

C / C ++ / C # preferido.

Answer 1

En C, podría hacer algo como lo siguiente, donde n = 0 indicaría el dígito más a la derecha

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

Cambie [19-x] a [20-x] si quiere n = 1 para el dígito más a la derecha.

Answer 2

Esto funciona para entradas sin firmar de hasta 451069, como se explica aquí :

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.

Poniéndolo a prueba:

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

Me sorprendería si es más rápido, sin embargo. Tal vez deberías reconsiderar tu problema.

Answer 3

La razón por la que no funcionará (fácilmente) con operaciones de bits es que la base del sistema decimal (10) no es una potencia de la base del sistema binario (2).

Si estuvieras codificando en base 8, tendrías pow(2, 3) == 8 , y podrías extraer cada dígito octal como un bloque de tres bits.

Entonces realmente tiene que convertir a la base 10, que generalmente se hace convirtiendo a una cadena (con toString (Java) o sprintf (C), como los otros han mostrado en sus respuestas).

Answer 4

Puede intentar un desplazamiento a la izquierda de bit a bit (para N-1) y luego leer el dígito en [0], ya que esto podría ser un enfoque de ensamblador.

123456 -> 456 -> leer primer dígito

Answer 5

Una implementación más eficiente podría ser algo como esto:

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

Esto ahorra el esfuerzo de convertir todos los dígitos al formato de cadena si solo quiere uno de ellos. Y no es necesario asignar espacio para la cadena convertida.

Si la velocidad es una preocupación, puede precalcular una matriz de potencias de 10 y usar n para indexar en esta matriz:

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

Como lo mencionaron otros, esto es lo más cercano a las operaciones bit a bit para la base 10.

Answer 6

Usa matemáticas de base 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;
    }
}

Produce:

6
5
4
3
2
1

Answer 7

Acabo de pasar el tiempo escribiendo esto en base a las respuestas aquí, así que pensé que lo compartiría.

Esto se basa en la respuesta de Brannon, pero le permite obtener más de un dígito a la vez. En mi caso, lo uso para extraer partes de una fecha y hora guardadas en un int donde los dígitos están en formato aaaammddhhnnssm_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);
}

Lo hice una extensión, es posible que no desee, pero aquí está el uso de la muestra:

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

resultados:

año = 2001

mes = 6

día = 7

Answer 8

value = (number% (10 ^ position)) / 10 ^ (position - 1)

Ejemplo:

número = 23846

position = 1 -> value = 6

position = 2 -> value = 4

position = 3 -> value = 8

Aquí hay un método simple de utilidad de Objective-C para hacer esto:

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

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

Answer 9

El siguiente código dará un enésimo dígito desde la derecha de un número:

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

Answer 10

Solo por diversión, aquí está la clase de extensión C #:

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

Uso:

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

Answer 11

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