Вступ

У теорії чисел число вважається злим, якщо в його бінарному поданні є парне число 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>

EDIT: Я вважаю, що це питання не є дублікатом цього питання , оскільки, хоча це питання просить підрахувати кількість одиниць, це питання задає, чи кількість парних рівних. Хоча ви можете вирішити це питання, просто порахувавши біти, є й інші підходи .

Збірка 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)видаляє найменш значущий біт, встановлений на 1 в n, тому що декрементація n перетворює всі відстаючі 0 's на 1 ' і очищає 1, що негайно слідує (за допомогою поширення перенесення), залишаючи все інше незмінним.

  Приклад для n = 24 (11000 у двійковій):

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

Тому ми обробляємо стільки рекурсивних викликів, скільки є 1 -х у двійковому поданні n , щоразу перетворюючи результат !. Останній дзвінок завжди повертається 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, ми отримуємо

Таким чином, int(bin(n),13)%2дорівнює 1 + (кількість одиниць bin(n)) за модулем 2.

Якщо nзло, то результат 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 # Interactive Compiler) , 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
• v1.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, передане як аргумент першого командного рядка. Він також передбачає, що це сценарій оболонки (щоб він міг execсам).

Після модифікації він повторюється, використовуючи exec $0, поки число (in $1) не досягне нуля, розділивши його на два в кожній ітерації. Він також підсумовує (не $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

Спробуйте в Інтернеті!

Альтернатива відповіді Роберта С. , це уникає вбудованого розбиття бітів, але закінчується менш гофрованим, а завдяки 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

Стакс , 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 спасибі Кевіну Крейссену! -54 завдяки НГМ! -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

Мова Вольфрама (Mathematica) , 24 22 байти

• Збережено два байти завдяки Міші Лаврову .

2∣DigitCount [#, 2,1] &

Спробуйте в Інтернеті!

PHP, 37 36 байт

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

Щоб запустити його:

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

Або спробуйте в Інтернеті!

Друкує 1істинно, і 0неправдиво.

-1 байт завдяки Benoit Esnard !

Брахілог , 4 байти

ḃo-0

Спробуйте в Інтернеті!

У кількох тестових випадках (😈 зло і 👼 ні.)

Використовує щось, що я нещодавно виявив про -предикат: його документація просто говорить про "різницю елементів [введення]", але те, що він насправді робить, - "сума парних елементів (починаючи з 0-го) введення, мінус сума непарних -вкладені елементи введення ".

Ось

ḃ перетворює число в масив двійкових цифр,

o сортує їх, щоб зібрати всі 1.

Тепер, якби було парне число 1s, було б рівне число 1s в парних і непарних індексах. Тож -після цього давали б 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

Attache , 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 (витративши два байти на перехід до стандартної версії / фальшивості) .

Відредаговано так, щоб відобразити консенсус про те, що 0 для truthy та 1 для falesy добре, особливо в мові, яка не має свого роду if(boolean)конструкцію.

Python 2, 29 байт

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

Спробуйте в Інтернеті!

Повертає 1, якщо True, інакше 0.

Перетворює число у двійковий рядок типу "0b11", рахує число 1s, отримує доповнення результату та повертає останній біт доповнення (спасибі, 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

16-бітна ціла функція arg в AX (яка знищена), повертає значення в PF.

Апаратне забезпечення обчислює паритет результату для нас у прапорі четності x86 . Абонент може використовувати jp/ jnpвести гілку, або що завгодно.

Працює точно так само, як відповідь Z80 / 8080 @ cschultz ; насправді 8086 був призначений для полегшення механічного перенесення джерел з 8080 .

Зауважте, що PF встановлюється лише з низького байту більш широких результатів, тому test edi,ediне буде працювати для версії x86-64. Вам доведеться горизонтально-xor зменшити до 16 біт, або popcnt eax, edi/ and al,1(де 0 - truthy).

C ++ (gcc) (-O0),  36  31 байт

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

Спробуйте в Інтернеті!

C ++ (клакс) , 35 байт

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

Спробуйте в Інтернеті!

Ось моя перша спроба кодування в гольф, сподіваюся, я не порушив жодного правила, яке, можливо, пропустив.

Edit:
- Збережено 5 байт завдяки Frech: @ Джонатан замінені !=на -і returnвід i=(остання заміна чи не здається , працювати з брязкотом , хоча)
- Так , здається, суперечка , чи повинен я використовувати GCC -O0 зловживання, я думав , що зможу просто дайте обидві версії

SML , 32 байти

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

Пояснення:

• % це ім'я функції
• приймає вхід у repl і повертає 1, якщо зло, 0 в іншому випадку
• n є вхід, повертає (n +% (n // 2))% 2

Зроблено двома нудьгуючими студентами Карнегі Меллоном

Четвертий (gforth) , 53 байти

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

Спробуйте в Інтернеті!

Пояснення

Бере xor-суму цифр двійкової форми числа. (повторно ділиться на 2 і xors залишок зі значенням "сума")

Пояснення коду

: 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 байт

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

-4 байти завдяки @Okx за те, про що я не повинен був забути себе.

Спробуйте в Інтернеті.

Пояснення:

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

Зверніть увагу , що кодування символів для 0і 1є 48та 49, але підсумовуючи їх і приймати по модулю 2 все ще тримає правильні результати , так 48%2 = 0і 49%2 = 1.

Perl 6 , 21 байт

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

Перевірте це

Розширено:

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

Сітківка 0,8,2 , 28 байт

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

11

^$

Спробуйте в Інтернеті! Посилання включає тестові випадки. Пояснення:

.+
$*

Перетворити в одинарне.

+`(1+)\1
$+0

Часткове бінарне перетворення (залишає зайві нулі).

0

Видаліть усі нулі.

11

Модулюйте їх на два.

^$

Перевірте, чи є результат нульовим.

x86 Збірка, 12 11 байт

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 байт, завдяки пропозиції @ roofcat

Утиліти Bash + GNU, 33

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

Спробуйте в Інтернеті!

Читає дані від STDIN. Виходи 1 для True та 0 для False.

• dc перетворює вхід у двійковий рядок
• tr знімає нулі
• wc підраховує залишки (і зворотний новий рядок, що виправляє почуття логіки
• dc обчислює підрахунок mod 2 і виводить відповідь

Python 2, 28 27 байт

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

Спробуйте в Інтернеті!

Повертає значення truthy, якщо саме це один з the ones-bit is a 1і the result of calling this function on n/2 is truthyє true (або n==0). Він працює тому n/2, що еквівалентний правильному бітовому зсуву з поділом на підлогу (так тільки для Python 2).

Альтернативна версія, також 28 27 байт

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

Спробуйте в Інтернеті!

На основі методу K&R підрахунку встановлених бітів, на які посилається vazt.

І те й інше могло б бути на два байти коротше, якщо вихід дозволив фальсий означати зло.

Редагувати: Дякую Амфібологічному за збереження байта!

APL (Dyalog Unicode) , 10 байт ^SBCS

Анонімна негласна функція. Може взяти будь-який масив цілих чисел як аргумент.

≠⌿1⍪2∘⊥⍣¯1

Спробуйте в Інтернеті!

2∘⊥⍣¯1 перетворити у двійкові, використовуючи стільки цифр, скільки потрібно найбільшої кількості, роздільних цифр уздовж первинної осі

1⍪ подайте їх уздовж первинної осі

≠⌿ Зменшення XOR вздовж первинної осі

J , 9 байт

Анонімна негласна функція. Може взяти будь-який цілий масив як аргумент.

1-2|1#.#:

Спробуйте в Інтернеті!

1- один мінус (тобто логічне заперечення)

2| мод-2

1#. сума (літ. база-1 оцінка)

#: двійкове представлення