introduction

En théorie des nombres, un nombre est considéré comme mauvais s'il existe un nombre pair de 1 dans sa représentation binaire. Dans le défi d'aujourd'hui, vous identifierez si un nombre donné est mauvais ou non.

Défi

Votre travail consiste à écrire un programme complet ou une fonction qui accepte un seul entier non négatif en entrée et en sortie (ou en retour), que ce nombre soit mauvais ou non.

• Vous pouvez afficher toute valeur de vérité si le nombre est mauvais et toute valeur de fausseté si le nombre n'est pas mauvais.
• Vous pouvez entrer et sortir dans n’importe quel format acceptable .
• Les failles standard sont interdites.
• La séquence OEIS A001969 est la séquence contenant tous les nombres diaboliques.
• Voici une liste des 10000 premiers numéros pervers, pour référence (et plus de tests!)
• Cette question est le code-golf , donc le plus court, mieux c'est.
• Ne soyez pas rebutés par des réponses extrêmement courtes dans les langues de golf. Je vous encourage à soumettre dans la langue de votre choix.

• Voici quelques cas de test:

  3 => True
  11 => False
  777 => True
  43 => True
  55 => False
  666 => False
  

Le classement

Au bas de la page se trouve un extrait de pile contenant un classement pour cette question. (Merci, @MartinEnder)

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

# Perl, 43 + 2 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

/* Configuration */

var QUESTION_ID = 169724; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 81420; // This should be the user ID of the challenge author.

/* App */

var answers = [],
  answers_hash, answer_ids, answer_page = 1,
  more_answers = true,
  comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];

  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if (OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });

    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    //else console.log(body);
  });

  valid.sort(function(a, b) {
    var aB = a.size,
      bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function(a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;

    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
      .replace("{{NAME}}", a.user)
      .replace("{{LANGUAGE}}", a.language)
      .replace("{{SIZE}}", a.size)
      .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery('<a>' + lang + '</a>').text();

    languages[lang] = languages[lang] || {
      lang: a.language,
      lang_raw: lang,
      user: a.user,
      size: a.size,
      link: a.link
    };
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function(a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i) {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
      .replace("{{NAME}}", lang.user)
      .replace("{{SIZE}}", lang.size)
      .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body {
  text-align: left !important;
  display: block !important;
}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 500px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr>
        <td>Language</td>
        <td>User</td>
        <td>Score</td>
      </tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr>
        <td></td>
        <td>Author</td>
        <td>Language</td>
        <td>Size</td>
      </tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr>
      <td>{{PLACE}}</td>
      <td>{{NAME}}</td>
      <td>{{LANGUAGE}}</td>
      <td>{{SIZE}}</td>
      <td><a href="{{LINK}}">Link</a></td>
    </tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr>
      <td>{{LANGUAGE}}</td>
      <td>{{NAME}}</td>
      <td>{{SIZE}}</td>
      <td><a href="{{LINK}}">Link</a></td>
    </tr>
  </tbody>
</table>

EDIT: Je pense que cette question n’est pas une copie de celle-ci , car si cette question demande de compter le nombre d’entre elles, cette question demande si le nombre d’entre elles est pair. Bien que vous puissiez accomplir cette question en comptant simplement les bits, il existe également d' autres approches .

Assemblage Z80 (8 bits), 2 octets

Le code suivant ne fonctionne qu'avec des valeurs allant jusqu'à 255:

; Input is given in register A.
; P flag is set if A is evil.
B7     or A
C9     ret

Version 16 bits (fonctionne sur tous les cas de test), 3 octets

Cela fonctionne avec des valeurs allant jusqu'à 65535.

; Input is given in BC.
; Output is the same as above.
78     ld A,B
A9     xor C
C9     ret

Si vous vous sentez aventureux, vous pouvez supprimer 1 octet en stockant l’entrée Aet Cainsi de suite.

      ld BC, 777
C5    push BC
F1    pop AF

puis en cours d'exécution

A9    xor C
C9    ret

Cependant, ceci impose un fardeau à l'appelant. Il est donc possible que les deux octets ( push BCet pop AF) soient également comptés.

JavaScript (ES6), 18 octets

f=n=>n?!f(n&~-n):1

Essayez-le en ligne!

Explication

La logique des bits va comme ceci:

• Pour les nombres entiers, cela ~-néquivaut à -(-n)-1, de sorte que c'est juste une autre façon de faire n-1. Dans ce cas particulier, nous aurions effectivement pu utiliser n-1.

• n & (n-1)supprime le moins bit significatif à 1 en n parce que décrémentation n tour à tour toutes fuite 0 « s dans 1 » s et efface le 1 qui suit immédiatement (par la propagation de transport), tout en laissant tout le reste inchangé.

  Exemple pour n = 24 (11000 en binaire):

    11000 (24)                  11000 (24)
  -     1                   AND 10111 (23)
  -------                   ---------
  = 10111 (23)              =   10000 (16)
     ^                           ^
     |                           |
     +--- this bit is cleared ---+
  

Par conséquent, nous traitons autant d'appels récursifs qu'il y a de 1 dans la représentation binaire de n , en inversant le résultat à chaque fois !. Le dernier appel revient toujours 1 .

Exemples:

f(24) = !f(16) = !!f(0) = !!1 = true
f(7) = !f(6) = !!f(4) = !!!f(0) = !!!1 = false

Python 2 , 25 octets

lambda n:int(bin(n),13)%2

Essayez-le en ligne!

bin(n)donne un résultat comme '0b10101'. En lisant ceci comme un entier de base 13, on obtient

qui réduit modulo 2 à ≡ 1 ⋅ 1 5 + 1 ⋅ 1 4 + 0 ⋅ 1 3 + 1 ⋅ 1 2 + 0 ⋅ 1 1 + 1 ⋅

Donc int(bin(n),13)%2est égal à 1 + (nombre d'unités bin(n)) modulo 2.

Si nest le mal, alors le résultat est 1; sinon c'est 0.

J'ai repris cette astuce de Noodle9 .

Japt -h!, 5 4 3 octets

¤å^

L'essayer

Explication

¤       :Convert to base-2 string
 å^     :Cumulatively reduce by XORing
        :Implicitly output the last element negated

C # (compilateur interactif Visual C #) , 43 38 octets

Golfed Essayez-le en ligne!

i=>Convert.ToString(i,2).Sum(c=>c)%2<1

Ungolfed

i => Convert.ToString( i, 2 ).Sum( c => c ) % 2 < 1

Code complet avec des tests

Func<Int32, Boolean> f = i => Convert.ToString( i, 2 ).Sum( c => c ) % 2 < 1;

Int32[] testCases = { 3, 11, 777, 43, 55 };

foreach( Int32 testCase in testCases ) {
    Console.Write( $" Input: {testCase}\nOutput: {f(testCase)}" );
    Console.WriteLine("\n");
}

Console.ReadLine();

Communiqués

• v1.1 - -5 bytes- Remplacé CountparSum
• v1.0 - 43 bytes- Solution initiale.

Remarques

• Aucun

Bash (aucun utilitaire externe), 56 44 octets

while(($1));do set $(($1/2)) $(($2+$1%2));done;!(($2%2))

(($1))&&exec $0 $[$1/2] $[$2+$1%2];!(($2%2))

Cela suppose que le numéro se trouve dans $1, ayant été passé en tant que premier argument de ligne de commande. Cela suppose également qu'il s'agit d'un script shell (afin qu'il puisse le faire execlui-même).

Il récidive, d'une manière, en utilisant exec $0, jusqu'à ce que le nombre (in $1) atteigne zéro, en le divisant par deux à chaque itération. Il additionne également $2le nombre de fois où nous obtenons un nombre impair. À la fin, le nombre initial était "diabolique" si la somme $2n'était pas étrange.

Exemple d'invocations:

$ ./script 3 && echo evil
evil

$ ./script 11 && echo evil

$ ./script 777 && echo evil
evil

$ ./script 43 && echo evil
evil

$ ./script 55 && echo evil

Pour 0:

$ ./script 0 && echo evil
./script: line 1: ((: %2: syntax error: operand expected (error token is "%2")
evil

Résultat correct, avec un petit extra sur le côté.

R , 37 26 octets

!sum(scan()%/%2^(0:31))%%2

Essayez-le en ligne!

Une alternative à la réponse de Robert S. , cela évite le fractionnement de bits intégré mais finit par devenir moins golfé et grâce à JayCe et digEmAll finit par arriver légèrement plus golfeur.

$2^{31}-1$

05AB1E , 4 octets

bSOÈ

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

b       # Convert to binary string
        #  i.e. 777 → 1100001001
 S      # Change it to a list of 0s and 1s
        #  i.e. 1100001001 → ['1','1','0','0','0','0','1','0','0','1']
  O     # Take the sum
        #  i.e. ['1','1','0','0','0','0','1','0','0','1'] → 4
   È    # Check if it's even (1 as truthy, 0 as falsey)
        #  i.e. 4 → 1

Stax , 4 octets

:1|e

Exécuter et déboguer

:1|e Full program, implicit input-evaluation
:1   Count set bits
  |e Check if even

R , 99 98 44 34 28 octets

-1 merci à Kevin Cruijssen! -54 grâce à ngm! -10 merci à Giuseppe! -6 merci à JayCe!

!sum(intToBits(scan())>0)%%2

Essayez-le en ligne!

Sinon, en utilisant le binaryLogicpackage (39 octets):

!sum(binaryLogic::as.binary(scan()))%%2

C (gcc) , 36 octets

c;f(n){for(c=0;n;c++)n&=n-1;n=~c&1;}

Essayez-le en ligne!

Méthode de K & R https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan

Doit être compilé avec le niveau d'optimisation 0

Wolfram Language (Mathematica) , 24 22 octets

• Sauvé deux octets grâce à Misha Lavrov .

2∣DigitCount [#, 2,1] &

Essayez-le en ligne!

PHP, 37 36 octets

<?=1&~substr_count(decbin($argn),1);

Pour l'exécuter:

echo '<input>' | php -nF <filename>

Ou essayez-le en ligne!

Imprime 1pour vrai et 0pour faux.

-1 octet grâce à Benoit Esnard !

Brachylog , 4 octets

ḃo-0

Essayez-le en ligne!

Avec plusieurs cas de test (😈 est mauvais et 👼 ne l'est pas.)

Utilise quelque chose que j'ai découvert récemment à propos du -prédicat: sa documentation ne dit que "la différence d'éléments de [input]", mais ce qu'elle fait en réalité est "la somme d'éléments pair-indexés (à partir de 0) d'entrées, moins la somme d'impairs -indexed éléments d'entrée ".

Ici,

ḃ convertit le nombre en un tableau de chiffres binaires,

o les trie pour rassembler tous les 1.

Maintenant, s'il y avait un nombre pair de 1, il y aurait un nombre égal de 1 dans les indices pairs et les indices impairs. Donc -après cela donnerait un 0. Mais s'il y avait un nombre impair de 1, il y aurait un 1 supplémentaire qui sortait, la différence étant soit -1 soit 1.

Donc, finalement, nous affirmons que la différence est 0, et obtenons un résultat vrai ou faux en fonction de cela. Avec des exigences de sortie plus flexibles , ceci pourrait être supprimé pour une réponse de 3 octets, avec 0 en sortie de vérité et -1 et 1 en sortie de Falsey.

INTERCAL , 90 65 63 octets

DOWRITEIN:1
DO:2<-'#0$#65535'~?':1~:1'
DOREADOUT:2
PLEASEGIVEUP

Essayez-le en ligne!

Ungolfed et étendu (pour ce que ça vaut la peine) avec des commentaires de style C.

DO WRITE IN :1 //Store user input in 1
DO :2<-:1~:1 //Select just the ones. So will convert binary 10101 to 111
DO :3<-:?2 //Run the unary xor over the result. Essentially, xor with the right bitshifted
           //(with wraparound) value).
DO :9<-#0$#65535 //Intermingle the 16 bit values of all 0's and all 1's, to create a
                 //32 bit number with 1's in the odd positions.
DO :4<-:9~:3 //It turns out that at this point, evil numbers will have no bits in odd
             //positions, and non-evil numbers will have precisely one bit in an odd
             //position. Therefore, the ~ will return 0 or 1 as appropriate.
PLEASE READ OUT :4 //Politely output
PLEASE GIVE UP //Polite and self explanatory

J'ai dû faire quelques concessions pour que cela soit réalisable dans INTERCAL. Le premier est, comme pour tous les programmes INTERCAL, la saisie numérique doit être écrite. Donc, si vous voulez entrer, 707vous fournissez SEVEN OH SEVEN.

La seconde est qu'INTERCAL n'a pas vraiment de valeur de vérité ou de fausseté appropriée. Au lieu de cela, il générera le chiffre romain I(1) si le nombre n'est pas mauvais, ou un 0 (généralement représenté par le fait -que les chiffres romains ne peuvent normalement pas représenter 0).

Si vous souhaitez les inverser pour que les nombres pervers renvoient 1 et les nombres non pervers, 0, vous pouvez modifier les lignes 4 et 5 de la version sans golf comme suit, bien que cela ajoute 3 octets.

DO:9<-#65535$#0
DO:4<-#1~:9~3

Attaché , 13 12 octets

Even@Sum@Bin

Essayez-le en ligne!

( De 13 octets: Even@1&`~@Bin)

Ceci est une composition de trois fonctions:

1. Bin
2. Sum
3. Even

Cela vérifie que le Sumde l' Binélargissement de l'aire d' entrée est Even.

dc , 18 16 octets

[2~rd1<M+]dsMx2%

Renvoie (à la pile) 0 pour le mal et 1 pour pas le mal

Essayez-le en ligne!

Assez simple - applique récursivement l'opérateur quotient / reste combiné ~au nouveau quotient et additionne tous les restants, puis modifie par 2 (après avoir passé deux octets à basculer sur une vérité / falsification standard) .

Modifié pour refléter le consensus selon lequel 0 pour la vérité et 1 pour la fausseté est acceptable, en particulier dans un langage qui n’a aucune sorte de if(boolean)construction.

Python 2, 29 octets

lambda n:~bin(n).count('1')&1

Essayez-le en ligne!

Retourne 1 si vrai, sinon 0.

Convertit le nombre en chaîne binaire telle que '0b11', compte le nombre de 1, obtient le complément du résultat et renvoie le dernier bit du complément (merci, https://codegolf.stackexchange.com/users/53560/cdlane !) (1 ​​si le numéro d'origine était pair, 0 si il était impair).

x86-16, 3 octets

Liste NASM:

 1                                  parity16:
 2 00000000 30E0                        xor al,ah
 3 00000002 C3                          ret

Fonction entière 16 bits arg dans AX (détruit), valeur renvoyée dans PF.

Le matériel calcule la parité du résultat pour nous, dans l' indicateur de parité de x86 . L'appelant peut utiliser jp/ jnppour créer une branche ou ce qu'il veut.

Fonctionne exactement comme la réponse Z80 / 8080 de @ cschultz ; En fait, 8086 a été conçu pour faciliter le portage de source mécanique à partir de 8080 .

Notez que PF est uniquement défini à partir de l'octet de poids faible de résultats plus larges, donc test edi,edine fonctionnerait pas pour une version x86-64. Il vous faudrait horizontalement jusqu'à 16 bits ou popcnt eax, edi/ and al,1(0 étant la vérité).

C ++ (gcc) (-O0),  36  31 octets

int f(int i){i=!i||i%2-f(i/2);}

Essayez-le en ligne!

C ++ (clang) , 35 octets

int f(int i){return!i||i%2-f(i/2);}

Essayez-le en ligne!

Voici ma première tentative de code-golf, en espérant ne pas avoir enfreint une règle que j'ai peut-être manquée.

Edit:
- 5 octets enregistrés grâce à Frech: @ Jonathan remplacé !=par -et returnpar i=(le dernier remplacement ne semble pas fonctionner avec clang bien)
- Comme il semble y avoir un débat si je devrais utiliser abus gcc -O0, je pensais que je pouvais il suffit de donner les deux versions

SML , 32 octets

fun%0=1| %n=(n+ %(n div 2))mod 2

Explication:

• % est le nom de la fonction
• prend en entrée dans repl et retourne 1 si mal, 0 sinon
• n est entré, renvoie (n +% (n // 2))% 2

Fait par 2 étudiants Carnegie Mellon ennuyés

Forth (gforth) , 53 octets

: f 1 swap begin 2 /mod -rot xor swap ?dup 0= until ;

Essayez-le en ligne!

Explication

Prend le xor-sum des chiffres de la forme binaire du nombre. (divise à plusieurs reprises par 2 et xors le reste avec la valeur "somme")

Explication du code

: f              \ begin a new word definition
  1 swap         \ place 1 on the stack below the input (n)
  begin          \ start an indefinite loop
    2 /mod       \ get the quotient and remainder of dividing n by 2
    -rot         \ move the sum and remainder to the top of the stack
    xor          \ xor the sum and remainder
    swap         \ move the quotient back to the top of the stack
    ?dup         \ duplicate if > 0
    0=           \ get "boolean" indicating if quotient is 0
  until          \ end the loop if it is, otherwise go back to the beginning
;                \ end the word definition

Java 8, 40 36 octets

n->n.toString(n,2).chars().sum()%2<1

-4 octets grâce à @Okx pour quelque chose que je n'aurais pas dû m'oublier moi-même ..

Essayez-le en ligne.

Explication:

n->                // Method with Integer parameter and boolean return-type
  n.toString(n,2)  //  Convert the integer to a binary String
   .chars()        //  Convert that to an IntStream of character-encodings
   .sum()          //  Sum everything together
    %2<1           //  And check if it's even

Notez que l'encodage des caractères pour 0et 1sont 48et 49, mais en les additionnant et en prenant modulo-2, les résultats sont corrects, car 48%2 = 0et 49%2 = 1.

Perl 6 , 21 octets

*.base(2).comb(~1)%%2

Essaye-le

Étendu:

*\        # WhateverCode lambda (this is the parameter)
.base(2)  # Str representing the binary
.comb(~1) # find the "1"s

%% 2      # is the count of "1"s divisible by 2?

Retina 0.8.2 , 28 octets

.+
$*
+`(1+)\1
$+0
0

11

^$

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

.+
$*

Convertir en unaire.

+`(1+)\1
$+0

Conversion binaire partielle (laisse des zéros supplémentaires).

0

Supprimer tous les zéros.

11

Modulo les uns par deux.

^$

Testez si le résultat est zéro.

Assemblage x86, 12 à 11 octets

F3 0F B8 44 24 04  popcnt      eax,dword ptr [esp+4] ; Load EAX with the number of ones in arg
F7 D0              not         eax ; One's complement negation of EAX
24 01              and         al,1 ; Isolate bottom bit of EAX
C3                 ret             

-1 octet grâce à la suggestion de @ ceilingcat

FrapperUtilitaires + GNU, 33

dc -e2o?p|tr -d 0|wc -c|dc -e?2%p

Essayez-le en ligne!

Lit les entrées de STDIN. Sorties 1 pour Vrai et 0 pour Faux.

• dc convertit l'entrée en chaîne binaire
• tr supprime les zéros
• wc compte les restants (et le retour à la ligne final, ce qui corrige le sens de la logique
• dc calcule le compte mod 2 et affiche la réponse

Python 2, 28 27 octets

f=lambda n:n<1or n&1^f(n/2)

Essayez-le en ligne!

Renvoie une valeur de vérité si exactement un the ones-bit is a 1et the result of calling this function on n/2 is truthyest vrai (oun==0 ). Cela fonctionne parce que cela n/2équivaut à un décalage de bits correct avec division au sol (donc uniquement avec Python 2).

Version alternative, également 28 27 octets

g=lambda n:n<1or g(n&n-1)^1

Essayez-le en ligne!

Basé sur la méthode K & R de comptage des bits définis référencés par vazt.

Les deux pourraient être plus courts de deux octets si la sortie permettait à falsey de signifier le mal.

Edit: Merci à Amphibological pour la sauvegarde d’un octet!

APL (Dyalog Unicode) , ^SBCS 10 octets

Fonction tacite anonyme. Peut prendre n'importe quel tableau d'entiers en argument.

≠⌿1⍪2∘⊥⍣¯1

Essayez-le en ligne!

2∘⊥⍣¯1 convertir en binaire, en utilisant autant de chiffres que nécessaire en fonction du nombre le plus grand, séparer les chiffres le long de l'axe principal

1⍪ les préfixes le long de l'axe principal

≠⌿ Réduction XOR le long de l'axe primaire

J , 9 octets

Fonction tacite anonyme. Peut prendre n'importe quel tableau entier en argument.

1-2|1#.#:

Essayez-le en ligne!

1- un moins (ie négation logique de)

2| le mod-2 de

1#. la somme (lit. l'évaluation de base 1) de

#: la représentation binaire