int i = 20;
string output = Convert.ToString(i, 2); //Base2 formatting
i = -20;
output = Convert.ToString(i, 2);
Valor Esperado Real 
20 00000000000000000000000000010100 10100 
-20 10000000000000000000000000010100 11111111111111111111111111101100 

Puedo ver que quizás la salida binaria de 20 ha sido truncado, pero no entiendo la salida de -20. He basado mis expectativas en base2 la notación más una creencia de que el firmado elemento de un número entero se expresa en el primer dígito de más a la izquierda. 0 para positivo y 1 negativo. Alguien puede explicar los resultados, en concreto, de -20?

OriginalEl autor FuzzyFrog | 2011-07-22

7 Comentarios

  1. 33

    Los números negativos .NETO se representa en binario como Complemento a dos.

    De MSDN – Convertir.El Método ToString (Int32, Int32):

    Si el valor es negativo y toBase es de 2, 8, o 16, la cadena devuelta utiliza el complemento a dos de la representación

    muy bonita respuesta!
    La sobrecarga de long menciona este btw. 🙂 +1
    Se parece a la int uno menciona también…

    OriginalEl autor Oded

  2. 5

    por entero
    -20 es 11111111111111111111111111101100
    El sistema es el uso de 2 de Complementar de forma predeterminada.
    1 del Elogio no es la ideal para el cálculo.

    (2 cumplido es invertir de todos los bits más uno)

    de a 2 se Complementan , lo que hará 20 + (-20) = 0, podemos calcular las matemáticas fácilmente sin preocupación positivo o negativo.

    por ejemplo, en signed char :
    15 = 00001111,
    -18 = 2 del Elogio de la (00010010) = 11101101 + 1 = 11101110

    00001111
    +11101110
    =11111101

    Desde el primer bit es 1, sabemos que es un valor negativo.
    Vamos a hacer un reverse 2 del Elogio.

    11111101 – 1 = 11111100 => -(00000011) da -3 15 + (-18) = -3

    Es Compl-e-ment, no Compl-i-ment!

    OriginalEl autor Steven Song

  3. 3
    int value = 31;
    string binary = Convert.ToString(value, 2);
    Console.WriteLine(binary.PadLeft(8, '0'));          //Outputs "00011111"
    Esto no parece responder a la pregunta. La pregunta era acerca de las representaciones binarias de enteros en C#, no la forma de la almohadilla de una cadena, o lo que sea que están tratando de demostrar aquí.
    Mientras que el mal explicado, qucooln presenta una explicación de una de las diferencias entre la real y el esperado, ya que el valor no estaba rellena con ceros. Sería más útil si él hubiera escrito esta: Console.WriteLine(Convert.ToString(20, 2).PadLeft(32, '0')); // 00000000000000000000000000010100 para mostrar la manera correcta de lograr el resultado esperado.

    OriginalEl autor qucooln

  4. 3

    Esto es básicamente la misma respuesta como todos los demás se han publicado, simplemente envasados en un método.

      ///<summary>
      ///Method to convert an integer to a string containing the number in binary. A negative 
      ///number will be formatted as a 32-character binary number in two's compliment.
      ///</summary>
      ///<param name="theNumber">self-explanatory</param>
      ///<param name="minimumDigits">if binary number contains fewer characters leading zeros are added</param>
      ///<returns>string as described above</returns>
      public static string IntegerToBinaryString(int theNumber, int minimumDigits)
      {
         return Convert.ToString(theNumber, 2).PadLeft(minimumDigits, '0');
      }

    OriginalEl autor RenniePet

  5. 0

    Esta función hace exactamente lo que usted desea

    string ConvertToFuzzyFrogBinary(int input)
    {
        int prefix = (input).ToString("d8").Length-(Math.Abs((input))).ToString("d8").Length;
        string binary_num = "00000000000000000000000000000000".Substring(0,32-Convert.ToString(Math.Abs(input),2).Length)+Convert.ToString(Math.Abs(input),2);
        return "1".Substring(0,prefix)+binary_num.Substring(prefix,32-prefix);
    }
    Bienvenido a ASÍ. ¿Te importaría ampliar su respuesta un poco para explicar cómo se resuelve el problema?

    OriginalEl autor Soraiko

  6. 0

    Si usted quiere deshacerse de este «efecto» de uso Math.Abs() método para obtener valor de número sin signo,

    string output = Convert.ToString(Math.Abs(i), 2); //Base2 

    OriginalEl autor sll

  7. 0

    Aquí es una rutina que yo escribí y que hace lo que el interrogador quería. Un mero 5 años demasiado tarde!

    ///<summary>Convert a number into a string of bits</summary>
    ///<param name="value">Value to convert</param>
    ///<param name="minBits">Minimum number of bits, usually a multiple of 4</param>
    ///<exception cref="InvalidCastException">Value must be convertible to long</exception>
    ///<exception cref="OverflowException">Value must be convertible to long</exception>
    ///<returns></returns>
    public static string ShowBits<T>(this T value, int minBits)
    {
        long x = Convert.ToInt64(value);
        string retVal = Convert.ToString(x, 2);
        if (retVal.Length > minBits) retVal = Regex.Replace(retVal, @"^1+", "1");   //Replace leading 1s with a single 1 - can pad as needed below
        if (retVal.Length < minBits) retVal = new string(x < 0 ? '1' : '0', minBits - retVal.Length) + retVal;  //Pad on left with 0/1 as appropriate
        return retVal;
    }

    OriginalEl autor Mick Bruno

Dejar respuesta

Please enter your comment!
Please enter your name here