Some tiny edits

Author: bap2pecs0

ACM/Divide and Conquer/11378_Bey_Battle/11378.cc

@@ -1,24 +1,16 @@
 #include <iostream>
-#include <vector>
 #include <algorithm>
 #include <fstream>
 #include <map>
 
 using namespace std;
 
 typedef long long ll;
-// typedef vector<ll> vi;
-// typedef vector<vi> vvi;
 typedef map<ll, ll> dict;
 
 ll N;
-//vvi plane(100000, vi(2));
 dict plane;
 
-// bool compare(vi p1, vi p2) {
-// 	return p1[0]<p1[0];
-// }
-
 bool cover(ll L) {
 	if (L==1) return true;
 
@@ -44,34 +36,24 @@ int main() {
 	// streambuf *cinbuf = std::cin.rdbuf(); //save old buf
 	// cin.rdbuf(in.rdbuf()); //redirect std::cin to in.txt!
 
-	// ofstream out("out.txt");
-	// streambuf *coutbuf = std::cout.rdbuf(); //save old buf
-	// cout.rdbuf(out.rdbuf()); //redirect std::cout to out.txt!
-
 	while	(cin >> N)	{
 		plane.clear();
 		for (ll i=0; i<N; ++i) {
 			ll x,y;
 			cin >> x >> y;
 			plane[x] = y;
 		}
-		//sort(plane.begin(), plane.begin()+N, compare);
 
 		ll L=0, R=4000001, mid;
 		while (R - L != 1) {
 			mid = (L+R) >> 1;
-			//cout << R << " " << L<< " "  << mid << endl;
 			if (cover(mid)) {
 				L = mid;
 			} else {
 				R = mid;
 			}
 		}
-		// for (ll i=0; i<N; ++i) {
-		// 	// ll tmp = max(abs(plane[i][0] - plane[i+1][0]), abs(plane[i][1] - 
-		// 	// 	plane[i+1][1]));
-		// 	// Max = min(tmp, Max);
-		// }
+
 		cout << L << endl;
 	}
 	return 0;

ACM/Divide and Conquer/11378_Bey_Battle/in.txt

@@ -506,4 +506,4 @@
 -20901 -17385
 -1343 -49230
 5037 -46873
--4285 57582
+-4285 57582

ACM/Divide and Conquer/11378_Bey_Battle/out.txt

@@ -1 +1,9 @@
 3138
+2576
+2167
+1376
+1945
+833
+2486
+1179
+1987

ACM/Divide and Conquer/11378_Bey_Battle/out3.txt

@@ -0,0 +1,9 @@
+3138
+2576
+2167
+1376
+1945
+833
+2486
+1179
+1987

ACM/Greedy Algorithms/10718/10718

@@ -0,0 +1,54 @@
+/*
+Algorithm design:
+
+first we locate the valid bits of the number N. For example, for 100 50 60,
+the valid bits are the last four bits. Becasue we have:
+
+100 - 1100100
+50 -   110010
+60 -   111100
+
+We can notice that 50 and 60 has the first bits in common.
+
+Let's substract 32 from them.
+50-32-16 = 2  - 0010
+60-32-16 = 12 - 1100
+
+So we only need to focus on the last four digits of 100, which is:
+0100
+
+So the best possible four bits are:
+1011
+
+Now we scan from the leftmost (greediest),
+
+can we have 1?
+- 1000 is in range [0010, 1100]. yes
+can we have 0?
+- 1000 is in range [0010, 1100]. yes
+can we have 1?
+- 1010 is in range [0010, 1100]. yes
+can we have 1?
+- 1011 is in range [0010, 1100]. yes
+
+Now let's change to another situation. What if the range is [0010, 1000]
+
+can we have 1?
+- 1000 is in range [0010, 1000]. yes
+can we have 0?
+- 1000 is in range [0010, 1000]. yes
+can we have 1?
+- 1010 is not in range [0010, 1000]. no
+So the solution is 1010 plue the first two bits. the number is 111010 = 58
+*/
+
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+
+typedef long long ll;
+
+int main() {
+	
+}

ACM/Greedy Algorithms/10718/10718.cc

@@ -0,0 +1,38 @@
+#include <iostream>
+#include <fstream>
+#include <vector>
+
+using namespace std;
+
+typedef long long ll;
+typedef vector<ll> vi;
+
+ll n;
+vi a(100000);
+
+int main() {
+	// Unit tests:
+
+	// ifstream in("in.txt");
+	// streambuf *cinbuf = std::cin.rdbuf(); //save old buf
+	// cin.rdbuf(in.rdbuf()); //redirect std::cin to in.txt!
+
+	while (cin>>n) {
+		if (n==0) return 0;
+
+		for (ll i=0; i<n; ++i) {
+			cin>>a[i];
+		}
+
+		ll work = 0;
+		for (ll i=0; i<n; i++) {
+			if (a[i] != 0) {
+				a[i+1] += a[i];
+				work += abs(a[i]);
+			}
+		}
+
+		cout << work << endl;
+	}
+	return 0;
+}

ACM/Greedy Algorithms/10718/10718.pdf

@@ -0,0 +1,15 @@
+10
+100 200 300 400 500 -500 -400 -300 -200 -100
+10
+100 200 300 400 500 -100 -200 -300 -400 -500
+10
+100 -100 200 -200 300 -300 400 -400 500 -500
+3
+-10 20 -10
+10
+100 200 300 400 500 600 700 800 900 -4500
+10
+-2100 500 400 300 200 500 800 400 600 -1600
+15
+-1 -2 -3 -4 5 -6 7 -8 9 -10 11 -12 13 -14 15
+0

ACM/Greedy Algorithms/11054/11054

@@ -3,38 +3,114 @@
 What if you can not use additional data structures?
 '''
 
-'''Algorithm Design
+'''
 Confusions:
 1. What do you mean by "all unique characters"? I assume it is ACSII string with
  value 0~255.
 2. What do you mean by "cannot use addtional data structures"? I assume I can 
 only use string.
+3. Does the string need to include all 256 characters? Or just need to have no 
+duplicates. (assume the later one)
 Examples:
 1) agshdhfkd -> False
 2) agsdhfk -> True
-Design:
-	Create a hash function to map all unique characters
 '''
 
-def hash_function(char):
-    return ord(char)
-    
+# Idea: hash table
 # time: O(n)
 # space: O(1) - fixed size 256
-def all_unique_string(string):
+def all_unique_character_1(string):
     table = [0 for x in range(256)]
     for char in string:
-        index = hash_function(char)
+        # ord returns the integer ordinal of a one-character string
+        index = ord(char)
         if table[index] == 0:
             table[index] = 1
         else:
             return False
     return True
 
-if __name__ == '__main__':
-    print all_unique_string('agshdhfkd')
-    print all_unique_string('agsdhfk')
+# Idea: hash table
+# time: ?
+# space: O(1)
+def all_unique_character_2(string):
+    table = []
+    for char in string:
+        if char in table:
+            return False
+        table.append(char)
+    return True
 
+# Idea: use bit vector, since Mac OS is in 64 bit, we need 4 vectors
+# time: O(n)
+# space: O(1)
+def all_unique_character_3(string):
+    checker_1 = checker_2 = checker_3 = checker_4 = 0
+    for char in string:
+        order = ord(char)
+        if order < 64:
+            if (checker_1 & (1<<order)) != 0:
+                return False
+            checker_1 |= 1<<order
+        elif order < 128:
+            order -= 64
+            if (checker_2 & (1<<order)) != 0:
+                return False
+            checker_2 |= 1<<order
+        elif order < 192:
+            order -= 128
+            if (checker_3 & (1<<order)) != 0:
+                return False
+            checker_3 |= 1<<order
+        else:
+            order -= 192
+            if (checker_4 & (1<<order)) != 0:
+                return False
+            checker_4 |= 1<<order
+    return True
+
+
+''' Below are Unit Tests '''
+
+def unit_test_1(func):
+    input_string = 'agshdhfkd'
+    expected = False
+    if func(input_string) == expected:
+        print "Pass: Unit Test 1"
+    else:
+        print "Fail: Unit Test 1"
 
+def unit_test_2(func):
+    input_string = 'agsdhfk'
+    expected = True
+    if func(input_string) == expected:
+        print "Pass: Unit Test 2"
+    else:
+        print "Fail: Unit Test 2"
 
+def unit_test_3(func):
+    input_string = 'agsdhfkA123BGW'
+    expected = True
+    if func(input_string) == expected:
+        print "Pass: Unit Test 3"
+    else:
+        print "Fail: Unit Test 3"
 
+def unit_test_4(func):
+    input_string = 'agsdhfkA123BGW278'
+    expected = False
+    if func(input_string) == expected:
+        print "Pass: Unit Test 4"
+    else:
+        print "Fail: Unit Test 4"
+
+def run_unit_tests(func):
+    unit_test_1(func)
+    unit_test_2(func)  
+    unit_test_3(func)  
+    unit_test_4(func)
+
+if __name__ == '__main__':
+    run_unit_tests(all_unique_character_1)
+    run_unit_tests(all_unique_character_2)
+    run_unit_tests(all_unique_character_3)

ACM/Greedy Algorithms/11054/11054.cc

@@ -7,20 +7,25 @@
 terminator. A null terminator means that the string ends with a '\0' character 
 (which has ASCII code 0)
 
-It is almost the same as revert a linked list
+It is almost the same as reverting a linked list
 
 '''
 
-
 # clarification questions:
 # 1) input is a string ending with '\0'
 # 2) i cannot use .reverse()
 
 class Node:
-    def __init__(self,data,next):
+    def __init__(self,data,successor):
         self.data = data
-        self.next = next
+        self.next = successor
 
+def reverseString(node):
+    head = Node('\0',node)
+    pre = None
+    while head != None:
+        head.next, pre, head = pre, head, head.next
+    return pre.next
 
 def reverseNodeList(node,previous):
     if node.next == None:  
@@ -52,7 +57,7 @@ def reverseCStyleString(c_str):
     node2 = Node('c',node1)
     node3 = Node('b',node2)
     node4 = Node('a',node3)
-    node = reverseCStyleString(node4)
+    node = reverseString(node4)
     while True:
         print node.data
         if node.next==None:break

ACM/Greedy Algorithms/11054/11054.pdf

@@ -44,7 +44,6 @@ def merge(lst1,lst2):
 	else:
 		return [lst2[0]] + merge(lst2[1:],lst1)
 
-
 if __name__ == '__main__':
 	node1 = Node(4,None)
 	node2 = Node(2,node1)
@@ -55,8 +54,3 @@ def merge(lst1,lst2):
 		print node.data
 		if node.next==None:break
 		node = node.next
-
-
-
-
-

ACM/Greedy Algorithms/11054/in.txt

@@ -3,6 +3,9 @@
 
 Question: given a string "3:8,5,2:    5,11:22,5,7,       4,100", compress to "2:8,11:22,100"
 
+
+[1:4],[2:6],7 --> [1:7]
+
 Limitations:
 1) cannot deal with bad input such as '1,3,2:::::::5,,::::,,'