Quicksort in Haskell:

quicksort [] = []
quicksort (p:xs) = quicksort (filter (<= p) xs) ++ [p] ++ quicksort (filter (> p) xs)

It has sensible and consistent names for functions and variables.

long bin(long x, long a) {
   long y = 1;
   ...

Names are consistent for sure.

Fast exponentiation would be one of my first choices as well along with several other pieces of code that rely on bit masks, specially DP with bit masks, for example storing all ancestors of a node of a tree that are 1 << i distant from it and then using those values to calculate lca of two nodes: That's what I call perfection, the way it all fits together.

That said since we are choosing a piece of code I would like to post the code to calculate the z function:

        public int[] functionZ(char[] str, int n) {
		int[] z = new int[n];

		int l = 0;
		int r = 0;
		z[0] = n;

		for (int i = 1; i < n; i++) {
			z[i] = Math.min(z[i - l], r - i + 1);

			while (i + z[i] < n) {
				if (str[z[i]] != str[i + z[i]]) {
					break;
				}
				z[i]++;
			}

			if (i + z[i] - 1 > r) {
				l = i;
				r = i + z[i] - 1;
			}

			r = Math.max(r, i);
		}

		return z;
	}

So fast, so beautiful and so powerful!

Though a one-liner, my favorite is the recursive implementation of Euclid's Algorithm (GCD):

int gcd(int a, int b) {
  return a ? gcd(b % a, a) : b;
}

gcd in python, is my favourite (from fractions module, not mine)

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

I like my implementations of string algorithms. For example, KMP:

int pi[100000];

void build_pi (string& str)
{
    int k = pi[0] = -1;
    
    for (int i = 0; i < str.size(); ++i)
    {
        for (; k >= 0 && str[i] != str[k]; k = pi[k]);
        
        pi[i + 1] = ++k;
    }
}

void kmp_match (string& p, string& text)
{
    build_pi(p);
    
    for (int i = 0, k = 0; i < text.size(); ++i)
    {
        for (; k >= 0 && text[i] != p[k]; k = pi[k]);
        
        if (++k == p.size())
            cout << "match at: " << i - p.size() + 1 << endl;
    }
}

I like my segment tree!

node seg[2 * N]; // N is some power of two

void add(int i, node x)
{
	seg[i += N] = x;
	for(i /= 2; i; i /= 2)
		seg[i] = merge(seg[i * 2], seg[i * 2 + 1]);
}

node get(int l, int r)
{
	node resL, resR;
	for(l += N, r += N; l < r; l /= 2, r /= 2)
	{
		if(l % 2)
			resL = merge(resL, seg[l++]);
		if(r % 2)
			resR = merge(seg[--r], resR);
	}
	return merge(resL, resR);
}

Computing Euler's totient function for all natural numbers <= n in O(n*log n):

int[] phi = new int[n + 1];
for (int i = 1; i <= n; ++i) {
  phi[i] += i;
  for (int j = 2 * i; j <= n; j += i) {
    phi[j] -= phi[i];
  }
}

Sparse Table Data Structure (masterpiece)

int arr[MAXN];
int mx[MAXN][LOGN];
void init() {
    for (int i = 0; i < n; i++)
        mx[i][0] = arr[i];
    for (int j = 1; (1 << j) <= n; j++)
        for (int i = 0; i + (1 << j) - 1 < n; i++)
	    mx[i][j] = max(mx[i][j - 1], mx[i + (1 << (j - 1))][j - 1]);
}

Floyd-Warshall algorithm

for(int k = 0; k < n; k++)
  for(int i = 0; i < n; i++)
    for(int j = 0; j < n; j++)
      d[i][j] = min(d[i][j], d[i][k] + d[k][j]);

Computing Modular Inverses (Modulo a Prime) for Natural Numbers <= N:

inv[1] = 1;
for (int i = 2; i < N; i++) { inv[i] = (MOD - (MOD / i) * inv[MOD % i] % MOD) % MOD; }

A one-liner to calculate modular inverse, returns 0 if gcd(a,m) != 1.

int inv(int a, int m) {
 return a < 2 ? a : ((1 - m * 1ll * inv(m % a, a)) / a % m + m) % m;
}

Path compression!

On a related note, how do I add codes in comments, with proper formatting?

The power of Python.

def isPalindrome(s):
  if s == s[::-1]:
    return True
  return False

a, b = b, a   #Swapping

Bogosort.

vector<int> bogosort(vector<int> A) {
    while(!is_sorted(begin(A),end(A))) random_shuffle(begin(A),end(A));
    return A;}

Maximum flow. (Can the code be made better?)

int maxFlow(int[][] cap, int source, int sink) {
  for (int flow = 0; ; ++flow)
    if (!augmentPath(cap, new boolean[cap.length], source, sink))
      return flow;
}

boolean augmentPath(int[][] cap, boolean[] vis, int i, int sink) {
  if (i == sink) return true;
  vis[i] = true;
  for (int j = 0; j < vis.length; j++)
    if (!vis[j] && cap[i][j] > 0 && augmentPath(cap, vis, j, sink)) {
      --cap[i][j];
      ++cap[j][i];
      return true;
    }
  return false;
}

Two pointers:

for (int L = 0, R = 0; L < n; L++) {
    while (R < n && !someCondition(R)) R++;
    updateSomething(L, R);
}

Binary search without overflow:

// 000[1]11
int binarySearchFirstTrueValue(IntPredicate predicate, int fromInclusive, int toExclusive) {
  int lo = fromInclusive;
  int hi = toExclusive;
  while (lo < hi) {
    int mid = (lo & hi) + ((lo ^ hi) >> 1);
    if (!predicate.test(mid))
      lo = mid + 1;
    else
      hi = mid;
  }
  return hi;
}

Take a Look at his codes -> Archon.JK

Seeing many binary searches here I will put mine, which is in my opinion much more clear and safe. Everybody knows that binary search is extremely prone to mistakes, especially for beginners, so here's my completely invulnerable to any mistakes approach.

int kl = 1, kp = 1e9, res = 0;
while (kl <= kp) {
  int cur = (kl + kp) / 2;
  if (Test(cur)) {
    res = cur;
    kl = cur + 1;
  } else {
    kp = cur - 1;
  }
}
return res;

What's so special?

First reason: I keep an invariant that interval [kl, kp] is something I don't know anything about. Stop condition is obvious — that interval is nonempty <=> (kl <= kp). Many people try to keep an invariant as sth like "I know that first element of my interval is good, about others I don't know" or "I know that first element is good, last is bad, rest unknown", but in my opinon this is much more complicated to maintain and demand much more thought about when to end this (look at this lo < hi - 1 in Xellos' code :<). Another kind of problems it omits are all about initialization, it may be also troublesome to those solutions with invariants other than mine.

Second reason: It's invulnerable to any bugs like "if beginning is odd, end is even and checked value is not good, then blah, blah and I will end up in infinite loop" or "if beginning is negative, end is positive, then stupid division of negative numbers will cause rounding in bad side, so blahblah, infinite loop". I got those +1 and -1 in case of success or failure, so my search interval is clearly strictly shrinking, no matter what, being even/odd/positive/negative is of no relevance.

Convex hull in O(n*log(n)) in Python:

# how to use: convex_hull([(0, 0),(2, 0),(0, 2),(2, 2),(1, 1)])
def convex_hull(points):
    def remove_middle(a, b, c):
        cross = (a[0] - b[0]) * (c[1] - b[1]) - (a[1] - b[1]) * (c[0] - b[0])
        dot = (a[0] - b[0]) * (c[0] - b[0]) + (a[1] - b[1]) * (c[1] - b[1])
        return cross < 0 or cross == 0 and dot <= 0

    hull = []

    for p in sorted(points) + sorted(points, reverse=True):
        while len(hull) >= 2 and remove_middle(hull[-2], hull[-1], p):
            hull.pop()
        hull.append(p)

    return hull[:-1]

calculate n-th Fibonacchi number (possibly modulo something) in

pair<ll, ll> fib1(ll n) {
  if (n == 0) return {0, 1};
  auto cur = fib1(n / 2);
  ll b = cur.first;      
  ll c = cur.second;     
  ll a = c - b;          
  ll F1 = c * c - a * a;  
  ll F2 = c * c + b * b;  
  if (n % 2) return {F2, F1 + F2};
  return {F1, F2};
}

ll fib(ll n) { return fib1(n).first; }

Reading single integer from input:

int n;
cin >> n;

Recursive Fenwick-Tree masterpiece [Please read the sentence with a proper British accent!]

int fen[N];

int get(int idx) {
	return idx > 0? fen[idx] + get(idx - (idx & -idx)): 0;
}

int upd(int idx, int v) {
	return idx < N? fen[idx] += v, upd(idx + (idx & -idx), v): 0;
}

Z- and prefix- functions, maybe :)

    int p[n];
    p[0] = 0;
    for(int i = 1; i < n; i++)
    {
        p[i] = p[i - 1];
        while(s[i] != s[p[i]]) p[i] = p[p[i] - 1];
        if(s[i] == s[p[i]]) p[i]++;
    }
/*----------------*/
    int z[n];
    int l = 0, r = 0;
    for(int i = 1; i < n; i++)
    {
        z[i] = max(0, min(z[i - l], r - i));
        while(i + z[i] < n && s[z[i]] == s[i + z[i]]) z[i]++;
        if(i + z[i] > r) l = i, r = i + z[i];
    }

Some short code

bool isPowerOfTwo(int n)
{
     return !(n & (n - 1));
}
void swap(int& a, int& b)
{
     a=a+b-(b=a);
}

in Java

public static boolean isPrime(int n) 
{
    return !new String(new char[n]).matches(".?|(..+?)\\1+");
}

int days(int y, int m, int d)
{ // number of days from 1 january 0 (1-indexed)
	if (m < 2) y--, m += 12;
	return 365 * y + y / 4 - y / 100 + y / 400 + (153 * m + 1) / 5 + d - (y == -1);
}

for (int mask = (1 << k) - 1; mask < (1 << n); )
{ // all masks with n bits and k ones, add yout code before if
	if (mask == 0) break;
	int x = mask & -mask, y = mask + x;
	mask = (((mask & ~y) / x) >> 1) | y;
}

Computing inverse modulo MOD for all natural numbers < MOD in O(n):

void GetAllInverseElements(int mod){
  ll inv[mod]; inv[1] = 1;
  for (int i=2; i<mod; i++){
    inv[i]= (mod/i) * inv[mod % i];
    inv[i]= (mod - inv[i] %mod)% mod;
  }
}

My favourite is implicit cartesian tree: http://pastebin.com/8fhVg3r4