Algorithm on H&W

Bit Twiddling Hacks Summary

Wed, 27 May 2026 22:40:00 +0800

Bit Twiddling Hacks Summary

This note summarizes practical techniques from Bit Twiddling Hacks.
It follows the same style as common-algorithm-patterns.md: each topic has Explanation + C++ Framework.

0) Preconditions and Portability

Explanation

Bit hacks are highly sensitive to integer representation and shift semantics:

Prefer unsigned fixed-width types like uint32_t / uint64_t.
Right-shifting negative signed values is implementation-defined.
Be careful with overflow-prone expressions such as x - y.

Code Framework

#include <bit>
#include <cstdint>
#include <limits>

using u32 = uint32_t;
using u64 = uint64_t;
using i32 = int32_t;

1) Sign and Opposite-Sign Detection

Explanation

Sign extraction is often normalized to -1 / 0 / 1.
Two values have opposite signs when their sign bits differ.

Code Framework

int sign3(int x) {
    return (x > 0) - (x < 0); // -1 / 0 / 1
}

bool oppositeSigns(int x, int y) {
    return (x ^ y) < 0;
}

2) Branchless abs / min / max

Explanation

Useful when branch misprediction is expensive, but always benchmark against normal standard-library versions first.

Common Algorithm Patterns

Wed, 27 May 2026 22:02:00 +0800

Common Algorithm Patterns

Each pattern has only two parts: Explanation + Code Framework.

1) Framework Thinking (Traversal First)

Explanation

Most problems are traversal problems in disguise: arrays, linked lists, trees, graphs.
Identify the data structure first, then pick traversal order, then fill business logic into the skeleton.

Code Framework

#include <vector>
using namespace std;

struct ListNode {
    int val;
    ListNode* next;
};

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
};

void processValue(int x) {
    // TODO: business logic
    (void)x;
}

void traverseArray(const vector<int>& nums) {
    for (int i = 0; i < (int)nums.size(); ++i) {
        processValue(nums[i]);
    }
}

void traverseList(ListNode* head) {
    for (ListNode* p = head; p != nullptr; p = p->next) {
        processValue(p->val);
    }
}

void traverseTree(TreeNode* root) {
    if (root == nullptr) return;
    // Pre-order
    processValue(root->val);
    traverseTree(root->left);
    traverseTree(root->right);
    // Post-order
}

2) Binary Search (Shrink Search Space)

Explanation

Use binary search when monotonicity exists.
The key is consistency: interval definition + boundary update rules.

[GLP] Why Is It Running Slow?

Wed, 07 Jul 2021 11:36:45 +0800

A colleague dropped some code on me and asked why applying a semi-transparent mask to images was so slow. Apparently it was written by a “strong algorithm engineer” from another team. Here it is:

# -*- coding: utf-8 -*-
import numpy as np
import os
import cv2

def put_mask(img_path, output_fold):
    image = cv2.imread(r'E:\testdemo.jpg')
    bbox1 = [72, 41, 208, 330]
    bbox2 = [100, 80, 248, 334]
    zeros1 = np.zeros((image.shape), dtype=np.uint8)
    zeros2 = np.zeros((image.shape), dtype=np.uint8)
    zeros_mask1 = cv2.rectangle(zeros1, (bbox1[0], bbox1[1]), (bbox1[2], bbox1[3]), color=(0, 0, 255), thickness=-1)
    zeros_mask2 = cv2.rectangle(zeros2, (bbox2[0], bbox2[1]), (bbox2[2], bbox2[3]), color=(0, 255, 0), thickness=-1)
    zeros_mask = np.array((zeros_mask1 + zeros_mask2))
    try:
        alpha = 1    # opacity of the original image
        beta = 0.5   # opacity of the mask layer
        gamma = 0
        # blend original image with mask
        mask_img = cv2.addWeighted(image, alpha, zeros_mask, beta, gamma)
        cv2.imwrite(os.path.join(output_fold, 'mask_img.jpg'), mask_img)
    except:
        print('error')
    put_mask(img_path='107.jpg', output_fold=r'E:\output')

My first reaction: this is pretty careless. Python is easy to write — that’s true — but that doesn’t mean anything goes.

[Autodesk] Play With Bloom Filter

Fri, 07 Aug 2020 11:38:41 +0800

What Is a Bloom Filter?

A Bloom filter is a space-efficient probabilistic data structure used to test whether an element is a member of a set. When an element is added, it is hashed by K independent hash functions, each mapping the element to a position in a bit array, which is then set to 1.

To query membership, the same K positions are checked:

If any bit is 0 → the element is definitely not in the set.
If all bits are 1 → the element is probably in the set (false positives are possible).

The key difference from a single-hash bitmap: using K hash functions spreads the load and significantly reduces collision probability.