Escriba un programa / función que tome dos enteros en el rango de $0$ a $255$ inclusive, y devuelva si las formas binarias de los números son exactamente un bit diferentes.

Por ejemplo, $1$ y $0$ tienen formas binarias 00000001y 00000000, que están un poco separadas. Del mismo modo, $152$ y $24$ son 010011000y 000011000, por lo que devuelven verdadero.

Sin embargo , su código debe ser impecable , de modo que si se voltea un bit de su programa, debería arrojar un error. Por ejemplo, si su programa era el byte únicoa(01100001), entonces los 8 programas modificados posibles:

á ! A q i e c `

Debe arrojar un error. Asegúrese de que está modificando por bytes (p. Ej. á, Allí arriba está representando el byte $225$ , no el carácter real de dos bytes á).

Casos de prueba:

0,1     => Truthy
1,0     => Truthy
152,24  => Truthy
10,10   => Falsey
10,11   => Truthy
11,12   => Falsey
255,0   => Falsey

Reglas:

• Proporcione un marco de prueba que pueda verificar que su programa esté correctamente prístino, ya que habrá muchos programas posibles (número de bytes * 8), o una prueba completa de impecabilidad.
  • Por favor asegúrese de que su programa es válido antes de publicarlo.
• La salida debe ser verdadero / falso (de cualquier manera está bien), o bien dos valores distintos sin error
• Los errores pueden ser tiempo de ejecución, compilador, intérprete, etc.

Python 2 , 35 bytes

lambda a,b:(a^b)&-(a^b)in[a^b or[]]

Pruébalo en línea!

Utiliza la verificación de potencia de dos n&-n==n, eliminando el n==0falso positivo.

Como referencia, estos son los pares de operadores binarios one-char que están separados un poco, lo que los hace difíciles de usar:

+ /
- /
* +
% -
< |
< >

Afortunadamente, &y ^no están entre estos.

También tenga en cuenta que ==puede convertirse <=, y +puede convertirse en el personaje de comentario #.

Python 2 , 41 bytes

lambda a,b:bin(a^b).count(`+True`)is+True

Pruébalo en línea!

Tomando TFeld's lambda a,b:bin(a^b).count('1')==1 y haciéndolo prístino cambiando los 1's a +Truey ==para is. Gracias a Jo King por 1 byte.

Python 2 , 72 67 50 bytes

lambda a,b:sum(map(int,'{:b}'.format(a^b)))is+True

Pruébalo en línea!

_{-5 bytes, gracias a Jo King}

Devoluciones True/False para veracidad / falsey.

El programa es básicamente el mismo que lambda a,b:bin(a^b).count('1')==1 , pero sin números y otros caracteres que funcionan cuando se invierte el bit.

Funciona asegurándose de que casi todo sea una función con nombre (que son bastante inmaculadas)

La prueba prístina al final voltea un solo bit (para cada bit) y prueba la función en una entrada. Si eso funciona (correcto o no), se imprime esa variación. Sin programas impresos = función prístina.

Java 8, 68 61 56 45 bytes

a->b->(a.bitCount(a^b)+"").equals(-~(a^a)+"")

-11 bytes gracias a @EmbodimentOfIgnorance , reemplazando constante java.awt.Font.BOLD con -~(a^a).

Pruébalo en línea.

Explicación:

La función base más corta sería:

a->b->a.bitCount(a^b)==1

Pruébalo en línea.

Esto se modifica para que no haya un dígito, =ni uno de los +/*operandos en él para cálculos numéricos (entonces el+ concatenación de cadenas está bien):

Los +""y .equalsson para comparar en String.equals(String)lugar de int==int.
NOTA: Integer.equals(int)se podría utilizar aquí, pero sería más bytes, ya que tanto el .bitCounty java.awt.Font.BOLDson primitivos inten lugar de Integer-Objetos, por lo que un adicional new Integer(...)sería necesaria para transformar uno de los dos para un Integer-objeto, antes de poder utilizar el .equals.

C (gcc) , 56 bytes

d(a,b){return(sizeof((char)d))^__builtin_popcount(a^b);}

Pruébalo en línea!

Devuelve 0si el par difiere en 1, de lo contrario no es cero. Ligeramente inusual para C, a menos que considere volver EXIT_SUCCESSsi el par difiere en 1, cualquier otro valor de lo contrario.

Se utiliza sizeof((char)d))para producir la constante 1de una manera prístina y al mismo tiempo obliga al nombre de la función a ser impecable.

Luego XORs 1 con el popcount de XOR de los argumentos. Afortunadamente, el ^símbolo es fácil de mantener prístino, al igual que el identificador muy largo __builtin_popcount.

Mientras tanto, aquí está el script utilizado para probar la solución:

#!/bin/bash

SOURCE_FILE=$1
FOOT_FILE=$2
TMP_SRC=temp.c

LENGTH="$(wc -c <"$SOURCE_FILE")"
BITS=$((LENGTH*8))

cat "$SOURCE_FILE" >"$TMP_SRC"
cat "$FOOT_FILE" >>"$TMP_SRC"
if gcc -w $TMP_SRC -o t.out >/dev/null 2>&1; then
    if ./t.out; then
        echo "Candidate solution..."
    else
        echo "Doesn't even work normally..."
        exit
    fi
else
    echo "Doesn't even compile..."
    exit
fi

for i in $(seq 1 $BITS); do
    ./flipbit "$i" <"$SOURCE_FILE" >"$TMP_SRC"
    cat "$FOOT_FILE" >>"$TMP_SRC"
    if gcc -w $TMP_SRC -o t.out >/dev/null 2>&1; then
        echo "Testing flipped bit $i:"
        cat "$TMP_SRC"

        ./t.out >/dev/null 2>&1
        STATUS=$?
        if [ "$STATUS" -eq 0 ]; then
            echo "It works!"
            exit
        elif [ "$STATUS" -eq 1 ]; then
            echo "It doesn't work..."
            exit
        else
            echo "It crashes"
        fi
    fi
done

Que usa la ./flipbitherramienta que escribí cuya fuente es simplemente:

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

int main(int argc, char *argv[]) {
    int bittoflip = atoi(argv[1]) - 1;
    int ch;

    while ((ch = fgetc(stdin)) != EOF) {
        if (bittoflip < 8 && bittoflip >= 0) {
            putchar(ch ^ (1 << bittoflip));
        } else {
            putchar(ch);
        }

        bittoflip -= 8;
    }

    return 0;
}

Las partes difíciles fueron:

• Espacio en blanco: todos los espacios en blanco (incluidas las nuevas líneas) tienen gemelos prístinos que funcionarán de manera similar
• Comparación: =no funciona bien, ya que puede ser una comparación en todos los casos que pueda aparecer. Del mismo modo -no funciona bien. Así^ lo se utiliza para afirmar la igualdad con 1.
• Nombres de variables: f entraría en conflicto con b, por lo que tuvo que usar d como el nombre de la función.

R , 38 37 bytes

-1 byte gracias a Nick Kennedy.

dpois(log2(bitwXor(scan(),scan())),T)

Pruébalo en línea! (Gracias a Giuseppe por configurar el TIO correctamente).

Prueba de que es impecable (usando el corrector de Nick Kennedy ).

Salidas 0 para falsey, y un valor positivo para la verdad, que entiendo es aceptable ya que R interpretará esto como Falso y Verdadero.

Explicación: bitwXor(a,b)da (como un entero) el XOR bit a bit entre ay b. Para verificar si es una potencia de 2, verifique si su registro en la base 2 es un entero. La función dpoisproporciona la función de densidad de probabilidad de la distribución de Poisson: su valor es 0 para valores no enteros y algo positivo para enteros no negativos. El Testá allí porque dpoisrequiere un segundo argumento (cualquier trabajo real positivo, yT se interpreta como 1).

Si insistimos en generar valores distintos, la siguiente versión genera FALSO o VERDADERO en 42 bytes (gracias a Giuseppe por -8 bytes):

dpois(log2(bitwXor(scan(),scan())),T)%in%F

y también es prístina . Pruébalo en línea!

R , 83 bytes

t(identical(sum(.<-as.double(intToBits(Reduce(bitwXor,scan())))),sum(T^el(.[-T]))))

Pruébalo en línea!

Prueba de que esto es prístino

Eludir el hecho de que as.integer, as.doubleetc. , están solo un poco lejos is.integer, is.doubleetc. fue lo más difícil. Al final, usar sum(T^el(.[-T])como una forma de generar uno y verificar que as.doubleha devuelto un vector de longitud> 1 fue lo mejor que pude hacer. La envoltura tes manejar el hecho de que de lo contrario identicalpuede convertirse ide~tical.

Julia 0.7 , 20 bytes

(a,b)->ispow2(a⊻b)

Pruébalo en línea!

Aquí hay un validador prístino que intenta ejecutar cada función anónima modificada contra alguna entrada, y ninguna de las dos pasa con éxito. Tenga en cuenta que el código tiene un carácter unicode de varios bytes, y algunas posibles salidas del cambio de bits ni siquiera están incluidas, ya que producen cadenas UTF-8 no válidas.

C # (compilador interactivo de Visual C #) , 37 bytes

a=>b=>a!=b&((a^b)&-(a^b)).Equals(a^b)

La a=>b=>parte no se puede cambiar o la función no es válida.

En a!=b, =no se puede cambiar ya intque no se puede convertir a bool.

Pruébalo en línea!

C # (Visual C # interactivo Compilador) , 128 101 77 70 61 74 bytes

-27 bytes gracias a Ascii-Only

a=>b=>{var d=Math.Log(a^b,(int)Math.E);return d.Equals((int)Math.Abs(d));}

Pruébalo en línea!

Tienes que ser bastante creativo para obtener números en C # sin usar literales. Solo usa el operador ^. Las variables a, b están a más de 1 bit de distancia entre sí y todo lo demás es una palabra clave / nombre.

JavaScript (ES6 en modo estricto), 61 bytes

(y,z,e)=>eval(`(y${(e='^=z)*!(y&~-y)')!='^=z)*!(y&~-y)'||e}`)

Pruébalo en línea! o asegúrese de que todos los programas modificados sean incorrectos

Maravilloso , 47 36 bytes

a,b->a.bitCount(a^b).equals(-~(a^a))

Pruébalo en línea!

Versión adaptada de Kevin Cruijssen la respuesta Java .

MATLAB, 37 bytes

@(c,e)eq(nnz(de2bi(bitxor(c,e))),eye)

Lo sentimos, no hay enlace TIO, porque no puedo hacer que el conjunto de pruebas funcione bajo Octave. Gracias @ExpiredData por algunos comentarios útiles.

Banco de pruebas:

program = '@(c,e)eq(nnz(de2bi(bitxor(c,e))),eye)';
number_of_characters = nnz(program);
success = [];
for character_counter = 0 : number_of_characters
    for bit_no = 1:8
        prog_temp = program;
        if(character_counter > 0)
            prog_temp(character_counter) = bitxor(double(prog_temp(character_counter)),2^(bit_no-1));
        elseif(bit_no<8) % Test the unmodified program once
            continue
        end
        try
            eval(prog_temp);
            eval('ans(2,3)');
            disp(prog_temp)
            success(end+1)=1;   
        catch
            success(end+1)=0;
        end 
    end
end
assert(nnz(success)==1)

Perl 6 , 77 43 bytes

Gracias a Jo King por -33 bytes.

{elems(i)eq(sum [+^](@_).polymod(+@_ xx*))}

Esto es equivalente a

{1 eq(sum [+^](@_).polymod(2 xx*))}

1 fue reescrito como elems([""]) . 2fue reescrito como sum(elems([""]),elems([""])); elems(["",""])puede parecer que funciona peroelems([""-""]) también es válido y parece colgar el probador.

Pruébalo en línea!

JavaScript (Node.js) , 20 bytes

b=>d=>[i=d^b][i--&i]

Pruébalo en línea!

validador por Arnauld, modificado (no uso estricto)