Algorithms on Unnamed Website

Proving That Fenwick Trees are Fast

Anthony Wang — Thu, 10 Apr 2025 14:13:20 -0400

Fenwick trees are really fast (although you can speed them up 10x using cache and SIMD tricks). But can we prove this using Dafny?

Kublai: Oh nooooo not Dafny again!

Don’t worry, we’ll only write a few lines of Dafny code this time. Still, you should read my previous Fenwick tree posts since otherwise this post probably won’t make much sense.

Formally Verifying Fenwick Trees

Anthony Wang — Sat, 15 Mar 2025 21:30:06 -0400

Kublai: Hey, it’s you again! That formal verification thing you mentioned last time sucks!

Huh? You mean our proof of the ICan’tBelieveItCanSort algorithm?

Kublai: Yeah! ICan’tBelieveItCanSort? More like ICanBelieveItObviouslyCanSort! After watching that visualization a few times, it intuitively makes so much sense. It’s trivial.

Trivial? I’m banning that word. If you consider something to be trivial, you probably haven’t pondered it deeply enough.

ICanProveItCanSort!

Anthony Wang — Sun, 23 Feb 2025 19:46:46 -0500

I previously blogged about the ICan’tBelieveItCanSort algorithm, which is a weird insertion sort-like algorithm that defies all common sense and somehow sorts arrays. Well, if you read that post and watch the visualization a few times, it should make more intuitive sense why it works.

Kublai: Hey, I don’t believe you! Your visualization looks pretty cool, but how can you be sure this wacky algorithm works for all inputs?

Glad you asked! To dispel all doubt, here’s a formal proof.

Fenwick Trees are Awesome!

Anthony Wang — Tue, 14 Jan 2025 20:53:04 -0500

This post will only use one-based indexing since that’s what Fenwick trees traditionally use, although they can also be modified to use zero-based indexing.

So imagine you have an array $A$ of size $N$, and you’d like to support two operations. The first one, called $Update(i, v)$, is trivial: Given an index $i$, add $v$ to $A_i$. Easy peasy!

Solving Shortest Paths With Transformers

Anthony Wang — Wed, 11 Dec 2024 11:29:07 -0500

Introduction

Motivation

Neural networks are capable of impressive feats of off-distribution generalization. For instance, we discussed in class a program trained to convert sketches of cats into realistic looking pictures of cats that was able to draw a cat with three eyes given a sketch with three eyes, even though there were no 3-eyed cats in the training data. However, neural networks also often learn non-robust features that cause them to perform poorly off-distribution (e.g., adversarial examples for an image classifier). In this project, we will investigate the question of when transformers generalize off-distribution via a case study on a simple synthetic task. More specifically, the goal of our project is to make progress towards answering the following question:

ICan'tBelieveItCanSort!

Anthony Wang — Mon, 04 Nov 2024 12:20:49 -0500

I recently learned a new sorting algorithm called the ICan’tBelieveItCanSort algorithm:

for (int i = 0; i < n; i++)
 for (int j = 0; j < n; j++)
 if (A[i] < A[j])
 swap(A[i], A[j]);

Wait what? The more I think about this, the more I think it shouldn’t work. This sorts in increasing order?

But it does actually work, and I think watching a visualization is the best way to convince yourself.

I still can’t believe it can sort! But this algorithm does have a certain aesthetic elegance so I definitely encourage you to use it in all your programs to troll the next person who reads your code!

"Bad Apple!!" But It's An Animated QR Code of "Bad Apple!!"

Anthony Wang — Wed, 15 May 2024 00:14:48 -0400

Rejected intro for our final report:

Imagine a scenario where Kevin and Anthony are on an airplane, and Kevin would like to share a PDF of the 6.8301 textbook on his phone with Anthony. But in an unfortunate twist of fate, Kevin has an iPhone and cannot AirDrop the file to Anthony’s Android phone, and neither person wants to pay for airplane Wi-Fi. Other data transfer methods like Ethernet or USB drives require additional hardware and for both devices to have the necessary ports. This scenario is not unique, and there are other cases where existing data transfer methods fail, such as in remote locations or during power outages.

Fast Multipole Methods

Anthony Wang — Wed, 08 May 2024 11:52:04 -0400

Help I’m trapped in a final projects factory!

Fortunately this semester I have no final exams, just five freaking final projects. One of them was due last week and already graded, so I’m publishing it on this website here. It’s a Pluto notebook and has some flashy visualizations, but it’s honestly pretty light on substance, although it did get a grade of 100%. I probably wasted too much time playing with trying to find stable 3-body configurations. You can either download the notebook and run it in Pluto.jl, or copy the link and run it on Binder.

854 Rap

Anthony Wang — Wed, 24 Jan 2024 21:46:18 -0500

In November 30, 2022, ChatGPT was released. Actually, this has nothing to do with the topic of today’s post. For that, we need to go back three weeks.

6.854, now known as 6.5210, is MIT’s Advanced Algorithms class taught by Professor David Karger, known for being a great but tough class. Back in November 2022, some friends and I were taking the class, and fortunately, none of the assignments involve writing a rap about algorithms, but we decided to write one anyways for fun and perform it in-class. (We also orchestrated a live performance of a splay tree with humans representing the nodes, but it ended up being too hectic.)

Dead Pixels

Anthony Wang — Tue, 19 Dec 2023 21:15:01 +0000

The problem

Billiam Wender just bought a new BenQ gaming monitor! His monitor is an N by M rectangle of pixels. Each pixel currently has a brightness level between 0 and 255 inclusive.

However, Billiam suspects that his gaming monitor is defective and contains dead pixels! Oh no! He would like to find which subrectangle (a smaller rectangle contained inside the entire rectangle) of the monitor’s grid of pixels has the lowest average brightness level, because that’s probably where the dead pixels are located. Help Billiam find the dead pixels! Output a single integer, the smallest average brightness of any subrectangle of the monitor’s rectangular grid of pixels.

Spelling Reform is Hard, NP-Hard

Anthony Wang — Tue, 07 Nov 2023 15:54:08 +0000

Spelling sucks. “Though” rhymes with “go”. “Thought” rhymes with “got”. “Through” rhymes with… “true”, “grew”, “who”, “lieu”, “you”, “flu”, “moo”, “shoe”, “coup”, “queue”, and “view”. Enough examples, let’s fix this madness!

Here’s a hypothetical procedure to reform English spelling: for every word, it has some IPA pronunciation. For instance, “through” is pronounced “θɹu”. Now let’s replace every letter in the IPA pronunciations with strings of one or more letters, such as mapping all occurrences of “θ” to “th”, “ɹ” to “r” and “u” to “oo”. Of course, we don’t want the new phonetics-based spellings to get too crazy, so we should minimize the total number of changes between the old and new spellings. Let’s define the “amount of change” between two spellings as the minimum number of insertions, deletions, and single-character replacements, which is technically called the Levenshtein edit distance. In our little example, the edit distance between “through” and “throo” is 3, because we have to replace the “u” with an “o” and delete the last two characters. Lastly, we should make this sum of edit distances weighted by the frequency of each word in typical English, since people care a lot more if the spelling of “through” changes versus the spelling of “queue”.

Beating the Time Limit

Anthony Wang — Wed, 25 Jan 2023 01:30:50 +0000

#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
#include <bits/stdc++.h>
using namespace std;

int main() {
	int N = 1e5;
	long long sum = 0;
	for (int i = 0; i < N; ++i) {
		for (int j = 0; j < N; ++j) {
			sum += i^j;
		}
	}
	cout << sum;
}

Hey you! We have here an O(N^2) algorithm with N = 10^5, doing a ridiculous number of operations. How long do you think it takes for this code to run on my laptop?

Installing Every Arch Package

Anthony Wang — Wed, 26 Jan 2022 21:52:58 -0600

Challenge accepted. Let’s do it!

First things first, let’s generate a list of all official Arch Linux packages. Fortunately, pacman, the best pragmatic package manager in existence, makes this a breeze.

pacman -Sql

Great, now let’s install it all!

sudo pacman -S $(pacman -Sql)

10 seconds later, you’ll find yourself with… unresolvable package conflicts detected?

OK, fine, let’s disable dependency checking then:

sudo pacman -Sdd $(pacman -Sql)

Nope, didn’t work. We have to do something about the conflicting packages!