collabedit.txt

/* Hello from ThousandEyes */

/* Hello from Nelson */

/*

1
|\
2 3__
| |\ \
4 5 6 7

DFS: 1, 2, 4, 3, 5, 6, 7
BFS: 1,2,3,4,5,6,7

*/

public class Node {

    private int content;
    private List<Node> children;
    
    public Node(int content, List<Node> children) {
        this.content = content;
        this.children = children;
    }
    
    public void dfs() {
        System.out.print("DFS: ");
    
         dfs_step(this, new HashSet());
    }
    
    private void dfs_step(Node node, Set<Node> visitedNodes) {
        System.out.println(content + ",");
        visitedNodes.add(this)
        
        for(Node node : children) {
            if (!visitedNode.contains(node)) {
                dfs_step(node);
            }
        }
    }
    
    public void bfs() {
        System.out.print("BFS: ");
        
        List<Node> queue = new LinkedList<Node>();
        queue.add(this);
        
        for (Node node : queue) {
            System.out.print(content + ",");
            queue.remove(node);
            queue.addAll(node.children);
        }
        
    }
    
    
    equals
    
    hashcode
}


tb_temperatures
country_id | region_id | temperature
US    | CA | 30
US    | NY | 20
US    | TX | 35
PT    | LIS | 25

Q1: a query that outputs the country,region,temp with the highest temperature

select country_id, region_id, temperature from tb_temperatures order by temperature limit 1

Q2: a query that outputs the region,temp with highest temperature for each country

select country_id, region_id, temperature from tb_temperatures tb_outer tb_outer.temperatur =
    (select max(temperature) from tb_temperatures where country_id = tb_outer.country_id group by country_id)

   

/*

http://d3js.org/
http://jsfiddle.net/RubuJ/

Draw a scatter plot using d3
- use svg <circle>s for the points
- use d3 data-binding (enter/exit)

Here's some data:
[[1,3],[2,5],[3,6],[4,1],[7,4],[9,5]]

*/


public class Node {
    public int type;
    public double value;
    public List<Node> neighbors;
}

public class Graph {
    protected Node root;
    
    public Map<Integer, Double> computeAverages() {
        Map<Integer, Double> sums = new HashMap<Integer, Double>();
        Map<int, int> counts = new HashMap<int, int>();
        
        dfs_step(root, answer, counts, new HashSet<Node>());
        
        Map<int, double> answer = new HashMap<int, double>();
        
        for (Map.Entry<int, double> sum : sums) {
            double average = sum.getValue() / counts.get(sum.getKey());
            answer.put(sum.getKey(), average);
        }
        
        return answer;
    }
        
    private dfs_step(Node node, Map<int, double> currentSum, Map<int, int> countOfNodesPerType, Set<Node> visitedNodes) {
        
        for (Node node : node.neighbours) {
            if (!visitedNodes.contains(visitedNodes)) {
                Integer countOfNodes = countOfNodesPerType.get(node.type);
                Double currentSum = currentSum.get(node.type);
                
                if (countOfNodes == null) {
                    countOfNodes = new Integer(1);
                } else {
                    countOfNodes ++;
                }
                
                if (currentSum == null) {
                    currentSum = 0d;
                }
                    
                
                double newSum = currentSum + node.value;
            
                currentSum.put(node.type, newSum)
                countOfNodesPerType.put(node.type, countOfNodes);
                
                visitedNodes.add(node);
                
                dfs_step(node, currentSum, countOfNodesPerType, visitedNodes);
            }
        }
    }
}


public class BlockingQueue<T> {

    private LinkedList<T> queue = new LinkedList<T>();
    private int maxSize;

    public BlockingQueue(int maxSize) {
        this.maxSize = maxSize;
    }

    public T get() {
        while (true) {
            synchronized(queue) {
                if (!queue.empty()) {
                   T object = queue.removeFirst();
                   
                   // notify all producers waiting
                   queue.notifyAll();
                   
                   
                   return object;
                }
                
                try {
                    queue.wait();
                } catch (InterrupetedException e) {
                }
            }
        }
    }
    
    
    public void put(T obj) { 
        while(true) {
            synchronized(queue) {
                if (queue.size() == maxSize) {
                    try {
                        queue.wait();
                    } catch (InterrupedException e) {
                    }
                } else {
                    queue.add(obj);
                    
                    // notify all consumers waiting
                    queue.notifyAll();
                }
            }       
        }
    }

}