add

Author: Hawstein

Diff for: 1.2

@@ -2,42 +2,30 @@
 #include <cstring>
 using namespace std;
 
-void swap(char &a, char &b)
-{
+void swap(char &a, char &b){
     a = a^b;
     b = a^b;
     a = a^b;
 }
 
-void reverse2(char *s)
-{
+void reverse2(char *s){
     int n = strlen(s);
     for(int i=0; i<n/2; ++i)
         swap(s[i], s[n-i-1]);
 }
 
-void reverse(char *s)
-{
-    char *end = s;
-    char tmp;
-    if(s)
-    {
-        while(*end)
-            ++end;
-        --end;
-        while(s < end)
-        {
-            tmp = *s;
-            *s++ = *end;
-            *end-- = tmp;
-        }
-    }
+void reverse1(char *s){
+    if(!s) return;
+    char *p = s, *q = s;
+    while(*q) ++q;
+    --q;
+    while(p < q)
+        swap(*p++, *q--);
 }
-int main()
-{
+
+int main(){
     char s[] = "1234567890";
-    reverse2(s);
+    reverse1(s);
     cout<<s<<endl;
     return 0;
-    
 }

Diff for: 1.2.cpp

@@ -19,10 +19,11 @@ bool isAnagram(string s, string t){
     int len = s.length();
     int c[256];
     memset(c, 0, sizeof(c));
-    for(int i=0; i<len; ++i)
+    for(int i=0; i<len; ++i){
         ++c[(int)s[i]];
-    for(int i=0; i<len; ++i)
         --c[(int)t[i]];
+    }
+        
     for(int i=0; i<256; ++i)
         if(c[i] != 0)
             return false;

Diff for: 1.4

@@ -1,10 +1,13 @@
 #include <iostream>
 #include <cstdio>
+#include <cstring>
 using namespace std;
 
 void zero(int **a, int m, int n){
     bool *row = new bool[m];
     bool *col = new bool[n];
+    memset(row, false, sizeof(row));
+    memset(col, false, sizeof(col));
     for(int i=0; i<m; ++i)
         for(int j=0; j<n; ++j)
             if(a[i][j] == 0){

Diff for: 1.4.cpp

@@ -1,15 +1,33 @@
 #include <iostream>
 using namespace std;
 
+int Count2(int n){
+    int count = 0;
+    while(n > 0){
+        if(n%10 == 2)
+            ++count;
+        n /= 10;
+    }
+    return count;
+}
+
+int Count2s1(int n){
+    int count = 0;
+    for(int i=0; i<=n; ++i)
+        count += Count2(i);
+    return count;
+
+}
+
 int Count2s(int n){
     int count = 0;
     int factor = 1;
     int low = 0, cur = 0, high = 0;
 
     while(n/factor != 0){
-        low = n - (n/factor) * factor;
-        cur = (n/factor) % 10;
-        high = n / (factor*10);
+        low = n - (n/factor) * factor;//低位数字
+        cur = (n/factor) % 10;//当前位数字
+        high = n / (factor*10);//高位数字
 
         switch(cur){
         case 0:
@@ -29,8 +47,36 @@ int Count2s(int n){
 
     return count;
 }
+
+int Countis(int n, int i){
+    if(i<1 || i>9) return -1;//i只能是1到9
+
+    int count = 0;
+    int factor = 1;
+    int low = 0, cur = 0, high = 0;
+
+    while(n/factor != 0){
+        low = n - (n/factor) * factor;//低位数字
+        cur = (n/factor) % 10;//当前位数字
+        high = n / (factor*10);//高位数字
+
+        if(cur < i)
+            count += high * factor;
+        else if(cur == i)
+            count += high * factor + low + 1;
+        else
+            count += (high + 1) * factor;
+
+        factor *= 10;
+    }
+
+    return count;
+}
 int main(){
     for(int i=1; i<1000; ++i)
-        cout<<i<<" "<<Count2s(i)<<endl;
+        cout<<Count2s1(i)<<" "<<Count2s(i)<<" "<<Countis(i, 2)<<endl;
+    // int n = 999;
+    // for(int i=1; i<10; ++i)
+    //     cout<<Countis(n, i)<<endl;
     return 0;
 }

Diff for: 1.7

@@ -0,0 +1,35 @@
+#include <iostream>
+using namespace std;
+
+const int kMaxInt = ~(1<<31);
+
+int ShortestDist(string text[], int n, string word1, string word2){
+    int min = kMaxInt / 2;
+    int pos1 = -min;
+    int pos2 = -min;
+
+    for(int pos=0; pos<n; ++pos){
+        if(text[pos] == word1){
+            pos1 = pos;
+            int dist = pos1 - pos2;
+            if(dist < min)
+                min = dist;
+        }
+        else if(text[pos] == word2){
+            pos2 = pos;
+            int dist = pos2 - pos1;
+            if(dist < min)
+                min = dist;
+        }
+    }
+
+    return min;
+}
+int main(){
+    string text[] = {
+        "What","is","your","name","My","name","is","Hawstein"
+    };
+    int len = 8;
+    cout<<ShortestDist(text, len, "is", "name")<<endl;
+    return 0;
+}

Diff for: 1.7.cpp

@@ -0,0 +1,50 @@
+#include <iostream>
+#include <algorithm>
+#include "hash.h"
+using namespace std;
+
+Hash hash;
+
+inline bool cmp(string s1, string s2){//按长度从大到小排
+    return s2.length() < s1.length();
+}
+
+bool MakeOfWords(string word, int length){
+    //cout<<"curr: "<<word<<endl;
+    int len = word.length();
+    //cout<<"len:"<<len<<endl;
+    if(len == 0) return true;
+
+    for(int i=1; i<=len; ++i){
+        if(i == length) return false;//取到原始串，即自身
+        string str = word.substr(0, i);
+        //cout<<str<<endl;
+        if(hash.find((char*)&str[0])){
+            if(MakeOfWords(word.substr(i), length))
+                return true;
+        }
+    }
+    return false;
+}
+
+void PrintLongestWord(string word[], int n){
+    for(int i=0; i<n; ++i)
+        hash.insert((char*)&word[i][0]);
+    sort(word, word+n, cmp);
+
+    for(int i=0; i<n; ++i){
+        if(MakeOfWords(word[i], word[i].length())){
+            cout<<"Longest Word: "<<word[i]<<endl;
+            return;
+        }
+    }
+}
+
+int main(){
+    string arr[] = {"test", "tester", "testertest", "testing", 
+				"apple", "seattle", "banana",  "batting", "ngcat", 
+                "batti","bat", "testingtester", "testbattingcat"};
+    int len = 13;
+    PrintLongestWord(arr, len);
+    return 0;
+}

Diff for: 20.4

@@ -0,0 +1,56 @@
+#include <cstring>
+
+const int kWordSize = 26 + 5;
+const int kNodeSize = 1200 + 5;
+const int kHashSize = 10001; //大质数
+
+struct Node{
+    char word[kWordSize];
+    Node *next;
+};
+Node node[kNodeSize + 1];
+Node* head[kHashSize + 1];
+
+class Hash{
+public:
+    Hash();
+    unsigned int hash(const char* str);
+    void insert(const char* str);
+    bool find(const char* str);
+private:
+    unsigned int seed;
+    unsigned int size;
+};
+
+Hash::Hash():seed(131),size(0){
+    memset(head, 0, sizeof(head));
+}
+
+unsigned int Hash::hash(const char* str){
+    unsigned int hash = 0;
+    while(*str++)
+        hash = hash * seed + (*str);
+    return (hash & 0x7FFFFFFF) % kHashSize;
+}
+
+void Hash::insert(const char* str){
+    unsigned int id = hash(str);
+    char *dst = (char*)node[size].word;
+    while(*dst++ = *str++);
+    node[size].next = head[id];
+    head[id] = &node[size];
+    ++size;
+}
+
+bool Hash::find(const char* str){
+    unsigned int id = hash(str);
+    for(Node* p=head[id]; p ; p=p->next){
+        char *dst = (char*)p->word;
+        int i = 0;
+        while(*(str+i) && *(dst+i)==*(str+i))
+            ++i;
+        if(*(str+i)=='\0' && *(dst+i)=='\0')
+            return true;
+    }
+    return false;
+}