Wprowadzenie

W teorii liczb liczba jest uważana za złą, jeśli w jej reprezentacji binarnej występuje parzysta liczba 1. W dzisiejszym wyzwaniu będziesz identyfikować, czy dana liczba jest zła, czy nie.

Wyzwanie

Twoim zadaniem jest napisanie pełnego programu lub funkcji, która przyjmuje jedną, nieujemną liczbę całkowitą jako dane wejściowe i wyjściowe (lub zwraca), niezależnie od tego, czy ta liczba jest zła, czy nie.

• Możesz podać dowolną prawdziwą wartość, jeśli liczba jest zła, i dowolną wartość fałszu, jeśli liczba nie jest zła.
• Możesz wprowadzać i wyprowadzać w dowolnym akceptowalnym formacie .
• Standardowe luki są niedozwolone.
• Sekwencja OEIS A001969 to sekwencja zawierająca wszystkie złe liczby.
• Oto lista pierwszych 10000 złych liczb w celach informacyjnych (i więcej przypadków testowych!)
• To pytanie jest w golfa kodu , więc im krótszy, tym lepiej.
• Nie zniechęcaj się bardzo krótkimi odpowiedziami w językach golfowych. Zachęcam do przesyłania w dowolnym języku.

• Oto kilka przypadków testowych:

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

Tabela liderów

U dołu strony znajduje się fragment stosu zawierający tabelę wyników dla tego pytania. (Dzięki, @MartinEnder)

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik jest sumą dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie tabeli wyników:

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

EDYCJA: Uważam, że to pytanie nie jest duplikatem tego , ponieważ podczas gdy to pytanie wymaga policzenia liczby jedności, to pytanie pyta, czy liczba parzystych jest parzysta. Mimo, że można osiągnąć to pytanie przez zliczenie liczby bitów, istnieją inne metody zbyt .

Zespół Z80 (8 bitów), 2 bajty

Poniższy kod działa tylko z wartościami do 255:

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

Wersja 16-bitowa (działa na wszystkich testach), 3 bajty

Działa to z wartościami do 65535.

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

Jeśli masz ochotę na przygodę, możesz zgolić 1 bajt, przechowując dane wejściowe Ai tym Cpodobne

      ld BC, 777
C5    push BC
F1    pop AF

a następnie bieganie

A9    xor C
C9    ret

Obciąża to jednak program wywołujący, więc może się zdarzyć, że dwa bajty ( push BCi pop AF) również zostaną policzone.

JavaScript (ES6), 18 bajtów

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

Wypróbuj online!

Wyjaśnienie

Bitowa logika wygląda następująco:

• Dla liczb całkowitych ~-njest równoważne -(-n)-1, więc jest to po prostu inny sposób działania n-1. W tym konkretnym przypadku moglibyśmy faktycznie użyć n-1.

• n & (n-1)usuwa najmniej znaczący bit ustawiony na 1 w n, ponieważ zmniejszenie n zamienia wszystkie końcowe 0 na 1 i usuwa 1, który następuje bezpośrednio (przez propagację przenoszenia), pozostawiając wszystko inne bez zmian.

  Przykład dla n = 24 (11000 dwójkowo):

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

Dlatego przetwarzamy tyle wywołań rekurencyjnych, ile jest 1 w reprezentacji binarnej n , odwracając wynik za każdym razem za pomocą !. Ostatnie połączenie zawsze zwraca 1 .

Przykłady:

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

Python 2 , 25 bajtów

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

Wypróbuj online!

bin(n)daje wynik jak '0b10101'. Czytamy to jako liczbę całkowitą base-13

co zmniejsza moduł 2 do ≡ 1 ⋅ 1 5 + 1 ⋅ 1 4 + 0 ⋅ 1 3 + 1 ⋅ 1 2 + 0 ⋅ 1 1 + 1 ⋅

Więc int(bin(n),13)%2równa się 1 + (liczba jedynek bin(n)) modulo 2.

Jeśli njest zły, wynik wynosi 1; w przeciwnym razie jest to 0.

Wybrałem tę sztuczkę z Noodle9 .

Japt -h!, 5 4 3 bajty

¤å^

Spróbuj

Wyjaśnienie

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

C # (interaktywny kompilator Visual C #) , 43 38 bajtów

Gra w golfa Wypróbuj online!

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

Bez golfa

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

Pełny kod z testami

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

Wydawnictwa

• v1.1 - -5 bytes- Zamieniono CountnaSum
• v1.0 - 43 bytes- Wstępne rozwiązanie.

Notatki

• Żaden

Bash (bez zewnętrznych narzędzi), 56 44 bajtów

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

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

Zakłada się, że liczba została znaleziona $1, ponieważ została przekazana jako pierwszy argument wiersza poleceń. Zakłada również, że jest to skrypt powłoki (aby mógł execsam).

Powtarza się, po pewnym czasie, używając exec $0, aż liczba (in $1) osiągnie zero, dzieląc ją przez dwa w każdej iteracji. Sumuje także (in $2) liczbę razy, gdy otrzymujemy liczbę nieparzystą. Na koniec oryginalny numer był „zły”, jeśli suma $2nie była nieparzysta.

Przykładowe inwokacje:

$ ./script 3 && echo evil
evil

$ ./script 11 && echo evil

$ ./script 777 && echo evil
evil

$ ./script 43 && echo evil
evil

$ ./script 55 && echo evil

Dla 0:

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

Prawidłowy wynik, z odrobiną dodatkowej z boku.

R , 37 26 bajtów

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

Wypróbuj online!

Alternatywa dla odpowiedzi Roberta S. pozwala uniknąć wbudowanego dzielenia bitów, ale kończy się mniej golfa, a dzięki JayCe i digEmAll kończy się nieco bardziej golfowo.

$2^{31}-1$

05AB1E , 4 bajty

bSOÈ

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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 bajty

:1|e

Uruchom i debuguj

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

R , 99 98 44 34 28 bajtów

-1 dzięki Kevin Cruijssen! -54 dzięki ngm! -10 dzięki Giuseppe! -6 dzięki JayCe!

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

Wypróbuj online!

Alternatywnie, używając binaryLogicpakietu (39 bajtów):

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

C (gcc) , 36 bajtów

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

Wypróbuj online!

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

Musi zostać skompilowany z poziomem optymalizacji 0

Wolfram Language (Mathematica) , 24 22 bajtów

• Zaoszczędził dwa bajty dzięki Miszy Ławrowowi .

2∣DigitCount [#, 2,1] i

Wypróbuj online!

PHP, 37 36 bajtów

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

Aby uruchomić:

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

Lub wypróbuj online!

Drukuje 1na prawdę i 0na fałsz.

-1 bajt dzięki Benoit Esnard !

Brachylog , 4 bajty

ḃo-0

Wypróbuj online!

Z wieloma przypadkami testowymi (😈 jest złe, a 👼 nie jest.)

Wykorzystuje coś, co odkryłem ostatnio o -predykacie: jego dokumentacja mówi tylko „różnicę elementów [danych wejściowych]”, ale tak naprawdę robi to „sumę elementów o indeksie parzystym (zaczynając od 0) danych wejściowych, pomniejszoną o sumę nieparzystych -indexed elementy wejściowe ".

Tutaj,

ḃ konwertuje liczbę na tablicę cyfr binarnych,

o sortuje je, aby zebrać wszystkie 1.

Gdyby liczba parzystych była równa 1, liczba parzysta byłaby równa 1 w parzystych i nieparzystych. Więc -po tym dałoby zero. Ale jeśli byłaby nieparzysta liczba 1, wystałaby dodatkowa 1, powodując różnicę -1 lub 1.

W końcu twierdzimy, że różnica jest 0, i otrzymujemy prawdziwy lub fałszywy wynik zgodnie z tym. Przy bardziej elastycznych wymaganiach dotyczących wyjścia można to usunąć dla odpowiedzi 3-bajtowej, przy czym 0 to wyjście zgodne z prawdą, a -1 i 1 jako oba wyjścia falsey.

INTERCAL , 90 65 63 bajtów

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

Wypróbuj online!

Nie ulepszone i rozszerzone (za to, co jest warte) z komentarzami w stylu 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

Musiałem poczynić kilka ustępstw, aby było to możliwe w INTERCAL. Pierwszym jest, podobnie jak we wszystkich programach INTERCAL, wprowadzanie danych numerycznych. Więc jeśli chcesz wprowadzić dane 707, podaj je SEVEN OH SEVEN.

Po drugie, INTERCAL tak naprawdę nie ma właściwej wartości prawdziwości lub fałszu. Zamiast tego wyświetli cyfrę rzymską I(1), jeśli liczba nie jest zła, lub 0 (zwykle reprezentowane jako, -ponieważ cyfry rzymskie zwykle nie mogą reprezentować 0).

Jeśli chcesz je odwrócić, aby liczby zła zwracały 1, a liczby zła zwracały 0, możesz zmienić linie 4 i 5 z wersji bez golfa w następujący sposób, chociaż dodaje 3 bajty.

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

Attache , 13 12 bajtów

Even@Sum@Bin

Wypróbuj online!

(Stary 13 bajtów: Even@1&`~@Bin)

Jest to kompozycja trzech funkcji:

1. Bin
2. Sum
3. Even

Ta sprawdza, że Sumz Binary rozbudową wejścia jest Even.

dc , 18 16 bajtów

[2~rd1<M+]dsMx2%

Zwraca (do stosu) 0 za zło i 1 za nie zło

Wypróbuj online!

Dość proste - rekurencyjnie stosuje połączony operator ilorazu / reszty ~do nowego ilorazu i dodaje wszystkie reszty razem, a następnie modyfikuje o 2 (po spędzeniu dwóch bajtów na przejściu do standardowej wartości prawda / fałsz) .

Edytowane w celu odzwierciedlenia konsensusu, że 0 dla prawdy i 1 dla fałszu jest w porządku, szczególnie w języku, który nie ma żadnej if(boolean)konstrukcji.

Python 2, 29 bajtów

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

Wypróbuj online!

Zwraca 1, jeśli Prawda, w przeciwnym razie 0.

Konwertuje liczbę na ciąg binarny, taki jak „0b11”, liczy liczbę 1, pobiera uzupełnienie wyniku i zwraca ostatni bit uzupełnienia (dzięki, https://codegolf.stackexchange.com/users/53560/cdlane !) (1, jeśli oryginalny numer był parzysty, 0, jeśli był nieparzysty).

x86-16, 3 bajty

Lista NASM:

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

16-bitowa funkcja liczb całkowitych arg w AX (która jest zniszczona), zwracana wartość w PF.

Sprzęt oblicza dla nas parzystość wyniku na podstawie flagi parzystości x86 . Dzwoniący może użyć jp/ jnpdo rozgałęzienia lub cokolwiek zechce.

Działa dokładnie tak, jak odpowiedź Z80 / 8080 @ cschultz ; w rzeczywistości 8086 został zaprojektowany, aby ułatwić mechaniczne przenoszenie źródeł z 8080 .

Zauważ, że PF jest ustawiany tylko od niskiego bajtu szerszych wyników, więc test edi,edinie działałby dla wersji x86-64. Musiałbyś xor poziomo do 16 bitów, lub popcnt eax, edi/ and al,1(gdzie 0 to prawda).

C ++ (gcc) (-O0),  36  31 bajtów

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

Wypróbuj online!

C ++ (clang) , 35 bajtów

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

Wypróbuj online!

Oto moja pierwsza próba gry w golfa z kodem, mam nadzieję, że nie złamałem żadnej zasady, którą mogłem przegapić.

Edycja:
- Zapisano 5 bajtów dzięki @Jonathan Frech: zastąpiony !=przez -i returnprzez i=(ostatni zamiennik nie wydaje się jednak działać z clang)
- Ponieważ wydaje się, że toczy się debata, czy powinienem użyć nadużycia gcc -O0, pomyślałem, że mógłbym po prostu podaj obie wersje

SML , 32 bajty

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

Wyjaśnienie:

• % to nazwa funkcji
• pobiera dane wejściowe w repl i zwraca 1 jeśli zło, 0 w przeciwnym razie
• n jest wejściem, zwraca (n +% (n // 2))% 2

Wykonane przez 2 znudzonych studentów Carnegie Mellon

Dalej (gforth) , 53 bajty

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

Wypróbuj online!

Wyjaśnienie

Przyjmuje sumę xor cyfr postaci binarnej liczby. (wielokrotnie dzieli przez 2, a xors resztę wartością „suma”)

Objaśnienie kodu

: 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 bajtów

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

-4 bajty dzięki @Okx za coś, czego sam nie powinienem zapomnieć ...

Wypróbuj online.

Wyjaśnienie:

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

Zauważ, że znaki kodujące dla 0i 1są 48i 49, ale sumowanie ich i przyjmowanie modulo-2 nadal zawiera prawidłowe wyniki, ponieważ 48%2 = 0i 49%2 = 1.

Perl 6 , 21 bajtów

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

Sprawdź to

Rozszerzony:

*\        # 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 bajtów

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

11

^$

Wypróbuj online! Link zawiera przypadki testowe. Wyjaśnienie:

.+
$*

Konwertuj na unary.

+`(1+)\1
$+0

Częściowa konwersja binarna (pozostawia dodatkowe zera).

0

Usuń wszystkie zera.

11

Modulo te przez dwa.

^$

Sprawdź, czy wynik wynosi zero.

Zestaw x86, 12 11 bajtów

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 bajt dzięki sugestii @ ceilingcat

Narzędzia Bash + GNU, 33

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

Wypróbuj online!

Odczytuje dane wejściowe ze STDIN. Wyjścia 1 dla wartości True i 0 dla wartości False.

• dc konwertuje dane wejściowe na ciąg binarny
• tr usuwa zera
• wc zlicza pozostałe (i końcowy znak nowej linii, co koryguje logikę
• dc oblicza zliczanie mod 2 i wysyła odpowiedź

Python 2, 28 27 bajtów

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

Wypróbuj online!

Zwraca wartość truthy jeśli dokładnie jeden z the ones-bit is a 1i the result of calling this function on n/2 is truthyjest prawdą (lub n==0). Działa ponieważn/2 jest równoważne poprawnemu przesunięciu bitów z podziałem podłogi (więc tylko Python 2).

Wersja alternatywna, również 28 27 bajtów

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

Wypróbuj online!

Oparty na metodzie K&R zliczania zestawów bitów, do których odwołuje się vazt.

Oba mogą być o dwa bajty krótsze, jeśli dane wyjściowe pozwolą falsey oznaczać zło.

Edycja: Podziękowania dla Amphibological za uratowanie bajtu!

APL (Dyalog Unicode) , 10 bajtów ^SBCS

Anonimowa ukryta funkcja. Jako argument może przyjąć dowolną tablicę liczb całkowitych.

≠⌿1⍪2∘⊥⍣¯1

Wypróbuj online!

2∘⊥⍣¯1 konwertuj na binarny, używając tyle cyfr, ile potrzeba przez największą liczbę, oddzielne cyfry wzdłuż osi głównej

1⍪ dodawaj te wzdłuż głównej osi

≠⌿ Redukcja XOR wzdłuż osi głównej

J , 9 bajtów

Anonimowa ukryta funkcja. Może przyjmować dowolną tablicę liczb całkowitych jako argument.

1-2|1#.#:

Wypróbuj online!

1- jeden minus (tj. logiczna negacja)

2| mod-2 z

1#. suma (lit. ocena podstawy 1) z

#: reprezentacja binarna