studio - superponer graficas en r

La impresión binaria no funciona en C

Question

Estoy tratando de imprimir binarios usando máscara de bit de 32 bits en c, pero la representación binaria no se está imprimiendo en la sentencia if.

unsigned int bit_mask = 2147483648;
int decimal = 2;
printf("/nBinary representation of 2: /n");
while(bit_mask > 0){
    if((decimal & bit_mask) == 0)
        printf("0");
    else
        printf("1");
    bit_mask = bit_mask >> 1;
}

decimal = 255;
printf("/n/nBinary representation of 255: /n");
while(bit_mask > 0){
    if((decimal & bit_mask) == 0)
        printf("0");
    else
        printf("1");
    bit_mask = bit_mask >> 1;
}

decimal = 32;
printf("/n/nBinary representation of 32: /n");
while(bit_mask > 0){
    if((decimal & bit_mask) == 0)
        printf("0");
    else
        printf("1");
    bit_mask = bit_mask >> 1;
}

decimal = -1;
printf("/n/nBinary representation of -1: /n");
while(bit_mask > 0){
    if((decimal & bit_mask) == 0)
        printf("0");
    else
        printf("1");
    bit_mask = bit_mask >> 1;
}

decimal = -255;
printf("/n/nBinary representation of -255: /n");
while(bit_mask > 0){
    if((decimal & bit_mask) == 0)
        printf("0");
    else
        printf("1");
    bit_mask = bit_mask >> 1;
}

int random_number =  (rand() % INT_MAX) + (rand() % INT_MIN);
printf("/n/nBinary representation of %d: /n", random_number);
while(bit_mask > 0){
    if((random_number & bit_mask) == 0)
        printf("0");
    else
        printf("1");
    bit_mask = bit_mask >> 1;
}

PD: el programa ahora solo funciona para 2 pero aún no imprime los otros valores (255, 32, -1, -255)

Answer 1

Si se realizan las correcciones sugeridas por BLUEPIXY y por mí, el código generará la respuesta con los bits en la secuencia correcta.

#include <stdio.h>

int main(void)
{
    for (unsigned value = 2; value < 1024; value = value * 3 + 1)
    {
        unsigned bit_mask = 0x80000000;  // 2147483648

        printf("Binary representation of %3u: ", value);
        while (bit_mask > 0)
        {
            if ((value & bit_mask) == 0)
                printf("0");
            else
                printf("1");
            bit_mask >>= 1;
        }
        putchar(''/n'');
    }
    return 0;
}

Salida:

Binary representation of   2: 00000000000000000000000000000010
Binary representation of   7: 00000000000000000000000000000111
Binary representation of  22: 00000000000000000000000000010110
Binary representation of  67: 00000000000000000000000001000011
Binary representation of 202: 00000000000000000000000011001010
Binary representation of 607: 00000000000000000000001001011111

La salida no se invierte, a pesar de lo que dice BLUEPIXY en los comentarios .

El cuerpo del bucle podría convertirse en una función como void print_binary(unsigned value) con un esfuerzo mínimo, y que luego se llamaría desde un bucle. La pregunta editada con más o menos el mismo bucle escrito seis (!) Veces es una parodia: no escriba un código como ese. Cuando copie un código de esa manera, hay una función esperando a ser escrita.

#include <stdio.h>

void print_binary(unsigned value)
{
    unsigned bit_mask = 0x80000000;  // 2147483648

    while (bit_mask > 0)
    {
        if ((value & bit_mask) == 0)
            printf("0");
        else
            printf("1");
        bit_mask >>= 1;
    }
}

Esta función se puede utilizar para imprimir la representación binaria de un unsigned int sin unsigned int sin agregar ninguna decoración. Se puede usar razonablemente en general. En este contexto específico, puede escribir una función de contenedor para manejar el otro formato:

void fmt_binary(int value)
{
    printf("Binary representation of %3d: ", value);
    print_binary((unsigned)value);
    putchar(''/n'');
}

El lanzamiento no es necesario siempre que tengas un prototipo para print_binary() en el alcance. A partir de C99, debe tener presente una declaración de función, pero eso no tiene por qué ser un prototipo. Sin embargo, compilar sin prototipos presentes es una tontería. Y debería encontrar las opciones que aseguren que su compilador se queja si intenta escatimar. Para GCC, puede usar:

gcc -std=c11 -O3 -g -Wall -Wextra -Werror -Wmissing-prototypes -Wstrict-prototypes …

Puede o no agregar -Wold-style-declaration o -Wold-style-definition dependiendo de la base de código con la que está tratando y la versión de GCC que está usando (y de cuán descuidado está al escribir el código). Hay otras opciones que consideraría, como -Wshadow , pero si su código se compila limpiamente con lo que se muestra, es poco probable que se encuentre con muchos problemas que no son de lógica.

Con fmt_binary() definido, puede escribir main() :

#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// … declarations or definitions of fmt_binary and print_binary

int main(void)
{
    for (int value = 2; value < 1024; value = value * 3 + 1)
        fmt_binary(value);
    fmt_binary(2);
    fmt_binary(255);
    fmt_binary(32);
    fmt_binary(-1);
    fmt_binary(-255);
    srand(time(0));     // Better than no call to srand()
    int random_number =  (rand() % INT_MAX) + (rand() % INT_MIN);
    fmt_binary(random_number);
    return 0;
}

El resultado del ejemplo podría ser:

Binary representation of   2: 00000000000000000000000000000010
Binary representation of   7: 00000000000000000000000000000111
Binary representation of  22: 00000000000000000000000000010110
Binary representation of  67: 00000000000000000000000001000011
Binary representation of 202: 00000000000000000000000011001010
Binary representation of 607: 00000000000000000000001001011111
Binary representation of   2: 00000000000000000000000000000010
Binary representation of 255: 00000000000000000000000011111111
Binary representation of  32: 00000000000000000000000000100000
Binary representation of  -1: 11111111111111111111111111111111
Binary representation of -255: 11111111111111111111111100000001
Binary representation of -1758826555: 10010111001010100110111111000101