Écrivez un programme / fonction qui prend deux entiers compris entre $0$ et $255$ inclus, et retourne si les formes binaires des nombres sont exactement un bit différentes.

Par exemple, $1$ et $0$ ont des formes binaires 00000001et 00000000, qui sont séparées d'un bit. De même, $152$ et $24$ sont 010011000et 000011000, donc ils retournent vrai.

Cependant , votre code doit être vierge , de sorte que si un bit de votre programme est retourné, il devrait générer une erreur. Par exemple, si votre programme était le seul octeta(01100001), alors les 8 programmes modifiés possibles:

á ! A q i e c `

doit lancer une erreur. Assurez-vous que vous modifiez par octets (par exemple, le áhaut représente réellement l'octet $225$ , pas le caractère réel sur deux octets á).

Cas de test:

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

Règles:

• Fournissez un cadre de test qui peut vérifier que votre programme est correctement vierge, car il y aura beaucoup de programmes possibles (nombre d'octets * 8), ou bien une preuve complète de pureté.
  • Veuillez vous assurer que votre programme est valide avant de le publier.
• La sortie doit être véridique / falsey (dans tous les cas, c'est bien), ou bien deux valeurs distinctes sans erreur
• Les erreurs peuvent être l'exécution, le compilateur, l'interpréteur, etc.

Python 2 , 35 octets

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

Essayez-le en ligne!

Utilise le contrôle de puissance de deux n&-n==n, éliminant les n==0faux positifs.

Pour référence, ce sont les paires d'opérateurs binaires à un caractère qui sont séparées d'un bit, ce qui les rend difficiles à utiliser:

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

Heureusement, &et ^n'en font pas partie.

Notez également que cela ==peut devenir <=et +peut devenir le caractère de commentaire #.

Python 2 , 41 octets

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

Essayez-le en ligne!

Prendre TFeld lambda a,b:bin(a^b).count('1')==1 et le rendre vierge en changeant les 1 en +Trueet ==vers is. Merci à Jo King pour 1 octet.

Python 2 , 72 67 50 octets

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

Essayez-le en ligne!

_{-5 octets, merci à Jo King}

Renvoie True/ Falsepour pour vérité / falsey.

Le programme est fondamentalement le même que lambda a,b:bin(a^b).count('1')==1, mais sans chiffres et autres caractères qui fonctionnent lorsqu'ils sont inversés.

Fonctionne en s'assurant que presque tout est une fonction nommée (qui sont toutes assez vierges)

Le test vierge à la fin retourne un seul bit (pour chaque bit) et essaie la fonction sur une entrée. Si cela fonctionne (correct ou non), cette variation est imprimée. Aucun programme imprimé = fonction vierge.

Java 8, 68 61 56 45 octets

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

-11 octets grâce à @EmbodimentOfIgnorance , en remplaçant constant java.awt.Font.BOLD par -~(a^a).

Essayez-le en ligne.

Explication:

La fonction de base la plus courte serait:

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

Essayez-le en ligne.

Ceci est modifié afin qu'il n'y ait pas de chiffre,, =ni l'un des +/*opérandes qu'il contient pour les calculs numériques (donc la +concaténation de chaîne est correcte):

Le +""et .equalssont à comparer au String.equals(String)lieu de int==int.
REMARQUE: Integer.equals(int)pourrait être utilisé ici, mais serait plus d'octets, car les deux .bitCountet java.awt.Font.BOLDsont primitifs intau lieu de Integer-objets, donc un supplément new Integer(...)serait nécessaire pour transformer l'un des deux en un Integer-objet, avant de pouvoir utiliser le .equals.

C (gcc) , 56 octets

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

Essayez-le en ligne!

Renvoie 0si la paire diffère de 1, non nul sinon. Un peu inhabituel pour C, à moins que vous ne pensiez qu'il revienne EXIT_SUCCESSsi la paire diffère de 1, toute autre valeur sinon.

Utilise sizeof((char)d))pour produire la constante 1d'une manière vierge tout en forçant également le nom de la fonction à être vierge.

Il XORs ensuite que 1 avec le popcount du XOR des arguments. Heureusement, le ^symbole est facile à garder vierge, tout comme l'identifiant très long __builtin_popcount.

En attendant, voici le script utilisé pour tester la solution:

#!/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

Qui utilise l' ./flipbitoutil que j'ai écrit dont la source est simplement:

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

Les morceaux difficiles étaient:

• Espaces: tous les espaces (y compris les sauts de ligne) ont des jumeaux immaculés qui fonctionneront de la même manière
• Comparaison: =ne fonctionne pas bien, car elle peut être une comparaison dans tous les cas où elle peut apparaître. De même -ne fonctionne pas bien. Ainsi ^est utilisé pour affirmer l'égalité avec 1.
• Noms de variables: f se heurterait à b, donc devait utiliser d comme nom de fonction à la place.

R , 38 37 octets

-1 octet grâce à Nick Kennedy.

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

Essayez-le en ligne! (Merci à Giuseppe d'avoir correctement configuré le TIO.)

Preuve qu'il est vierge (en utilisant le vérificateur de Nick Kennedy ).

Sorties 0 pour falsey, et une valeur positive pour véridique, ce que je comprends est acceptable car R interprétera ces derniers comme faux et vrai.

Explication: bitwXor(a,b)donne (sous forme d'entier) le XOR au niveau du bit entre aet b. Pour vérifier s'il s'agit d'une puissance de 2, vérifiez si sa base de connexion 2 est un entier. La fonction dpoisdonne la fonction de densité de probabilité de la distribution de Poisson: sa valeur est 0 pour les valeurs non entières, et quelque chose de positif pour les entiers non négatifs. Le Test là car dpoisnécessite un deuxième argument (tout travail réel positif, etT est interprété comme 1).

Si nous insistons pour produire des valeurs distinctes, la version suivante génère FALSE ou TRUE en 42 octets (merci à Giuseppe pour -8 octets):

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

et est également vierge . Essayez-le en ligne!

R , 83 octets

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

Essayez-le en ligne!

Preuve que c'est vierge

Contourner le fait que as.integer, as.doubleetc. ne sont que légèrement éloignés is.integer, is.doubleetc. était le plus difficile. En fin de compte, le mieux que je pouvais faire était d' utiliser sum(T^el(.[-T])à la fois la génération d'un et la vérification qui as.doubleavait renvoyé un vecteur de longueur> 1. L'emballage test de gérer le fait que, autrement, identicalpeut devenir ide~tical.

Julia 0,7 , 20 octets

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

Essayez-le en ligne!

Voici un validateur vierge qui essaie d'exécuter chaque fonction anonyme modifiée sur une entrée, et aucun ne réussit. Notez que le code a un caractère unicode multi-octets et que certaines sorties possibles du retournement de bits ne sont même pas incluses, car celles-ci produisent des chaînes UTF-8 invalides.

C # (Visual C # Interactive Compiler) , 37 octets

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

La a=>b=>pièce ne peut pas être modifiée, sinon la fonction n'est pas valide.

Dans a!=b, le =ne peut pas être changé car intne peut pas être converti en bool.

Essayez-le en ligne!

C # (Visual C # Interactive Compiler) , 128 101 77 70 61 74 octets

-27 octets grâce à Ascii-Only

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

Essayez-le en ligne!

Vous devez être assez créatif pour obtenir des nombres en C # sans utiliser de littéraux. Utilise uniquement l'opérateur ^. Les variables a, b sont toutes à plus d'un bit l'une de l'autre et tout le reste est un mot-clé / nom.

JavaScript (ES6 en mode strict), 61 octets

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

Essayez-le en ligne! ou Assurez-vous que tous les programmes modifiés sont incorrects

Groovy , 47 36 octets

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

Essayez-le en ligne!

Version adaptée de la réponse Java de Kevin Cruijssen .

MATLAB, 37 octets

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

Désolé, pas de lien TIO, car je ne peux pas faire fonctionner la suite de tests sous Octave. Merci @ExpiredData pour quelques commentaires utiles.

Suite de tests:

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 octets

Merci à Jo King pour -33 octets.

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

Cela équivaut à

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

1a été réécrit comme elems([""]). 2a été réécrit comme sum(elems([""]),elems([""])); elems(["",""])peut sembler fonctionner mais elems([""-""])est également valide et semble bloquer le testeur.

Essayez-le en ligne!

JavaScript (Node.js) , 20 octets

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

Essayez-le en ligne!

validateur par Arnauld, modifié (ne pas utiliser strictement)