paranoiacblack

street_type_re = re.compile(r'\b\S+\.?$', re.IGNORECASE)


expected = ["Street", "Avenue", "Boulevard", "Drive", "Court", "Place", "Square", "Lane", "Road", 
            "Trail", "Parkway", "Commons"]

# UPDATE THIS VARIABLE
mapping = { "St": "Street",
            "St.": "Street",
            "Ave": "Avenue",

paranoiacblack

<h1>Ok</h1>
Welp

paranoiacblack

#ifndef __HASH_FAMILY_H__
#define __HASH_FAMILY_H__

class HashFamily {
public:
  // Self-contained Prime numbers
  enum Prime {
    A = 54059,
    B = 76963,
    C = 68969

paranoiacblack

#ifndef __DISTANCE_HEAP_H__
#define __DISTANCE_HEAP_H__

#include "heap.h"
#include "node.h"
#include <utility>

using std::pair;

struct DistancePair {

paranoiacblack

#include "undirected_graph.h"
#include <string>
#include <cassert>

using std::string;

int main() {
  UndirectedGraph<int> g;
  g.addVertex(1);
  g.addVertex(2);

paranoiacblack

#ifndef __EDGE_H__
#define __EDGE_H__

#include "node.h"

struct Edge {
  Node* from;
  Node* to;
  double weight;

paranoiacblack

#include "graph_node.h"
#include <vector>

using std::vector;

bool is_connected(vector<GraphNode*> nodes) {
  for (unsigned i = 0; i < nodes.size(); ++i) {
    for (unsigned j = 0; j < nodes.size(); ++j) {
      if (i == j) {
	continue;

paranoiacblack

#ifndef __AVL_H__
#define __AVL_H__

#include <iostream>
#include <list>
#include <algorithm>

template<typename T>
class Avl {
private:

paranoiacblack

#include "tree.h"
#include <utility>
#include <string>

using namespace std;

struct DictionaryNode {
  pair<string, string> word_meaning_pair;

  DictionaryNode(const string& word, const string& meaning)

paranoiacblack

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

bool binary_search_rec(const vector<int>& v, unsigned start, unsigned end, int target) {
  int middle = (start + end) / 2;
  if (start == end) {
    return false;