介绍

在数论中，如果二进制表示形式中的偶数个数为1，则该数字被认为是邪恶的。在今天的挑战中，您将确定给定的数字是否为邪恶。

挑战

您的工作是编写一个完整的程序或函数，以接受单个非负整数作为输入并输出（或返回）该数字是否为邪恶。

• 如果数字是邪恶的，则可以输出任何真值，而如果数字不是邪恶的，则可以输出任何虚假的值。
• 您可以以任何可接受的格式输入和输出。
• 不允许出现标准漏洞。
• OEIS序列A001969是包含所有邪恶数字的序列。
• 这是前10000个邪恶数字的列表，以供参考（还有更多测试用例！）
• 这个问题是代码高尔夫，所以越短越好。
• 不要被打高尔夫球的简短答案所困扰。我鼓励您以喜欢的任何语言提交。

• 以下是一些测试案例：

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

排行榜

页面底部是一个堆栈片段，其中包含此问题的页首横幅。（谢谢@MartinEnder）

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以通过打败旧分数来保持标题。例如：

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

如果您想在标头中包含多个数字（例如，因为您的分数是两个文件的总和，或者您想单独列出解释器标志罚分），请确保实际分数是标头中的最后一个数字：

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

您还可以将语言名称设置为链接，然后该链接将显示在页首横幅代码段中：

# [><>](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>

编辑：我认为这个问题是不是重复这个，因为这而问题是问计数的人的数量，这个问题是问的人的数量是偶数。尽管您可以通过简单地计算位数来解决此问题，但是还有其他方法。

Z80汇编（8位），2字节

以下代码仅适用于最大为255的值：

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

16位版本（适用于所有测试用例），3字节

最多可使用65535。

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

如果您喜欢冒险，可以通过将输入存储在其中来减少1个字节A，C如下所示

      ld BC, 777
C5    push BC
F1    pop AF

然后运行

A9    xor C
C9    ret

但是，这给调用者带来了负担，因此可能也应同时计算两个字节（push BC和pop AF）。

JavaScript（ES6），18个字节

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

在线尝试！

说明

按位逻辑如下所示：

• 对于整数，~-n等于-(-n)-1，因此只是另一种处理方式n-1。在那种特殊情况下，我们实际上可以使用n-1。

• n & (n-1)删除n中设置为1的最低有效位，因为递减n会将所有尾随的0变为1，并清除紧随其后的1（通过进位传播），而其他所有内容保持不变。

  n = 24的示例（二进制为11000）：

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

因此，在n的二进制表示形式中，我们处理的递归调用数量与1一样多，每次都用反转结果。最后一次调用始终返回1。!

例子：

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

Python 2，25个字节

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

在线尝试！

bin(n)给出类似的结果'0b10101'。将其读取为以13为底的整数，我们得到

这降低了模2至 ≡ 1 ⋅ 1 5 + 1 ⋅ 1 4 + 0 ⋅ 1 3 + 1 ⋅ 1 2 + 0 ⋅ 1 1 + 1 ⋅

因此int(bin(n),13)%2等于1 +（1中的个数bin(n)）模2。

如果n是邪恶的，则结果为1；否则为1。否则为0。

我从Noodle9获得了这个技巧。

Japt -h!，5 4 3字节

¤å^

试试吧

说明

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

C＃（Visual C＃交互式编译器），43 38字节

高尔夫 在线尝试！

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

不打高尔夫球

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

完整的测试代码

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();

发布

• V1.1 - -5 bytes-替换Count到Sum
• 1.0 - 43 bytes-初始溶液。

笔记

• 没有

Bash（无外部实用程序），56 44字节

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

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

假设已在中找到该数字，并将$1其作为第一个命令行参数传递。它还假定这是一个Shell脚本（以便它exec本身可以）。

它使用递归重复使用exec $0，直到（in $1）中的数字达到零，在每次迭代中将其除以2。它还将求和$2的次数相加（以表示）。最后，如果总和$2不是奇数，则原始数字为“邪恶” 。

调用示例：

$ ./script 3 && echo evil
evil

$ ./script 11 && echo evil

$ ./script 777 && echo evil
evil

$ ./script 43 && echo evil
evil

$ ./script 55 && echo evil

对于0：

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

正确的结果，侧面还有一些额外的东西。

R，37 26字节

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

在线尝试！

罗伯特·S（Robert S.）的答案的一种替代方法，它避免了内置的位拆分，但是减少了高尔夫球运动，这要归功于杰伊（JayCe）和digEmAll最终使高尔夫球手变得更加高尔夫球。

$2^{31}-1$

05AB1E，4 个字节

bSOÈ

在线尝试或验证所有测试用例。

说明：

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个字节

:1|e

运行并调试

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

[R，99 98 44 34 28字节

-1感谢Kevin Cruijssen！-54感谢ngm！-10感谢朱塞佩！-6感谢JayCe！

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

在线尝试！

或者，使用 binaryLogic包（39个字节）：

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

C（gcc），36个字节

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

在线尝试！

K＆R的方法 https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan

必须以优化级别0进行编译

Wolfram语言（Mathematica），24 22字节

• 感谢Misha Lavrov节省了两个字节。

2∣DigitCount [＃，2,1]＆

在线尝试！

PHP，37 36字节

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

要运行它：

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

或在线尝试！

打印1为true和0false。

-1个字节感谢Benoit Esnard！

Brachylog，4个字节

ḃo-0

在线尝试！

有多个测试用例（😈是邪恶的，👼不是。）

使用我最近发现的有关-谓词的内容：其文档仅显示“ [input]的元素之差”，但实际上所做的是“ input的偶数索引元素的总和（从0开始），减去奇数的总和索引的输入元素”。

这里，

ḃ 将数字转换为二进制数字数组，

o 对它们进行排序以将所有1组合在一起。

现在，如果偶数为1，则偶数索引和奇数索引的个数等于1。所以-其后的值将为0。但是，如果奇数个数为1，则将有一个额外的1伸出，导致差值为-1或1。

因此，最后，我们断言差异是0，并据此得出对或错的结果。对于更灵活的输出要求，可以将其删除以得到3个字节的答案，其中0为真实输出，-1和1为两个虚假输出。

INTERCAL，90 65 63字节

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

在线尝试！

用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

为了使这在INTERCAL中可行，我不得不做出一些让步。首先，与所有INTERCAL程序一样，必须将数字输入写出。因此，如果您想输入707，则可以提供SEVEN OH SEVEN。

第二个问题是INTERCAL并没有真正的真实性或虚假性。相反，I如果数字不是邪恶的，它将输出罗马数字（1），或者输出0（通常表示为-罗马数字通常不能表示0）。

如果要翻转这些值，以使邪恶数字返回1而非邪恶数字返回0，则可以从非高尔夫版本更改行4和5，如下所示，尽管它确实增加了3个字节。

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

附件，13 12字节

Even@Sum@Bin

在线尝试！

（旧的13个字节： Even@1&`~@Bin）

这是三个功能的组合：

1. Bin
2. Sum
3. Even

这将检查输入Sum的三Bin进制展开式的Even。

dc，18 16字节

[2~rd1<M+]dsMx2%

返回（返回堆栈）0为邪恶，1为非邪恶

在线尝试！

相当简单-将组合的商/余数运算符递归地应用~到新商，并将所有余数相加，然后加2的mod （在花了两个字节以翻转为标准的true / falsy之后）。

编辑以反映共识，即0为真，1为虚假是可以的，尤其是在没有任何if(boolean)构造的语言中。

Python 2，29个字节

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

在线尝试！

如果为True，则返回1，否则返回0。

将数字转换为二进制字符串，例如“ 0b11”，计算1的数目，获取结果的补码，然后返回补码的最后一位（谢谢， https://codegolf.stackexchange.com/users/53560/cdlane！）（如果原始数字为偶数则为1，如果为奇数则为0）。

x86-16，3个字节

NASM列表：

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

AX中的16位整数函数arg（已销毁），PF中的返回值。

硬件在x86的奇偶校验标志中为我们计算结果的奇偶校验。呼叫者可以使用jp/ jnp进行分支，也可以随意分支。

就像@cschultz的Z80 / 8080答案一样工作 ; 实际上8086 旨在简化8080的机械源移植。

请注意，PF仅从较宽结果的低字节设置，因此test edi,edi不适用于x86-64版本。您必须对16位进行水平异或，或popcnt eax, edi/ and al,1（其中0为真）。

C ++（gcc）（-O0）， 36  31字节

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

在线尝试！

C ++（clang），35个字节

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

在线尝试！

这是我第一次尝试打高尔夫球，希望我没有违反任何我可能错过的规则。

编辑：
-保存5个字节感谢@Jonathan弗雷希：取代!=通过-和return通过i=（上次更换似乎没有工作，虽然铿锵不）
-由于有似乎是一个辩论中，我是否应该使用gcc -O0虐待，我以为我可以只给两个版本

SML，32字节

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

说明：

• % 是函数名称
• takes in input in repl and returns 1 if evil, 0 otherwise
• n is input, returns (n + %(n//2)) % 2

Made by 2 bored Carnegie Mellon Students

Forth (gforth), 53 bytes

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

Try it online!

Explanation

Takes the xor-sum of the digits of the binary form of the number. (repeatedly divides by 2 and xors the remainder with the "sum" value)

Code Explanation

: 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 bytes

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

-4 bytes thanks to @Okx for something I shouldn't have forgotten myself..

Try it online.

Explanation:

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

Note that the character encoding for 0 and 1 are 48 and 49, but summing them and taking modulo-2 still holds the correct results because 48%2 = 0 and 49%2 = 1.

Perl 6, 21 bytes

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

Test it

Expanded:

*\        # 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 bytes

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

11

^$

Try it online! Link includes test cases. Explanation:

.+
$*

Convert to unary.

+`(1+)\1
$+0

Partial binary conversion (leaves extra zeroes).

0

Delete all the zeros.

11

Modulo the ones by two.

^$

Test whether the result is zero.

x86 Assembly, 12 11 bytes

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 byte thanks to @ceilingcat's suggestion

Bash + GNU utilities, 33

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

Try it online!

Reads input from STDIN. Outputs 1 for True and 0 for False.

• dc converts input to a binary string
• tr removes zeros
• wc counts remaining ones (and trailing newline, which corrects sense of logic
• dc calculates count mod 2 and outputs the answer

Python 2, 28 27 bytes

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

Try it online!

Returns a truthy value if exactly one of the ones-bit is a 1 and the result of calling this function on n/2 is truthy is true (or n==0). It works because n/2 is equivalent to a right bitshift with floor division (so Python 2 only).

Alternate version, also 28 27 bytes

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

Try it online!

Based on the K&R method of counting set bits referenced by vazt.

Both of these could be two bytes shorter if the output allowed falsey to mean evil.

Edit: Thanks to Amphibological for saving a byte!

APL (Dyalog Unicode), 10 bytes^SBCS

Anonymous tacit function. Can take any array of integers as argument.

≠⌿1⍪2∘⊥⍣¯1

Try it online!

2∘⊥⍣¯1 convert to binary, using as many digits as needed by the largest number, separate digits along primary axis

1⍪ prepend ones along the primary axis

≠⌿ XOR reduction along the primary axis

J, 9 bytes

Anonymous tacit function. Can take any integer array as argument.

1-2|1#.#:

Try it online!

1- one minus (i.e. logical negation of)

2| the mod-2 of

1#. the sum (lit. the base-1 evaluation) of

#: the binary representation