ferristseng

def parse_options(opts):
  if opts:
    return '?%s' % '&'.join(['%s=%s' % (k, v) for (k, v) in opts.iteritems()])
  return ''

ferristseng

use std::mem::{swap};
use std::fmt::{Debug};

struct MaxHeap<T> {
  inner: Vec<T>
}

impl<T> MaxHeap<T> where T: PartialOrd<T> + Debug {
  #[inline]
  fn new() -> MaxHeap<T> {

ferristseng

#![feature(box_syntax)]

use std::collections::{LinkedList, VecDeque};

use Tree::{Leaf, Node};

pub enum Tree<T> {
  Leaf,
  Node(Box<Tree<T>>, Box<Tree<T>>, T)
}

ferristseng

#![feature(box_syntax)]

use Tree::{Leaf, Node};

#[derive(Debug)]
pub enum Tree<T> {
  Leaf,
  Node(Box<Tree<T>>, Box<Tree<T>>, T)
} 

ferristseng

#![feature(unicode, str_char)]
#![allow(deprecated)]

fn max(l: usize, r: usize) -> usize {
  if l > r { l } else { r }
}

pub fn lcs(s0: &str, s1: &str) -> usize {
  let s0_tlen = s0.width(false);
  let s1_tlen = s1.width(false);

ferristseng

pub fn print_matrix_diag(mm: &[&[usize]]) {
  assert!(mm.len() > 0);

  let xdim = mm[0].len();
  let ydim = mm.len();
  let maxdim = xdim + ydim - 1;

  println!("---");
  for i in 0..maxdim {
    print_el(mm, i as isize, 0, xdim, ydim);

ferristseng

use std::collections::VecDeque;


pub struct SlidingWindowMaximumIterator<'a, T : 'a> {
  ascend: VecDeque<&'a T>,
  slice: &'a [T],
  sizek: usize,
  index: usize
}

ferristseng

#![feature(str_char)]

use std::ascii::AsciiExt;
use std::usize::MAX;

fn is_palindrome(s: &str) -> bool {
  assert!(s.is_ascii());

  let mid = s.len() / 2;
  let mut left_ptr = if s.len() % 2 == 0 { mid - 1 } else { mid };

ferristseng

#![feature(zero_one)]

use std::cmp::Ord;
use std::num::Zero;
use std::ops::{Neg, Add};

fn largest_contiguous_sum<T>(slice: &[T]) -> T 
  where T : Neg + Add<T, Output = T> + Zero + Ord + Copy
{
  let mut maxnow = T::zero();

ferristseng

extern crate futures;
extern crate tokio_core;
extern crate tokio_uds;

use std::io;
use std::io::{Error, Write};
use std::io::ErrorKind;
use std::io::Read;
use std::net::SocketAddr;
use futures::Future;