Bit Manipulation

def get_bit(x: int, i: int) -> int:
    """Bit i of x, as 0 or 1. Bits count from 0 at the right."""
    return (x >> i) & 1


def set_bit(x: int, i: int) -> int:
    """x with bit i turned on."""
    return x | (1 << i)


def clear_bit(x: int, i: int) -> int:
    """x with bit i turned off."""
    return x & ~(1 << i)


def toggle_bit(x: int, i: int) -> int:
    """x with bit i flipped."""
    return x ^ (1 << i)


def pop_count(x: int) -> int:
    """How many bits of x (x >= 0) are set. Each pass clears the lowest one."""
    count = 0
    while x != 0:
        x &= x - 1
        count += 1
    return count


def lowest_set_bit(x: int) -> int:
    """Only the lowest set bit of x: 12 (1100) gives 4 (0100)."""
    return x & -x


def is_power_of_two(x: int) -> bool:
    """A power of two has exactly one set bit, so clearing it leaves 0."""
    return x > 0 and (x & (x - 1)) == 0


if __name__ == "__main__":
    x = 12  # 1100 in binary
    print(get_bit(x, 2), get_bit(x, 0))  # 1 0
    print(set_bit(x, 0), clear_bit(x, 3), toggle_bit(x, 1))  # 13 4 14
    # Each line: n, pop_count, lowest_set_bit, is_power_of_two.
    for n in [12, 16, 7, 0]:
        print(n, pop_count(n), lowest_set_bit(n), is_power_of_two(n))

// Bit i of x, as 0 or 1. Bits count from 0 at the right.
export function getBit(x: number, i: number): number {
  return (x >> i) & 1;
}

// x with bit i turned on.
export function setBit(x: number, i: number): number {
  return x | (1 << i);
}

// x with bit i turned off.
export function clearBit(x: number, i: number): number {
  return x & ~(1 << i);
}

// x with bit i flipped.
export function toggleBit(x: number, i: number): number {
  return x ^ (1 << i);
}

// How many bits of x (x >= 0) are set. Each pass clears the lowest one.
export function popCount(x: number): number {
  let count = 0;
  while (x !== 0) {
    x &= x - 1;
    count++;
  }
  return count;
}

// Only the lowest set bit of x: 12 (1100) gives 4 (0100).
export function lowestSetBit(x: number): number {
  return x & -x;
}

// A power of two has exactly one set bit, so clearing it leaves 0.
export function isPowerOfTwo(x: number): boolean {
  return x > 0 && (x & (x - 1)) === 0;
}

const x = 12; // 1100 in binary
console.log(getBit(x, 2), getBit(x, 0)); // 1 0
console.log(setBit(x, 0), clearBit(x, 3), toggleBit(x, 1)); // 13 4 14
// Each line: n, popCount, lowestSetBit, isPowerOfTwo.
for (const n of [12, 16, 7, 0]) {
  console.log(n, popCount(n), lowestSetBit(n), isPowerOfTwo(n));
}

package main

import "fmt"

// getBit returns bit i of x, as 0 or 1. Bits count from 0 at the right.
func getBit(x, i int) int {
	return (x >> i) & 1
}

// setBit returns x with bit i turned on.
func setBit(x, i int) int {
	return x | (1 << i)
}

// clearBit returns x with bit i turned off. Go spells AND NOT as &^.
func clearBit(x, i int) int {
	return x &^ (1 << i)
}

// toggleBit returns x with bit i flipped.
func toggleBit(x, i int) int {
	return x ^ (1 << i)
}

// popCount returns how many bits of x (x >= 0) are set. Each pass clears the
// lowest one.
func popCount(x int) int {
	count := 0
	for x != 0 {
		x &= x - 1
		count++
	}
	return count
}

// lowestSetBit returns only the lowest set bit of x: 12 (1100) gives 4 (0100).
func lowestSetBit(x int) int {
	return x & -x
}

// isPowerOfTwo reports whether x is a power of two. A power of two has exactly
// one set bit, so clearing it leaves 0.
func isPowerOfTwo(x int) bool {
	return x > 0 && x&(x-1) == 0
}

func main() {
	x := 12 // 1100 in binary

	fmt.Println(getBit(x, 2), getBit(x, 0))                    // 1 0
	fmt.Println(setBit(x, 0), clearBit(x, 3), toggleBit(x, 1)) // 13 4 14
	// Each line: n, popCount, lowestSetBit, isPowerOfTwo.
	for _, n := range []int{12, 16, 7, 0} {
		fmt.Println(n, popCount(n), lowestSetBit(n), isPowerOfTwo(n))
	}
}

using System;

public class Solution
{
    // Bit i of x, as 0 or 1. Bits count from 0 at the right.
    public static int GetBit(int x, int i) => (x >> i) & 1;

    // x with bit i turned on.
    public static int SetBit(int x, int i) => x | (1 << i);

    // x with bit i turned off.
    public static int ClearBit(int x, int i) => x & ~(1 << i);

    // x with bit i flipped.
    public static int ToggleBit(int x, int i) => x ^ (1 << i);

    // How many bits of x (x >= 0) are set. Each pass clears the lowest one.
    public static int PopCount(int x)
    {
        int count = 0;
        while (x != 0)
        {
            x &= x - 1;
            count++;
        }
        return count;
    }

    // Only the lowest set bit of x: 12 (1100) gives 4 (0100).
    public static int LowestSetBit(int x) => x & -x;

    // A power of two has exactly one set bit, so clearing it leaves 0.
    public static bool IsPowerOfTwo(int x) => x > 0 && (x & (x - 1)) == 0;

    public static void Main()
    {
        int x = 12; // 1100 in binary
        Console.WriteLine($"{GetBit(x, 2)} {GetBit(x, 0)}"); // 1 0
        Console.WriteLine($"{SetBit(x, 0)} {ClearBit(x, 3)} {ToggleBit(x, 1)}"); // 13 4 14
        // Each line: n, PopCount, LowestSetBit, IsPowerOfTwo.
        foreach (int n in new[] { 12, 16, 7, 0 })
        {
            Console.WriteLine($"{n} {PopCount(n)} {LowestSetBit(n)} {IsPowerOfTwo(n)}");
        }
    }
}

public class Solution {
    // Bit i of x, as 0 or 1. Bits count from 0 at the right.
    static int getBit(int x, int i) {
        return (x >> i) & 1;
    }

    // x with bit i turned on.
    static int setBit(int x, int i) {
        return x | (1 << i);
    }

    // x with bit i turned off.
    static int clearBit(int x, int i) {
        return x & ~(1 << i);
    }

    // x with bit i flipped.
    static int toggleBit(int x, int i) {
        return x ^ (1 << i);
    }

    // How many bits of x (x >= 0) are set. Each pass clears the lowest one.
    static int popCount(int x) {
        int count = 0;
        while (x != 0) {
            x &= x - 1;
            count++;
        }
        return count;
    }

    // Only the lowest set bit of x: 12 (1100) gives 4 (0100).
    static int lowestSetBit(int x) {
        return x & -x;
    }

    // A power of two has exactly one set bit, so clearing it leaves 0.
    static boolean isPowerOfTwo(int x) {
        return x > 0 && (x & (x - 1)) == 0;
    }

    public static void main(String[] args) {
        int x = 12; // 1100 in binary
        System.out.println(getBit(x, 2) + " " + getBit(x, 0)); // 1 0
        System.out.println(setBit(x, 0) + " " + clearBit(x, 3) + " " + toggleBit(x, 1)); // 13 4 14
        // Each line: n, popCount, lowestSetBit, isPowerOfTwo.
        for (int n : new int[] {12, 16, 7, 0}) {
            System.out.println(n + " " + popCount(n) + " " + lowestSetBit(n) + " " + isPowerOfTwo(n));
        }
    }
}