Cómo voltear aleatoriamente un bit binario de char en C/C++

En primer lugar, averigüe qué carácter representa el bit:

param es tu bit para voltear...

char *byteToWrite = &A[sizeof(A) - (param / 8) - 1];

Eso le dará un puntero al carácter en ese desplazamiento de matriz (-1 para 0 desplazamiento de matriz frente al tamaño)

Luego obtenga el módulo (o más cambios de bit si se siente aventurero) para averiguar qué bit cambiar aquí:

*byteToWrite ^= (1u << param % 8);

Entonces eso debería dar como resultado un parámetro de 5 para el byte en A[10] para tener su 5to bit alternado.

1. almacenar los valores de 2^n en una matriz
2. generar una semilla de número aleatorio
3. recorre x veces (en este caso 5) y ve data ^= valores_almacenados[número_aleatorio]

Alternativamente a almacenar los valores 2^n en una matriz, podría cambiar un poco a una potencia aleatoria de 2 como:

data ^= (1<<random%7)

Reflejando el primer comentario, realmente podría escribir esa línea 5 veces en su función y evitar por completo la sobrecarga de un bucle for.

Tienes un número de 32 bits. Puede tratar los bits como partes del número y simplemente modificar este número con algún número aleatorio de 5 bits.

int count_1s(int )
{
  int m = 0x55555555;
  int r = (foo&m) + ((foo>>>1)&m);
  m = 0x33333333;
  r = (r&m) + ((r>>>2)&m);
  m = 0x0F0F0F0F;
  r = (r&m) + ((r>>>4)&m);
  m = 0x00FF00FF;
  r = (r&m) + ((r>>>8)&m);
  m = 0x0000FFFF;
  return r = (r&m) + ((r>>>16)&m);
}

void main()
{
   char input[] = "0A F5 6D 02";
   char data[4] = {};
   scanf("%2x %2x %2x %2x", &data[0], &data[1], &data[2], &data[3]);
   int *x = reinterpret_cast<int*>(data);
   int y = rand();
   while(count_1s(y) != 5)
   {
      y = rand(); // let's have this more random
   }
   *x ^= y;
   printf("%2x %2x %2x %2x" data[0], data[1], data[2], data[3]);
   return 0;
}

No veo ninguna razón para convertir toda la cadena de ida y vuelta desde y hacia la notación hexadecimal. Simplemente elija un carácter aleatorio de la cadena hexadecimal, conviértalo en un dígito, cámbielo un poco, vuelva a convertirlo en carácter hexadecimal.

En llano C:

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>

int main (void)
{
    char *hexToDec_lookup = "0123456789ABCDEF";
    char hexstr[] = "0A F5 6D 02";

    /* 0. make sure we're fairly random */
    srand(time(0));

    /* 1. loop 5 times .. */
    int i;

    for (i=0; i<5; i++)
    {
        /* 2. pick a random hex digit
              we know it's one out of 8, grouped per 2 */
        int hexdigit = rand() & 7;
        hexdigit += (hexdigit>>1);

        /* 3. convert the digit to binary */
        int hexvalue = hexstr[hexdigit] > '9' ? hexstr[hexdigit] - 'A'+10 : hexstr[hexdigit]-'0';

        /* 4. flip a random bit */
        hexvalue ^= 1 << (rand() & 3);

        /* 5. write it back into position */
        hexstr[hexdigit] = hexToDec_lookup[hexvalue];

        printf ("[%s]\n", hexstr);
    }

    return 0;
}

^{It podría incluso sería posible omitir los pasos de conversión a y desde ASCII: cambie un poco la cadena de caracteres, verifique si todavía es un dígito hexadecimal válido y, si es necesario, ajústelo.}

1. Primero, elija al azar x posiciones (cada posición consiste en el índice de matriz y la posición del bit).

2. Ahora si quieres voltear i^th bit desde la derecha para un número n. Encuentre el resto de n by 2ⁿ como :

código:

int divisor = (2,i);
int remainder = n % divisor;
int quotient = n / divisor;
remainder = (remainder == 0) ? 1 : 0; // flip the remainder or the i th bit from right. 

n = divisor * quotient + remainder;

1. Tome mod 8 de entrada (5% 8)

2. cambio 0x80 a la derecha por valor de entrada (por ejemplo, 5)

3. XOR este valor con (entrada/8) elemento de su matriz de caracteres.

código:

void flip_bit(int bit)
{
    Array[bit/8]  ^= (0x80>>(bit%8));
}