righthandabacus

#!/usr/bin/env python

"""
Given $k$ sorted lists, each of size $n$, find a range $(p,q)$ such that:
    1. q-p is minimized
    2. for any list, there is an element $r$, such that $p <= r <= q$

Example:
    [4, 10, 15, 24]
    [0, 9, 12, 20]

righthandabacus

def heapalgo(items, n):
    """heap algorithm to generate all permutations in-place
    
    Args:
        items: list of items
        n: initially the list of items, only permute on the first n-items
    Generates:
        a permutation of first n items of the list, in-place shuffle performed
    """
    assert items, "cannot go with empty list"

righthandabacus

import atexit
import time
import logging
import signal
import os

def sighandler(sigcode, x):
    print("Signal Exit!!", flush=True)
    print([sigcode, x], flush=True)
    exitcall()

righthandabacus

def stalinsort(unsorted):
    """Stalin sort: O(n) sort algorithm that iterate down a
    list of elements, any element which is out of order is
    eliminated.
    https://www.facebook.com/ProgrammersCreateLife/photos/a.241809332534619/1934139766634892/?type=1&theater
  
    Args:
        unsorted: Iterable of elements that support >= operator
    Returns:
        A list of subset of the input

righthandabacus

import argparse

# Expose argparser into global scope
_parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
_subcmds = _parser.add_subparsers(
    title="Commands",
    description="Available actions",
    dest="subcmd")

# Subcommand argparse decorator

righthandabacus

# 2D multivariate normal
# with covariance matrix [3 2; 2 5], i.e. Var(x)=3, Var(y)=5, Cov(x,y)=2
# Break down covariacne matrix with Cholesky decomposition and multiply with iid std normal random numbers

Sigma = [4 9; 9 25]
S = chol(Sigma) # upper triangular part, i.e. S' * S == Sigma
iidnorm = randn(2,1000)
rv = S' * iidnorm # 2x1000 matrix of 1000 random number pairs conforms to the covariance matrix Sigma

# Plot in 2D

righthandabacus

"""
generate n random walks from 0 to T with N steps

Returns:
   t (range) of time from 0 to T with N steps
   W (nxN array) of random walks
"""
function rwalks(T,N,n)
    dt = T/N
    dW = sqrt(dt)*randn(n,N)

righthandabacus

/* Knuth, Dancing Link, 2000
 *
 * This program solve the covering set problem using the DLX algorithm in the
 * abovementioned paper.
 */

#include <iostream>
#include <vector>
#include <string>
#include <memory> // for shared_ptr

righthandabacus

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import print_function

import datetime
import os
import subprocess
import time
import urlparse
from StringIO import StringIO

righthandabacus

from __future__ import print_function
import itertools
import hashlib

# generate a rainbow table for HKID
# 2017-02-11

def checkdigit(a, i, j, k, l, m, n):
    numeric = [ord(a) - 65 + 1, int(i), int(j), int(k), int(l), int(m), int(n)]
    weight = range(8,1,-1)