introduzione

Nella teoria dei numeri, un numero è considerato malvagio se nella sua rappresentazione binaria è presente un numero pari di 1. Nella sfida di oggi, identificherai se un determinato numero è cattivo.

Sfida

Il tuo compito è quello di scrivere un programma completo o una funzione che accetta un singolo intero non negativo come input e output (o restituisce) indipendentemente dal fatto che quel numero sia o meno male.

• Puoi generare qualsiasi valore di verità se il numero è cattivo e qualsiasi valore di falsa se il numero non è cattivo.
• È possibile immettere e produrre in qualsiasi formato accettabile .
• Le scappatoie standard non sono ammesse.
• La sequenza OEIS A001969 è la sequenza che contiene tutti i numeri cattivi.
• Ecco un elenco dei primi 10000 numeri malvagi, per riferimento (e altri casi di test!)
• Questa domanda è code-golf , quindi più breve è, meglio è.
• Non lasciarti scoraggiare da risposte estremamente brevi nelle lingue del golf. Ti incoraggio a inviare in qualsiasi lingua tu voglia.

• Ecco alcuni casi di test:

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

La classifica

Nella parte inferiore della pagina è presente uno snippet di stack contenente una classifica per questa domanda. (Grazie, @MartinEnder)

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

# [><>](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: credo che questa domanda non sia un duplicato di questo , perché mentre quella domanda sta chiedendo di contare il numero di quelli, questa domanda sta chiedendo se il numero di quelli è pari. Sebbene sia possibile rispondere a questa domanda semplicemente contando i bit, esistono anche altri approcci .

Z80 Assembly (8 bit), 2 byte

Il codice seguente funziona solo con valori fino a 255:

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

Versione a 16 bit (funziona su tutti i casi di test), 3 byte

Funziona con valori fino a 65535.

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

Se ti senti avventuroso, puoi radere via 1 byte memorizzando l'ingresso Ae in questo Cmodo

      ld BC, 777
C5    push BC
F1    pop AF

e poi in esecuzione

A9    xor C
C9    ret

Tuttavia, ciò comporta un onere per il chiamante, quindi è possibile che vengano conteggiati anche i due byte ( push BCe pop AF).

JavaScript (ES6), 18 byte

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

Provalo online!

Spiegazione

La logica bit a bit va così:

• Per numeri interi, ~-nequivale a -(-n)-1, quindi solo un altro modo di fare n-1. In quel caso particolare, avremmo effettivamente potuto usare n-1.

• n & (n-1)rimuove il bit meno significativo impostato su 1 in n poiché il decremento di n trasforma tutti gli 0 finali in 1 in e cancella l' 1 che segue immediatamente (portando la propagazione), lasciando invariato tutto il resto.

  Esempio per n = 24 (11000 in binario):

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

Pertanto, elaboriamo tutte le chiamate ricorsive quante sono 1 nella rappresentazione binaria di n , invertendo il risultato ogni volta con !. L'ultima chiamata restituisce sempre 1 .

Esempi:

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

Python 2 , 25 byte

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

Provalo online!

bin(n)dà un risultato simile '0b10101'. Leggendolo come un intero di base 13, otteniamo

che riduce il modulo 2 a ≡ 1 ⋅ 1 5 + 1 ⋅ 1 4 + 0 ⋅ 1 3 + 1 ⋅ 1 2 + 0 ⋅ 1 1 + 1 ⋅

Quindi è int(bin(n),13)%2uguale a 1 + (numero di quelli in bin(n)) modulo 2.

Se nè cattivo, allora il risultato è 1; altrimenti è 0.

Ho preso questo trucco da Noodle9 .

Japt -h!, 5 4 3 byte

¤å^

Provalo

Spiegazione

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

C # (compilatore interattivo Visual C #) , 43 38 byte

Golf Provalo online!

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

Ungolfed

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

Codice completo con test

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

Uscite

• v1.1 - -5 bytes- Sostituito CountaSum
• v1.0 - 43 bytes- Soluzione iniziale.

Gli appunti

• Nessuna

Bash (nessuna utility esterna), 56 44 byte

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

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

Ciò presuppone che il numero sia stato trovato $1, essendo stato passato come primo argomento della riga di comando. Presuppone anche che si tratti di uno script di shell (in modo che possa farlo da execsolo).

Si ricorre, dopo una moda, usando exec $0, fino a quando il numero (in $1) raggiunge lo zero, dividendolo per due in ogni iterazione. Somma anche (in $2) il numero di volte in cui otteniamo un numero dispari. Alla fine, il numero originale era "malvagio" se la somma $2non è dispari.

Invocazioni di esempio:

$ ./script 3 && echo evil
evil

$ ./script 11 && echo evil

$ ./script 777 && echo evil
evil

$ ./script 43 && echo evil
evil

$ ./script 55 && echo evil

Per 0:

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

Risultato corretto, con un po 'di extra sul lato.

R , 37 26 byte

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

Provalo online!

Un'alternativa alla risposta di Robert S. , questo evita la suddivisione dei bit incorporata ma finisce per essere meno golfoso e grazie a JayCe e digEmAll finisce per diventare leggermente più golfista.

$2^{31}-1$

05AB1E , 4 byte

bSOÈ

Provalo online o verifica tutti i casi di test .

Spiegazione:

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 byte

:1|e

Esegui ed esegui il debug

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

R , 99 98 44 34 28 byte

-1 grazie a Kevin Cruijssen! -54 grazie a ngm! -10 grazie a Giuseppe! -6 grazie a JayCe!

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

Provalo online!

In alternativa, usando il binaryLogicpacchetto (39 byte):

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

C (gcc) , 36 byte

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

Provalo online!

Metodo da K&R https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan

Deve essere compilato con il livello di ottimizzazione 0

Wolfram Language (Mathematica) , 24 22 byte

• Salvato due byte grazie a Misha Lavrov .

2|DigitCount [#, 2,1] &

Provalo online!

PHP, 37 36 byte

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

Per eseguirlo:

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

O provalo online!

stampe 1 per vero e0 per falso.

-1 byte grazie a Benoit Esnard !

Brachylog , 4 byte

ḃo-0

Provalo online!

Con più casi di test (😈 è male e 👼 non lo è).

Usa qualcosa che ho scoperto di recente sul - predicato: la sua documentazione dice semplicemente "la differenza di elementi di [input]", ma ciò che effettivamente fa è "somma di elementi a indice pari (a partire da 0) di input, meno la somma di dispari -indexed elementi di input ".

Qui,

ḃ converte il numero in una matrice di cifre binarie,

o li ordina per riunire tutti gli 1.

Ora, se ci fosse un numero pari di 1, ci sarebbe un numero uguale di 1 in indici pari e indici dispari. Così la- successivo darebbe uno 0. Ma se ci fosse un numero dispari di 1, ci sarebbe un ulteriore 1 che sporge, con conseguente differenza di -1 o 1.

Quindi, infine, affermiamo che la differenza è 0e otteniamo un risultato vero o falso in base a ciò. Con requisiti di output più flessibili , questo potrebbe essere rimosso per una risposta a 3 byte, con 0 come output true e -1 e 1 come entrambi output output.

INTERCAL , 90 65 63 byte

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

Provalo online!

Ungolfed ed espanso (per quello che vale) con commenti in stile 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

Ho dovuto fare alcune concessioni per renderlo possibile in INTERCAL. Il primo è, come con tutti i programmi INTERCAL, l'input numerico deve essere scritto. Quindi, se si desidera inserire, 707si fornirebbe SEVEN OH SEVEN.

Il secondo è che INTERCAL non ha davvero un vero valore di verità o falsità. Invece, produrrà il numero romano I(1) se il numero non è cattivo, o uno 0 (tipicamente rappresentato come -dato che i numeri romani normalmente non possono rappresentare 0).

Se vuoi capovolgerli in modo che i numeri malvagi restituiscano 1 e i numeri non malvagi restituiscano 0, puoi cambiare le righe 4 e 5 dalla versione non golf come segue, anche se aggiunge 3 byte.

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

Attache , 13 12 byte

Even@Sum@Bin

Provalo online!

(Di 13 byte: Even@1&`~@Bin)

Questa è una composizione di tre funzioni:

1. Bin
2. Sum
3. Even

Questo controlla che il Sumdella Binespansione ary dell'ingresso è Even.

dc , 18 16 byte

[2~rd1<M+]dsMx2%

Restituisce (in pila) 0 per il male e 1 per il male

Provalo online!

Abbastanza semplice: applica ricorsivamente l'operatore ~di quoziente / resto combinato al nuovo quoziente e aggiunge tutti i resti insieme, quindi le mod di 2 (dopo aver speso due byte per passare a una verità / falsa standard) .

Modificato per riflettere il consenso sul fatto che 0 per la verità e 1 per la falsità vanno bene, specialmente in un linguaggio che non ha alcun tipo di if(boolean)costrutto.

Python 2, 29 byte

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

Provalo online!

Restituisce 1 se Vero, altrimenti 0.

Converte il numero in una stringa binaria come '0b11', conta il numero di 1s, ottiene il complemento del risultato e restituisce l'ultimo bit del complemento (grazie, https://codegolf.stackexchange.com/users/53560/cdlane !) (1 ​​se il numero originale era pari, 0 se era dispari).

x86-16, 3 byte

Elenco NASM:

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

Funzione intera 16 bit arg in AX (che viene distrutta), restituisce valore in PF.

L'hardware calcola la parità del risultato per noi, nella Parity Flag di x86 . Il chiamante può usare jp/jnp per diramare o qualunque cosa gli piaccia.

Funziona esattamente come la risposta Z80 / 8080 di @ cschultz ; infatti l'8086 è stato progettato per semplificare il porting meccanico della sorgente dall'8080 .

Si noti che PF è impostato solo dal byte basso di risultati più ampi, quindi test edi,edinon funzionerebbe per una versione x86-64. Dovresti orizzontale-xo fino a 16 bit, o popcnt eax, edi/ and al,1(dove 0 è vero).

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

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

Provalo online!

C ++ (clang) , 35 byte

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

Provalo online!

Ecco il mio primo tentativo di giocare a golf con il codice, spero di non aver infranto nessuna regola che avrei potuto perdere.

Edit:
- Saved 5 bytes thanks to @Jonathan Frech : replaced != by - and return by i= (the last replacement does not seem to work with clang though)
- Since there seems to be a debate whether I should use gcc -O0 abuse, I thought I could just give both versions

SML, 32 Bytes

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

Explaination:

• % is function name
• 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