zpconn

## tree_weight.py
from collections import defaultdict


def weights(triples):
    tree = defaultdict(list)
    weights = defaultdict(int)
    cache = defaultdict(int)
    for t in triples:
        weights[t[0]] = t[2]
        tree[t[1]].append(t[0])

## inverse_phone.py
def product(lists):
	result = [[]]
	for l in lists:
		result = [x + [y] for x in result for y in l]
	for prod in result:
		yield prod

def inverse_phone(mappings, s):
	numbers = set([int(n) for n in s])
	combinations = product([mappings[n] for n in numbers])

## trie.py
def trie(*words):
    root = {}
    for word in words:
        curr_node = root
        for letter in word:
            curr_node = curr_node.setdefault(letter, {})
        curr_node.setdefault(None, None)
    return root

def trie_contains(trie, word):

## rabin-karp.py
class RollingHash:
  s = None
  start = 0
  end = 0
  hash = 0

  def __init__(self, s, length):
    self.s = s
    self.end = length - 1
    for i in range(length):

## README.md

      
              3 files
            
          
              0 forks
            
          
              0 comments
            
          
              0 stars
            
          
                zpconn
                / README.md
            
            
              Last active
              August 29, 2015 14:00
            
              
                Spherical alpha shapes
              
          
    This example demonstrates spherical alpha shapes in the orthographic projection. An alpha shape is a generalized concave hull which seeks to characterize the "shape" of a set of points on a surface. It is obtained here by computing the (spherical) Delaunay triangulation (accomplished with the aid of an excellent script from Jason Davies), stripping out triangles that are "too big", and then merging the resulting mesh to remove excess interior geometry that remains from the triangulation.

  
## reservoir_max.py
import random

def rand_max(arr):
	curr_max = 0
	curr_max_idx = 0
	curr_max_count = 1
	for i,x in enumerate(arr):
		if x > curr_max:
			curr_max = x
			curr_max_idx = i

## kalman.html
<!DOCTYPE html>
<html>
<head>
<style type="text/css">
html,
body {
    margin: 0;
    overflow: hidden;
    height: 100%;
}
	from collections import defaultdict


	def weights(triples):
	tree = defaultdict(list)
	weights = defaultdict(int)
	cache = defaultdict(int)
	for t in triples:
	weights[t[0]] = t[2]
	tree[t[1]].append(t[0])
	def product(lists):
	result = [[]]
	for l in lists:
	result = [x + [y] for x in result for y in l]
	for prod in result:
	yield prod

	def inverse_phone(mappings, s):
	numbers = set([int(n) for n in s])
	combinations = product([mappings[n] for n in numbers])
	def trie(*words):
	root = {}
	for word in words:
	curr_node = root
	for letter in word:
	curr_node = curr_node.setdefault(letter, {})
	curr_node.setdefault(None, None)
	return root

	def trie_contains(trie, word):
	class RollingHash:
	s = None
	start = 0
	end = 0
	hash = 0

	def __init__(self, s, length):
	self.s = s
	self.end = length - 1
	for i in range(length):
	import random

	def rand_max(arr):
	curr_max = 0
	curr_max_idx = 0
	curr_max_count = 1
	for i,x in enumerate(arr):
	if x > curr_max:
	curr_max = x
	curr_max_idx = i
	<!DOCTYPE html>
	<html>
	<head>
	<style type="text/css">
	html,
	body {
	margin: 0;
	overflow: hidden;
	height: 100%;
	}