hamming-distance updated

app/problems/hamming-distance.json

@@ -0,0 +1,33 @@
+{
+    "name": "Hamming Distance",
+    "id": "hamming-distance",
+    "discuss_link": "http://www.fgdsb.com/2015/01/03/hamming-distance/",
+    "desc": "<p>Write a function to calculate Hamming distance between two integers</p>",
+    "difficulty": "Easy",
+    "source": "Microsoft",
+    "time": "2015-02-19 22:14:25",
+    "tags": [
+        "Math"
+    ],
+    "code_cpp": "int hamming(int a , int b) {\n}",
+    "code_java": "public class Solution {\n    public int hamming(int a , int b) {\n    }\n}",
+    "code_ruby": "# @param a: integer, b: integer\n# @return integer\ndef hamming(a, b)\nend",
+    "code_python": "# @param a: integer, b: integer\n# @return integer\ndef hamming(a, b):",
+    "code_lua": "-- @param a: integer, b: integer\n-- @return integer\nfunction hamming(a, b)\nend",
+    "in_type_cpp": [
+        ""
+    ],
+    "ret_type_cpp": "",
+    "out_type_cpp": "",
+    "judge_type_cpp": "equal",
+    "in_type_java": [
+        ""
+    ],
+    "ret_type_java": "",
+    "out_type_java": "",
+    "judge_type_java": "equal",
+    "judge_type_ruby": "equal",
+    "judge_type_python": "equal",
+    "judge_type_lua": "equal",
+    "judge_call": "function(@)"
+}

app/problems/lca-1.json

@@ -2,9 +2,9 @@
     "name": "Lowest Common Ancestor",
     "id": "lca-1",
     "discuss_link": "http://www.fgdsb.com/2015/01/03/lowest-common-ancestor/",
-    "desc": "<p>Given an arbitrary binary tree and two values, write a function to find the least common ancestor.</p>",
+    "desc": "<p>Given an arbitrary binary tree and two values, write a function to find the lowest common ancestor.</p>",
     "difficulty": "Medium",
-    "source": "CC150",
+    "source": "LinkedIn",
     "time": "2015-02-03 20:14:36",
     "tags": [],
     "code_cpp": "/*\nstruct TreeNode {\n    TreeNode(int v = 0) :val(v){}\n    int val{ 0 };\n    TreeNode* left{ nullptr };\n    TreeNode* right{ nullptr };\n};\n*/\nTreeNode* lca(TreeNode* root, int m, int n) {\n}",

app/problems/lca-2.json

@@ -4,7 +4,7 @@
     "discuss_link": "http://www.fgdsb.com/2015/01/03/lowest-common-ancestor/",
     "desc": "<p>Follow up for \"Lowest Common Ancestor\":<br><br>How if the given binary tree are binary search tree?</p>",
     "difficulty": "Medium",
-    "source": "CC150",
+    "source": "LinkedIn",
     "time": "2015-02-03 22:21:15",
     "tags": [],
     "code_cpp": "/*\nstruct TreeNode {\n    TreeNode(int v = 0) :val(v){}\n    int val{ 0 };\n    TreeNode* left{ nullptr };\n    TreeNode* right{ nullptr };\n};\n*/\nTreeNode* lca(TreeNode* root, int m, int n) {\n}",

app/problems/problems.json

@@ -200,14 +200,14 @@
         "id": "lca-1",
         "name": "Lowest Common Ancestor",
         "difficulty": "Medium",
-        "source": "CC150"
+        "source": "LinkedIn"
     },
     {
         "time": "2015-02-03 22:21:15",
         "id": "lca-2",
         "name": "Lowest Common Ancestor II",
         "difficulty": "Medium",
-        "source": "CC150"
+        "source": "LinkedIn"
     },
     {
         "time": "2015-02-08 16:59:46",
@@ -299,5 +299,12 @@
         "name": "Zigzag Iterator",
         "difficulty": "Easy",
         "source": "Google"
+    },
+    {
+        "time": "2015-02-19 22:14:25",
+        "id": "hamming-distance",
+        "name": "Hamming Distance",
+        "difficulty": "Easy",
+        "source": "Microsoft"
     }
 ]

judge/build_tests/hamming-distance.rb

@@ -0,0 +1,17 @@
+require './common'
+require '../ruby/common'
+
+class Test_hamming_distance < TestBase
+  def initialize(name)
+    super(name)
+  end
+
+  def add_test
+  end
+
+  def gen_tests
+    @test_in, @test_out = [[]], []
+  end
+end
+
+Test_hamming_distance.new 'hamming-distance'

judge/cpp/solution.h

@@ -1,27 +1,19 @@
-/*
-class Iterator {
-public:
-    int get_next();
-    bool has_next();
-};
-*/
-
-class ZigzagIterator {
-public:
-    ZigzagIterator(Iterator& a, Iterator& b) :_its{a,b} {
-        _pointer = a.has_next() ? 0 : 1;
+vector<int> longest_subarray(vector<int>& arr) {
+    cout << arr << endl;
+    int sum = 0, length = 0, begin = -1;
+    unordered_map<int, int> record = {{0,-1}};
+    for(int i = 0; i < arr.size(); ++i) {
+        sum += arr[i];
+        if(record.count(sum)) {
+            auto first = record[sum];
+            if(i - first > length) {
+                length = i - first;
+                begin = first + 1;
+            }
+        } else {
+            record[sum] = i;
+        }
     }
-
-    int get_next() {
-        int ret = _its[_pointer].get_next(), old = _pointer;
-        do {
-            if(++_pointer >= 2) _pointer = 0;
-        } while(!_its[_pointer].has_next() && _pointer != old);
-        return ret;
-    }
-
-    bool has_next() { return _its[_pointer].has_next(); }
-private:
-    Iterator _its[2];
-    int _pointer;
-};
+    if(begin < 0) return {};
+    else return vector<int>(arr.begin()+begin, arr.begin()+begin+length);
+}

judge/cpp/src.cpp

@@ -1,6 +1,6 @@
 #include "common.h"
 #include "solution.h"
-#include "tests/zigzag-iterator.h"
+#include "tests/longest-zero-subarray.h"
 
 int main() {
     judge();

judge/java/Solution.java

@@ -1,23 +1,5 @@
-package judge;import java.util.*;import java.lang.*;import java.io.*;import datastruct.*; /*
-public class Iterator {
-    public int get_next();
-    public boolean has_next();
-}
-*/
-
-public class PeekIterator {
-    public PeekIterator(Iterator it) {
-    }
-
-    public int peek() {
-        return 1;
-    }
-
-    public boolean has_next() {
-        return false;
-    }
-
-    public int get_next() {
-        return 2;
+package judge;import java.util.*;import java.lang.*;import java.io.*;import datastruct.*; public class Solution {
+    public List<Integer> longest_seq(int[][] mat) {
+        return new ArrayList<Integer>();
     }
 }

judge/java/src.java

@@ -4,10 +4,10 @@
 import java.io.*;
 import tests.test_common;
 import datastruct.*;
-import tests.zigzag_iterator;
+import tests.longest_inc_seq_matrix;
 
 public class src {
     public static void main (String[] args) throws java.lang.Exception {
-        zigzag_iterator.judge();
+        longest_inc_seq_matrix.judge();
     }
 }

judge/lua/solution.lua

@@ -8,27 +8,30 @@
 -- function Iterator:get_next()
 -- end
 
-ZigzagIterator = class()
+PeekIterator = class()
 
-function ZigzagIterator: ctor(i0, i1)
-    self.its = {i0,i1}
-    if i0:has_next() then 
-        self.pointer = 1
-    else 
-        self.pointer = 2 
+function PeekIterator: ctor(it)
+	self.it = it
+    self.peeks = nil
+end
+
+function PeekIterator: peek()
+	if self.peeks == nil then
+        self.peeks = self.it:get_next()
     end
+    return self.peeks
 end
 
-function ZigzagIterator: has_next()
-    return self.its[self.pointer]:has_next()
+function PeekIterator: has_next()
+	return self.it:has_next() or self.peeks
 end
 
-function ZigzagIterator: get_next()
-    local ret, old = self.its[self.pointer]:get_next(), self.pointer;
-    while true do
-        self.pointer = self.pointer + 1
-        if self.pointer > 2 then self.pointer = 1 end
-        if self.its[self.pointer]:has_next() or self.pointer == old then break end
+function PeekIterator: get_next()
+	if self.peeks == nil then
+        return self.it:get_next()
+    else
+        ret = self.peeks
+        self.peeks = nil
+        return ret
     end
-    return ret
-end
+end

judge/lua/src.lua

@@ -1,4 +1,4 @@
 package.path = package.path .. ';/Users/yanxingwang/Projects/node_proj/fgdsb_judge/judge/lua/?.lua;'
 require "common"
-require "tests/zigzag-iterator"
+require "tests/peek-iterator"
 judge()

judge/python/solution.py

@@ -1,26 +1,5 @@
 from common import *
-# class Iterator:
-#   def get_next(self):
-#       ...
-#
-#   def has_next(self):
-#       ...
-
-class ZigzagIterator:
-    # @param i0: Iterator object, i1: Iterator object
-    def __init__(self, i0, i1):
-        self.its = [i0,i1]
-        if i0.has_next(): self.pointer = 0
-        else: self.pointer = 1
-
-    # @return boolean
-    def has_next(self):
-        return self.its[self.pointer].has_next()
-
-    # @return integer
-    def get_next(self):
-        ret, old = self.its[self.pointer].get_next(), self.pointer;
-        while True:
-            self.pointer = (self.pointer + 1) % 2
-            if self.its[self.pointer].has_next() or self.pointer == old: break
-        return ret
+def plus_num(a, b):
+    print a
+    print b
+    return a + b

judge/python/src.py

@@ -1,5 +1,5 @@
 from common import *
 from solution import *
-from tests.zigzag_iterator import *
+from tests.a_plus_b import *
 
 judge()

judge/ruby/solution.rb

@@ -1,31 +1,16 @@
-# class Iterator
-#   def get_next()
-#       ...
-#   end   
-#
-#   def has_next()
-#       ...
-#   end
-# end
+# class TreeNode
+#    attr_accessor :left, :right, :val
+#    def initialize(v)
+#        @val, @left, @right = v, nil, nil
+#    end
 
-class ZigzagIterator
-    # @param i0: Iterator object, i1: Iterator object
-    def initialize(i0, i1)
-        @its, @pointer = [i0,i1], i0.has_next() ? 0 : 1
-    end
-
-    # @return boolean
-    def has_next()
-        @its[@pointer].has_next()
-    end
-
-    # @return integer
-    def get_next()
-        ret, old = @its[@pointer].get_next, @pointer;
-        loop do 
-            @pointer = (@pointer + 1) % 2
-            break if @its[@pointer].has_next or @pointer == old
-        end
-        ret
-    end
+# @param root, TreeNode
+# @param m,n, integer
+# @return TreeNode
+def lca(root, m, n)
+    return nil if root.nil?
+    return root if root.val == m or root.val == n
+    l, r = lca(root.left, m, n), lca(root.right, m, n)
+    return root if l and r
+    return l ? l : r
 end

judge/ruby/src.rb

@@ -1,5 +1,5 @@
 require './judge/ruby/common'
 require './judge/ruby/solution'
-require './judge/ruby/tests/zigzag-iterator'
+require './judge/ruby/tests/lca-1'
 
 judge