¿Es este número malo?

34

Introducción

En teoría de números, un número se considera malvado si hay un número par de 1 en su representación binaria. En el desafío de hoy, estarás identificando si un número dado es malo o no.

Reto

Su trabajo consiste en escribir un programa completo o una función que acepte un número entero no negativo como entrada y salida (o retorno) independientemente de si ese número es malo o no.

  • Puede generar cualquier valor verdadero si el número es malo, y cualquier valor falso si el número no es malo.
  • Puede ingresar y enviar en cualquier formato aceptable .
  • Las lagunas estándar no están permitidas.
  • La secuencia OEIS A001969 es la secuencia que contiene todos los números malvados.
  • Aquí hay una lista de los primeros 10000 números malvados, para referencia (¡y más casos de prueba!)
  • Esta pregunta es el , así que cuanto más corto, mejor.
  • No se desanime por las respuestas extremadamente cortas en idiomas de golf. Te animo a enviar en cualquier idioma que te guste.
  • Aquí hay algunos casos de prueba:

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

La tabla de posiciones

Al final de la página hay un fragmento de pila que contiene una tabla de clasificación para esta pregunta. (Gracias, @ MartinEnder)

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

EDITAR: Creo que esta pregunta no es un duplicado de esto , porque mientras que esa pregunta es contar el número de unos, esta pregunta es si el número es par. Aunque puede lograr esta pregunta simplemente contando los bits, también hay otros enfoques .

Anfibológico
fuente
2
Relacionado (XOR-ing cada dígito binario es lo mismo que tomar la suma módulo-2).
Kevin Cruijssen
44
Posible duplicado de Count the number of ones in a unsigned 16-bit integer
Beta Decay
2
@BetaDecay, pero eso no funciona a la inversa: es decir, no puede tomar todas estas respuestas y eliminar el mod 2. Por lo tanto, este desafío invita a algunos métodos nuevos.
Anfibológico el
13
Creo que 666 => Falsedebería ser un caso de prueba.
user2390246
3
La tabla de posiciones está rota para mí
Jo King

Respuestas:

35

Conjunto Z80 (8 bits), 2 bytes

El siguiente código solo funciona con valores de hasta 255:

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


Versión de 16 bits (funciona en todos los casos de prueba), 3 bytes

Esto funciona con valores de hasta 65535.

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

Si te sientes aventurero, puedes reducir 1 byte almacenando la entrada AyC así

      ld BC, 777
C5    push BC
F1    pop AF

y luego corriendo

A9    xor C
C9    ret

Sin embargo, esto pone la carga sobre la persona que llama, por lo que puede ser que los dos bytes ( push BCy pop AF) también se cuenten.

cschultz2048
fuente
Me gusta esto, pero ¿cómo funciona? mi memoria para el ensamblaje (6502 + brazo) es que orson bit a bit con 2 operandos
northern-bradley
2
@ northern-bradley En el Z80, está implícito que el segundo operando de la ormnemónica es el acumulador A. En este caso, el comando no cambia A. Solo actualiza el registro de estado (y en particular, el indicador de paridad) a reflejar el contenido de A.
cschultz2048
1
¿Está Ppermitido según codegolf.meta.stackexchange.com/a/8509/29560 ? Es un solo bit dentro del Fregistro (flags) que tiene solo tres pares de instrucciones afectadas por él. Además, esta respuesta no menciona que solo compite por valores de 8 bits, ya que Aes un registro de 8 bits. Esto significa que no puede dar una respuesta 777o cualquier otro valor sin signo superior a 255.
CJ Dennis
2
Malditos incorporados:P
Jo King
1
@ cschultz2048 Aestá emparejado F, por lo que no aceptaría ABo BAcomo un valor de 16 bits. BCes de 16 bits, pero luego necesita una instrucción adicional para cargar uno de ellos Aantes de XORear el otro. Siempre he mencionado que mis respuestas Z80 funcionan completamente hasta 255 o 65535, dependiendo de la pregunta. ¿Quizás agregar una versión de 16 bits también? Entonces 2 bytes para valores de 8 bits, 3 bytes para valores de 16 bits.
CJ Dennis
25

JavaScript (ES6), 18 bytes

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

Pruébalo en línea!

Explicación

La lógica bit a bit es así:

  • Para enteros, ~-nes equivalente a -(-n)-1, por lo que solo es otra forma de hacerlo n-1. En ese caso particular, podríamos haberlo usado n-1.
  • n & (n-1)elimina el bit menos significativo establecido en 1 en n porque la disminución de n convierte todos los 0 finales en 1 y borra el 1 que sigue inmediatamente (por propagación de acarreo), mientras deja todo lo demás sin cambios.

    Ejemplo para n = 24 (11000 en binario):

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

Por lo tanto, procesamos tantas llamadas recursivas como haya 1 en la representación binaria de n , invirtiendo el resultado cada vez con !. La última llamada siempre devuelve 1 .

Ejemplos:

f(24) = !f(16) = !!f(0) = !!1 = true
f(7) = !f(6) = !!f(4) = !!!f(0) = !!!1 = false
Arnauld
fuente
Hola, entiendo lo que hace el código, pero no puedo entender la lógica / razonamiento detrás de él, a pesar de haber leído varios artículos sobre operaciones bit a bit, verificar si un número es una potencia de 2, etc. Sé lo que es una función recursiva . Simplemente no entiendo por qué se ha utilizado de esta manera y por qué esto funciona para responder al rompecabezas, es decir, el vínculo entre la recursión y! F (potencia de dos) <==> número maligno. Si tienes tiempo, la explicación sería bienvenida :) ¡gracias!
Supafly
1
@supafly He agregado una explicación. Y por cierto: ¡bienvenido a PPCG!
Arnauld
El procesamiento es muy claro ahora. Aún así, la idea / razonamiento es realmente mágico. ¡Gracias por la explicación!
Supafly
13

Python 2 , 25 bytes

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

Pruébalo en línea!

bin(n)da un resultado como '0b10101'. Al leer esto como un entero de base 13, obtenemos

que reduce el módulo 2 a 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).

Entonces int(bin(n),13)%2es igual a 1 + (número de unidades en bin(n)) módulo 2.

Si nes malo, entonces el resultado es 1; de lo contrario es 0.

Aprendí este truco de Noodle9 .

Lynn
fuente
Dado que este es Python 2, el código se puede acortar aún más con el desuso repr backtick sintaxis: lambda n:int(`n`,13)%2. Pruébalo en línea!
GarethPW
Sí, tuve un poco de pedo cerebral allí y olvidé el propósito del argumento base de int. Whoops!
GarethPW
11

Japt -h!, 5 4 3 bytes

¤å^

Intentalo


Explicación

¤       :Convert to base-2 string
 å^     :Cumulatively reduce by XORing
        :Implicitly output the last element negated
Lanudo
fuente
@LuisfelipeDejesusMunoz, portar la solución 05AB1E de Kevin también funciona a 5 bytes, si quieres probar eso.
Shaggy
¤¬x vEsta es la respuesta de Kevin
Luis felipe De jesus Munoz
@LuisfelipeDejesusMunoz, sí, eso es todo.
Shaggy
8

C # (compilador interactivo de Visual C #) , 43 38 bytes


Golfed Pruébelo en línea!

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

Sin golf

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

Código completo con pruebas

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

Lanzamientos

  • v1.1 - -5 bytes- Reemplazado CountporSum
  • v1.0 - 43 bytes- Solución inicial.

Notas

  • Ninguna
auhmaan
fuente
2
Votaron por la risa que me brindó su versión "no golfista".
Jack Brounstein
8

Bash (sin utilidades externas), 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))

Esto supone que el número se encuentra en $1, después de haber sido pasado como el primer argumento de línea de comando. También supone que este es un script de shell (para que pueda hacerlo exec).

Recurre, de una manera, usando exec $0, hasta que el número (in $1) llegue a cero, dividiéndolo por dos en cada iteración. También suma (in $2) la cantidad de veces que obtenemos un número que es impar. Al final, el número original era "malvado" si la suma $2no es impar.

Invocaciones de ejemplo:

$ ./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 correcto, con un poco de extra en el lateral.

Kusalananda
fuente
7

R , 37 26 bytes

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

Pruébalo en línea!

Una alternativa a la respuesta de Robert S. , evita la división de bits incorporada pero termina siendo menos golfosa y gracias a JayCe y digEmAll termina siendo un poco más golfista.

Solo funciona para enteros positivos menores que 231-1.

Giuseppe
fuente
¿Por qué no codificar 31 en lugar de log2? Pruébalo en línea!
digEmAll
@digEmAll Lo que a su vez significa que no es necesario definir x
JayCe
@digEmAll thanks! I wasn't sure about precision issues, although I suppose that past 2311 we (probably) lose precision in the %/% and %% operators so it would be a moot point.
Giuseppe
Also intToBits supports only integer values up to 2^31-1 ;)
digEmAll
6

05AB1E, 4 bytes

bSOÈ

Try it online or verify all test cases.

Explanation:

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
Kevin Cruijssen
fuente
5

Stax, 4 bytes

:1|e

Run and debug it

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

R, 99 98 44 34 28 bytes

-1 thanks to Kevin Cruijssen! -54 thanks to ngm! -10 thanks to Giuseppe! -6 thanks to JayCe!

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

Try it online!


Alternatively, using the binaryLogic package (39 bytes):

!sum(binaryLogic::as.binary(scan()))%%2
Robert S.
fuente
2
I don't know R too well, but I'm pretty sure ==0 can be <1 :)
Kevin Cruijssen
1
43 bytes?
ngm
1
Nice! 34 bytes is possible
Giuseppe
1
This works as well I think : 32 bytes But requires a bit of an explanations :)
digEmAll
1
it's easy to turn this into a full program for some more bytes
JayCe
5

C (gcc), 36 bytes

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

Try it online!

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

Must be compiled with optimization level 0

vazt
fuente
Doesn't compile on gcc 5.4.0: error: expected constructor, destructor, or type conversion before '(' token (arrow is pointing at the f in the function name). What compiler flag(s) do I need?
villapx
1
Doesn't work with -O.
nwellnhof
2
"Returns 0 for truthy, 1 for falsey" Is this legal? Not trying to discredit your answer, just curious, and because it would save me a byte. Note: The word truthy in the question links to this answer. And this comment also mentions truthiness.
Borka223
@nwellnhof @villapx Compiles fine on my 7.3.0 - just make sure you're not missing the -O0 compiler flag.
@Borka223 hmmm after months of perusing this site, I was under the impression that truthy and falsey could be anything, so long as they are consistent within your solution. However, the answer you linked certainly seems to contradict that. I went ahead and added the byte. Thanks
vazt
4

PHP, 37 36 bytes

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

To run it:

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

Or Try it online!

Prints 1 for true, and 0 for false.

-1 byte thanks to Benoit Esnard!

Davіd
fuente
1
I think you can save one byte by removing the modulo operation: <?=1&~substr_count(decbin($argn),1);. This one also prints 0 for false.
Benoit Esnard
Thanks @BenoitEsnard! That's very clever, I've updated my answer :) You learn something new every day!
Davіd
4

Brachylog, 4 bytes

ḃo-0

Try it online!

With multiple test cases (😈 is evil and 👼 is not.)

Uses something I discovered recently about the - predicate: its documentation just says "the difference of elements of [input]", but what it actually does is "sum of even-indexed elements (starting from 0th) of input, minus the sum of odd-indexed elements of input".

Here,

converts the number into an array of binary digits,

o sorts them to bring all the 1s together.

Now, if there were an even number of 1s, there would be an equal number of 1s in even indices and odd indices. So the - after that would give a 0. But if there were an odd number of 1s, there would be an extra 1 sticking out, resulting in the difference being either -1 or 1.

So, finally, we assert that the difference is 0, and get a true or false result according to that. With more flexible output requirements, this could be removed for a 3 byte answer, with 0 as truthy output and -1 and 1 as both falsey outputs.

sundar - Reinstate Monica
fuente
4

INTERCAL, 90 65 63 bytes

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

Try it online!

Ungolfed and expanded (for what it's worth) with C style comments.

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

I had to make a few concessions to make this feasible in INTERCAL. The first is, as with all INTERCAL programs, numerical input must be written out. So if you want to input 707 you would provide SEVEN OH SEVEN.

The second is that INTERCAL doesn't really have proper truthy or falsy value. Instead, it will output the Roman Numeral I (1) if the number is not evil, or a 0 (typically represented as - since Roman Numerals can't normally represent 0).

If you want to flip those so that evil numbers return 1 and non-evil numbers return 0, you can change lines 4 and 5 from the ungolfed version as follows, although it does add 3 bytes.

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

Attache, 13 12 bytes

Even@Sum@Bin

Try it online!

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

This is a composition of three functions:

  1. Bin
  2. Sum
  3. Even

This checks that the Sum of the Binary expansion of the input is Even.

Conor O'Brien
fuente
:| i have no words
ASCII-only
@ASCII-only quite succinct, eh? c:
Conor O'Brien
3

dc, 18 16 bytes

[2~rd1<M+]dsMx2%

Returns (to the stack) 0 for evil and 1 for not evil

Try it online!

Fairly straightforward - recursively applies the combined quotient/remainder operator ~ to the new quotient and adds all the remainders together, then mods by 2 (after spending two bytes to flip to a standard truthy/falsy).

Edited to reflect consensus that 0 for truthy and 1 for falsy is okay, especially in a language that has no sort of if(boolean) construct.

Sophia Lechner
fuente
3

Python 2, 29 bytes

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

Try it online!

Returns 1 if True, else 0.

Converts the number to a binary string like '0b11', counts the number of 1s, gets the complement of result, and returns the last bit of the complement (thanks, https://codegolf.stackexchange.com/users/53560/cdlane!) (1 if the original number was even, 0 if it was odd).

Triggernometry
fuente
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).

Peter Cordes
fuente
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

Annyo
fuente
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

CarManuel
fuente
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
reffu
fuente
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.

Kevin Cruijssen
fuente
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

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?
Brad Gilbert b2gills
fuente
*.base(2)%9%%2
Jo King
Ah, that doesn't work for digits with more than 9 bits...
Jo King
1
{:3(.base(2))%%2}
nwellnhof
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.

Neil
fuente
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

Govind Parmar
fuente
@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
Digital Trauma
fuente
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!

Jack Brounstein
fuente
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

Adám
fuente
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

Adám
fuente
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