Introdução

Na teoria dos números, um número é considerado mau se houver um número par de 1's em sua representação binária. No desafio de hoje, você identificará se um determinado número é mau ou não.

Desafio

Seu trabalho é escrever um programa ou função completo que aceite um número inteiro único e não negativo como entrada e saída (ou retorno), independentemente de esse número ser mau.

• Você pode emitir qualquer valor verdadeiro se o número for ruim e qualquer valor falso se o número não for ruim.
• Você pode inserir e enviar em qualquer formato aceitável .
• As brechas padrão não são permitidas.
• A sequência OEIS A001969 é a sequência que contém todos os números incorretos .
• Aqui está uma lista dos primeiros 10000 números malignos, para referência (e mais casos de teste!)
• Esta questão é código-golfe , portanto, quanto menor, melhor.
• Não se deixe levar por respostas extremamente curtas em idiomas de golfe. Convido você a enviar em qualquer idioma que desejar.

• Aqui estão alguns casos de teste:

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

The Leaderboard

Na parte inferior da página, há um snippet de pilha que contém um cabeçalho para esta pergunta. (Obrigado, @MartinEnder)

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet do placar de líderes:

# [><>](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: Eu acredito que esta questão não é uma duplicata disso , porque, embora essa pergunta esteja pedindo a contagem do número de unidades, essa pergunta está perguntando se o número de unidades é par. Embora você possa realizar essa pergunta simplesmente contando os bits, há outras abordagens também .

Conjunto Z80 (8 bits), 2 bytes

O código a seguir funciona apenas com valores de até 255:

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

Versão de 16 bits (funciona em todos os casos de teste), 3 bytes

Isso funciona com valores de até 65535.

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

Se você estiver se sentindo aventureiro, pode economizar 1 byte armazenando a entrada Ae Cassim por diante

      ld BC, 777
C5    push BC
F1    pop AF

e depois correndo

A9    xor C
C9    ret

No entanto, isso sobrecarrega o chamador; portanto, os dois bytes ( push BCe pop AF) também devem ser contados.

JavaScript (ES6), 18 bytes

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

Experimente online!

Explicação

A lógica bit a bit é assim:

• Para números inteiros, ~-né equivalente a -(-n)-1, de modo que apenas outra maneira de fazer n-1. Nesse caso em particular, poderíamos realmente ter usado n-1.

• n & (n-1)remove o bit menos significativo a 1 no n porque decrementing n transforma tudo arrastando 0 é em 1 's e limpa a 1 que se segue imediatamente (carry propagação), deixando tudo o resto inalterado.

  Exemplo para n = 24 (11000 em binário):

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

Portanto, temos o processo tantas chamadas recursivas, pois há 1 é na representação binária de n , invertendo o resultado cada vez com !. A última chamada sempre retorna 1 .

Exemplos:

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

Python 2 , 25 bytes

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

Experimente online!

bin(n)dá um resultado como '0b10101'. Lendo isso como um número inteiro de base 13, obtemos

Então, int(bin(n),13)%2é igual a 1 + (número de unidades em bin(n)) módulo 2.

Se né mau, então o resultado é 1; caso contrário, é 0.

Eu peguei esse truque no Noodle9 .

Japonês -h!, 5 4 3 bytes

¤å^

Tente

Explicação

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

C # (compilador interativo do Visual C #) , 43 38 bytes

Golfe Experimente online!

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

Ungolfed

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

Código completo com testes

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

Lançamentos

• v1.1 - -5 bytes- Substituído CountparaSum
• v1.0 - 43 bytes- Solução inicial.

Notas

• Nenhum

Bash (sem utilitários externos), 56 44 bytes

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

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

Isso pressupõe que o número seja encontrado $1, tendo sido passado como o primeiro argumento da linha de comando. Ele também pressupõe que esse seja um script de shell (para que ele execpróprio possa ).

Ele recorre, de certa forma, usando exec $0, até o número (in $1) chegar a zero, dividindo-o por dois em cada iteração. Também soma (in $2) o número de vezes que obtemos um número ímpar. No final, o número original era "mau" se a soma $2não fosse ímpar.

Invocações de exemplo:

$ ./script 3 && echo evil
evil

$ ./script 11 && echo evil

$ ./script 777 && echo evil
evil

$ ./script 43 && echo evil
evil

$ ./script 55 && echo evil

Para 0:

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

Resultado correto, com um pouco de extra ao lado.

R , 37 26 bytes

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

Experimente online!

Uma alternativa à resposta de Robert S. , isso evita a divisão de bits incorporada, mas acaba com menos golfismo e, graças a JayCe e digEmAll, acaba sendo um pouco mais golfista.

Funciona apenas para números inteiros positivos menores que .$2^{31}-1$

05AB1E , 4 bytes

bSOÈ

Experimente online ou verifique todos os casos de teste .

Explicação:

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 bytes

:1|e

Execute e depure

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

R , 99 98 44 34 28 bytes

-1 graças a Kevin Cruijssen! -54 graças a ngm! -10 graças a Giuseppe! -6 agradecimentos a JayCe!

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

Experimente online!

Como alternativa, usando o binaryLogicpacote (39 bytes):

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

C (gcc) , 36 bytes

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

Experimente online!

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

Deve ser compilado com o nível de otimização 0

Wolfram Language (Mathematica) , 24 22 bytes

• Economizou dois bytes graças a Misha Lavrov .

2∣DigitCount [#, 2,1] e

Experimente online!

PHP, 37 36 bytes

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

Para executá-lo:

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

Ou Experimente online!

Imprime 1para verdadeiro e 0para falso.

-1 byte graças a Benoit Esnard !

Braquilog , 4 bytes

ḃo-0

Experimente online!

Com vários casos de teste (😈 é mau e 👼 não é).

Usa algo que descobri recentemente sobre o -predicado: sua documentação diz apenas "a diferença de elementos de [input]", mas o que realmente faz é "soma dos elementos indexados pares (a partir de 0) da entrada, menos a soma de ímpares" elementos de entrada indexados ".

Aqui,

ḃ converte o número em uma matriz de dígitos binários,

o classifica-os para reunir todos os 1s.

Agora, se houvesse um número par de 1s, haveria um número igual de 1s em índices pares e ímpares. Portanto, o -que se seguiu daria um 0. Mas se houvesse um número ímpar de 1s, haveria 1 extra, resultando na diferença sendo -1 ou 1.

Então, finalmente, afirmamos que a diferença é 0e obtemos um resultado verdadeiro ou falso de acordo com isso. Com requisitos de saída mais flexíveis , isso poderia ser removido para uma resposta de 3 bytes, com 0 como saída de verdade e -1 e 1 como ambas as saídas de falsey.

INTERCAL , 90 65 63 bytes

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

Experimente online!

Ungolfed e expandido (pelo que vale a pena) com comentários no estilo 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

Eu tive que fazer algumas concessões para tornar isso possível no INTERCAL. A primeira é que, como em todos os programas INTERCAL, a entrada numérica deve ser gravada. Então, se você quiser inserir, 707você forneceria SEVEN OH SEVEN.

A segunda é que INTERCAL realmente não tem valor de verdade ou falsidade. Em vez disso, ele emitirá o numeral romano I(1) se o número não for ruim ou um 0 (normalmente representado como -porque os algarismos romanos normalmente não podem representar 0).

Se você quiser inverter esses números para que os números maus retornem 1 e os números não maus retornem 0, você pode alterar as linhas 4 e 5 da versão não armazenada da seguinte maneira, embora adicione 3 bytes.

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

Anexo , 13 12 bytes

Even@Sum@Bin

Experimente online!

(Old 13 bytes: Even@1&`~@Bin)

Esta é uma composição de três funções:

1. Bin
2. Sum
3. Even

Isso verifica que o Sumda Binexpansão ary da entrada é Even.

dc , 18 16 bytes

[2~rd1<M+]dsMx2%

Retorna (para a pilha) 0 para o mal e 1 para não o mal

Experimente online!

Bastante direto - aplica recursivamente o operador de quociente / restante combinado ~ao novo quociente e adiciona todos os restantes, depois mods por 2 (depois de gastar dois bytes para alternar para uma verdade / falsidade padrão) .

Editado para refletir o consenso de que 0 para verdade e 1 para falsidade são aceitáveis, especialmente em um idioma que não possui nenhum tipo de if(boolean)construção.

Python 2, 29 bytes

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

Experimente online!

Retorna 1 se True, caso contrário 0.

Converte o número em uma string binária como '0b11', conta o número de 1s, obtém o complemento do resultado e retorna o último bit do complemento (obrigado, https://codegolf.stackexchange.com/users/53560/cdlane !) (1 ​​se o número original for par, 0 se for ímpar).

x86-16, 3 bytes

Listagem NASM:

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

A função inteira de 16 bits arg no AX (destruída), retorna o valor em PF.

O hardware calcula a paridade do resultado para nós, no Parity Flag de x86 . O chamador pode usar jp/ jnppara ramificar ou o que quiser.

Funciona exatamente como a resposta Z80 / 8080 da @ cschultz ; de fato, o 8086 foi projetado para facilitar a transferência de fontes mecânica do 8080 .

Observe que PF é definido apenas a partir do byte baixo de resultados mais amplos; portanto test edi,edi, não funcionaria para uma versão x86-64. Você precisaria xor horizontal até 16 bits ou popcnt eax, edi/ and al,1(onde 0 é verdade).

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

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

Experimente online!

C ++ (clang) , 35 bytes

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

Experimente online!

Aqui está minha primeira tentativa no código de golfe, espero que não quebrei nenhuma regra que eu poderia ter perdido.

Edit:
- Saved 5 bytes, graças ao @ Jonathan Frech: substituídas !=por -e returnpelo i=(a última substituição não parece trabalhar com clang embora)
- Uma vez que não parece ser um debate se eu deveria usar gcc -O0 abuso, eu pensei que eu pudesse basta dar as duas versões

SML , 32 bytes

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

Explicação:

• % é o nome da função
• recebe entrada em repl e retorna 1 se mal, 0 caso contrário
• n é entrada, retorna (n +% (n // 2))% 2

Feito por 2 estudantes entediados de Carnegie Mellon

Quarto (gforth) , 53 bytes

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

Experimente online!

Explicação

Pega a xoroma dos dígitos da forma binária do número. (divide repetidamente por 2 e xou o restante com o valor "sum")

Código Explicação

: 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 graças a @Okx por algo que eu não deveria ter me esquecido ..

Experimente online.

Explicação:

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

Observe que os caracteres que codificam para 0e 1são 48e 49, mas somando-os e recebendo o módulo-2, ainda mantém os resultados corretos porque 48%2 = 0e 49%2 = 1.

Perl 6 , 21 bytes

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

Teste-o

Expandido:

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

^$

Experimente online! O link inclui casos de teste. Explicação:

.+
$*

Converta para unário.

+`(1+)\1
$+0

Conversão binária parcial (deixa zeros extras).

0

Exclua todos os zeros.

11

Módulo os dois por dois.

^$

Teste se o resultado é zero.

Montagem x86, 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 graças à sugestão de @ ceilingcat

Utilitários Bash + GNU, 33

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

Experimente online!

Lê a entrada de STDIN. Saídas 1 para True e 0 para False.

• dc converte a entrada em uma sequência binária
• tr remove zeros
• wc conta os restantes (e a nova linha à direita, que corrige o senso de lógica
• dc calcula contagem mod 2 e gera a resposta

Python 2, 28 27 bytes

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

Experimente online!

Retorna um valor verdadeiro se exatamente um de the ones-bit is a 1e the result of calling this function on n/2 is truthyfor verdadeiro (ou n==0). Funciona porque n/2é equivalente a um deslocamento de bits correto com a divisão do piso (somente no Python 2).

Versão alternativa, também 28 27 bytes

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

Experimente online!

Com base no método K&R de contagem de bits de conjunto referenciados por vazt.

Ambos podem ser dois bytes mais curtos se a saída permitir que falsey signifique mal.

Edit: Obrigado a Amphibological por salvar um byte!

APL (Dyalog Unicode) , ^{SBCS de} 10 bytes

Função tácita anônima. Pode usar qualquer matriz de números inteiros como argumento.

≠⌿1⍪2∘⊥⍣¯1

Experimente online!

2∘⊥⍣¯1 converter para binário, usando quantos dígitos forem necessários para o maior número, separar dígitos ao longo do eixo primário

1⍪ precede aqueles ao longo do eixo primário

≠⌿ Redução de XOR ao longo do eixo primário

J , 9 bytes

Função tácita anônima. Pode usar qualquer matriz inteira como argumento.

1-2|1#.#:

Experimente online!

1- um menos (isto é, negação lógica de)

2| o mod-2 de

1#. a soma (lit. a avaliação de base 1) de

#: a representação binária