이 숫자는 사악합니까?


34

소개

숫자 이론에서 이진수 표현에 짝수의 1이 있으면 숫자는 악의로 간주됩니다. 오늘의 도전에서, 당신은 주어진 숫자가 악한 지 아닌지를 식별하게 될 것입니다.

도전

당신의 임무는 음수가 아닌 단일 정수를 입력으로 받아들이고 그 숫자가 사악한 지 여부를 출력 (또는 반환)하는 전체 프로그램 또는 함수를 작성하는 것입니다.

  • 숫자가 악한 경우 진실한 값을 출력하고 악수가 아닌 경우 거짓 값을 출력 할 수 있습니다 .
  • 허용되는 형식으로 입력 및 출력 할 수 있습니다 .
  • 표준 허점 은 허용되지 않습니다.
  • OEIS 시퀀스 A001969 는 모든 사악한 숫자를 포함하는 시퀀스입니다.
  • 다음 은 참조 용 (및 더 많은 테스트 사례)을위한 첫 10000 개의 악한 숫자 목록입니다.
  • 이 질문은 이므로 짧을수록 좋습니다.
  • 골프 언어로 된 짧은 답변으로 연기하지 마십시오. 원하는 언어로 제출할 것을 권장합니다.
  • 다음은 몇 가지 테스트 사례입니다.

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

리더 보드

페이지 맨 아래에는이 질문에 대한 리더 보드가 포함 된 스택 스 니펫이 있습니다. (감사합니다, @MartinEnder)

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

# Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

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

헤더에 여러 개의 숫자를 포함 시키려면 (예 : 점수가 두 파일의 합계이거나 인터프리터 플래그 페널티를 별도로 나열하려는 경우) 실제 점수가 헤더 의 마지막 숫자 인지 확인하십시오 .

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

언어 이름을 링크로 만들어 리더 보드 스 니펫에 표시 될 수도 있습니다.

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

편집 : 나는이 질문의 중복없는 생각 그 질문은 사람의 수를 계산하기 위해 요구되는 반면,이 질문은 사람의 수가 짝수 여부를 묻는 때문에. 단순히 비트 수를 계산하여이 질문을 수행 할 있지만 다른 방법도 있습니다 .


2
관련 (모든 이진수에 대한 XOR-ing은 sum modulo-2를 취하는 것과 같습니다).
케빈 크루이 센


2
@BetaDecay 그러나 반대로 작동하지 않습니다. 즉, 이러한 답변을 모두 가져 와서 mod 2를 제거 할 수는 없습니다. 따라서이 도전은 새로운 방법을 초대합니다.
Amphibological

13
나는 그것이 666 => False테스트 사례 라고 생각합니다 .
user2390246

3
리더 보드가 깨졌습니다
Jo King

답변:


35

Z80 어셈블리 (8 비트), 2 바이트

다음 코드는 최대 255 개의 값으로 만 작동합니다.

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


16 비트 버전 (모든 테스트 사례에서 작동), 3 바이트

이것은 최대 65535의 값으로 작동합니다.

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

당신이 모험을 좋아하는 경우에 입력을 저장하여 1 바이트를 면도 할 수 AC과 같이

      ld BC, 777
C5    push BC
F1    pop AF

그런 다음 실행

A9    xor C
C9    ret

그러나 이로 인해 호출자에게 부담이되므로 2 바이트 ( push BCpop AF)도 계산해야합니다.


나는 이것을 좋아하지만 어떻게 작동합니까? 조립을위한 나의 기억 (6502 + arm)은 ors가 2 개의 피연산자로 비트 단위라는 것입니다
Northern-bradley

2
@ northern-bradley Z80에서는 or니모닉 의 두 번째 피연산자 가 누산기 A 라는 것을 암시합니다 .이 경우 명령은 A를 변경하지 않습니다. 상태 레지스터 (특히 패리티 플래그) 만 새로 고칩니다. A의 내용을 반영합니다.
cschultz2048

1
인가 P에 따라 허용 codegolf.meta.stackexchange.com/a/8509/29560 ? F(플래그) 레지스터 내의 단일 비트 이며 영향을받는 명령은 세 쌍만 있습니다. 또한이 답변 A은 8 비트 레지스터 이기 때문에 8 비트 값에 대해서만 경쟁한다고 언급하지 않습니다 . 이는 777255 이상의 다른 서명되지 않은 값에 대한 답변을 제공 할 수 없음을 의미합니다 .
CJ Dennis

2
젠장 내장:P
조 왕

1
@ cschultz2048이와 AF이므로 16 비트 값으로 AB또는 BA을 허용하지 않습니다 . BC16 비트이지만 A다른 XOR하기 전에 이들 중 하나를로드하려면 추가 명령어가 필요합니다 . Z80 답변은 질문에 따라 최대 255 또는 65535까지 완벽하게 작동한다고 항상 언급했습니다. 16 비트 버전을 추가 할 수도 있습니까? 따라서 8 비트 값의 경우 2 바이트, 16 비트 값의 경우 3 바이트.
CJ 데니스

25

자바 스크립트 (ES6), 18 바이트

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

온라인으로 사용해보십시오!

설명

비트 논리는 다음과 같습니다.

  • 정수의 경우는와 ~-n동일 -(-n)-1하므로 또 다른 방법입니다 n-1. 이 특별한 경우에는 실제로 사용할 수있었습니다 n-1.
  • n & (n-1)n을 줄이면 모든 후행 01 로 바꾸고 (전파를 통해) 바로 뒤에 오는 1 을 지우고 다른 것은 변경하지 않기 때문에 n 에서 1 로 설정된 최하위 비트를 제거합니다 .

    n = 24의 예 (2 진에서 11000) :

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

따라서 n 의 이진 표현에서 1 이있는만큼 많은 재귀 호출을 처리 하여 매번 결과를 반전시킵니다 . 마지막 호출은 항상 1을 반환합니다 .!

예 :

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

안녕하세요, 코드의 기능을 이해하고 있지만 비트 연산에 대한 기사를 읽거나 숫자가 2의 거듭 제곱인지 확인하는 등의 논리 / 추론을 이해할 수는 없습니다. 재귀 함수가 무엇인지 알고 있습니다. . 나는 이것이 왜 이런 식으로 사용되었고 왜 퍼즐에 답하는 데 도움이되는지, 즉 재귀와! f (power of two) <==> evil number 사이의 링크를 얻는 이유를 얻지 못합니다. 시간이 있으면 설명을 환영합니다 :) 감사합니다!
supafly

1
@ supafly 설명을 추가했습니다. 그리고 BTW : PPCG에 오신 것을 환영합니다!
Arnauld

처리는 지금 매우 명확합니다. 그래도 아이디어 / 추론은 정말 마술입니다! 설명 감사합니다!
supraly

13

파이썬 2 , 25 바이트

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

온라인으로 사용해보십시오!

bin(n)같은 결과를 제공합니다 '0b10101'. 이것을 밑이 13 인 정수로 읽으면

은 모듈로 2를1 1 5 + 1 1 4 + 0 1 3 + 로 감소시킵니다 1 1 2 + 0 1 1 + 1 1

11135+1134+0133+1132+0131+1130
1 + 1 + 0 + 1 + 0 + 1
115+114+013+112+011+110(mod2)
1+1+0+1+0+1(mod2).

따라서 int(bin(n),13)%21 + (에서 1의 수 bin(n)) 모듈로 2 와 같습니다 .

n악한 경우 결과는 1입니다. 그렇지 않으면 0입니다.

Noodle9 에서이 트릭을 집어 들었습니다 .


이것은 Python 2이므로 더 이상 사용되지 않는 repr backtick 구문으로 코드를 더 단축 할 수 있습니다 lambda n:int(`n`,13)%2. 온라인으로 사용해보십시오!
GarethPW

네, 약간의 뇌 방귀가 있었고 int의 기본 주장의 목적을 잊었습니다. 으악!
GarethPW


8

C # (Visual C # 대화식 컴파일러) , 43 38 바이트


골프 온라인으로 해보십시오!

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

언 골프

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

테스트를 포함한 전체 코드

Func<Int32, Boolean> f = i => Convert.ToString( i, 2 ).Sum( c => c ) % 2 < 1;

Int32[] testCases = { 3, 11, 777, 43, 55 };

foreach( Int32 testCase in testCases ) {
    Console.Write( $" Input: {testCase}\nOutput: {f(testCase)}" );
    Console.WriteLine("\n");
}

Console.ReadLine();

자료

  • 버전 1.1 - -5 bytes- 대체 CountSum
  • V1.0 - 43 bytes- 초기 솔루션입니다.

노트

  • 없음

2
당신의 "ungolfed"버전이 준 멍청이에 대한 찬성.
Jack Brounstein

8

배시 (외부 유틸리티 없음), 56 44 바이트

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

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

이 숫자는에서 $1첫 번째 명령 행 인수로 전달 된 것으로 가정합니다 . 또한 이것이 쉘 스크립트라고 가정합니다 (그래서 exec스스로 가능).

exec $0숫자 (in $1)이 0에 도달 할 때 까지을 사용하여 패션을 반복 한 후 각 반복에서 2로 나눕니다. 또한 $2홀수의 숫자를 얻는 횟수를 합산 합니다. 결국 합계가 $2홀수가 아닌 경우 원래 숫자는 "악" 입니다.

예제 호출 :

$ ./script 3 && echo evil
evil

$ ./script 11 && echo evil

$ ./script 777 && echo evil
evil

$ ./script 43 && echo evil
evil

$ ./script 55 && echo evil

의 경우 0:

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

측면에 약간의 추가로 정확한 결과.


7

R , 37 26 바이트

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

온라인으로 사용해보십시오!

대안 Robert S.의 답변에 내장 비트 분할을 피할 수는 있지만 골프는 덜 하고 JayCe와 digEmAll 덕분에 약간 골퍼가됩니다.

오직 양의 정수 미만 작동 .2311


log2 대신 31을 하드 코딩하지 않는 이유는 무엇입니까? 온라인으로 사용해보십시오!
digEmAll


2311%/%%%

또한 intToBits는 최대 2 ^ 31-1까지의 정수 값만 지원합니다.)
digEmAll



5

R , 99 98 44 34 28 바이트

Kevin Cruijssen에게 -1 감사합니다! ngm 덕분에 -54! 주세페 덕분에 -10! JayCe에게 -6 감사합니다!

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

온라인으로 사용해보십시오!


또는 binaryLogic패키지 사용 (39 바이트) :

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

2
나는 R을 잘 모른다. 그러나 나는 확실 ==0할 것이다 <1:)
Kevin Cruijssen



1
이것은 잘 작동합니다 : 32 바이트 그러나 약간의 설명이 필요합니다 :)
digEmAll

1
JayCe

5

C (gcc) , 36 바이트

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

온라인으로 사용해보십시오!

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

최적화 수준 0으로 컴파일해야합니다.


gcc 5.4.0에서 컴파일하지 않습니다 : error: expected constructor, destructor, or type conversion before '(' token(화살표는 f함수 이름에서를 가리킴 ). 어떤 컴파일러 플래그가 필요합니까?
villapx

1
와 함께 작동하지 않습니다 -O.
nwellnhof

2
"진실한 경우 0을 반환하고 거짓 인 경우 1을 반환합니다"이것이 합법적인가요? 답을 불신하지 않고 호기심을 느끼면 바이트를 절약 할 수 있기 때문입니다. 참고 :에 대한 질문 링크의 단어 truthy 이 답변 . 그리고이 의견 은 또한 진실성을 언급합니다.
Borka223

@nwellnhof @villapx 내 7.3.0에서 잘 컴파일됩니다- -O0컴파일러 플래그가 누락되지 않았는지 확인하십시오 .

@ Borka223 hmmm이 사이트를 수개월 동안 숙고 한 후에는 솔루션 내에서 일관성이 유지되는 한 진실되고 허위가 될 수 있다는 인상을 받았습니다. 그러나 당신이 연결 한 대답은 확실히 모순되는 것 같습니다. 나는 바이트를 추가했다. 감사합니다
vazt


4

PHP, 37 36 바이트

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

그것을 실행하려면 :

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

또는 온라인으로 사용해보십시오!

1참과 0거짓으로 인쇄 합니다 .

Benoit Esnard 덕분에 -1 바이트 !


1
모듈로 연산을 제거하여 1 바이트를 절약 할 수 있다고 생각합니다 <?=1&~substr_count(decbin($argn),1);. 이것도 0을 거짓으로 출력합니다.
Benoit Esnard

감사합니다 @BenoitEsnard! 그것은 매우 영리합니다. 나는 나의 대답을 업데이트했습니다 :) 당신은 매일 새로운 것을 배웁니다!
Davіd

4

Brachylog , 4 바이트

ḃo-0

온라인으로 사용해보십시오!

여러 테스트 사례 (😈는 악하고 👼은 아닙니다)

-술어 에 대해 최근에 발견 한 것을 사용합니다 . 문서에 "[입력]의 요소 차이"라고 표시되어 있지만 실제로 수행하는 것은 "입력의 짝수 색인 요소 (0에서 시작)의 합에서 홀수의 합을 뺀 것입니다. -인덱싱 된 입력 요소 "

이리,

숫자를 이진수 배열로 변환합니다.

o 모든 1을 하나로 모으기 위해 정렬합니다.

이제 짝수의 1이 있다면 짝수의 인덱스와 홀수의 인덱스에 같은 수의 1이있을 것입니다. 그래서- 이후에는 0이됩니다. 그러나 홀수가 1이면 여분의 1이 튀어 나와 차이가 -1 또는 1이됩니다.

마지막으로, 우리는 그 차이가이라고 주장하고, 0그 결과에 따라 참 또는 거짓 결과를 얻습니다. 하여 보다 유연한 출력 요건 이 모두 falsey 출력으로서 출력 truthy -1과 1과 0, 3 바이트 답변을 제거 할 수있다.


4

INTERCAL , 90 65 63 바이트

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

온라인으로 사용해보십시오!

C 스타일 주석으로 ungolfed 및 확장 (가치있는 것).

DO WRITE IN :1 //Store user input in 1
DO :2<-:1~:1 //Select just the ones. So will convert binary 10101 to 111
DO :3<-:?2 //Run the unary xor over the result. Essentially, xor with the right bitshifted
           //(with wraparound) value).
DO :9<-#0$#65535 //Intermingle the 16 bit values of all 0's and all 1's, to create a
                 //32 bit number with 1's in the odd positions.
DO :4<-:9~:3 //It turns out that at this point, evil numbers will have no bits in odd
             //positions, and non-evil numbers will have precisely one bit in an odd
             //position. Therefore, the ~ will return 0 or 1 as appropriate.
PLEASE READ OUT :4 //Politely output
PLEASE GIVE UP //Polite and self explanatory

INTERCAL에서 이것을 가능하게하기 위해 몇 가지 양보를해야했습니다. 첫 번째는 모든 INTERCAL 프로그램과 마찬가지로 숫자 입력을 작성해야합니다. 입력하고 싶다면707 하려면을 제공하십시오 SEVEN OH SEVEN.

두 번째는 INTERCAL이 실제로 진실하거나 거짓된 가치를 가지고 있지 않다는 것입니다. 대신 로마 숫자를 출력합니다.I 숫자가 악의가 아닌 경우 (1)를 하거나 0 ( -로마 숫자는 일반적으로 0을 나타낼 수 없으므로 일반적으로 표시됨)을 출력합니다.

악의 숫자가 1을 반환하고 악의가 아닌 숫자가 0을 반환하도록 뒤집기를 원한다면 3 바이트를 추가하더라도 다음과 같이 ungolfed 버전에서 4와 5 행을 변경할 수 있습니다.

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


3

dc , 18 16 바이트

[2~rd1<M+]dsMx2%

악의 경우 0을, 스택이 아닌 경우 1을 반환합니다.

온라인으로 사용해보십시오!

매우 간단하게 재귀 적으로 결합 된 몫 / 리마인더 연산자 ~를 새로운 몫에 적용하고 나머지를 모두 더한 다음 2 바이트를 씁니다 (2 바이트를 소비하여 표준 진실 / 거짓으로 뒤집기) .

진실성에 대해서는 0, 거짓에 대해서는 1, 특히 if(boolean)구성 이없는 언어에서는 괜찮다는 합의를 반영하도록 편집했습니다 .


3

파이썬 2, 29 바이트

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

온라인으로 사용해보십시오!

True이면 1을, 그렇지 않으면 0을 반환합니다.

숫자를 '0b11'과 같은 이진 문자열로 변환하고 1의 개수를 세고 결과의 보수를 얻은 다음 보수의 마지막 비트 (감사, https://codegolf.stackexchange.com/users/53560/cdlane !) (원래 번호가 짝수이면 1, 홀수이면 0).


1
No fewer bytes but lambda n:~bin(n).count('1')&1 replaces the modular division with something potentially less expensive.
cdlane

3

x86-16, 3 bytes

NASM listing:

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

16-bit integer function arg in AX (which is destroyed), return value in PF.

The hardware calculates the parity of the result for us, in x86's Parity Flag. The caller can use jp / jnp to branch, or whatever they like.

Works exactly like @cschultz's Z80 / 8080 answer; in fact 8086 was designed to make mechanical source-porting from 8080 easy.

Note that PF is only set from the low byte of wider results, so test edi,edi wouldn't work for an x86-64 version. You'd have to horizontal-xor down to 16 bits, or popcnt eax, edi / and al,1 (where 0 is truthy).


3

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

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

Try it online!


C++ (clang), 35 bytes

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

Try it online!


Here is my first attempt at code golfing, hope I didn't break any rule I might have missed.

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


Welcome to PPCG! You may be able to save a byte by golfing != to - and another four by golfing return to i=.
Jonathan Frech

@JonathanFrech It's been a long time since I did C++, does it implicitly return the last assigned expression in a function if there's no return statement? I'm guessing it's a gcc thing?
sundar - Reinstate Monica

1
It is a gcc specific undefined behaviour abuse on optimization level O0.
Jonathan Frech

By switching to K&R C, you can get it down to 23 bytes (very impressive!) Try it online!
ErikF

@JonathanFrech: why do people insist on using that stupid gcc -O0 hack? It's not like the length of a language's total boilerplate matters much when comparing implementations. Also, it makes it more interesting to choose between return vs. call-by-reference (updating *i in place). I'd rather write C or C++ answers, not un-optimized-gcc-only answers, because un-optimized-gcc isn't a very useful language.
Peter Cordes

3

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


Welcome to PPCG, and good first answer!
mbomb007

2

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

2

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.


1
n.toString(n,2) saves 4 bytes.
Okx

@Okx Not sure how I forgot about that one, lol.. Thanks! ;)
Kevin Cruijssen

If you're allowed to use 1 and 0 instead of true and false (not sure for Java), you can change to: ~n.toString(n,2).chars().sum()%2 to save one byte.
Mario Ishac

1
@MarDev Unfortunately 0 and 1 aren't truthy/falsey in Java, only booleans/Booleans are. If a challenge would state two distinct outputs are allowed the <1 could have been removed to save 2 bytes indeed. :)
Kevin Cruijssen


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.


2

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


@ceilingcat Good catch!
Govind Parmar

1
Suggest inc eax instead of not eax. Also may want to mention that this requires a processor with support for the popcnt instruction.
ceilingcat

1
also you do not have to take arg from stack. see allowed calling conventions codegolf.stackexchange.com/a/161497/17360 (Peter Cordes's more in-depth answer codegolf.stackexchange.com/a/165020/17360)
qwr

1
Note that you may return a boolean in FLAGS stackoverflow.com/a/48382679/3163618
qwr

Shouldn't 666 be a test case?
Arcanist Lupus

2

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

2

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!


You can remove the spaces between the 1 and the or to save +1 byte. Nice solution!
Amphibological

Man, I thought I tried that. Good catch!
Jack Brounstein

2

APL (Dyalog Unicode), 10 bytesSBCS

Anonymous tacit function. Can take any array of integers as argument.

≠⌿12∘⊥⍣¯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


2

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


Nice one! the boring approach is 9 bytes: 2|1+1#.#:
Conor O'Brien

This only seems to work because 777 in the input makes every number be represented in 10 bits. Replace it with e.g. 480 and the output flips.
FrownyFrog

@ConorO'Brien Boring trumps incorrect.
Adám

@FrownyFrog Fixed.
Adám
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.