This is the C/C++/C#/Java/Javascript/Perl/PHP/Pike bitwise XOR assignment operator. An XOR (exclusive or) conditional statement evaluates to true if and only if one of the two operands involved is true. Example: 0 ^ 0 = false 1 ^ 0 = true 0 ^ 1 = true 1 ^ 1 = false //Regular OR would evaluate this … Read more
This is less to do with C, and more to do with mathematics. The hash << 5 + hash expression is the same as hash * 32 + hash or just hash * 33. Basic algebra states these things are true (these are written in C): /* #1 */ (a * b + a * … Read more
k=25; ++k; k++; k|7&12; After the first 3 lines, k is 27. In the fourth expression, the bitwise AND operator & has higher precedence than the bitwise OR operator |, so it is equivalent to 27|(7&12); Converting the values to binary gives us 11011|(00111&01100); The inner part evaluates to 00100, then 11011|00100 evaluates to 11111, … Read more
Signed ints use Two’s complement in order to represent negative numbers. 1 represented in int32: 0000 0000 0000 0000 0000 0000 0000 0001 -1 represented in int32, using Two’s complement: 1111 1111 1111 1111 1111 1111 1111 1111 XORing the two results in: 1111 1111 1111 1111 1111 1111 1111 1110 which, for signed ints, … Read more
In C, in the result of the binary &, each bit depends on the two corresponding bits in the operands. If the bit in the same position is set (1) in both operands, it is set in the result. If it is clear (0) in either operand, it is clear in the result. For example, … Read more
If what you want is a division method faster than division by repeated subtraction (which you posted), and that will run indefinitely when you try to divide by zero, you can implement your own version of the Goldschmidt division, and not throw an error when the divisor is zero. The algorithm works like this: 1. … Read more
It turns out there is a general solution, which does not depend on word size, or even on two’s complement arithmetic. Here it is: int is_zero(int x) { unsigned y = x; unsigned c0 = y^y; unsigned c1 = ~(~c0 + ~c0); unsigned c1h = ~c0 ^ (~c0 >> c1); unsigned y2 = y + … Read more
It’s mentioned in Spec: Arithmetic operators: &^ bit clear (AND NOT) So it computes the AND connection of the first operand and the negated value of the second operand. Its name “bit clear” comes from what it does. Examined using it on two 1-bit value: if the second operand is 1, it means to “clear”: … Read more
I hope I understood your question right. You are looking for the XOR operator. C = A ^ B A 110101 B 101100 ——– C 011001 XOR will always be 1 if the two inputs are “different”. See: | A | B | XOR | |—+—+—–| | 0 | 0 | 0 | | 0 … Read more
We know school principle: if the sum of decimal digits is divisible by 9, then number is divisible by 9. The same approach works for any base of number system b and divisor b-1: for base=4 we can check that sum of two-bits chunks is divisible by 3. We can repeat this process until all … Read more
How’s that? from itertools import groupby input_list = [0, 1, 0, 0, 1, 1, 1, 0, 1, 0] results = [0, 0] # First value is zeros, second is ones for key, values in groupby(input_list): results[key] += (2**len(tuple(values))) – 1 assert results == [6,9] solved a pythonic way of doubling consecutive binary bits [closed]
Those aren’t bitwise operators per se. They’re operators, and each type can define for itself what it will do with them. The & and | operators map to the __and__ and __or__ methods of an object respectively. Sets define operations for these (intersection and union respectively), while lists do not. Lists define an operation for … Read more
In C# you write it like so: bool b = (flag & a) != 0; You can’t assign an int to a bool in C#, like you can in C++. (In C++ the compiler generates code that effectively does the same as the code above, although most C++ compilers will generate a warning if you … Read more
You could efficiently extract the month with bitwise operations if you represented the date in a binary format, e.g., 5 bits for the day of the month, 4 bits for the month number, and the rest for the year, rather than as decimal digits. For your example, the date would be (2011 << 9) + … Read more
When n++ & 1 executes, lets expect n is odd number at the moment, condition is true. Post incrementation is applied and n is even when result += n executes. Thats why its counting even numbers instead of odd. Modify code to while(n < 99) result += !(n++ & 1) ? n : 0; and … Read more