Einführung

In der Zahlentheorie wird eine Zahl als böse angesehen, wenn ihre binäre Darstellung eine gerade Zahl von Einsen enthält. In der heutigen Herausforderung werden Sie feststellen, ob eine bestimmte Zahl böse ist oder nicht.

Herausforderung

Ihre Aufgabe ist es, ein vollständiges Programm oder eine vollständige Funktion zu schreiben, die eine einzelne, nicht negative Ganzzahl als Eingabe akzeptiert und ausgibt (oder zurückgibt), unabhängig davon, ob diese Zahl böse ist oder nicht.

• Sie können jeden Wahrheitswert ausgeben , wenn die Zahl böse ist, und jeden falschen Wert, wenn die Zahl nicht böse ist.
• Sie können in jedem akzeptablen Format eingeben und ausgeben .
• Standardlücken sind nicht zulässig.
• OEIS-Sequenz A001969 ist die Sequenz, die alle bösen Zahlen enthält.
• Hier ist eine Liste der ersten 10000 bösen Zahlen als Referenz (und weitere Testfälle!)
• Diese Frage ist Code-Golf , also je kürzer, desto besser.
• Lassen Sie sich nicht von extrem kurzen Antworten in Golfsprachen abschrecken. Ich ermutige Sie, in jeder Sprache einzureichen, die Sie mögen.

• Hier sind einige Testfälle:

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

Das Leaderboard

Am Ende der Seite befindet sich ein Stapel-Snippet mit einer Rangliste für diese Frage. (Danke, @MartinEnder)

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

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

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

# [><>](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: Ich glaube, diese Frage ist kein Duplikat davon , denn während diese Frage die Anzahl von Einsen zählt, fragt diese Frage, ob die Anzahl von Einsen gerade ist. Obwohl Sie können diese Frage durch einfaches Zählen der Bits erreichen, gibt es auch andere Ansätze .

Z80-Assembly (8 Bit), 2 Byte

Der folgende Code funktioniert nur mit Werten bis 255:

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

16-Bit-Version (funktioniert in allen Testfällen), 3 Byte

Dies funktioniert mit Werten bis zu 65535.

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

Wenn Sie sich abenteuerlustig fühlen, können Sie 1 Byte sparen, indem Sie die Eingabe in Aund Cso speichern

      ld BC, 777
C5    push BC
F1    pop AF

und dann rennen

A9    xor C
C9    ret

Dies belastet den Aufrufer jedoch, so dass möglicherweise auch die beiden Bytes ( push BCund pop AF) gezählt werden müssen.

JavaScript (ES6), 18 Byte

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

Probieren Sie es online!

Erläuterung

Die bitweise Logik sieht folgendermaßen aus:

• Für ganze Zahlen ~-nist das gleichbedeutend damit -(-n)-1, dass nur eine andere Art zu tun ist n-1. In diesem speziellen Fall hätten wir tatsächlich verwenden können n-1.

• n & (n-1)entfernt das am wenigsten signifikante Bit gesetzt 1 in n weil Erniedrigen n alle Hinter dreht 0 's in 1 s und löscht die 1 , die (durch Übertragsfortpflanzungs) unmittelbar folgt, während alles andere unverändert bleibt.

  Beispiel für n = 24 (11000 in binär):

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

Daher verarbeiten wir wie viele rekursive Aufrufe da es 1 ‚s in der Binärdarstellung von n , die mit jeder invertierende führen !. Der letzte Aufruf gibt immer 1 zurück .

Beispiele:

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

Probieren Sie es online!

bin(n)gibt ein Ergebnis wie '0b10101'. Wenn wir dies als Ganzzahl zur Basis 13 lesen, erhalten wir

Also int(bin(n),13)%2gleich 1 + (Anzahl der Einsen in bin(n)) Modulo 2.

Wenn nböse ist, ist das Ergebnis 1; sonst ist es 0.

Ich habe diesen Trick von Noodle9 aufgegriffen .

Japt -h!, 5 4 3 Bytes

¤å^

Versuch es

Erläuterung

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

C # (Visual C # Interactive Compiler) , 43 38 Byte

Golf Versuchen Sie es online!

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

Ungolfed

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

Vollständiger Code mit Tests

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

Releases

• v1.1 - -5 bytes- Ersetzt CountdurchSum
• v1.0 - 43 bytes- Anfangslösung.

Anmerkungen

• Keiner

Bash (keine externen Dienstprogramme), 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))

Dies setzt voraus, dass die Zahl in gefunden $1wurde und als erstes Befehlszeilenargument übergeben wurde. Es wird auch davon ausgegangen, dass dies ein Shell-Skript ist (so dass es sich execselbst kann ).

Es wiederholt sich auf eine Art und Weise, indem es verwendet exec $0, bis die Zahl (in $1) Null erreicht und sie in jeder Iteration durch zwei dividiert. Es summiert auch die Häufigkeit, mit $2der wir eine ungerade Zahl erhalten. Am Ende war die ursprüngliche Zahl "böse", wenn die Summe $2nicht ungerade ist.

Beispielaufrufe:

$ ./script 3 && echo evil
evil

$ ./script 11 && echo evil

$ ./script 777 && echo evil
evil

$ ./script 43 && echo evil
evil

$ ./script 55 && echo evil

Für 0:

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

Richtiges Ergebnis, mit ein bisschen mehr auf der Seite.

R , 37 26 Bytes

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

Probieren Sie es online!

Eine Alternative zur Antwort von Robert S., die das eingebaute Bit-Splitting vermeidet , aber weniger Golf spielt und dank JayCe und digEmAll etwas mehr Golf spielt.

Funktioniert nur für positive Ganzzahlen unter .$2^{31}-1$

05AB1E , 4 Bytes

bSOÈ

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Führen Sie es aus und debuggen Sie es

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

R , 99 98 44 34 28 Bytes

-1 Danke an Kevin Cruijssen! -54 danke an ngm! -10 danke an Giuseppe! -6 danke an JayCe!

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

Probieren Sie es online!

Alternativ können Sie das binaryLogicPaket (39 Byte) verwenden:

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

C (gcc) , 36 Bytes

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

Probieren Sie es online!

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

Muss mit Optimierungsstufe 0 übersetzt werden

Wolfram Language (Mathematica) , 24 22 Bytes

• Zwei Bytes dank Misha Lavrov gespeichert .

2.DigitCount [#, 2,1] &

Probieren Sie es online!

PHP, 37-36 Bytes

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

Um es auszuführen:

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

Oder versuchen Sie es online!

Druckt 1für wahr und 0für falsch.

-1 Byte Danke an Benoit Esnard !

Brachylog , 4 Bytes

ḃo-0

Probieren Sie es online!

Mit mehreren Testfällen (😈 ist böse und 👼 ist nicht.)

Verwendet etwas, was ich kürzlich über das -Prädikat herausgefunden habe: In seiner Dokumentation steht nur "der Unterschied der Elemente von [Eingabe]", aber was es tatsächlich tut, ist "Summe der geraden indizierten Elemente (beginnend mit dem 0.) der Eingabe abzüglich der Summe der ungeraden indizierte Elemente der Eingabe ".

Hier,

ḃ wandelt die Zahl in ein Array von Binärziffern um,

o sortiert sie, um alle Einsen zusammenzubringen.

Wenn es nun eine gerade Anzahl von Einsen gäbe, gäbe es eine gleiche Anzahl von Einsen in geraden und ungeraden Indizes. Das Nachher -würde also eine 0 ergeben. Aber wenn es eine ungerade Zahl von 1s gäbe, würde eine zusätzliche 1 herausragen, was dazu führt, dass der Unterschied entweder -1 oder 1 ist.

Schließlich behaupten wir also, der Unterschied sei 0und erhalten dementsprechend ein wahres oder falsches Ergebnis. Bei flexibleren Ausgabeanforderungen könnte dies für eine 3-Byte-Antwort beseitigt werden, wobei 0 als wahrheitsgemäße Ausgabe und -1 und 1 als beide falschen Ausgaben gelten.

INTERCAL , 90 65 63 Bytes

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

Probieren Sie es online!

Ungolfed und erweitert (was es wert ist) mit Kommentaren im C-Stil.

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

Ich musste ein paar Zugeständnisse machen, um dies in INTERCAL möglich zu machen. Das erste ist, wie bei allen INTERCAL-Programmen, dass die numerische Eingabe ausgeschrieben werden muss. Also, wenn Sie eingeben möchten, 707würden Sie zur Verfügung stellen SEVEN OH SEVEN.

Das zweite ist, dass INTERCAL nicht wirklich den richtigen Wert für Wahrheit oder Falschheit hat. Stattdessen wird die römische Ziffer I(1) ausgegeben, wenn die Zahl nicht böse ist, oder eine 0 (normalerweise dargestellt, -da römische Ziffern normalerweise nicht 0 darstellen können).

Wenn Sie diese umdrehen möchten, sodass böse Zahlen 1 und nicht böse Zahlen 0 zurückgeben, können Sie die Zeilen 4 und 5 von der ungolfed-Version wie folgt ändern, obwohl 3 Bytes hinzugefügt werden.

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

Attache , 13 12 Bytes

Even@Sum@Bin

Probieren Sie es online!

(Old 13 Bytes Even@1&`~@Bin)

Dies ist eine Komposition aus drei Funktionen:

1. Bin
2. Sum
3. Even

Dies prüft, ob der Wert Sumder Bintatsächlichen Erweiterung der Eingabe ist Even.

Gleichstrom , 18 16 Bytes

[2~rd1<M+]dsMx2%

Gibt (auf den Stapel) 0 für böse und 1 für nicht böse zurück

Probieren Sie es online!

Ziemlich einfach - Wendet den kombinierten Quotienten- / Restoperator rekursiv ~auf den neuen Quotienten an und addiert alle Reste. Anschließend werden die Modifikationen um 2 erhöht (nachdem zwei Bytes aufgewendet wurden, um zu einer Standardwahrheit / -fälschung zu wechseln) .

Bearbeitet, um den Konsens widerzuspiegeln, dass 0 für Wahrhaftigkeit und 1 für Falschheit in Ordnung ist, insbesondere in einer Sprache, die keine Art von if(boolean)Konstrukt hat.

Python 2, 29 Bytes

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

Probieren Sie es online!

Gibt 1 zurück, wenn True, sonst 0.

Wandelt die Zahl in eine Binärzeichenfolge wie '0b11' um, zählt die Zahl von 1s, erhält das Komplement des Ergebnisses und gibt das letzte Bit des Komplements zurück (danke, https://codegolf.stackexchange.com/users/53560/cdlane !) (1, wenn die ursprüngliche Nummer gerade war, 0, wenn sie ungerade war).

x86-16, 3 Bytes

NASM-Auflistung:

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

16-Bit-Integer-Funktion arg in AX (die zerstört wird), Rückgabewert in PF.

Die Hardware berechnet die Parität des Ergebnisses für uns im x86-Paritätsflag . Der Anrufer kann mit jp/ jnpverzweigen oder was immer er möchte.

Funktioniert genau wie die Z80 / 8080-Antwort von @ cschultz ; Tatsächlich wurde 8086 entwickelt, um das mechanische Portieren von Quellen aus 8080 zu vereinfachen .

Beachten Sie, dass PF nur aus dem unteren Byte der breiteren Ergebnisse festgelegt wird und daher test edi,edifür eine x86-64-Version nicht funktioniert. Sie müssten horizontal-xoder bis zu 16 Bit oder popcnt eax, edi/ and al,1(wobei 0 wahr ist).

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

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

Probieren Sie es online!

C ++ (clang) , 35 Bytes

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

Probieren Sie es online!

Hier ist mein erster Versuch, Code-Golf zu spielen. Ich hoffe, ich habe keine Regel gebrochen, die ich möglicherweise übersehen habe.

Edit:
- 5 Bytes gespart dank @Jonathan Frech: ersetzt !=durch -und returndurch i=(die letzte Ersetzung scheint jedoch nicht mit Clang zu funktionieren)
- Da es eine Debatte zu geben scheint, ob ich gcc -O0-Missbrauch verwenden sollte, dachte ich, ich könnte gib einfach beide versionen an

SML , 32 Bytes

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

Erklärung:

• % ist der Funktionsname
• Nimmt die Eingabe in repl auf und gibt 1 zurück, wenn es böse ist, sonst 0
• n wird eingegeben, gibt (n +% (n // 2))% 2 zurück

Gemacht von 2 gelangweilten Carnegie Mellon Studenten

Viertens (gviertens) , 53 Bytes

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

Probieren Sie es online!

Erläuterung

Nimmt die xor-Summe der Ziffern der Binärform der Zahl. (Wiederholt dividiert durch 2 und xor den Rest mit dem "Summen" -Wert)

Code Erklärung

: 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 danke an @Okx für etwas, das ich nicht vergessen hätte sollen ..

Probieren Sie es online aus.

Erläuterung:

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

Beachten Sie, dass die Zeichenkodierung für 0und 1sind 48und 49, aber sie summiert und unter Modulo-2 hält immer noch die richtigen Ergebnisse , weil 48%2 = 0und 49%2 = 1.

Perl 6 , 21 Bytes

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

Probier es aus

Erweitert:

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

^$

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

.+
$*

In Unary konvertieren.

+`(1+)\1
$+0

Teilweise binäre Konvertierung (lässt zusätzliche Nullen).

0

Löschen Sie alle Nullen.

11

Modulo diejenigen von zwei.

^$

Testen Sie, ob das Ergebnis Null ist.

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 dank @ ceilingcats Vorschlag

Bash + GNU-Dienstprogramme, 33

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

Probieren Sie es online!

Liest die Eingabe von STDIN. Ausgänge 1 für True und 0 für False.

• dc wandelt die Eingabe in eine Binärzeichenfolge um
• tr Entfernt Nullen
• wc zählt die verbleibenden Zeilen (und die nachgestellte Zeile, die den Sinn für Logik korrigiert)
• dc berechnet count mod 2 und gibt die antwort aus

Python 2, 28 27 Bytes

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

Probieren Sie es online!

Gibt einen Wahrheitswert zurück, wenn genau einer von the ones-bit is a 1und the result of calling this function on n/2 is truthywahr ist (oder n==0). Es funktioniert, weil n/2es einer Bitverschiebung nach rechts mit Unterteilung entspricht (also nur Python 2).

Alternative Version, auch 28 27 Bytes

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

Probieren Sie es online!

Basierend auf der von vazt referenzierten K & R-Methode zum Zählen von gesetzten Bits.

Beides könnte zwei Bytes kürzer sein, wenn die Ausgabe zulässt, dass Falsey böse bedeutet.

Edit: Danke an Amphibological für das Speichern eines Bytes!

APL (Dyalog Unicode) , 10 Byte ^SBCS

Anonyme stillschweigende Funktion. Kann ein beliebiges Array von Ganzzahlen als Argument verwenden.

≠⌿1⍪2∘⊥⍣¯1

Probieren Sie es online!

2∘⊥⍣¯1 Konvertieren Sie in eine Binärdatei, indem Sie so viele Ziffern verwenden, wie für die größte Zahl erforderlich sind. Trennen Sie die Ziffern entlang der Primärachse

1⍪ stellen Sie diejenigen entlang der Hauptachse voran

≠⌿ XOR-Reduktion entlang der Primärachse

J 9 Bytes

Anonyme stillschweigende Funktion. Kann ein beliebiges Integer-Array als Argument verwenden.

1-2|1#.#:

Probieren Sie es online!

1- eins minus (dh logische Negation von)

2| der mod-2 von

1#. die Summe (lit. die Basis-1-Bewertung) von

#: die binäre Darstellung