├── .gitignore
├── huawei
    ├── 0039.cpp
    ├── 0100.cpp
    ├── 0007.cpp
    ├── 0049.cpp
    ├── 0106.cpp
    ├── 0034.cpp
    ├── 0011.cpp
    ├── 0012.cpp
    ├── 0076.cpp
    ├── 0061.cpp
    ├── 0022.cpp
    ├── 0046.cpp
    ├── 0015.cpp
    ├── 0084.cpp
    ├── 0105.cpp
    ├── 0013.cpp
    ├── 0062.cpp
    ├── 0099.cpp
    ├── 0009.cpp
    ├── 0037.cpp
    ├── 0001.cpp
    ├── 0091.cpp
    ├── 0038.cpp
    ├── 0002.cpp
    ├── 0090.cpp
    ├── 0058.cpp
    ├── 0014.cpp
    ├── 0051.cpp
    ├── 0055.cpp
    ├── 0108.cpp
    ├── 0003.cpp
    ├── 0010.cpp
    ├── 0035.cpp
    ├── 0086.cpp
    ├── 0072.cpp
    ├── 0006.cpp
    ├── 0097.cpp
    ├── 0008.cpp
    ├── 0004.cpp
    ├── 0104.cpp
    ├── 0080.cpp
    ├── 0096.cpp
    ├── 0107.cpp
    ├── 0040.cpp
    ├── 0060.cpp
    ├── 0073.cpp
    ├── 0103.cpp
    ├── 0101.cpp
    ├── 0059.cpp
    ├── 0023.cpp
    ├── 0083.cpp
    ├── 0031.cpp
    ├── 0048.cpp
    ├── 0081.cpp
    ├── 0056.cpp
    ├── 0082.cpp
    ├── 0041.cpp
    ├── 0074.cpp
    ├── 0069.cpp
    ├── 0033.cpp
    ├── 0005.cpp
    ├── 0047.cpp
    ├── 0021.cpp
    ├── 0092.cpp
    ├── 0075.cpp
    ├── 0053.cpp
    ├── 0094.cpp
    ├── 0093.cpp
    ├── 0078.cpp
    ├── 0024.cpp
    ├── 0026.cpp
    ├── 0071.cpp
    ├── 0036.cpp
    ├── 0052.cpp
    ├── 0045.cpp
    ├── 0063.cpp
    ├── 0027.cpp
    ├── 0079.cpp
    ├── 0102.cpp
    ├── 0064.cpp
    ├── 0019.cpp
    ├── 0065.cpp
    ├── 0030.cpp
    ├── 0070.cpp
    ├── 0068.cpp
    ├── 0066.cpp
    ├── 0032.cpp
    ├── 0020.cpp
    ├── 0088.cpp
    ├── 0025.cpp
    ├── 0029.cpp
    ├── 0044.cpp
    ├── 0017.cpp
    ├── 0077.cpp
    ├── 0043.cpp
    ├── 0067.cpp
    ├── 0042.cpp
    ├── 0095.cpp
    ├── 0087.cpp
    ├── 0054.cpp
    ├── 0050.cpp
    ├── 0089.cpp
    ├── 0057.cpp
    ├── 0018.cpp
    └── 0098.cpp
├── create_README.py
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | .vscode
2 | *.exe
3 | a.out
4 | in.txt


--------------------------------------------------------------------------------
/huawei/0039.cpp:
--------------------------------------------------------------------------------
1 | // 0039.判断两个IP是否属于同一子网
2 | // keywords: 题目不见了


--------------------------------------------------------------------------------
/huawei/0100.cpp:
--------------------------------------------------------------------------------
 1 | // 0100.等差数列
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int n;
 9 |     while(cin >> n)
10 |     {
11 |         cout << n*(2+3*n-1)/2 << endl;
12 |     }
13 |     return 0;
14 | }


--------------------------------------------------------------------------------
/huawei/0007.cpp:
--------------------------------------------------------------------------------
 1 | // 0007.取近似值
 2 | 
 3 | #include<iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     double d;
 9 |     long long a;
10 |     cin >> d;
11 |     a = d + 0.5;
12 |     cout << a;
13 |     
14 |     return 0;
15 | }


--------------------------------------------------------------------------------
/huawei/0049.cpp:
--------------------------------------------------------------------------------
 1 | // 0049.多线程
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int n;
 9 |     while(cin >> n)
10 |     {
11 |         while(n--) cout << "ABCD";
12 |         cout << endl;
13 |     }
14 |     return 0;
15 | }


--------------------------------------------------------------------------------
/huawei/0106.cpp:
--------------------------------------------------------------------------------
 1 | // 0106.字符逆序
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | #include <algorithm>
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 |     char a[101];
11 |     cin.getline(a, 101);
12 |     reverse(a, a+strlen(a));
13 |     cout << a;
14 |     return 0;
15 | }


--------------------------------------------------------------------------------
/huawei/0034.cpp:
--------------------------------------------------------------------------------
 1 | // 0034.图片整理
 2 | 
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s;
10 |     while(getline(cin, s))
11 |     {
12 |         sort(s.begin(), s.end());
13 |         cout << s << endl;
14 |     }
15 |     return 0;
16 | }


--------------------------------------------------------------------------------
/huawei/0011.cpp:
--------------------------------------------------------------------------------
 1 | // 0011.数字颠倒
 2 | 
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | #include <cstring>
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 |     char num[100];
11 |     cin.getline(num,100);
12 |     reverse(num, num+strlen(num));
13 |     cout << num;
14 |     
15 |     return 0;
16 | }


--------------------------------------------------------------------------------
/huawei/0012.cpp:
--------------------------------------------------------------------------------
 1 | // 0012.字符串反转
 2 | 
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | #include <cstring>
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 |     char num[10000];
11 |     cin.getline(num,10000);
12 |     reverse(num, num+strlen(num));
13 |     cout << num;
14 |     
15 |     return 0;
16 | }


--------------------------------------------------------------------------------
/huawei/0076.cpp:
--------------------------------------------------------------------------------
 1 | // 0076.尼科彻斯定理
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int n, m;
 9 |     while(cin >> n)
10 |     {
11 |         m = n*n - n + 1;
12 |         for(int i = 0; i < n-1; i++)
13 |         {
14 |             cout << m+2*i << '+';
15 |         }
16 |         cout << m+2*(n-1) << endl;
17 |     }
18 |     return 0;
19 | }


--------------------------------------------------------------------------------
/huawei/0061.cpp:
--------------------------------------------------------------------------------
 1 | // 0061.放苹果
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int f(int m, int n)
 7 | {
 8 |     if(m < 0) return 0;
 9 |     if(m == 1 || n == 1) return 1;
10 |     return f(m, n-1) + f(m-n, n);
11 | }
12 | 
13 | int main()
14 | {
15 |     int m, n;
16 |     while(cin >> m >> n)
17 |     {
18 |         cout << f(m, n) << endl;
19 |     }
20 |     return 0;
21 | }


--------------------------------------------------------------------------------
/huawei/0022.cpp:
--------------------------------------------------------------------------------
 1 | // 0022.汽水瓶
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int n, cnt;
 9 |     while(cin >> n && n != 0)
10 |     {
11 |         cnt = 0;
12 |         while(n > 1)
13 |         {
14 |             n -= 3;
15 |             cnt += 1;
16 |             n += 1;
17 |         }
18 |         cout << cnt << endl;
19 |     }
20 |     return 0;
21 | }


--------------------------------------------------------------------------------
/huawei/0046.cpp:
--------------------------------------------------------------------------------
 1 | // 0046.按字节截取字符串
 2 | 
 3 | // 根据题意，在判题系统中，汉字以2个字节存储。
 4 | #include <iostream>
 5 | #include <cstring>
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 |     string s;
11 |     int n;
12 |     while(cin >> s >> n)
13 |     {
14 |         if(s[n-1] < 0) s = s.substr(0, n-1);
15 |         else s = s.substr(0, n);
16 |         cout << s << endl;
17 |     }
18 |     return 0;
19 | }


--------------------------------------------------------------------------------
/huawei/0015.cpp:
--------------------------------------------------------------------------------
 1 | // 0015.求int型数据在内存中存储时1的个数
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int cnt(int num)
 7 | {
 8 |     int cnt = 0;
 9 |     while(num != 0)
10 |     {
11 |         if( num % 2 ) cnt ++;
12 |         num /= 2;
13 |     }
14 |     return cnt;
15 | }
16 | 
17 | int main()
18 | {
19 |     int num;
20 |     cin >> num;
21 |     cout << cnt(num);
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/huawei/0084.cpp:
--------------------------------------------------------------------------------
 1 | // 0083.统计大写字母个数
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s;
10 |     while(getline(cin, s))
11 |     {
12 |         int cnt = 0;
13 |         for(int i = 0; i < s.size(); i++)
14 |         {
15 |             if(isupper(s[i])) cnt ++;
16 |         }
17 |         cout << cnt << endl;
18 |     }
19 |     return 0;
20 | }


--------------------------------------------------------------------------------
/huawei/0105.cpp:
--------------------------------------------------------------------------------
 1 | // 0105.记负均正II
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     double sum = 0;
 9 |     int a, c = 0, cnt = 0;
10 |     while(cin >> a)
11 |     {
12 |         if (a < 0) {
13 |             cnt ++;
14 |         }else {
15 |             c ++;
16 |             sum += a;
17 |         }
18 |     }
19 |     printf("%d\n%.1lf", cnt, sum/c);
20 |     return 0;
21 | }


--------------------------------------------------------------------------------
/huawei/0013.cpp:
--------------------------------------------------------------------------------
 1 | // 0013.句子逆序
 2 | 
 3 | #include <iostream>
 4 | #include <stack>
 5 | #include <string>
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 |     string s;
11 |     stack<string> sa;
12 |     while(cin >> s)
13 |     {
14 |         sa.push(s);
15 |     }
16 |     while(!sa.empty())
17 |     {
18 |         s = sa.top();
19 |         sa.pop();
20 |         cout << s << ' ';
21 |     }
22 |     
23 |     return 0;
24 | }


--------------------------------------------------------------------------------
/huawei/0062.cpp:
--------------------------------------------------------------------------------
 1 | // 0062.查找输入整数二进制中1的个数
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int cnt(int num)
 7 | {
 8 |     int cnt = 0;
 9 |     while(num != 0)
10 |     {
11 |         if( num % 2 ) cnt ++;
12 |         num /= 2;
13 |     }
14 |     return cnt;
15 | }
16 | 
17 | int main()
18 | {
19 |     int num;
20 |     while(cin >> num)
21 |     {
22 |         cout << cnt(num) << endl;
23 |     }
24 |     return 0;
25 | }


--------------------------------------------------------------------------------
/huawei/0099.cpp:
--------------------------------------------------------------------------------
 1 | // 0099.自守数
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int n;
 9 |     while(cin >> n)
10 |     {
11 |         int cnt = 0;
12 |         for(int i = 0; i < n; i++)
13 |         {
14 |             int j = 10;
15 |             for(; i%j != i; j *= 10);
16 |             if (i*i % j== i) cnt ++;
17 |         }
18 |         cout << cnt << endl;
19 |     }
20 |     return 0;
21 | }


--------------------------------------------------------------------------------
/huawei/0009.cpp:
--------------------------------------------------------------------------------
 1 | // 0009.提取不重复的整数
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int mp[10];
 7 | 
 8 | int main()
 9 | {
10 |     int num;
11 |     cin >> num;
12 |     if(num == 0) cout << 0;
13 |     while(num != 0)
14 |     {
15 |         int t = num%10;
16 |         if(mp[t] == 0)
17 |         {
18 |             mp[t] = 1;
19 |             cout << t;
20 |         }
21 |         num /= 10;
22 |     }
23 |     return 0;
24 | }


--------------------------------------------------------------------------------
/huawei/0037.cpp:
--------------------------------------------------------------------------------
 1 | // 0037.统计每个月兔子的总数
 2 | 
 3 | // 斐波那契数列
 4 | #include <iostream>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int n;
10 |     while(cin >> n)
11 |     {
12 |         int a = 1, b = 0, c = 0;    // 1个月，2个月，3个月及以上的兔子数
13 |         while(--n)
14 |         {
15 |             c += b;
16 |             b = a;
17 |             a = c;
18 |         }
19 |         cout << a+b+c << endl;
20 |     }
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/huawei/0001.cpp:
--------------------------------------------------------------------------------
 1 | // 0001.字符串最后一个单词的长度
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int i = 0, cnt = 0;
10 |     char s[5001];
11 | 
12 |     cin.getline(s, 5001);
13 |     for(i = strlen(s)-1; i >= 0 && s[i]==' '; i--);
14 |     for(; i >= 0; i--)
15 |     {
16 |         if(s[i] == ' ') break;
17 |         cnt ++;
18 |     }
19 |     cout << cnt;
20 | 
21 |     return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/huawei/0091.cpp:
--------------------------------------------------------------------------------
 1 | // 0091.201301 JAVA 题目2-3级
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int f(int n, int m)
 7 | {
 8 |     if(n == 0&& m == 0) return 0;
 9 |     else if(n == 0) return 1;
10 |     else if(m == 0) return 1;
11 |     else return f(n-1, m) + f(n, m-1);
12 | }
13 | 
14 | int main()
15 | {
16 |     int n, m;
17 |     while(cin >> n >> m)
18 |     {
19 |         cout << f(n, m) << endl;
20 |     }
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/huawei/0038.cpp:
--------------------------------------------------------------------------------
 1 | // 0038.求小球落地5次后所经历的路程和第5次反弹的高度
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int n;
 9 |     while (cin >> n)
10 |     {
11 |         double sum = n;
12 |         double hei = n;
13 |         for (int i = 0; i < 4; i++) {
14 |             hei /= 2;
15 |             sum += hei*2;
16 |         }
17 |         cout << sum << endl;
18 |         cout << hei/2 << endl;
19 |     }
20 |     return 0;
21 | }


--------------------------------------------------------------------------------
/huawei/0002.cpp:
--------------------------------------------------------------------------------
 1 | // 0002.计算字符个数
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int cnt = 0;
10 |     char s[5001], a;
11 | 
12 |     cin.getline(s, 5001);
13 |     a = getchar();
14 |     a = toupper(a);
15 |     for(int i = 0; i < strlen(s); i++)
16 |     {
17 |         if(toupper(s[i]) == a){
18 |             cnt ++;
19 |         }
20 |     }
21 |     cout << cnt;
22 | 
23 |     return 0;
24 | }


--------------------------------------------------------------------------------
/huawei/0090.cpp:
--------------------------------------------------------------------------------
 1 | // 0090.合法IP
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int a,b,c,d;
 9 |     while(scanf("%d.%d.%d.%d", &a,&b,&c,&d) != EOF)
10 |     {
11 |         if (a > 255 || b > 255 || c > 255 || d > 255
12 |            || a < 0 || b < 0 || c < 0 || d < 0) {
13 |             cout << "NO" << endl;
14 |         } else {
15 |             cout << "YES" << endl;
16 |         }
17 |     }
18 |     return 0;
19 | }


--------------------------------------------------------------------------------
/huawei/0058.cpp:
--------------------------------------------------------------------------------
 1 | // 0058.输入n个整数，输出其中最小的k个
 2 | 
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int n, m;
10 |     while(cin >> n >> m)
11 |     {
12 |         int a[n];
13 |         for(int i = 0; i < n; i++)
14 |             cin >> a[i];
15 |         sort(a, a+n);
16 |         for(int i = 0; i < m; i++)
17 |             cout << a[i] << ' ';
18 |         cout << endl;
19 |     }
20 |     return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/huawei/0014.cpp:
--------------------------------------------------------------------------------
 1 | // 0014.字串的连接最长路径查找
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | #include <algorithm>
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 |     int n;
11 |     string s[1000];
12 |     cin >> n;
13 |     getchar();
14 |     for (int i = 0; i < n; i++)
15 |     {
16 |         getline(cin, s[i]);
17 |     }
18 |     sort(s, s+n);
19 |     for(int i = 0; i < n; i++)
20 |     {
21 |         cout << s[i] << endl;
22 |     }
23 |     return 0;
24 | }


--------------------------------------------------------------------------------
/huawei/0051.cpp:
--------------------------------------------------------------------------------
 1 | // 0051.输出单向链表中倒数第k个结点
 2 | 
 3 | #include <iostream>
 4 | #include <vector>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int n;
10 |     while(cin >> n)
11 |     {
12 |         int a;
13 |         vector<int> v;
14 |         for(int i = 0; i < n; i++)
15 |         {
16 |             cin >> a;
17 |             v.push_back(a);
18 |         }
19 |         cin >> a;
20 |         cout << v[v.size()-a] << endl;
21 |     }
22 |     return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/huawei/0055.cpp:
--------------------------------------------------------------------------------
 1 | // 0055.（练习用）挑7
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int n = 0;
 9 |     int mp[30001];
10 |     mp[0] = 0;
11 |     for(int i = 1; i <= 30000; i++)
12 |     {
13 |         string s = to_string(i);
14 |         if(i%7==0 || s.find('7') != s.npos) mp[i] = mp[i-1]+1;
15 |         else mp[i] = mp[i-1];
16 |     }
17 |     while(cin >> n)
18 |     {
19 |         cout << mp[n] << endl;
20 |     }
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/huawei/0108.cpp:
--------------------------------------------------------------------------------
 1 | // 0108.求最小公倍数
 2 | 
 3 | //由于两个数的乘积等于这两个数的最大公约数与最小公倍数的积
 4 | 
 5 | #include <iostream>
 6 | using namespace std;
 7 | 
 8 | int gcd(int x, int y)
 9 | {  
10 |     while (x * y)
11 |     {  
12 |         if (x > y) {  
13 |             x %= y;  
14 |         } else if (x < y) {  
15 |             y %= x;  
16 |         }  
17 |     }  
18 |     return x > y ? x : y;  
19 | }
20 | 
21 | int main()
22 | {
23 |     int a, b;
24 |     cin >> a >> b;
25 |     cout << a * b / gcd(a, b);
26 |     return 0;
27 | }


--------------------------------------------------------------------------------
/huawei/0003.cpp:
--------------------------------------------------------------------------------
 1 | // 0003.明明的随机数
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int mp[1001], n, m;
10 |     while(cin >> n)
11 |     {
12 |         memset(mp, 0, sizeof(mp));
13 |         for(int i = 0; i < n; i++)
14 |         {
15 |             cin >> m;
16 |             mp[m] = 1;
17 |         }
18 |         for(int i = 1; i < 1001; i ++)
19 |         {
20 |             if(mp[i]) cout << i << endl;
21 |         }
22 |     }
23 |     
24 |     return 0;
25 | }


--------------------------------------------------------------------------------
/huawei/0010.cpp:
--------------------------------------------------------------------------------
 1 | // 0010.字符个数统计
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | int mp[128];
 8 | 
 9 | int main()
10 | {
11 |     int c, cnt;
12 |     c = getchar();
13 |     while(c != '\n')
14 |     {
15 |         if(c >= 0 && c<=127)
16 |         {
17 |             if(mp[c] == 0)
18 |             {
19 |                 mp[c] = 1;
20 |                 cnt ++;
21 |             }
22 |         }
23 |         c = getchar();
24 |     }
25 |     cout << cnt;
26 |     
27 |     return 0;
28 | }


--------------------------------------------------------------------------------
/huawei/0035.cpp:
--------------------------------------------------------------------------------
 1 | // 0035.蛇形矩阵
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int n;
 9 |     while(cin >> n)
10 |     {
11 |         int t = 1;
12 |         for(int i = 1; i <= n; i++)
13 |         {
14 |             int s = t;
15 |             for(int j = i; j <= n; j++)
16 |             {
17 |                 cout << s << ' ';
18 |                 s += j+1;
19 |             }
20 |             cout << endl;
21 |             t += i;
22 |         }
23 |     }
24 |     return 0;
25 | }


--------------------------------------------------------------------------------
/huawei/0086.cpp:
--------------------------------------------------------------------------------
 1 | // 0086.求最大连续bit数
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int n;
 9 |     while(cin >> n)
10 |     {
11 |         int mcnt = 0, cnt = 0;
12 |         while(n != 0)
13 |         {
14 |             if(n%2 == 1) {
15 |                 cnt ++;
16 |                 mcnt = max(mcnt, cnt);
17 |             }else {
18 |                 cnt = 0;
19 |             }
20 |             n /= 2;
21 |         }
22 |         cout << mcnt << endl;
23 |     }
24 |     return 0;
25 | }


--------------------------------------------------------------------------------
/huawei/0072.cpp:
--------------------------------------------------------------------------------
 1 | // 0072.百钱买百鸡问题
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | void f()
 7 | {
 8 |     int x, y, z;
 9 |     for (x = 0; x <= 300/15; x++)
10 |     {
11 |         y = (200 - 14 * x) / 8;
12 |         z = 100 - x - (200 - 14 * x) / 8;
13 |         if ((200 - 14 * x) % 8 == 0 && y >= 0)
14 |         {
15 |             printf("%d %d %d\n", x, y, z);
16 |         }
17 |     }
18 |     return ;
19 | }
20 | 
21 | int main()
22 | {
23 |     int n;
24 |     while(cin >> n)
25 |     {
26 |         f();
27 |     }
28 |     return 0;
29 | }


--------------------------------------------------------------------------------
/huawei/0006.cpp:
--------------------------------------------------------------------------------
 1 | // 0006.质数因子
 2 | 
 3 | #include <iostream>
 4 | #include <cmath>
 5 | using namespace std;
 6 | 
 7 | int isP(long n)
 8 | {
 9 |     for(int i = 2; i < sqrt(n); i++)
10 |     {
11 |         if(n/i == 0) return 0;
12 |     }
13 |     return 1;
14 | }
15 | 
16 | int main()
17 | {
18 |     long n;
19 |     cin >> n;
20 |     for(long i = 2; i <= n;)
21 |     {
22 |         if(n%i == 0) {
23 |             printf("%d ", i);
24 |             n /= i;
25 |         }else {
26 |             for(i++; !isP(i); i++);
27 |         }
28 |     }
29 |     return 0;
30 | }


--------------------------------------------------------------------------------
/huawei/0097.cpp:
--------------------------------------------------------------------------------
 1 | // 0097.记负均正
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int n, m;
 9 |     while(cin >> n)
10 |     {
11 |         int c1 = 0, c2 = 0;
12 |         double aver = 0;
13 |         for(int i = 0; i < n; i++)
14 |         {
15 |             cin >> m;
16 |             if (m > 0) {
17 |                 aver += m;
18 |                 c1 ++;
19 |             } else if (m < 0) {
20 |                 c2 ++;
21 |             }
22 |         }
23 |         printf("%d %.1lf\n", c2, aver/c1);
24 |     }
25 |     return 0;
26 | }


--------------------------------------------------------------------------------
/huawei/0008.cpp:
--------------------------------------------------------------------------------
 1 | // 0008.合并表记录
 2 | 
 3 | #include <iostream>
 4 | #include <map>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int a, b, n;
10 |     map<int,int> mp;
11 |     cin >> n;
12 |     for(int i = 0; i < n; i++)
13 |     {
14 |         cin >> a >> b;
15 |         if(mp.find(a) != mp.end())
16 |         {
17 |             mp[a] += b;
18 |         }else
19 |         {
20 |             mp[a] = b;
21 |         }
22 |     }
23 |     for (auto it = mp.begin(); it != mp.end(); it ++)
24 |     {
25 |         printf("%d %d\n", it->first, it->second);
26 |     }
27 | 
28 |     return 0;
29 | }


--------------------------------------------------------------------------------
/huawei/0004.cpp:
--------------------------------------------------------------------------------
 1 | // 0004.字符串分隔
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | void prints(char *s, int len)
 8 | {
 9 |     if(len <= 8) {
10 |         int i = 0;
11 |         for (; i < len; i++) cout << s[i];
12 |         for (; i < 8; i++) cout << '0';
13 |         cout << endl;
14 |     } else {
15 |         prints(s, 8);
16 |         prints(s+8, len-8);
17 |     }
18 |     return ;
19 | }
20 | 
21 | int main(){
22 |     char a[101];
23 |     for(int i = 0; i < 2; i++)
24 |     {
25 |         cin.getline(a, 101);
26 |         prints(a, strlen(a));
27 |     }
28 |     return 0;
29 | }


--------------------------------------------------------------------------------
/huawei/0104.cpp:
--------------------------------------------------------------------------------
 1 | // 0104.字符串分割
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | int main(){
 8 |     string s;
 9 |     int n;
10 |     while(cin >> n)
11 |     {
12 |         getchar();
13 |         while(n--)
14 |         {
15 |             getline(cin, s);
16 |             while (s.size() >= 8)
17 |             {
18 |                 cout << s.substr(0, 8) << endl;
19 |                 s = s.substr(8);
20 |             }
21 |             if (s.size() > 0) {
22 |                 cout << s.append(8-s.size(), '0') << endl;
23 |             }
24 |         }
25 |     }
26 |     return 0;
27 | }


--------------------------------------------------------------------------------
/huawei/0080.cpp:
--------------------------------------------------------------------------------
 1 | // 0080.整形数组合并
 2 | 
 3 | #include <iostream>
 4 | #include <set>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int n, m, t;
10 |     while(cin >> n)
11 |     {
12 |         set<int> st;
13 |         while(n--)
14 |         {
15 |             cin >> t;
16 |             st.insert(t);
17 |         }
18 |         cin >> m;
19 |         while(m--)
20 |         {
21 |             cin >> t;
22 |             st.insert(t);
23 |         }
24 |         for(auto it = st.begin(); it != st.end(); it++)
25 |         {
26 |             cout << *it;
27 |         }
28 |         cout << endl;
29 |     }
30 |     return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/huawei/0096.cpp:
--------------------------------------------------------------------------------
 1 | // 0096.表示数字
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s;
10 |     while(getline(cin, s))
11 |     {
12 |         s.insert(0, 1, 'a');
13 |         s.append(1, 'a');
14 |         for(int i = 1; i < s.size(); i ++)
15 |         {
16 |             if (!isdigit(s[i-1]) && isdigit(s[i])) {
17 |                 cout << '*';
18 |             }else if(isdigit(s[i-1]) && !isdigit(s[i])) {
19 |                 cout << '*';
20 |             }
21 |             if(i != s.size()-1) cout << s[i];
22 |         }
23 |         cout << endl;
24 |     }
25 |     return 0;
26 | }


--------------------------------------------------------------------------------
/huawei/0107.cpp:
--------------------------------------------------------------------------------
 1 | // 0107.求解立方根
 2 | // keywords: 牛顿迭代法
 3 | 
 4 | #include <iostream>
 5 | using namespace std;
 6 | 
 7 | // 牛顿迭代法
 8 | 
 9 | #define E 0.01
10 | 
11 | double f(double x, double num)
12 | {
13 | 	return x*x*x - num;
14 | }
15 | 
16 | double _f(double x)
17 | {
18 | 	return 3*x*x;
19 | }
20 | 
21 | double cubeRoot(double num)
22 | {
23 | 	double r = 1;
24 |     double x0;
25 | 	do{
26 | 		x0 = r;
27 |         r = x0 - f(x0, num)/_f(x0);
28 | 	}while(f(r,num) > E || f(r, num) < -E);
29 | 
30 |     return r;
31 | }
32 | 
33 | int main()
34 | {
35 |     double num;
36 |     cin >> num;
37 |     printf("%.1lf", cubeRoot(num));
38 |     return 0;
39 | }


--------------------------------------------------------------------------------
/huawei/0040.cpp:
--------------------------------------------------------------------------------
 1 | // 0040.输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     string s;
 9 |     while(getline(cin,s))
10 |     {
11 |         int a=0, b=a, c=0, d=0;
12 |         for(int i = 0; i < s.size(); i++)
13 |         {
14 |             if(isalpha(s[i])){
15 |                 a ++;
16 |             } else if(s[i] == ' ') {
17 |                 b ++;
18 |             } else if(isdigit(s[i])) {
19 |                 c ++;
20 |             } else {
21 |                 d ++;
22 |             }
23 |         }
24 |         printf("%d\n%d\n%d\n%d\n",a,b,c,d);
25 |     }
26 |     return 0;
27 | }


--------------------------------------------------------------------------------
/huawei/0060.cpp:
--------------------------------------------------------------------------------
 1 | // 0060.查找组成一个偶数最接近的两个素数
 2 | 
 3 | #include <iostream>
 4 | #include <cmath>
 5 | using namespace std;
 6 | 
 7 | bool isPrim(int n)
 8 | {
 9 |     if(n < 2) return false; 
10 |     int t = sqrt(n);
11 |     for(int i = 2; i <= t; i++)
12 |     {
13 |         if(n%i==0) return false;
14 |     }
15 |     return true;
16 | }
17 | 
18 | int main()
19 | {
20 |     int n;
21 |     while(cin >> n)
22 |     {
23 |         for(int i = n/2; i >= 2; i--)
24 |         {
25 |             if(isPrim(i) && isPrim(n-i)) {
26 |                 cout << i << endl << n-i << endl;
27 |                 break;
28 |             }
29 |         }
30 |     }
31 |     return 0;
32 | }


--------------------------------------------------------------------------------
/huawei/0073.cpp:
--------------------------------------------------------------------------------
 1 | // 0073.计算日期到天数转换
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int isLeap(int y)
 7 | {
 8 |     if(y%400 == 0) return 1;
 9 |     else if(y%100 && y%4 == 0) return 1;
10 |     else return 0;
11 | }
12 | 
13 | int main()
14 | {
15 |     int month[13] = {0,0,31,28,31,30,31,30,31,31,30,31,30};
16 |     for(int i = 1; i < 13; i++)
17 |     {
18 |         month[i] += month[i-1];
19 |     }
20 |     int y, m, d;
21 |     while(cin >> y >> m >> d)
22 |     {
23 |         int day = 0;
24 |         if(m > 2) {
25 |             day = isLeap(y); 
26 |         }
27 |         day += month[m] + d;
28 |         cout << day << endl;
29 |     }
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/huawei/0103.cpp:
--------------------------------------------------------------------------------
 1 | // 0103.Redraiment的走法
 2 | // keywords: 最长上升子序列
 3 | 
 4 | #include <iostream>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int n, m = 0;
10 |     int a[10000], dp[10000];
11 |     while(cin >> n)
12 |     {
13 |         m = 0;
14 |         for(int i = 0; i < n; i++)
15 |         {
16 |             cin >> a[i];
17 |             dp[i] = 1;
18 |             for (int j = 0; j < i; j++)
19 |             {
20 |                 if(a[i] > a[j]) {
21 |                     dp[i] = max(dp[i], dp[j]+1);
22 |                 }
23 |             }
24 |             if(m < dp[i]) m = dp[i];
25 |         }
26 |         cout << m << endl;
27 |     }
28 |     
29 |     return 0;
30 | }


--------------------------------------------------------------------------------
/huawei/0101.cpp:
--------------------------------------------------------------------------------
 1 | // 0101.输入整型数组和排序标识，对其元素按照升序或降序进行排序
 2 | 
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | using namespace std;
 6 | 
 7 | void mysort(int num[], int len, bool f)
 8 | {
 9 |     sort(num, num+len);
10 |     if (f) {
11 |         reverse(num, num+len);
12 |     }
13 | }
14 | 
15 | int main()
16 | {
17 |     int num[10000], n, f;
18 |     while (cin >> n) 
19 |     {
20 |         for(int i = 0; i < n; i++)
21 |         {
22 |             cin >> num[i];
23 |         }
24 |         cin >> f;
25 |         mysort(num, n, f);
26 |         for(int i = 0; i < n; i++)
27 |         {
28 |             cout << num[i] << ' ';
29 |         }
30 |         cout << endl;
31 |     }
32 |     return 0;
33 | }


--------------------------------------------------------------------------------
/huawei/0059.cpp:
--------------------------------------------------------------------------------
 1 | // 0059.找出字符串中第一个只出现一次的字符
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     string s;
 9 |     int np[128];
10 |     while(getline(cin, s))
11 |     {
12 |         fill(np, np+128, 0);
13 |         for(int i = 0; i < s.size(); i++) np[s[i]] ++;
14 |         string r = "";
15 |         for(int i = 0; i < 128; i++) if(np[i] == 1) r+= (char)i;
16 |         if (r.empty()) {
17 |             cout << -1 << endl;
18 |             continue;
19 |         }
20 |         for(int i = 0; i < s.size(); i++)
21 |         {
22 |             if(r.find(s[i]) != r.npos){
23 |                 cout << s[i] << endl;
24 |                 break;
25 |             }
26 |         }
27 |     }
28 |     return 0;
29 | }


--------------------------------------------------------------------------------
/huawei/0023.cpp:
--------------------------------------------------------------------------------
 1 | // 0023.删除字符串中出现次数最少的字符
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s;
10 |     int np[26] = {0};
11 |     while(getline(cin, s))
12 |     {
13 |         memset(np, 0 ,sizeof(np));
14 |         for(int i = 0; i < s.size(); i++)
15 |         {
16 |             np[s[i]-'a'] ++;
17 |         }
18 |         int mc = 20;
19 |         for(int i = 0; i < 26; i++)
20 |         {
21 |             if(np[i] == 0) continue;
22 |             if(mc > np[i]) mc = np[i];
23 |         }
24 |         for(int i = 0; i < s.size(); i++)
25 |         {
26 |             if(np[s[i]-'a'] != mc) cout << s[i];
27 |         }
28 |         cout << endl;
29 |     }
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/huawei/0083.cpp:
--------------------------------------------------------------------------------
 1 | // 0083.二维数组操作
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int r, c, r1, c1, r2, c2, ri, ci, rt, ct;
 9 |     while(cin>>r>>c>>r1>>c1>>r2>>c2>>ri>>ci>>rt>>ct)
10 |     {
11 |         if(r>9||c>9)  cout<<"-1"<<endl;
12 |         else cout<<"0"<<endl;
13 |          
14 |         if(r1>=0 && r1<r && c1>=0 && c1<c && r2>=0 && r2<r && c2>=0 && c2<c) cout<<"0"<<endl;       
15 |         else cout<<"-1"<<endl;
16 |          
17 |         if(ri>=0 && ri<r) cout<<"0"<<endl;
18 |         else cout<<"-1"<<endl;
19 |          
20 |         if(ci>=0 && ci<c) cout<<"0"<<endl;
21 |         else cout<<"-1"<<endl;
22 |          
23 |         if(rt>=0 && rt<r && ct>=0 && ct<c) cout<<"0"<<endl;   
24 |         else cout<<"-1"<<endl;
25 |     }
26 | }


--------------------------------------------------------------------------------
/huawei/0031.cpp:
--------------------------------------------------------------------------------
 1 | // 0031.【中级】单词倒排
 2 | 
 3 | #include <iostream>
 4 | #include <vector>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s;
10 |     vector<string> v;
11 |     while(getline(cin, s))
12 |     {
13 |         s += ' ';
14 |         while(!s.empty())
15 |         {
16 |             int i = 0;
17 |             string c = "";
18 |             for(i = 0; i < s.size(); i++)
19 |             {
20 |                 if(!isalpha(s[i])) break;
21 |                 c += s[i];
22 |             }
23 |             if(!c.empty()) v.push_back(c);
24 |             s = s.substr(i+1);
25 |         }
26 |         for(int i = v.size()-1; i >0; i--)
27 |         {
28 |             cout << v[i] << ' ';
29 |         }
30 |         cout << v[0] << endl;
31 |     }
32 |     return 0;
33 | }


--------------------------------------------------------------------------------
/huawei/0048.cpp:
--------------------------------------------------------------------------------
 1 | // 0048.从单向链表中删除指定值的节点
 2 | 
 3 | #include <iostream>
 4 | #include <map>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int n, m, head, a, b;
10 |     while(cin >> n)
11 |     {
12 |         map<int, int> list;
13 |         cin >> head;
14 |         list[head] = -1;
15 |         for(int i = 0; i < n-1; i++)
16 |         {
17 |             cin >> a >> b;
18 |             if(list[b] == -1) {
19 |                 list[b] = a;
20 |                 list[a] = -1;
21 |             } else {
22 |                 list[a] = list[b];
23 |                 list[b] = a;
24 |             }
25 |         }
26 |         cin >> m;
27 |         for(a = head; a != -1; a = list[a])
28 |             if (a != m) cout << a << ' ';
29 |         cout << endl;
30 |     }
31 |     return 0;
32 | }


--------------------------------------------------------------------------------
/huawei/0081.cpp:
--------------------------------------------------------------------------------
 1 | // 0081.字符串匹配
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | char mp[128];
 8 | 
 9 | int main()
10 | {
11 |     char s[1000],l[1000];
12 |     while(cin.getline(s,1000))
13 |     {
14 |         cin.getline(l,1000);
15 |         memset(mp, 0, 128);
16 |         for(int i = 0; i < strlen(s); i++)
17 |         {
18 |             mp[s[i]] = 1;
19 |         }
20 |         for(int i = 0; i < strlen(l); i++)
21 |         {
22 |             mp[l[i]] = 0;
23 |         }
24 |         string flag = "true";
25 |         for(int i = 0; i < 128; i++)
26 |         {
27 |             if (mp[i]) {
28 |                 flag = "false";
29 |                 break;
30 |             }
31 |         }
32 |         cout << flag << endl;
33 |     }
34 |     return 0;
35 | }


--------------------------------------------------------------------------------
/huawei/0056.cpp:
--------------------------------------------------------------------------------
 1 | // 0056.iNOC产品部--完全数计算
 2 | 
 3 | // 只计算一遍500000的个数，也容易超时的可能原因：
 4 | // 1. 可能我算法的时间复杂度太大
 5 | // 2. 题目有点问题，说明实际测试的数应该小于明显500000.
 6 | // 实际只有以下4个数：6 28 296 8128
 7 | #include <iostream>
 8 | #include <cmath>
 9 | using namespace std;
10 | 
11 | bool isPerf(int n)
12 | {
13 |     int sum = 1;
14 |     int t = sqrt(n);
15 |     for(int i = 2; i <= t; i++){
16 |         if(n%i == 0) sum += i + n/i;
17 |     }
18 |     if(sum == n) return true;
19 |     return false;
20 | }
21 | 
22 | int main()
23 | {
24 |     int n = 0;
25 |     int mp[500001];
26 |     mp[1] = 0;
27 |     for(int i = 2; i <= 100001; i++)
28 |     {
29 |         if(isPerf(i)) mp[i] = mp[i-1]+1;
30 |         else mp[i] = mp[i-1];
31 |     }
32 |     while(cin >> n)
33 |     {
34 |         cout << mp[n] << endl;
35 |     }
36 |     return 0;
37 | }


--------------------------------------------------------------------------------
/huawei/0082.cpp:
--------------------------------------------------------------------------------
 1 | // 0082.将真分数分解为埃及分数
 2 | 
 3 | // 算法不同，埃及分数不唯一。故未AC属于正常现象。
 4 | // PS：目前也没有最优的算法获取项数最少的埃及分数。
 5 | 
 6 | #include <iostream>
 7 | #include <vector>
 8 | using namespace std;
 9 | 
10 | int main()
11 | {
12 |     string s;
13 |     int a, b;
14 |     while(getline(cin, s))
15 |     {
16 |         vector<int> r;
17 |         int f = s.find('/');
18 |         a = stoi(s.substr(0, f));
19 |         b = stoi(s.substr(f+1));
20 |         while(b % a != 0)
21 |         {
22 |             int i = b / a + 1;
23 |             a = a * i - b;
24 |             b = b * i;
25 |             r.push_back(i);
26 |         }
27 |         
28 |         for(int i = 0; i < r.size(); i++)
29 |         {
30 |             cout << "1/" << r[i] << "+";
31 |         }
32 |         cout << "1/" << b/a << endl;
33 |     }
34 |     return 0;
35 | }


--------------------------------------------------------------------------------
/huawei/0041.cpp:
--------------------------------------------------------------------------------
 1 | // 0041.称砝码
 2 | 
 3 | #include <iostream>
 4 | #include <vector>
 5 | #include <set>
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 |     int n, a[10], tmp;
11 |     while (cin >> n)
12 |     {
13 |         vector<int> v;
14 |         set<int> s;
15 |         for(int i = 0; i < n; i++) cin >> a[i];
16 |         for(int i = 0; i < n; i++) 
17 |         {
18 |             cin >> tmp;
19 |             for(int j = 0; j < tmp; j++) v.push_back(a[i]);
20 |         }
21 |         s.insert(0);
22 |         for(int i = 0; i < v.size(); i++)
23 |         {
24 |             set<int> t(s);
25 |             for(auto it = t.begin(); it != t.end(); it ++)
26 |             {
27 |                 s.insert(*it + v[i]);
28 |             }
29 |         }
30 |         cout << s.size() << endl;
31 |     }
32 |     return 0;
33 | }


--------------------------------------------------------------------------------
/huawei/0074.cpp:
--------------------------------------------------------------------------------
 1 | // 0074.参数解析
 2 | 
 3 | #include <iostream>
 4 | #include <vector>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s;
10 |     while(getline(cin, s))
11 |     {
12 |         vector<string> v;
13 |         s += ' ';
14 |         while(!s.empty())
15 |         {
16 |             if(s[0] == '"') {
17 |                 int f = s.find('"', 1);
18 |                 v.push_back(s.substr(1, f-1));
19 |                 s = s.substr(f+2);
20 |             }else{
21 |                 int f = s.find(' ');
22 |                 v.push_back(s.substr(0, f));
23 |                 s = s.substr(f+1);
24 |             }
25 |         }
26 |         cout << v.size() << endl;
27 |         for(int i = 0; i < v.size(); i++)
28 |         {
29 |             cout << v[i] << endl;
30 |         }
31 |     }
32 |     return 0;
33 | }


--------------------------------------------------------------------------------
/huawei/0069.cpp:
--------------------------------------------------------------------------------
 1 | // 0069.矩阵乘法
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int x, y, z;
 9 |     while(cin >> x >> y >> z)
10 |     {
11 |         int a[x][y], b[y][z];
12 |         for(int i = 0; i < x; i++)
13 |             for(int j = 0; j < y; j++)
14 |                 cin >> a[i][j];
15 |         for(int i = 0; i < y; i++)
16 |             for(int j = 0; j < z; j++)
17 |                 cin >> b[i][j];
18 |         for(int i = 0; i < x; i++)
19 |         {   
20 |             for(int j = 0; j < z; j++)
21 |             {
22 |                 int tmp = 0;
23 |                 for(int k = 0; k < y; k++)
24 |                     tmp += a[i][k]*b[k][j];
25 |                 cout << tmp << ' ';
26 |             }
27 |             cout << endl;
28 |         }
29 |     }
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/huawei/0033.cpp:
--------------------------------------------------------------------------------
 1 | // 0033.整数与IP地址间的转换
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     unsigned long n;
 9 |     int m[4], i;
10 |     string s;
11 |     while(getline(cin, s))
12 |     {
13 |         s += '.';
14 |         n = 0;
15 |         while(!s.empty())
16 |         {
17 |             i = s.find('.');
18 |             int tmp = stoul(s.substr(0,i));
19 |             n = (n<<8) | tmp;
20 |             s = s.substr(i+1);
21 |         }
22 |         cout << n << endl;
23 |         cin >> n;
24 |         getchar();
25 |         i = 0;
26 |         while(n != 0)
27 |         {
28 |             m[i++] = n%256;
29 |             n/=256;
30 |         }
31 |         for(int i = 3; i > 0; i--)
32 |         {
33 |             cout << m[i] << '.';
34 |         }
35 |         cout << m[0] << endl;
36 |     }
37 |     return 0;
38 | }


--------------------------------------------------------------------------------
/huawei/0005.cpp:
--------------------------------------------------------------------------------
 1 | // 0005.进制转换
 2 | 
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | #include <cstring>
 6 | using namespace std;
 7 | 
 8 | int turn(int c)
 9 | {
10 |     int a = toupper(c);
11 |     if(a >= 'A' && a <= 'Z')
12 |     {
13 |         return a - 'A' + 10;
14 |     }
15 |     else {
16 |         return a - '0';
17 |     }
18 | }
19 | 
20 | int main()
21 | {
22 |     char a[100];
23 |     while(cin.getline(a, 100))
24 |     {
25 |         int sum = 0;
26 |         reverse(a, a + strlen(a));
27 |         for(int i = 0; i < strlen(a); i++)
28 |         {
29 |             if (toupper(a[i]) == 'X') break;
30 |             int t = turn(a[i]);
31 |             for(int j = 0; j < i; j++)
32 |             {
33 |                 t *= 16;
34 |             }
35 |             sum += t;
36 |         }
37 |         cout << sum << endl;
38 |     }
39 |     return 0;
40 | }


--------------------------------------------------------------------------------
/huawei/0047.cpp:
--------------------------------------------------------------------------------
 1 | // 0047.线性插值
 2 | // PS: 这题指的重复数据，连续两个编号相同的数据使用第一组。
 3 | #include <iostream>
 4 | #include <map>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int m, n, a, b, c, d;
10 |     while (cin >> m >> n)
11 |     {
12 |         map<int, int> mp;
13 |         cin >> a >> b;
14 |         mp[a] = b;
15 |         cout << a << ' ' << b << endl;
16 |         for(int i = 0; i < m-1; i++)
17 |         {
18 |             cin >> c >> d;
19 |             if ( c == a ) continue;
20 |             mp[c] = d;
21 |             if (c - a > 1) {
22 |                 for(int i = 1; i < c-a; i++)
23 |                 {
24 |                     cout << a+i << ' ' << b+(d-b)/(c-a)*i << endl;
25 |                 }
26 |             }
27 |             cout << c << ' ' << d << endl;
28 |             a = c;
29 |             b = d;
30 |         }
31 |     }
32 |     
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/huawei/0021.cpp:
--------------------------------------------------------------------------------
 1 | // 0021.简单密码破解
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s;
10 |     string mp[10] = {"0", "1", "abc","def","ghi", "jkl","mno", "pqrs", "tuv", "wxyz"};
11 |     while(getline(cin, s))
12 |     {
13 |         for(int i = 0; i < s.size(); i++)
14 |         {
15 |             int c = s[i];
16 |             if (isupper(s[i])) {
17 |                 c = s[i]-'A'+1+'a';
18 |                 if(c > 'z') c = 'a';
19 |             } else if (islower(s[i])) {
20 |                 for(int j = 2; j < 10; j++)
21 |                 {
22 |                     if(mp[j].find(s[i]) != mp[j].npos)
23 |                     {
24 |                         c = j + '0';
25 |                     }
26 |                 }
27 |             }
28 |             printf("%c", c);
29 |         }
30 |     }
31 |     return 0;
32 | }


--------------------------------------------------------------------------------
/huawei/0092.cpp:
--------------------------------------------------------------------------------
 1 | // 0092.在字符串中找出连续最长的数字串
 2 | 
 3 | #include <iostream>
 4 | #include <vector>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s;
10 |     while(getline(cin, s))
11 |     {
12 |         vector<int> v;
13 |         int cnt = 0, mx = 0;
14 |         for(int i = 0; i < s.size(); i++)
15 |         {
16 |             if(isdigit(s[i])){
17 |                 cnt ++;
18 |                 if(cnt > mx){
19 |                     mx = cnt;
20 |                     v.clear();
21 |                 }
22 |                 if (cnt == mx) {
23 |                     v.push_back(i-cnt+1);
24 |                 }
25 |             } else {
26 |                 cnt = 0;
27 |             }
28 |         }
29 |         for(int i = 0; i < v.size(); i++)
30 |         {
31 |             cout << s.substr(v[i], mx);
32 |         }
33 |         cout << ',' << mx << endl;
34 |     }
35 |     return 0;
36 | }


--------------------------------------------------------------------------------
/huawei/0075.cpp:
--------------------------------------------------------------------------------
 1 | // 0075.公共字串计算
 2 | // keywords: 最长公共子串
 3 | 
 4 | #include <iostream>
 5 | using namespace std;
 6 | 
 7 | int lcs(string a, string b)
 8 | {
 9 |     int maxLen = 0;
10 |     a.insert(0, 1, ' ');
11 |     b.insert(0, 1, ' ');
12 |     int n = a.size(), m = b.size();
13 |     int dp[n][m];
14 |     for(int i = 0; i < n; i++) dp[i][0] = 0;
15 |     for(int j = 0; j < m; j++) dp[0][j] = 0;
16 |     for(int i = 1; i < n; i++) 
17 |     {
18 |         for(int j = 1; j < m; j++)
19 |         {
20 |             if(a[i] == b[j]) {
21 |                 dp[i][j] = dp[i-1][j-1] + 1;
22 |                 maxLen = max(maxLen, dp[i][j]);
23 |             } else {
24 |                 dp[i][j] = 0;
25 |             } 
26 |         }
27 |     }
28 |     return maxLen;
29 | }
30 | 
31 | int main()
32 | {
33 |     string a, b;
34 |     while(cin >> a >> b)
35 |     {
36 |         cout << lcs(a, b) << endl;
37 |     }
38 |     return 0;
39 | }


--------------------------------------------------------------------------------
/huawei/0053.cpp:
--------------------------------------------------------------------------------
 1 | // 0053.iNOC产品部-杨辉三角的变形
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int n;
10 |     while(cin >> n)
11 |     {
12 |         int np1[2*n+1], np2[2*n];
13 |         fill(np1, np1+2*n+1, 0);
14 |         fill(np2, np2+2*n, 0);
15 |         np1[1] = np2[1] = 1;
16 |         for(int i = 1; i <= n; i++)
17 |         {
18 |             for(int j = 1; j <= i; j++)
19 |                 np2[j] = np1[j] + np1[j-1] + np1[j+1];
20 |             for (int j = i+1; j <= 2*i-1; j++)
21 |                 np2[j] = np2[2*i-j];
22 |             memcpy(np1 + 1, np2, n*2*4);
23 |         }
24 |         int res = -1;
25 |         for(int i = 1; i <= n; i++)
26 |         {
27 |             if (np2[i]%2 == 0)
28 |             {
29 |                 res = i;
30 |                 break;
31 |             }
32 |         }
33 |         cout << res << endl;
34 |     }
35 |     return 0;
36 | }


--------------------------------------------------------------------------------
/huawei/0094.cpp:
--------------------------------------------------------------------------------
 1 | // 0094.记票统计
 2 | 
 3 | #include <iostream>
 4 | #include <map>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int n,m;
10 |     while(cin >> n)
11 |     {
12 |         getchar();
13 |         string s1[1000], s2[1000];
14 |         map<string,int> mp;
15 |         int cnt = 0;
16 |         for (int i = 0; i < n; i++)
17 |         {
18 |             cin >> s1[i];
19 |             mp[s1[i]] = 0;
20 |         }
21 |         cin >> m;
22 |         getchar();
23 |         for (int i = 0; i < m; i++)
24 |         {
25 |             cin >> s2[i];
26 |             if (mp.find(s2[i]) != mp.end()) {
27 |                 mp[s2[i]] ++;
28 |             }else {
29 |                 cnt ++;
30 |             }
31 |         }
32 |         for (int i = 0; i < n; i++)
33 |         {
34 |             cout << s1[i] << " : " << mp[s1[i]] << endl;
35 |         }
36 |         cout << "Invalid : " << cnt << endl;
37 | 
38 |     }
39 |     return 0;
40 | }


--------------------------------------------------------------------------------
/huawei/0093.cpp:
--------------------------------------------------------------------------------
 1 | // 0093.201301 JAVA题目0-1级
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int f(int sum1, int sum2, int v[], int idx, int n)
 7 | {
 8 |     if (idx < n) {
 9 |         return f(sum1+v[idx], sum2, v, idx+1, n) + f(sum1, sum2+v[idx], v, idx+1, n);
10 |     }else{
11 |         if(sum1 == sum2) return 1;
12 |         else return 0;
13 |     }
14 | }
15 | 
16 | int main()
17 | {
18 |     int n, m;
19 |     while(cin >> n)
20 |     {
21 |         int v[1000];
22 |         int sum1 = 0, sum2 = 0, j = 0;
23 |         for(int i = 0; i < n; i++)
24 |         {
25 |             cin >> m;
26 |             if(m % 5 == 0) sum1 += m;
27 |             else if (m % 3 == 0) sum2 += m;
28 |             else v[j++] = m;
29 |         }
30 |         int r = f(sum1, sum2, v, 0, j);
31 |         if(r > 0) {
32 |             cout << "true" << endl;
33 |         }else {
34 |             cout << "false" << endl;
35 |         }
36 |     }
37 |     return 0;
38 | }


--------------------------------------------------------------------------------
/huawei/0078.cpp:
--------------------------------------------------------------------------------
 1 | // 0078.超长正整数相加
 2 | // keywords: 模拟加法
 3 | 
 4 | #include <iostream>
 5 | #include <string>
 6 | #include <algorithm>
 7 | using namespace std;
 8 | 
 9 | string add(string a, string b)
10 | {
11 |     string r = "";
12 |     reverse(a.begin(), a.end());
13 |     reverse(b.begin(), b.end());
14 |     if(a.size() < b.size())
15 |     {
16 |         a.append(b.size()-a.size(), '0');
17 |     } else if(a.size() > b.size())
18 |     {
19 |         b.append(a.size()-b.size(), '0');
20 |     }
21 |     int c = 0;
22 |     for(int i = 0; i < a.size(); i++)
23 |     {
24 |         int t = a[i] + b[i] - '0'*2 + c;
25 |         r.append(1, t % 10+'0');
26 |         c = t / 10;
27 |     }
28 |     if(c) r.append(1, c+'0');
29 |     reverse(r.begin(), r.end());
30 |     return r;
31 | }
32 | 
33 | int main()
34 | {
35 |     string s1, s2;
36 |     while(getline(cin, s1))
37 |     {
38 |         getline(cin, s2);
39 |         cout << add(s1, s2) << endl;
40 |     }
41 | }


--------------------------------------------------------------------------------
/huawei/0024.cpp:
--------------------------------------------------------------------------------
 1 | // 0024.合唱队
 2 | // keywords: 最长上升子序列
 3 | 
 4 | #include <iostream>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     int n;
10 |     int m[10000], dp1[10000], dp2[10000];
11 |     while(cin >> n)
12 |     {
13 |         for(int i = 0; i < n; i++)
14 |         {
15 |             cin >> m[i];
16 |             dp1[i] = 1;
17 |             for(int j = 0; j < i; j++)
18 |             {
19 |                 if(m[i] > m[j]) dp1[i] = max(dp1[i], dp1[j]+1);
20 |             }
21 |         }
22 |         for(int i = n-1; i >= 0; i--)
23 |         {
24 |             dp2[i] = 1;
25 |             for(int j = n-1; j >= i; j--)
26 |             {
27 |                 if(m[i] > m[j]) dp2[i] = max(dp2[i], dp2[j]+1);
28 |             }
29 |         }
30 |         int mn = 0;
31 |         for(int i = 0; i < n; i++)
32 |         {
33 |             if(dp1[i] + dp2[i] - 1 > mn) mn = dp1[i] + dp2[i] - 1;
34 |         }
35 |         cout << n-mn << endl;
36 |     }
37 |     return 0;
38 | }


--------------------------------------------------------------------------------
/huawei/0026.cpp:
--------------------------------------------------------------------------------
 1 | // 0026.字符串排序
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | #include <vector>
 6 | #include <algorithm>
 7 | using namespace std;
 8 | 
 9 | bool cmp(pair<char, int> p1, pair<char, int> p2)
10 | {
11 |     if(toupper(p1.first) == toupper(p2.first)) return p1.second < p2.second;
12 |     return toupper(p1.first) < toupper(p2.first);
13 | }
14 | 
15 | int main()
16 | {
17 |     string s;
18 |     while(getline(cin, s))
19 |     {
20 |         vector<pair<char, int> > v;
21 |         for(int i = 0; i < s.size(); i++)
22 |         {
23 |             if(!isalpha(s[i])) continue;
24 |             v.push_back(make_pair(s[i], i));
25 |         }
26 |         sort(v.begin(), v.end(), cmp);
27 |         for(int i = 0, j = 0; i < s.size(); i++)
28 |         {
29 |             if (!isalpha(s[i])) {
30 |                 cout << s[i];
31 |             }else {
32 |                 cout << v[j++].first;
33 |             }
34 |         }
35 |         cout << endl;
36 |     }
37 |     return 0;
38 | }


--------------------------------------------------------------------------------
/huawei/0071.cpp:
--------------------------------------------------------------------------------
 1 | // 0071.字符串通配符
 2 | // keywords: 递归
 3 | 
 4 | #include <iostream>
 5 | using namespace std;
 6 | 
 7 | bool match(string a, string b)
 8 | {
 9 |     // 可以做一下剪枝
10 |     for(int i = 0, j = 0; i < a.size(); i++, j++)
11 |     {
12 |         if (a[i] == '*') {
13 |             bool f = false;
14 |             string s = a.substr(i+1);
15 |             for (int k = j; k < b.size(); k++)
16 |             {
17 |                 f = f || match(s, b.substr(k));
18 |             }
19 |             return f;
20 |         }
21 |         else if (a[i] == '?') {
22 |             continue;
23 |         }else if (a[i] != b[j]) {
24 |             return false;
25 |         }
26 |     }
27 |     return true;
28 | }
29 | 
30 | int main()
31 | {
32 |     string a, b;
33 |     while(getline(cin, a))
34 |     {
35 |         getline(cin, b);
36 |         if (match(a, b)) {
37 |             cout << "true" << endl;
38 |         }else {
39 |             cout << "false" << endl;
40 |         }
41 |             
42 |     }
43 |     return 0;
44 | }


--------------------------------------------------------------------------------
/huawei/0036.cpp:
--------------------------------------------------------------------------------
 1 | // 0036.字符串加密
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s;
10 |     int mp[26] = {0};
11 |     while(getline(cin, s))
12 |     {
13 |         string key = "";
14 |         fill(mp, mp+26, 0);
15 |         for(int i = 0; i < s.size(); i++)
16 |         {
17 |             int c = toupper(s[i])-'A';
18 |             if(mp[c] == 0){
19 |                 key += 'A'+c;
20 |                 mp[c] = 1;
21 |             }
22 |         }
23 |         for(int i = 0; i < 26; i++)
24 |         {
25 |             if(mp[i] == 0) key += 'A'+i;
26 |         }
27 |         getline(cin, s);
28 |         string res = "";
29 |         for(int i = 0; i < s.size(); i++)
30 |         {
31 |             int c = toupper(s[i])-'A';
32 |             if(islower(s[i])) {
33 |                 res += tolower(key[c]);
34 |             }else {
35 |                 res += key[c];
36 |             }
37 |         }
38 |         cout << res << endl;
39 |     }
40 |     return 0;
41 | }


--------------------------------------------------------------------------------
/huawei/0052.cpp:
--------------------------------------------------------------------------------
 1 | // 0052.计算字符串的距离
 2 | // keywords: levenshtein距离
 3 | 
 4 | #include <iostream>
 5 | #include <cmath>
 6 | using namespace std;
 7 | 
 8 | int findMin(int a, int b, int c)
 9 | {
10 |     a = min(a, b);
11 |     b = min(b, c);
12 |     return min(a, b);
13 | }
14 | 
15 | int levenshtein(string a, string b)
16 | {
17 |     a.insert(0, 1,' ');
18 |     b.insert(0, 1, ' ');
19 |     int n = a.size(), m = b.size();
20 |     int cost, lev[n][m];
21 |     for(int i = 0; i < n; i++) lev[i][0] = i;
22 |     for(int j = 0; j < m; j++) lev[0][j] = j;
23 |     for(int i = 1; i < n; i++)
24 |     {
25 |         for(int j = 1; j < m; j++)
26 |         {
27 |             if(a[i] == b[j]) cost = 0;
28 |             else cost = 1;
29 |             lev[i][j] = findMin(lev[i][j-1]+1, 
30 |                 lev[i-1][j]+1, lev[i-1][j-1]+cost);
31 |         }
32 |     }
33 |     return lev[n-1][m-1];
34 | }
35 | 
36 | int main()
37 | {
38 |     string a, b;
39 |     while(cin >> a >> b)
40 |     {
41 |         cout << levenshtein(a, b) << endl;
42 |     }
43 |     return 0;
44 | }


--------------------------------------------------------------------------------
/huawei/0045.cpp:
--------------------------------------------------------------------------------
 1 | // 0045.名字的漂亮度
 2 | 
 3 | #include <iostream>
 4 | #include <vector>
 5 | #include <map>
 6 | #include <algorithm>
 7 | using namespace std;
 8 | 
 9 | int score(string s)
10 | {
11 |     map<char,int> mp;
12 |     vector<int> v;
13 |     int sum = 0;
14 |     for(int i = 0; i < s.size(); i++)
15 |     {
16 |         if (mp.find(s[i]) == mp.end()) {
17 |             mp[s[i]] = 1;
18 |         }else {
19 |             mp[s[i]] ++;
20 |         }
21 |     }
22 |     for(auto it = mp.begin(); it != mp.end(); it ++)
23 |     {
24 |         v.push_back(it->second);
25 |     }
26 |     sort(v.begin(), v.end());
27 |     reverse(v.begin(), v.end());
28 |     for(int i = 0; i < v.size(); i++)
29 |     {
30 |         sum += (26-i)*v[i];
31 |     }
32 |     return sum;
33 | }
34 | 
35 | int main()
36 | {
37 |     int n;
38 |     string s;
39 |     while(cin >> n)
40 |     {
41 |         getchar();
42 |         for(int i = 0; i < n; i ++)
43 |         {
44 |             getline(cin, s);
45 |             cout << score(s) << endl;
46 |         }
47 |     }
48 |     return 0;
49 | }


--------------------------------------------------------------------------------
/huawei/0063.cpp:
--------------------------------------------------------------------------------
 1 | // 0063.DNA序列
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int n;
 9 |     string s;
10 |     while(getline(cin, s))
11 |     {
12 |         int sum = 0, maxidx = 0, maxsum = 0;
13 |         cin >> n;
14 |         getchar();
15 |         for(int i = 0; i < n; i++)
16 |         {
17 |             if(s[i] == 'C' || s[i] == 'G') {
18 |                 sum += 1;
19 |             }
20 |         }
21 |         maxsum = sum;
22 |         maxidx = 0;
23 |         for(int i = n; i < s.size(); i++)
24 |         {
25 |             if (s[i] == 'C' || s[i] == 'G') {
26 |                 sum += 1;
27 |             }
28 |             if (s[i-n] == 'C' || s[i-n] == 'G') {
29 |                 sum -= 1;
30 |             }
31 |             if (maxsum < sum) {
32 |                 maxidx = i-n+1;
33 |                 maxsum = sum;
34 |             }
35 |         }
36 |         for(int i = maxidx; i < maxidx + n; i++)
37 |         {
38 |             cout << s[i];
39 |         }
40 |         cout << endl;
41 |     }
42 |     return 0;
43 | }


--------------------------------------------------------------------------------
/huawei/0027.cpp:
--------------------------------------------------------------------------------
 1 | // 0027.查找兄弟单词
 2 | 
 3 | #include <iostream>
 4 | #include <vector>
 5 | #include <algorithm>
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 |     int n, m;
11 |     while(cin >> n)
12 |     {
13 |         getchar();
14 |         vector<string> v, r;
15 |         string s, t1, t2;
16 |         for(int i = 0; i < n; i++)
17 |         {
18 |             cin >> s;
19 |             v.push_back(s);
20 |         }
21 |         cin >> s;
22 |         cin >> m;
23 |         t1 = s;
24 |         sort(t1.begin(), t1.end());
25 |         for(int i = 0; i < n; i++)
26 |         {
27 |             t2 = v[i];
28 |             if (t2 == s) continue;
29 |             if (t2.size() == t1.size()) {
30 |                 sort(t2.begin(), t2.end());
31 |                 if (t2 == t1) {
32 |                     r.push_back(v[i]);
33 |                 }
34 |             }
35 |         }
36 |         sort(r.begin(), r.end());
37 |         cout << r.size() << endl;
38 |         if(r.size() >= m) {
39 |             cout << r[m-1] << endl;
40 |         }
41 |     }
42 |     return 0;
43 | }


--------------------------------------------------------------------------------
/huawei/0079.cpp:
--------------------------------------------------------------------------------
 1 | // 0079.计算字符串的相似度
 2 | // keywords: levenshtein距离
 3 | 
 4 | #include <iostream>
 5 | #include <cmath>
 6 | using namespace std;
 7 | 
 8 | int findMin(int a, int b, int c)
 9 | {
10 |     a = min(a, b);
11 |     b = min(b, c);
12 |     return min(a, b);
13 | }
14 | 
15 | int levenshtein(string a, string b)
16 | {
17 |     a.insert(0, 1,' ');
18 |     b.insert(0, 1, ' ');
19 |     int n = a.size(), m = b.size();
20 |     int cost, lev[n][m];
21 |     for(int i = 0; i < n; i++) lev[i][0] = i;
22 |     for(int j = 0; j < m; j++) lev[0][j] = j;
23 |     for(int i = 1; i < n; i++)
24 |     {
25 |         for(int j = 1; j < m; j++)
26 |         {
27 |             if(a[i] == b[j]) cost = 0;
28 |             else cost = 1;
29 |             lev[i][j] = findMin(lev[i][j-1]+1, 
30 |                 lev[i-1][j]+1, lev[i-1][j-1]+cost);
31 |         }
32 |     }
33 |     return lev[n-1][m-1];
34 | }
35 | 
36 | int main()
37 | {
38 |     string a, b;
39 |     while(cin >> a >> b)
40 |     {
41 |         cout << "1/" << levenshtein(a, b) + 1 << endl;
42 |     }
43 |     return 0;
44 | }


--------------------------------------------------------------------------------
/huawei/0102.cpp:
--------------------------------------------------------------------------------
 1 | // 0102.字符统计
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | #include <vector>
 6 | #include <map>
 7 | #include <algorithm>
 8 | using namespace std;
 9 | 
10 | bool cmp(pair<char, int> p1, pair<char, int> p2)
11 | {
12 |     if(p1.second == p2.second) return p1.first < p2.first;
13 |     return p1.second > p2.second;
14 | }
15 | 
16 | int main()
17 | {
18 |     string s;
19 |     while(getline(cin, s))
20 |     {
21 |         map<char, int> mp;
22 |         vector<pair<char, int> > v;
23 |         for(int i = 0; i < s.size(); i++)
24 |         {
25 |             if (isspace(s[i]) || isalnum(s[i]))
26 |             {
27 |                 mp[s[i]] ++;
28 |             }
29 |         }
30 |         for(auto it = mp.begin(); it != mp.end(); it++)
31 |         {
32 |             v.push_back(make_pair(it->first, it->second));
33 |         }
34 |         sort(v.begin(), v.end(), cmp);
35 |         for(auto it = v.begin(); it != v.end(); it++)
36 |         {
37 |             cout << it->first;
38 |         }
39 |         cout << endl;
40 |     }
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/huawei/0064.cpp:
--------------------------------------------------------------------------------
 1 | // 0064.MP3光标位置
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     int n;
 9 |     string s;
10 |     while(cin >> n >> s)
11 |     {
12 |         int idx = 1, jdx = 1;
13 |         int maxj = min(n, 4);
14 |         for(int i = 0; i < s.size(); i++)
15 |         {
16 |             if (s[i] == 'U') {
17 |                 if(idx == 1 && jdx == 1) {
18 |                     idx = n;
19 |                     jdx = maxj;
20 |                 } else {
21 |                     idx --;
22 |                     if(jdx != 1) jdx --;
23 |                 }
24 |             } else {
25 |                 if(idx == n && jdx == maxj) {
26 |                     idx = 1;
27 |                     jdx = 1;
28 |                 } else {
29 |                     idx ++;
30 |                     if(jdx != maxj) jdx ++;
31 |                 }
32 |             }
33 |         }
34 |         int now = idx;
35 |         for( ; jdx != 1; jdx --) idx --;
36 |         for(int i = 0; i < maxj; i++) cout << idx+i << ' ';
37 |         cout << endl << now << endl;
38 |     }
39 |     return 0;
40 | }


--------------------------------------------------------------------------------
/huawei/0019.cpp:
--------------------------------------------------------------------------------
 1 | // 0019.简单错误记录
 2 | 
 3 | #include <iostream>
 4 | #include <map>
 5 | #include <vector>
 6 | #include <algorithm>
 7 | using namespace std;
 8 | 
 9 | struct node
10 | {
11 |     int cnt;
12 |     int num;
13 | };
14 | 
15 | bool cmp(pair<string, node> p1, pair<string, node> p2){
16 |     return p1.second.num > p2.second.num;
17 | }
18 | 
19 | int main()
20 | {
21 |     string s;
22 |     map<string, node> mp;
23 |     int n = 0, num = 0;
24 |     node no;
25 |     //freopen("in.txt", "r", stdin);
26 |     while (getline(cin, s))
27 |     {
28 |         s = s.substr(s.rfind('\\')+1);
29 |         if(mp.find(s) == mp.end()) {
30 |             no.cnt = 1;
31 |             no.num = num;
32 |             mp[s] = no;
33 |         } else {
34 |             mp[s].cnt ++;
35 |         }
36 |         num ++;
37 |     }
38 |     vector<pair<string, node> > v(mp.begin(), mp.end());
39 |     sort(v.begin(), v.end(), cmp);
40 |     for(int i = v.size()>8?7:(v.size()-1); i >= 0; i--)
41 |     {
42 |         s = v[i].first;
43 |         int idx = s.find(' ');
44 |         if(idx > 16) s = s.substr(idx-16);
45 |         cout << s << ' ' << v[i].second.cnt << endl;
46 |     }
47 |     return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/huawei/0065.cpp:
--------------------------------------------------------------------------------
 1 | // 0065.查找两个字符串a,b中的最长公共子串
 2 | // keywords: 最长公共子串
 3 | 
 4 | #include <iostream>
 5 | using namespace std;
 6 | 
 7 | int lcs(string a, string b)
 8 | {
 9 |     if(a.size() > b.size()) {
10 |         string tmp = a;
11 |         a = b;
12 |         b = tmp;
13 |     }
14 |     a.insert(0, 1, ' ');
15 |     b.insert(0, 1, ' ');
16 |     int n = a.size(), m = b.size();
17 |     int dp[n][m];
18 |     int maxLen = 0, last;
19 |     for(int i = 0; i < n; i++) dp[i][0] = 0;
20 |     for(int j = 0; j < m; j++) dp[0][j] = 0;
21 |     for(int i = 1; i < n; i++) 
22 |     {
23 |         for(int j = 1; j < m; j++)
24 |         {
25 |             if(a[i] == b[j]) {
26 |                 dp[i][j] = dp[i-1][j-1] + 1;
27 |                 if(maxLen < dp[i][j]) {
28 |                     maxLen = dp[i][j];
29 |                     last = i;
30 |                 }
31 |             } else {
32 |                 dp[i][j] = 0;
33 |             } 
34 |         }
35 |     }
36 |     cout << a.substr(last-maxLen+1, maxLen) << endl;
37 |     return maxLen;
38 | }
39 | 
40 | int main()
41 | {
42 |     string a, b;
43 |     while(cin >> a >> b)
44 |     {
45 |         lcs(a, b);
46 |     }
47 |     return 0;
48 | }


--------------------------------------------------------------------------------
/huawei/0030.cpp:
--------------------------------------------------------------------------------
 1 | // 0030.字符串合并处理
 2 | 
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string a, b, s;
10 |     string np = "0123456789ABCDEF";
11 |     char c;
12 |     char mp[16] = {'0','8','4','C','2','A','6','E','1','9','5','D','3','B','7','F'};
13 |     while(cin >> a >> b)
14 |     {
15 |         s = a+b;
16 |         a = "";
17 |         b = "";
18 |         for(int i = 0; i < s.size(); i++)
19 |         {
20 |             if(i%2 == 0) a += s[i];
21 |             else b += s[i];
22 |         }
23 |         sort(a.begin(), a.end());
24 |         sort(b.begin(), b.end());
25 |         s = "";
26 |         for(int i = 0; i < a.size(); i++)
27 |         {
28 |             s += a[i];
29 |             if(i < b.size()) s += b[i];
30 |         }
31 |         a = "";
32 |         for(int i = 0; i < s.size(); i++)
33 |         {
34 |             c = s[i];
35 |             if ((c <= 'f' && c >= 'a') || (c <= 'F' && c >= 'A') 
36 |                 || (c <= '9' && c >= '0')) {
37 |                 c = mp[np.find(toupper(c))];
38 |             }
39 |             a += c;
40 |         }
41 |         cout << a << endl;
42 |     }
43 |     return 0;
44 | }


--------------------------------------------------------------------------------
/huawei/0070.cpp:
--------------------------------------------------------------------------------
 1 | // 0070.矩阵乘法计算量估算
 2 | 
 3 | #include <iostream>
 4 | #include <vector>
 5 | #include <stack>
 6 | #include <map>
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 |     int n, a, b;
12 |     string s;
13 |     while(cin >> n)
14 |     {
15 |         int cnt = 0;
16 |         vector<pair<int, int> > v;
17 |         stack<pair<int, int> > st;
18 |         for(int i = 0; i < n; i++)
19 |         {
20 |             cin >> a >> b;
21 |             v.push_back(make_pair(a, b));
22 |         }
23 |         getchar();
24 |         getline(cin, s);
25 |         for(int i = 0, j = 0; i < s.size(); i++)
26 |         {
27 |             if (s[i] != '(' && s[i] != ')') {
28 |                 st.push(v[j++]);
29 |             } else if(s[i] == ')') {
30 |                 if(st.size() == 1) break; //测试用例中出现了括号不匹配的例子。
31 |                 pair<int, int> p1 = st.top();
32 |                 st.pop();
33 |                 pair<int, int> p2 = st.top();
34 |                 st.pop();
35 |                 st.push(make_pair(p2.first, p1.second));
36 |                 cnt += p2.first * p1.first * p1.second;
37 |             }
38 |         }
39 |         cout << cnt << endl;
40 |     }
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/huawei/0068.cpp:
--------------------------------------------------------------------------------
 1 | // 0068.成绩排序
 2 | 
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | using namespace std;
 6 | 
 7 | struct student{
 8 |     int num;
 9 |     string name;
10 |     int score;
11 | };
12 | 
13 | bool cmp1(student s1, student s2)
14 | {
15 |     if(s1.score == s2.score) return s1.num < s2.num;
16 |     return s1.score > s2.score;
17 | }
18 | 
19 | bool cmp2(student s1, student s2)
20 | {
21 |     if(s1.score == s2.score) return s1.num < s2.num;
22 |     return s1.score < s2.score;
23 | }
24 | 
25 | int main()
26 | {
27 |     int n, m;
28 |     string s;
29 |     student st[1000];
30 |     while(cin >> n >> m)
31 |     {
32 |         getchar();
33 |         for(int i = 0; i < n; i++)
34 |         {
35 |             getline(cin, s);
36 |             int f = s.find(' ');
37 |             st[i].num = i;
38 |             st[i].name = s.substr(0, f);
39 |             st[i].score = stoi(s.substr(f+1));
40 |         }
41 |         if(m)
42 |             sort(st, st+n, cmp2);
43 |         else
44 |             sort(st, st+n, cmp1);
45 |         for(int i = 0; i < n; i++)
46 |         {
47 |             cout << st[i].name << ' ' << st[i].score << endl;
48 |         }
49 |     }
50 |     return 0;
51 | }


--------------------------------------------------------------------------------
/huawei/0066.cpp:
--------------------------------------------------------------------------------
 1 | // 0066.配置文件恢复
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     string s;
 9 |     string t1 = "reset";
10 |     string t2[] = {"reset", "board", "board", "reboot", "backplane"};
11 |     string t3[] = {"board", "add", "delet", "backplane", "abort"};
12 |     string an[] = {"board fault", "where to add", "no board at all", "impossible", "install first", "unkown command"};
13 |     while(getline(cin, s))
14 |     {
15 |         int idx = s.find(' ');
16 |         if(idx == s.npos) {
17 |             if(t1.find(s) != t1.npos) cout << "reset what" << endl;
18 |             else cout << "unkown command" << endl;
19 |         } else {
20 |             string s1 = s.substr(0, idx);
21 |             string s2 = s.substr(idx+1);
22 |             int cnt = 0, j = 5;
23 |             for(int i = 0; i < 5; i++)
24 |             {
25 |                 string tp1 = t2[i].substr(0, s1.size());
26 |                 string tp2 = t3[i].substr(0, s2.size());
27 |                 if(tp1 == s1 && tp2 == s2) {
28 |                     cnt ++;
29 |                     j = i;
30 |                 }
31 |             }
32 |             if(cnt != 1) j = 5;
33 |             cout << an[j] << endl;
34 |         }
35 |     }
36 |     return 0;
37 | }


--------------------------------------------------------------------------------
/huawei/0032.cpp:
--------------------------------------------------------------------------------
 1 | // 0032.字符串运用-密码截取
 2 | 
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | using namespace std;
 6 | 
 7 | int LPS(string s)
 8 | {
 9 |     int maxLen = 0, n = s.size();
10 |     bool p[n][n];
11 |     fill(p[0], p[0]+n*n, false);
12 |     for(int i = 0; i < n; i++) // 遍历每一个字符，并以该字符做中心向两边扩展
13 |     {
14 |         for(int j = 0; i-j >= 0 && i+j < n; j++) // aba 这种单中心的情况
15 |         {
16 |             if(s[i-j] == s[i+j]) {
17 |                 p[i-j][i+j] = true;
18 |                 if(2*j+1 > maxLen) maxLen = 2*j+1;
19 |             } else {
20 |                 p[i-j][i+j] = false;
21 |                 break;
22 |             }
23 |         }
24 | 
25 |         if(s[i] != s[i+1]) continue;
26 | 
27 |         for(int j = 0; i-j >= 0 && i+1+j < n; j++) // abba 这种双中心的情况
28 |         {
29 |             if(s[i-j] == s[i+1+j]) {
30 |                 p[i-j][i+1+j] = true;
31 |                 if(2*j+2 > maxLen) maxLen = 2*j+2;
32 |             } else {
33 |                 p[i-j][i+1+j] = false;
34 |                 break;
35 |             }
36 |         }
37 |     }    
38 | 
39 |     return maxLen;
40 | }
41 | 
42 | int main()
43 | {
44 |     string s;
45 |     while(getline(cin, s))
46 |     {
47 |         cout << LPS(s) << endl;
48 |     }
49 |     return 0;
50 | }


--------------------------------------------------------------------------------
/huawei/0020.cpp:
--------------------------------------------------------------------------------
 1 | // 0020.密码验证合格程序
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     string s;
 9 |     while( getline(cin, s) )
10 |     {
11 |         int A = 0, a = 0, num = 0, ctl = 0;
12 |         if(s.size() <= 8) {
13 |             cout << "NG" <<endl;
14 |             continue;
15 |         }
16 |         for(int i = 0; i < s.size(); i++)
17 |         {
18 |             if(isupper(s[i])){
19 |                 A = 1;
20 |             } else if(islower(s[i])){
21 |                 a = 1;
22 |             } else if(isdigit(s[i])){
23 |                 num = 1;
24 |             } else {
25 |                 ctl = 1;
26 |             }
27 |         }
28 |         if (A+a+num+ctl < 3) {
29 |             cout << "NG" <<endl;
30 |             continue;
31 |         }
32 |         int findFlag = false;
33 |         for(int i = 0; i < s.size()-6; i ++)
34 |         {
35 |             string s1 = s.substr(i,3);
36 |             string s2 = s.substr(i+3);
37 |             if (s2.find(s1) != s2.npos) {
38 |                 findFlag = true;
39 |                 break;
40 |             }
41 |         }
42 |         if (findFlag) {
43 |             cout << "NG" <<endl;
44 |             continue;
45 |         }
46 |         cout << "OK" << endl;
47 |     }
48 |     return 0;
49 | }


--------------------------------------------------------------------------------
/huawei/0088.cpp:
--------------------------------------------------------------------------------
 1 | // 0088.扑克牌大小
 2 | 
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string tb = "345678910JQKA2jokerJOKER";
10 |     string s;
11 |     while(getline(cin, s))
12 |     {
13 |         int idx = s.find('-');
14 |         string t1 = s.substr(0,idx);
15 |         string t2 = s.substr(idx+1);
16 |         int c1 = count(t1.begin(), t1.end(), ' ');
17 |         int c2 = count(t2.begin(), t2.end(), ' ');
18 |         if(c1 != c2) {
19 |             if(t1 == "joker JOKER" || t2 == "joker JOKER") {
20 |                 cout << "joker JOKER" << endl;
21 |             }else if(c1 == 3 ){
22 |                 cout << t1 << endl;
23 |             }else if(c2 == 3){
24 |                 cout << t2 << endl;
25 |             }else {
26 |                 cout << "ERROR" << endl;
27 |             }
28 |         } else {
29 |             string s1 = t1 + ' ', s2 = t2 + ' ';
30 |             s1 = s1.substr(0, s1.find(' '));
31 |             s2 = s2.substr(0, s2.find(' '));
32 |             int i1 = tb.find(s1);
33 |             int i2 = tb.find(s2);
34 |             if(i1 > i2) {
35 |                 cout << t1 << endl;
36 |             } else {
37 |                 cout << t2 << endl;
38 |             }
39 |         }
40 |     }
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/huawei/0025.cpp:
--------------------------------------------------------------------------------
 1 | // 0025.数据分类处理
 2 | 
 3 | #include <iostream>
 4 | #include <vector>
 5 | #include <map>
 6 | #include <set>
 7 | #include <algorithm>
 8 | using namespace std;
 9 | 
10 | int main()
11 | {
12 |     int n, m, tmp;
13 |     while(cin >> n)
14 |     {
15 |         int v[10000];
16 |         map<int, vector<pair<int, int> > > mp;
17 |         set<int> st;
18 |         int cnt = 0;
19 |         for (int i = 0; i < n; i++) cin >> v[i];
20 |         cin >> m;
21 |         for (int i = 0; i < m; i++)
22 |         {
23 |             cin >> tmp;
24 |             st.insert(tmp);
25 |         }
26 |         for(auto it = st.begin(); it != st.end(); it ++)
27 |         {
28 |             for(int i = 0; i < n; i++)
29 |             {
30 |                 string s1 = to_string(v[i]);
31 |                 string s2 = to_string(*it);
32 |                 if(s1.find(s2) != s1.npos) {
33 |                     mp[*it].push_back(make_pair(i, v[i]));
34 |                     cnt += 2;
35 |                 }
36 |             }
37 |         }
38 |         cout << cnt + mp.size() * 2;
39 |         for(auto it = mp.begin(); it != mp.end(); it ++)
40 |         {
41 |             cout << ' ' << it->first << ' ' << (it->second).size();
42 |             for (auto jt = (it->second).begin(); jt != (it->second).end(); jt ++)
43 |             {
44 |                 cout << ' ' << jt->first << ' ' << jt->second;
45 |             }
46 |         }
47 |         cout << endl;
48 |     }
49 |     return 0;
50 | }


--------------------------------------------------------------------------------
/huawei/0029.cpp:
--------------------------------------------------------------------------------
 1 | // 0029.字符串加解密
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | string encode(string s, string r)
 8 | {
 9 |     r = "";
10 |     char c;
11 |     for(int i = 0; i < s.size(); i++)
12 |     {
13 |         if(isalpha(s[i])) {
14 |             if(isupper(s[i])) {
15 |                 c = tolower(s[i]) + 1;
16 |                 if(c > 'z') c = 'a';
17 |             } else {
18 |                 c = toupper(s[i]) + 1;
19 |                 if(c > 'Z') c = 'A';
20 |             }
21 |         }else if(isdigit(s[i])){
22 |             c = s[i] + 1;
23 |             if(c > '9') c = '0';
24 |         }
25 |         r += c;
26 |     }
27 |     return r;
28 | }
29 | 
30 | string decode(string s, string r)
31 | {
32 |     r = "";
33 |     char c;
34 |     for(int i = 0; i < s.size(); i++)
35 |     {
36 |         if(isalpha(s[i])) {
37 |             if(isupper(s[i])) {
38 |                 c = tolower(s[i]) - 1;
39 |                 if(c < 'a') c = 'z';
40 |             } else {
41 |                 c = toupper(s[i]) - 1;
42 |                 if(c < 'A') c = 'Z';
43 |             }
44 |         }else if(isdigit(s[i])){
45 |             c = s[i] - 1;
46 |             if(c < '0') c = '9';
47 |         }
48 |         r += c;
49 |     }
50 |     return r;
51 | }
52 | 
53 | int main()
54 | {
55 |     string s1, s2, r;
56 |     while(getline(cin, s1))
57 |     {
58 |         getline(cin, s2);
59 |         cout << encode(s1, r) << endl;
60 |         cout << decode(s2, r) << endl;
61 |     }
62 |     return 0;
63 | }


--------------------------------------------------------------------------------
/huawei/0044.cpp:
--------------------------------------------------------------------------------
 1 | // 0044.Sudoku-Java
 2 | 
 3 | // 测试数据含有非唯一解，不在尝试AC
 4 | 
 5 | #include <iostream>
 6 | #include <vector>
 7 | #include <queue>
 8 | #include <map>
 9 | using namespace std;
10 | 
11 | int v[9][9];
12 | int lin[9][10], row[9][10], check[9][10];
13 | 
14 | bool test(int x, int y)
15 | {
16 |     int cnt = 0, t = 0, np[10];
17 |     fill(np, np+10, 0);
18 |     for(int i = 1; i < 10; i++) {
19 |         np[i] = lin[x][i] + row[y][i] + check[x/3*3+y/3][i];
20 |         if(np[i] != 0) {
21 |             cnt ++;
22 |         } else {
23 |             t = i;
24 |         }
25 |     }   
26 |     if(cnt == 8) {
27 |         v[x][y] = t;
28 |         lin[x][t] = 1;
29 |         row[y][t] = 1;
30 |         check[x/3*3+y/3][t] = 1;
31 |         return true;
32 |     }
33 | 
34 |     return false;
35 | }
36 | 
37 | int main()
38 | {
39 |     queue<pair<int, int> > q;
40 |     for(int i = 0; i < 9; i++){
41 |         for (int j = 0; j < 9; j++){
42 |             cin >> v[i][j];
43 |             lin[i][v[i][j]] = 1;
44 |             row[j][v[i][j]] = 1;
45 |             check[i/3*3+j/3][v[i][j]] = 1;
46 |             if(v[i][j] == 0) {
47 |                 q.push(make_pair(i,j));
48 |             }
49 |         }
50 |     }
51 |     while(!q.empty()) {
52 |         pair<int, int> p = q.front();
53 |         q.pop();
54 |         if (!test(p.first, p.second)) q.push(p);
55 |     }
56 |     for(int i = 0; i < 9; i++){
57 |         for (int j = 0; j < 9; j++){
58 |             cout << v[i][j] << ' ';
59 |         }
60 |         cout << endl;
61 |     }
62 |     return 0;
63 | }


--------------------------------------------------------------------------------
/huawei/0017.cpp:
--------------------------------------------------------------------------------
 1 | // 0017.坐标移动
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s;
10 |     while(getline(cin,s))
11 |     {
12 |         int x = 0, y = 0;
13 |         while(!s.empty())
14 |         {
15 |             int idx = s.find(';');
16 |             if (idx == 0) {
17 |                 s = s.substr(idx+1);
18 |                 continue;
19 |             }
20 |             string s1 = s.substr(0, idx);
21 |             char c = s1[0];
22 |             int err = 0;
23 |             for(int i = 1; i < s1.size(); i++)
24 |             {
25 |                 if(!isdigit(s1[i])) {
26 |                     err = 1;
27 |                     break;
28 |                 }
29 |             }
30 |             if(!err && s1.size() != 1)
31 |             {
32 |                 int num = stoi(s1.substr(1));
33 |                 switch (c)
34 |                 {
35 |                     case 'A':
36 |                         x -= num;
37 |                         break;
38 |                     case 'D':
39 |                         x += num;
40 |                         break;
41 |                     case 'W':
42 |                         y += num;
43 |                         break;
44 |                     case 'S':
45 |                         y -= num;
46 |                         break;
47 |                     default:
48 |                         break;
49 |                 }
50 |             }
51 |             s = s.substr(idx+1);
52 |         }
53 |         cout << x << ',' << y << endl;
54 |     }
55 |     return 0;
56 | }


--------------------------------------------------------------------------------
/huawei/0077.cpp:
--------------------------------------------------------------------------------
 1 | // 0077.火车进站
 2 | // keywords: 堆栈
 3 | 
 4 | #include <iostream>
 5 | #include <queue>
 6 | #include <algorithm>
 7 | #include <stack>
 8 | using namespace std;
 9 | 
10 | vector<string> v;
11 | 
12 | void print_queue(queue<int> q)
13 | {
14 |     string s;
15 |     while ( !q.empty() )
16 |     {
17 |         s += to_string(q.front());
18 |         s += ' ';
19 |         q.pop();
20 |     }
21 |     v.push_back(s);
22 | }
23 | 
24 | void func(queue<int> in, stack<int> st, queue<int> r, bool doPush)
25 | {
26 |     if ( in.empty() ) {   // 结束条件
27 |         if (doPush) return; // 入栈队列空了，再push不合理
28 |         while ( !st.empty() )
29 |         {
30 |             r.push(st.top());
31 |             st.pop();
32 |         }
33 |         print_queue(r);
34 |         return ;
35 |     } else {
36 |         if (doPush) {   // 入栈
37 |             st.push(in.front());
38 |             in.pop();
39 |         } else {        // 出栈 
40 |             if (st.empty()) return ;// 栈是空，直接返回
41 |             r.push(st.top());
42 |             st.pop();
43 |         }
44 | 
45 |         func(in, st, r, false);
46 |         func(in, st, r, true);
47 |     }
48 | }
49 | 
50 | int main()
51 | {
52 |     int n, num;
53 |     while(cin >> n)
54 |     {
55 |         v.clear();
56 |         queue<int> q, r;
57 |         stack<int> st;
58 |         for(int i = 0; i < n; i++) 
59 |         {
60 |             cin >> num;
61 |             q.push(num);
62 |         }
63 |         func(q, st, r, true);
64 |         sort(v.begin(), v.end());
65 |         for(int i = 0; i < v.size(); i++)
66 |         {
67 |             cout << v[i] << endl;
68 |         }
69 |     }
70 |     return 0;
71 | }


--------------------------------------------------------------------------------
/huawei/0043.cpp:
--------------------------------------------------------------------------------
 1 | // 0043.迷宫问题
 2 | // keywords: 树的遍历
 3 | 
 4 | // PS: 可以简化成树的层序遍历，唯一难点就是记录路径
 5 | 
 6 | #include <iostream>
 7 | #include <vector>
 8 | #include <stack>
 9 | #include <algorithm>
10 | using namespace std;
11 | 
12 | int main(){
13 |     int n, m;
14 |     int t[4][2] = {{-1,0}, {0,-1}, {1,0},{0,1}};
15 |     int v[12][12];
16 |     while(cin >> n >> m)
17 |     {
18 |         vector<pair<int,int> > r;
19 |         stack<pair<int,int> > s;
20 |         fill(v[0], v[0]+12*12, 1);
21 |         for(int i = 1; i <= n; i++)
22 |             for(int j = 1; j <= m; j++)
23 |                 cin >> v[i][j];
24 |         s.push(make_pair(1,1));
25 |         v[1][1] = 1;
26 |         while(!s.empty())
27 |         {
28 |             pair<int, int> p = s.top();
29 |             s.pop();
30 |             for(int i = 0; i < 4; i++){
31 |                 int x = p.first + t[i][0];
32 |                 int y = p.second + t[i][1];
33 |                 if(v[x][y] == 0) {
34 |                     v[x][y] = p.first * 100 + p.second; // 用于记录路径的上个点
35 |                     if(x == n && y == m) break; //  到达终点跳出
36 |                     s.push(make_pair(x,y));
37 |                 }
38 |             }
39 |         }
40 |         for (int x = n, y = m, t = v[n][m]; v[x][y] != 1; x = t/100, y = t%100)
41 |         {
42 |             t = v[x][y];
43 |             r.push_back(make_pair(x, y));
44 |         }
45 |         r.push_back(make_pair(1, 1));
46 |         reverse(r.begin(), r.end());
47 |         for(int i = 0; i < r.size(); i++)
48 |         {
49 |             cout << '(' << r[i].first-1 << ',' << r[i].second-1 << ')' << endl;
50 |         }
51 |     }
52 |     return 0;
53 | }


--------------------------------------------------------------------------------
/huawei/0067.cpp:
--------------------------------------------------------------------------------
 1 | // 0067.24点游戏算法
 2 | 
 3 | #include <iostream>
 4 | #include <algorithm>
 5 | #include <vector>
 6 | #include <cmath>
 7 | using namespace std;
 8 | 
 9 | double op(double a, double b, int opera)
10 | {
11 |     if(opera == 0) return a+b;
12 |     else if(opera == 1) return a-b;
13 |     else if(opera == 2) return a*b;
14 |     else if(opera == 3) return a/b;
15 |     return 0;
16 | }
17 | 
18 | bool cal24(vector<double> a, vector<int> o)
19 | {
20 |     // 考虑括号导致优先级变化
21 |     bool flag = false;
22 |     if(o.empty()) {
23 |         if( fabs(a[0]-24.0) < 0.01) flag = true;
24 |     } else {
25 |         for (int i = 0; i < o.size() && !flag; i++)
26 |         {
27 |             a[i] = op(a[i], a[i+1], o[i]);
28 |             a.erase(a.begin()+i+1);
29 |             o.erase(o.begin()+i);
30 |             flag |= cal24(a, o);
31 |         }
32 |     }
33 |     return flag;
34 | }
35 | 
36 | int main()
37 | {
38 |     double a[4];
39 |     int o[3];
40 |     while(cin >> a[0] >> a[1] >> a[2] >> a[3])
41 |     {
42 |         bool flag = false;
43 |         sort(a, a+4);
44 |         do {
45 |             for(int i = 0; i < 4 && !flag; i++) {
46 |                 o[0] = i;
47 |                 for(int j = 0; j < 4 && !flag; j++) {
48 |                     o[1] = j; 
49 |                     for(int k = 0; k < 4 && !flag; k++) {
50 |                         o[2] = k;
51 |                         vector<double> va(a, a+4);
52 |                         vector<int> vo(o, o+3);
53 |                         if(cal24(va, vo)) flag = true;
54 |                     }
55 |                 }
56 |             }
57 |         } while (next_permutation(a, a+4) && !flag);
58 |         if( flag ) cout << "true" << endl;
59 |         else cout << "false" << endl;
60 |     }
61 |     return 0;
62 | }
63 | 


--------------------------------------------------------------------------------
/huawei/0042.cpp:
--------------------------------------------------------------------------------
 1 | // 0042.学英语
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | string ge[10] = {"zero", "one", "two", "three", "four", "five", "six", "seven","eight", "nine"};
 7 | string ot[10] = {"ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
 8 | string shi[10] = {"zero", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};
 9 | 
10 | string printfHundred(int n)
11 | {
12 |     string s = "";
13 |     bool hasHundred = false;
14 |     if(n/100 != 0) {
15 |         s += ge[n/100] + " hundred";
16 |         hasHundred = true;
17 |     }
18 |     n %= 100;
19 |     if(n != 0) {
20 |         if (hasHundred) {
21 |             s += " and ";
22 |         }
23 |         if (n < 10) {
24 |             s += ge[n];
25 |         }else if (n < 20) {
26 |             s += ot[n-10];
27 |         }else {
28 |             s += shi[n/10];
29 |             if(n%10){
30 |                 s += " " + ge[n%10];
31 |             }
32 |         }
33 |     }
34 |     return s;
35 | }
36 | 
37 | int main()
38 | {
39 |     int n;
40 |     while (cin >> n)
41 |     {
42 |         if (n == 0) {
43 |             cout << "zero" << endl;
44 |             continue;
45 |         }
46 |         if (n/1000000000 != 0) {
47 |             cout << ge[n/1000000000] << " billion ";
48 |         } 
49 |         n %= 1000000000;
50 |         if(n/1000000 != 0) {
51 |             cout << printfHundred(n/1000000) << " million ";
52 |         }
53 |         n %= 1000000;
54 |         if(n/1000 != 0) {
55 |             cout << printfHundred(n/1000) << " thousand ";
56 |         }
57 |         n %= 1000;
58 |         if(n != 0) {
59 |             cout << printfHundred(n);
60 |         }
61 |         cout << endl;
62 |     }
63 |     return 0;
64 | }


--------------------------------------------------------------------------------
/huawei/0095.cpp:
--------------------------------------------------------------------------------
 1 | // 0095.人民币转换
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | string ge[10] = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
 7 | string ot[17] = { "", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾",
 8 |      "佰", "仟", "万", "拾", "佰", "仟","万" };
 9 | 
10 | void readItAfterPlot(string num)
11 | {
12 |     if(num == "00") {
13 |         cout << "整";
14 |         return ;
15 |     }
16 |     if (num[0] > '0') {
17 |         cout << ge[num[0]-'0'] << "角";
18 |     }
19 |     if (num[1] > '0') {
20 |         cout << ge[num[1]-'0'] << "分";
21 |     }
22 |     return ;
23 | }
24 | 
25 | void readItBeforePlot(string s)
26 | {
27 |     if (s == "0") return;
28 |     int j = s.size()-1;
29 |     if(!(j%4 == 1 && s[0] == '1')) {
30 |         cout << ge[s[0]-'0'];
31 |     }
32 |     cout << ot[j];
33 |     for(int i = 1; i < s.size(); i++)
34 |     {
35 |         if( (j-i)%4 == 0  && s[i] == '0') {
36 |             if (i >= 4 && j-i == 4 && s[i-1] + s[i-2] + s[i-3] == '0'*3) continue; // 100000001.11
37 |             cout << ot[j-i];
38 |             continue;
39 |         }
40 |         if(s[i] != '0') {
41 |             if(s[i-1] == '0') cout << "零";
42 |             //if(!((j-i)%4 == 1 && s[i] == '1')) {
43 |                 // 513.00 是伍佰壹拾叁元还是伍佰拾叁元的区别。
44 |                 cout << ge[s[i]-'0'];
45 |             //}
46 |             cout << ot[j-i];
47 |         }
48 |     }
49 |     cout << "元";
50 |     return ;
51 | }
52 | 
53 | int main()
54 | {
55 |     string s;
56 |     while(getline(cin, s))
57 |     {
58 |         int idx = s.find('.');
59 |         string t1 = s.substr(0, idx);
60 |         string t2 = s.substr(idx+1);
61 |         cout << "人民币";
62 |         readItBeforePlot(t1);
63 |         readItAfterPlot(t2);
64 |         cout << endl;
65 |     }
66 |     return 0;
67 | }


--------------------------------------------------------------------------------
/huawei/0087.cpp:
--------------------------------------------------------------------------------
 1 | // 0087.密码强度等级
 2 | 
 3 | #include <iostream>
 4 | #include <cstring>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     string s;
10 |     string r[7] =  {"VERY_WEAK", "WEAK", "AVERAGE", "STRONG", 
11 |         "VERY_STRONG", "SECURE", "VERY_SECURE"};
12 |     int ss[7] = {25, 25, 10, 10, 10, 10, 100};
13 |     while(getline(cin, s))
14 |     {
15 |         int score = 0;
16 |         if(s.size() <= 4){
17 |             score += 5;
18 |         }else if(s.size() >= 8) {
19 |             score += 25;
20 |         }else {
21 |             score += 10;
22 |         }
23 |         
24 |         int t1 = 0, t2 = 0, t3 = 0, t4 = 0, c1 = 0, c2 = 0, t;
25 |         for(int i = 0; i < s.size(); i++)
26 |         {
27 |             if(islower(s[i])) {
28 |                 t1 = 1;
29 |             } else if (isupper(s[i])) {
30 |                 t2 = 1;
31 |             }else if (isdigit(s[i])) {
32 |                 t3 = 1;
33 |                 c1 ++;
34 |             }else if (ispunct(s[i])) {
35 |                 t4 = 1;
36 |                 c2 ++;
37 |             }
38 |         }
39 |         if(c1 > 1) c1 = 2;
40 |         if(c2 > 1) {
41 |             c2 = 15;
42 |         } else {
43 |             c2 = 0;
44 |         }
45 |         score += t1*10 + t2*10 + t3*10*c1 + t4*10+c2; 
46 | 
47 |         t = t1 + t2 + t3 + t4;
48 |         if (t == 4) {
49 |             score += 5;
50 |         } else if(t1+t2==1 && t == 3) {
51 |             score += 3;
52 |         } else if (t1+t2>1 && t3 == 1) {
53 |             score += 2;
54 |         }
55 |         for(int i = 0; i < 7; i++)
56 |         {
57 |             score -= ss[i];
58 |             if(score < 0) {
59 |                 cout << r[i] << endl;
60 |                 break;
61 |             }
62 |         }
63 |     }
64 |     return 0;
65 | }


--------------------------------------------------------------------------------
/huawei/0054.cpp:
--------------------------------------------------------------------------------
 1 | // 0054.表达式求值
 2 | 
 3 | #include <iostream>
 4 | #include <stack>
 5 | using namespace std;
 6 | 
 7 | string mp = "+-*/)";
 8 | 
 9 | bool cmp(char c1, char c2)
10 | {
11 |     if (c1 =='(') {
12 |         return false;
13 |     } else if((c1=='+' || c1=='-') && (c2=='*' || c2=='/')){
14 |         return false;
15 |     }
16 |     return true;
17 | }
18 | 
19 | void doCal(stack<double> &st, stack<char> &so)
20 | {
21 |     double b = st.top();
22 |     st.pop();
23 |     double a = st.top();
24 |     st.pop();
25 |     int op = so.top();
26 |     so.pop();
27 |     if(op == '+') a = a+b;
28 |     else if(op == '-') a = a-b;
29 |     else if(op == '*') a = a*b;
30 |     else if(op == '/') a = a/b;
31 |     st.push(a);
32 |     return ;
33 | }
34 | 
35 | int main()
36 | {
37 |     string s;
38 |     while(getline(cin, s))
39 |     {
40 |         stack<double> st;
41 |         stack<char> so;
42 |         so.push('(');
43 |         s += ')';
44 |         bool nextIsOp = false;
45 |         for(int i = 0; i < s.size(); i++)
46 |         {
47 |             if(s[i]=='(') {
48 |                 so.push('(');
49 |             } else if(s[i]==')') {
50 |                 while(so.top() != '(') doCal(st, so);
51 |                 so.pop();
52 |             } else if (nextIsOp) {
53 |                 while(cmp(so.top(), s[i])) doCal(st, so);
54 |                 so.push(s[i]);
55 |                 nextIsOp = false;
56 |             } else {
57 |                 int j = i;
58 |                 if(s[j] == '-' || s[j] == '+') i++;
59 |                 while(mp.find(s[i]) == mp.npos) i++;
60 |                 string t = s.substr(j, i-j);
61 |                 st.push((double)stoi(t));
62 |                 i--;
63 |                 nextIsOp = true;
64 |             }
65 |         }
66 |         cout << st.top() << endl;
67 |     }
68 |     return 0;
69 | }


--------------------------------------------------------------------------------
/huawei/0050.cpp:
--------------------------------------------------------------------------------
 1 | // 0050.四则运算
 2 | 
 3 | #include <iostream>
 4 | #include <stack>
 5 | using namespace std;
 6 | 
 7 | string mp = "+-*/)]}";
 8 | // 当前运算符与符号栈的栈顶运算符做优先级比较，如果当前优先级高，则不做运算压入栈中，相同进行运算
 9 | bool cmp(char c1, char c2)
10 | {
11 |     if (c1 =='(') {
12 |         return false;
13 |     } else if((c1=='+' || c1=='-') && (c2=='*' || c2=='/')){
14 |         return false;
15 |     }
16 |     return true;
17 | }
18 | 
19 | void doCal(stack<double> &st, stack<char> &so)
20 | {
21 |     double b = st.top();
22 |     st.pop();
23 |     double a = st.top();
24 |     st.pop();
25 |     int op = so.top();
26 |     so.pop();
27 |     if(op == '+') a = a+b;
28 |     else if(op == '-') a = a-b;
29 |     else if(op == '*') a = a*b;
30 |     else if(op == '/') a = a/b;
31 |     st.push(a);
32 |     return ;
33 | }
34 | 
35 | int main()
36 | {
37 |     string s;
38 |     while(getline(cin, s))
39 |     {
40 |         stack<double> st;
41 |         stack<char> so;
42 |         so.push('(');
43 |         s += ')';
44 |         bool nextIsOp = false;
45 |         for(int i = 0; i < s.size(); i++)
46 |         {
47 |             if(s[i]=='{' || s[i]=='[' || s[i]=='(') {
48 |                 so.push('(');
49 |             } else if(s[i]==')' || s[i]==']' || s[i]=='}') {
50 |                 while(so.top() != '(') doCal(st, so);
51 |                 so.pop();
52 |             } else if (nextIsOp) {
53 |                 while(cmp(so.top(), s[i])) doCal(st, so);
54 |                 so.push(s[i]);
55 |                 nextIsOp = false;
56 |             } else {
57 |                 int j = i;
58 |                 if(s[j] == '-' || s[j] == '+') i++;
59 |                 while(mp.find(s[i]) == mp.npos) i++;
60 |                 string t = s.substr(j, i-j);
61 |                 st.push((double)stoi(t));
62 |                 i--;
63 |                 nextIsOp = true;
64 |             }
65 |         }
66 |         cout << st.top() << endl;
67 |     }
68 |     return 0;
69 | }


--------------------------------------------------------------------------------
/create_README.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/python3
 2 | 
 3 | import os
 4 | import re
 5 | 
 6 | keyword_url = {
 7 |     'Dijkstra算法':'https://ultraji.xyz/2019/06/algorithm_dijkstra.html'
 8 | }
 9 | 
10 | ## 查找目录中的代码文件（按文件名排序）
11 | # @param    path    代码文件目录
12 | # @return   代码文件的迭代对象
13 | def _find_code_file(path):
14 |     fname_rules = r'.*?\.(h|c|hh|cpp|java)$'
15 |     files = os.listdir(path)
16 |     files.sort()
17 |     for name in files:
18 |         if re.match(fname_rules, name):
19 |             tmp = os.path.join(path, name)
20 |             yield tmp
21 | 
22 | ## 创建表格一行
23 | # @param    path    解题CPP文件路径
24 | # @return   markdown格式的一行表格
25 | def _creat_table_row(path):
26 |     row_str = ""
27 |     with open(path, 'r', encoding='utf8') as tmp:
28 |         id_title = str(tmp.readline())
29 |         keywords = str(tmp.readline())
30 |     id, title = id_title[3:7],id_title[8:-1]
31 |     path = path.replace("\\", "/")
32 |     row_str = "| "+ id + " | " + title + " | " + "[Accepted](" + path + ")" + " | "
33 |     if keywords.find("keywords:") != -1:
34 |         for keyword in keywords[13:-1].split('、'):
35 |             print(keyword)
36 |             if not keyword in keyword_url:
37 |                 keyword_url[keyword] = " "
38 |             row_str += "[" + keyword + "](" + keyword_url[keyword] + ")" + "、"
39 |     row_str +=  " |\n"
40 |     return row_str
41 | 
42 | ## 创建4栏表格
43 | # @param    path    文件夹路径
44 | # @return   void
45 | def _creat_table(table_name, table_tab, path):
46 |     readme = open("README.md", 'a', encoding='utf8')
47 |     readme.write("## " + table_name + "\n\n")
48 |     for tab in table_tab:
49 |         readme.write("| " + tab + " ")        
50 |     readme.write("|\n")
51 |     readme.write("|---|---|---|---|\n")    
52 |     for fp in _find_code_file(path):
53 |         readme.write( _creat_table_row(fp) )
54 |     readme.write("\n")
55 |     readme.close()
56 | 
57 | 
58 | 
59 | if __name__ == '__main__':
60 |     with open("README.md", 'w', encoding='utf8') as readme:
61 |         readme.write("# 牛客网题解\n\n只为写一份简单易懂的代码。\n\n")
62 |     _creat_table("华为", ["ID","Title","C/C++","Keywords"], "huawei")


--------------------------------------------------------------------------------
/huawei/0089.cpp:
--------------------------------------------------------------------------------
 1 | // 0089.24点运算
 2 | // 这题不需要考虑括号，测试用例有问题，不再考虑AC
 3 | 
 4 | #include <iostream>
 5 | #include <algorithm>
 6 | #include <vector>
 7 | #include <cmath>
 8 | using namespace std;
 9 | 
10 | string mp = "#A234567891JQK";
11 | string tb = "+-*/";
12 | 
13 | double op(double a, double b, int opera)
14 | {
15 |     if(opera == 0) return a+b;
16 |     else if(opera == 1) return a-b;
17 |     else if(opera == 2) return a*b;
18 |     else if(opera == 3) return a/b;
19 |     return 0;
20 | }
21 | 
22 | bool cal24(double a[], int o[])
23 | {
24 |     vector<double> b(a, a+4);
25 |     for(int i = 0; i < 3; i++)
26 |         b[i+1] = op(b[i], b[i+1], o[i]);
27 |     if (fabs(b[3]-24.0)<0.01) return true;
28 |     else return false;
29 | }
30 | 
31 | bool func(double a[])
32 | {
33 |     bool flag = false;
34 |     int o[4];
35 |     sort(a, a+4);
36 |     do {
37 |         for(int i = 0; i < 4 && !flag; i++) {
38 |             o[0] = i;
39 |             for(int j = 0; j < 4 && !flag; j++) {
40 |                 o[1] = j; 
41 |                 for(int k = 0; k < 4 && !flag; k++) {
42 |                     o[2] = k;
43 |                     if (cal24(a, o)) {
44 |                         for(int m = 0; m < 3; m++)
45 |                             cout << mp[int(a[m])] << tb[o[m]];
46 |                         cout << mp[int(a[3])]  << endl;
47 |                         flag = true;
48 |                     }
49 |                 }
50 |             }
51 |         }
52 |     } while(next_permutation(a, a+4) && !flag);
53 |     return flag;
54 | }
55 | 
56 | int main()
57 | {
58 |     string s;
59 |     while(getline(cin, s))
60 |     {
61 |         double a[4];
62 |         bool flag = true;
63 |         s += ' ';
64 |         for(int i = 0; i < 4 && flag; i++)
65 |         {
66 |             int f = s.find(' ');
67 |             string t = s.substr(0, f);
68 |             if (t == "joker" || t == "JOKER")
69 |                 flag = false;
70 |             a[i] = (double)mp.find(t[0]);
71 |             s = s.substr(f+1);
72 |         }
73 |         if(!flag){
74 |             cout << "ERROR" << endl;
75 |         }else if (!func(a)) {
76 |             cout << "NONE" << endl;
77 |         }
78 |     }
79 | }


--------------------------------------------------------------------------------
/huawei/0057.cpp:
--------------------------------------------------------------------------------
 1 | // 0057.无线OSS－高精度整数加法
 2 | // keywords：模拟加法、模拟减法
 3 | 
 4 | #include <iostream>
 5 | #include <string>
 6 | #include <algorithm>
 7 | using namespace std;
 8 | 
 9 | string add(string a, string b)
10 | {
11 |     string r = "";
12 |     reverse(a.begin(), a.end());
13 |     reverse(b.begin(), b.end());
14 |     if (a.size() < b.size()) a.append(b.size()-a.size(), '0');
15 |     else if (a.size() > b.size()) b.append(a.size()-b.size(), '0');
16 |     int c = 0;
17 |     for(int i = 0; i < a.size(); i++)
18 |     {
19 |         int t = a[i] + b[i] - '0'*2 + c;
20 |         r.append(1, t % 10+'0');
21 |         c = t / 10;
22 |     }
23 |     if(c) r.append(1, c+'0');
24 |     reverse(r.begin(), r.end());
25 |     return r;
26 | }
27 | 
28 | string sub(string a, string b)
29 | {
30 |     string r = "";
31 |     reverse(a.begin(), a.end());
32 |     reverse(b.begin(), b.end());
33 |     if(a.size() < b.size()) a.append(b.size()-a.size(), '0');
34 |     else if(a.size() > b.size()) b.append(a.size()-b.size(), '0');
35 |     for(int i = 0; i < b.size(); i++)
36 |     {
37 |         int t = a[i] - b[i];
38 |         if (t < 0) {
39 |             t += 10;
40 |             int j = i;
41 |             for(; a[j] == '0'; j ++) {
42 |                 a[i] = '9';
43 |             }
44 |             a[j] -= 1;
45 |         }
46 |         r.append(1, t + '0');
47 |     }
48 |     reverse(r.begin(), r.end());
49 |     while(r[0] == '0') r.erase(0, 1);
50 |     return r;
51 | }
52 | 
53 | int main()
54 | {
55 |     string s1, s2;
56 |     while(cin >> s1 >> s2)
57 |     {
58 |         string r;
59 |         if(s1[0] != '-' && s2[0] != '-') {
60 |             r = add(s1, s2);
61 |         } else if(s1[0] == '-' && s2[0] == '-') {
62 |             r = add(s1.substr(1), s2.substr(1));
63 |             r.insert(0, 1, '-');
64 |         } else {
65 |             string t1, t2;
66 |             if(s1[0] == '-') {
67 |                 t1 = s1.substr(1);
68 |                 t2 = s2;
69 |             } else {
70 |                 t1 = s2.substr(1); 
71 |                 t2 = s1;  
72 |             }
73 |             if (t1 > t2 || t1.size() > t2.size()) {
74 |                 r = sub(t1, t2);
75 |                 r.insert(0, 1, '-');
76 |             }else {
77 |                 r = sub(t2, t1);
78 |             }
79 |         } 
80 |         cout << r << endl;
81 |     }
82 |     return 0;
83 | }


--------------------------------------------------------------------------------
/huawei/0018.cpp:
--------------------------------------------------------------------------------
  1 | // 0018.识别有效的IP地址和掩码并进行分类统计
  2 | 
  3 | #include <iostream>
  4 | #include <bits/stdc++.h>
  5 | using namespace std;
  6 | 
  7 | bool maskIsTrue(string s)
  8 | {
  9 |     unsigned long mask = 0;
 10 |     int tmp = 0;
 11 |     if (count(s.begin(), s.end(), '.') < 3) {
 12 |         return false;
 13 |     }
 14 |     s += '.';
 15 |     while(!s.empty())
 16 |     {
 17 |         int idx = s.find('.');
 18 |         string st = s.substr(0,idx);
 19 |         if (st.empty()) return false;
 20 |         tmp = stoi(st);
 21 |         if (tmp > 255 || tmp < 0) return false;
 22 |         mask = (mask<<8) | tmp;
 23 |         s = s.substr(idx+1);
 24 |     }
 25 |     bool firstOne = false;
 26 |     while(mask != 0)
 27 |     {
 28 |         if (mask%2 == 1) {
 29 |             firstOne = true;
 30 |         }
 31 |         else if(firstOne) {
 32 |             return false;
 33 |         }
 34 |         mask /= 2;
 35 |     }
 36 |     if(tmp == 255) return false;
 37 |     return true;
 38 | }
 39 | 
 40 | bool ipIsTrue(string s)
 41 | {
 42 |     unsigned long ip = 0;
 43 |     if (count(s.begin(), s.end(), '.') < 3) {
 44 |         return false;
 45 |     }
 46 |     s += '.';
 47 |     while(!s.empty())
 48 |     {
 49 |         int idx = s.find('.');
 50 |         string st = s.substr(0,idx);
 51 |         if (st.empty()) return false;
 52 |         int tmp = stoi(st);
 53 |         if (tmp > 255 || tmp < 0) return false;
 54 |         s = s.substr(idx+1);
 55 |     }
 56 |     return true;
 57 | }
 58 | 
 59 | void whichIp(string s, int &a, int &b, int &c, int &d, int &e, int &pri){
 60 |     int idx = s.find('.');
 61 |     int tmp = stoi(s.substr(0, idx));
 62 |     s = s.substr(idx+1);
 63 |     if (tmp > 0 && tmp < 127) {
 64 |         if (tmp == 10) {
 65 |             pri ++;
 66 |         }
 67 |         a ++;
 68 |     } else if (tmp < 192 && tmp > 127) {
 69 |         b ++;
 70 |         int tmp1 = stoi(s.substr(0, s.find('.')));
 71 |         if(tmp == 172 && tmp1 >= 16 && tmp1 <= 31){
 72 |             pri ++;
 73 |         }
 74 |     } else if (tmp >= 192 && tmp < 224) {
 75 |         c ++;
 76 |         int tmp1 = stoi(s.substr(0, s.find('.')));
 77 |         if(tmp == 192 && tmp1 == 168){
 78 |             pri ++;
 79 |         } 
 80 |     }else if (tmp >= 224 && tmp < 240) {
 81 |         d ++;
 82 |     } else if(tmp >= 240){
 83 |         e ++;
 84 |     }
 85 |     return ;
 86 | }
 87 | 
 88 | int main()
 89 | {
 90 |     string s;
 91 |     int a=0,b=0,c=0,d=0,e=0,err=0,pri=0;
 92 |     while(getline(cin, s))
 93 |     {
 94 |         int idx = s.find('~');
 95 |         string ip = s.substr(0,idx);
 96 |         string mask = s.substr(idx+1);
 97 |         if (!ipIsTrue(ip) || !maskIsTrue(mask)) {
 98 |             err ++;
 99 |             continue;
100 |         }
101 |         whichIp(ip,a,b,c,d,e,pri);
102 |     }
103 |     printf("%d %d %d %d %d %d %d", a,b,c,d,e,err,pri);
104 |     return 0;
105 | }


--------------------------------------------------------------------------------
/huawei/0098.cpp:
--------------------------------------------------------------------------------
  1 | // 0098.自动售货系统
  2 | 
  3 | #include <iostream>
  4 | #include <vector>
  5 | #include <algorithm>
  6 | #include <string>
  7 | using namespace std;
  8 | 
  9 | struct {
 10 |     int pri;
 11 |     int num;
 12 | } goods[7] = {{0,0}, {2,0}, {3,0}, {4,0}, {5,0}, {8,0}, {6,0}},
 13 | coins[5] = {{0,0}, {1,0}, {2,0}, {5,0}, {10,0}};
 14 | 
 15 | struct node
 16 | {
 17 |     string name;
 18 |     int pri;
 19 |     int num;
 20 |     bool operator < (node no) const {
 21 |         if (num == no.num) return name < no.name;
 22 |         return num > no.num;
 23 |     }
 24 | };
 25 | 
 26 | 
 27 | int pay = 0;
 28 | 
 29 | bool init(string cmd)
 30 | {
 31 |     int i;
 32 |     pay = 0;
 33 |     cmd = cmd.substr(2);
 34 |     string s = cmd.substr(0, cmd.find(' '));
 35 |     for(i = 1, s += '-'; i <= 6; i++)
 36 |     {
 37 |         int idx = s.find('-');
 38 |         string t = s.substr(0,idx);
 39 |         s = s.substr(idx+1);
 40 |         goods[i].num = stoi(t);
 41 |         goods[0].num += goods[i].num;
 42 |     }
 43 |     s = cmd.substr(cmd.find(' ')+1);
 44 |     for(i = 1, s += '-'; i <= 4; i++)
 45 |     {
 46 |         int idx = s.find('-');
 47 |         string t = s.substr(0, idx);
 48 |         s = s.substr(idx+1);
 49 |         coins[i].num = stoi(t);
 50 |     }
 51 |     cout << "S001:Initialization is successful" << endl;
 52 |     return true;
 53 | }
 54 | 
 55 | int check_pay(string cmd) {
 56 |     int p = stoi(cmd.substr(2));
 57 |     if (p != 1 && p != 2 && p != 5 && p != 10) {
 58 |         cout << "E002:Denomination error" << endl;
 59 |     }else if (p > coins[1].num + coins[2].pri * coins[2].num) {
 60 |         cout << "E003:Change is not enough, pay fail" << endl;
 61 |     }else if (p > 10) {
 62 |         cout << "E004:Pay the balance is beyond the scope biggest" << endl;
 63 |     }else if (goods[0].num == 0) {
 64 |         cout << "E005:All the goods sold out" << endl;
 65 |     } else {
 66 |         for(int i = 1; i <= 4; i++) {
 67 |             if(p == coins[i].pri) {
 68 |                 coins[i].num ++;
 69 |                 break;
 70 |             }
 71 |         }
 72 |         pay += p;
 73 |         cout << "S002:Pay success,balance=" << pay << endl;
 74 |     }
 75 |     return 0;
 76 | }
 77 | int buy(string cmd)
 78 | {
 79 |     string s = "A1A2A3A4A5A6";
 80 |     string name = cmd.substr(2);
 81 |     int g = name[1]-'0';
 82 |     if (s.find(name) == s.npos) {
 83 |         cout << "E006:Goods does not exist" << endl;
 84 |     } else if (goods[g].num == 0) {
 85 |         cout << "E007:The goods sold out" << endl;
 86 |     } else if (goods[g].pri > pay) {
 87 |         cout<<"E008:Lack of balance"<<endl;
 88 |     } else {
 89 |         pay -= goods[g].pri;
 90 |         goods[g].num --;
 91 |         goods[0].num --;
 92 |         cout<<"S003:Buy success,balance="<<pay<<endl;
 93 |     }
 94 |     return 0;
 95 | }
 96 | 
 97 | int return_coin()
 98 | {
 99 |     int i;
100 |     int ret[5] = {0,0,0,0,0};
101 |     if (pay == 0) {
102 |         cout<<"E009:Work failure";
103 |         return -1;
104 |     }
105 |     for(i = 4; pay != 0 && i>=1; i--)
106 |     {
107 |         while(pay >= coins[i].pri && coins[i].num > 0)
108 |         {
109 |             pay-=coins[i].pri;
110 |             coins[i].num --;
111 |             ret[i] ++;
112 |         }
113 |     }
114 |     for(i = 1; i <= 4; i++)
115 |         cout << coins[i].pri<<" yuan coin number=" << ret[i] << endl;
116 |     return 0;
117 | }
118 | 
119 | int query(string cmd)
120 | {
121 |     int num = -1;
122 |     
123 |     vector<node> v;
124 |     cmd = cmd.substr(2);
125 |     if(cmd.size()==1) num = cmd[0]-'0';
126 |     if (num == 0) {
127 |         for(int i = 1; i <= 6; i++)
128 |         {
129 |             string name = "A";
130 |             name += '0' + i;
131 |             node no = {name, goods[i].pri, goods[i].num};
132 |             v.push_back(no);
133 |         }
134 |         sort(v.begin(), v.end());
135 |         for(int i = 0; i < v.size(); i++)
136 |         {
137 |             cout << v[i].name <<' '<< v[i].pri << ' ' << v[i].num << endl;
138 |         }
139 |     } else if (num == 1) {
140 |         for(int i = 1; i <= 4; i++)
141 |             cout << coins[i].pri << " yuan coin number=" << coins[i].num << endl;
142 |     }
143 |     else
144 |         cout << "E010:Parameter error";
145 |     return 0;
146 | }
147 | int main()
148 | {
149 |     string cmd;
150 |     while(getline(cin,cmd))
151 |     {
152 |         pay = 0;
153 |         while(!cmd.empty())
154 |         {
155 |             int idx = cmd.find(';');
156 |             string tmp = cmd.substr(0, idx);
157 |             if(tmp[0] == 'r') {
158 |                 init(tmp);
159 |             } else if(tmp[0] == 'p') {
160 |                 check_pay(tmp);
161 |             } else if(tmp[0] == 'b') {
162 |                 buy(tmp);
163 |             } else if(tmp[0] == 'c') {
164 |                 return_coin();
165 |             } else if(tmp[0] == 'q') {
166 |                 query(tmp);
167 |             }
168 |             cmd = cmd.substr(idx+1);
169 |         }
170 |     }
171 |     return 0;
172 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # 牛客网题解
  2 | 
  3 | 只为写一份简单易懂的代码。
  4 | 
  5 | ## 华为
  6 | 
  7 | | ID | Title | C/C++ | Keywords |
  8 | |---|---|---|---|
  9 | | 0001 | 字符串最后一个单词的长度 | [Accepted](huawei/0001.cpp) |  |
 10 | | 0002 | 计算字符个数 | [Accepted](huawei/0002.cpp) |  |
 11 | | 0003 | 明明的随机数 | [Accepted](huawei/0003.cpp) |  |
 12 | | 0004 | 字符串分隔 | [Accepted](huawei/0004.cpp) |  |
 13 | | 0005 | 进制转换 | [Accepted](huawei/0005.cpp) |  |
 14 | | 0006 | 质数因子 | [Accepted](huawei/0006.cpp) |  |
 15 | | 0007 | 取近似值 | [Accepted](huawei/0007.cpp) |  |
 16 | | 0008 | 合并表记录 | [Accepted](huawei/0008.cpp) |  |
 17 | | 0009 | 提取不重复的整数 | [Accepted](huawei/0009.cpp) |  |
 18 | | 0010 | 字符个数统计 | [Accepted](huawei/0010.cpp) |  |
 19 | | 0011 | 数字颠倒 | [Accepted](huawei/0011.cpp) |  |
 20 | | 0012 | 字符串反转 | [Accepted](huawei/0012.cpp) |  |
 21 | | 0013 | 句子逆序 | [Accepted](huawei/0013.cpp) |  |
 22 | | 0014 | 字串的连接最长路径查找 | [Accepted](huawei/0014.cpp) |  |
 23 | | 0015 | 求int型数据在内存中存储时1的个数 | [Accepted](huawei/0015.cpp) |  |
 24 | | 0016 | 购物单 | [Accepted](huawei/0016.cpp) | [背包问题]( )、[动态规划]( )、 |
 25 | | 0017 | 坐标移动 | [Accepted](huawei/0017.cpp) |  |
 26 | | 0018 | 识别有效的IP地址和掩码并进行分类统计 | [Accepted](huawei/0018.cpp) |  |
 27 | | 0019 | 简单错误记录 | [Accepted](huawei/0019.cpp) |  |
 28 | | 0020 | 密码验证合格程序 | [Accepted](huawei/0020.cpp) |  |
 29 | | 0021 | 简单密码破解 | [Accepted](huawei/0021.cpp) |  |
 30 | | 0022 | 汽水瓶 | [Accepted](huawei/0022.cpp) |  |
 31 | | 0023 | 删除字符串中出现次数最少的字符 | [Accepted](huawei/0023.cpp) |  |
 32 | | 0024 | 合唱队 | [Accepted](huawei/0024.cpp) | [最长上升子序列]( )、 |
 33 | | 0025 | 数据分类处理 | [Accepted](huawei/0025.cpp) |  |
 34 | | 0026 | 字符串排序 | [Accepted](huawei/0026.cpp) |  |
 35 | | 0027 | 查找兄弟单词 | [Accepted](huawei/0027.cpp) |  |
 36 | | 0028 | 素数伴侣 | [Accepted](huawei/0028.cpp) |  |
 37 | | 0029 | 字符串加解密 | [Accepted](huawei/0029.cpp) |  |
 38 | | 0030 | 字符串合并处理 | [Accepted](huawei/0030.cpp) |  |
 39 | | 0031 | 【中级】单词倒排 | [Accepted](huawei/0031.cpp) |  |
 40 | | 0032 | 字符串运用-密码截取 | [Accepted](huawei/0032.cpp) |  |
 41 | | 0033 | 整数与IP地址间的转换 | [Accepted](huawei/0033.cpp) |  |
 42 | | 0034 | 图片整理 | [Accepted](huawei/0034.cpp) |  |
 43 | | 0035 | 蛇形矩阵 | [Accepted](huawei/0035.cpp) |  |
 44 | | 0036 | 字符串加密 | [Accepted](huawei/0036.cpp) |  |
 45 | | 0037 | 统计每个月兔子的总数 | [Accepted](huawei/0037.cpp) |  |
 46 | | 0038 | 求小球落地5次后所经历的路程和第5次反弹的高度 | [Accepted](huawei/0038.cpp) |  |
 47 | | 0039 | 判断两个IP是否属于同一子网 | [Accepted](huawei/0039.cpp) | [题目不见]( )、 |
 48 | | 0040 | 输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数 | [Accepted](huawei/0040.cpp) |  |
 49 | | 0041 | 称砝码 | [Accepted](huawei/0041.cpp) |  |
 50 | | 0042 | 学英语 | [Accepted](huawei/0042.cpp) |  |
 51 | | 0043 | 迷宫问题 | [Accepted](huawei/0043.cpp) | [树的遍历]( )、 |
 52 | | 0044 | Sudoku-Java | [Accepted](huawei/0044.cpp) |  |
 53 | | 0045 | 名字的漂亮度 | [Accepted](huawei/0045.cpp) |  |
 54 | | 0046 | 按字节截取字符串 | [Accepted](huawei/0046.cpp) |  |
 55 | | 0047 | 线性插值 | [Accepted](huawei/0047.cpp) |  |
 56 | | 0048 | 从单向链表中删除指定值的节点 | [Accepted](huawei/0048.cpp) |  |
 57 | | 0049 | 多线程 | [Accepted](huawei/0049.cpp) |  |
 58 | | 0050 | 四则运算 | [Accepted](huawei/0050.cpp) |  |
 59 | | 0051 | 输出单向链表中倒数第k个结点 | [Accepted](huawei/0051.cpp) |  |
 60 | | 0052 | 计算字符串的距离 | [Accepted](huawei/0052.cpp) | [levenshtein距离]( )、 |
 61 | | 0053 | iNOC产品部-杨辉三角的变形 | [Accepted](huawei/0053.cpp) |  |
 62 | | 0054 | 表达式求值 | [Accepted](huawei/0054.cpp) |  |
 63 | | 0055 | （练习用）挑7 | [Accepted](huawei/0055.cpp) |  |
 64 | | 0056 | iNOC产品部--完全数计算 | [Accepted](huawei/0056.cpp) |  |
 65 | | 0057 | 无线OSS－高精度整数加法 | [Accepted](huawei/0057.cpp) |  |
 66 | | 0058 | 输入n个整数，输出其中最小的k个 | [Accepted](huawei/0058.cpp) |  |
 67 | | 0059 | 找出字符串中第一个只出现一次的字符 | [Accepted](huawei/0059.cpp) |  |
 68 | | 0060 | 查找组成一个偶数最接近的两个素数 | [Accepted](huawei/0060.cpp) |  |
 69 | | 0061 | 放苹果 | [Accepted](huawei/0061.cpp) |  |
 70 | | 0062 | 查找输入整数二进制中1的个数 | [Accepted](huawei/0062.cpp) |  |
 71 | | 0063 | DNA序列 | [Accepted](huawei/0063.cpp) |  |
 72 | | 0064 | MP3光标位置 | [Accepted](huawei/0064.cpp) |  |
 73 | | 0065 | 查找两个字符串a,b中的最长公共子串 | [Accepted](huawei/0065.cpp) | [最长公共子串]( )、 |
 74 | | 0066 | 配置文件恢复 | [Accepted](huawei/0066.cpp) |  |
 75 | | 0067 | 24点游戏算法 | [Accepted](huawei/0067.cpp) |  |
 76 | | 0068 | 成绩排序 | [Accepted](huawei/0068.cpp) |  |
 77 | | 0069 | 矩阵乘法 | [Accepted](huawei/0069.cpp) |  |
 78 | | 0070 | 矩阵乘法计算量估算 | [Accepted](huawei/0070.cpp) |  |
 79 | | 0071 | 字符串通配符 | [Accepted](huawei/0071.cpp) | [递归]( )、 |
 80 | | 0072 | 百钱买百鸡问题 | [Accepted](huawei/0072.cpp) |  |
 81 | | 0073 | 计算日期到天数转换 | [Accepted](huawei/0073.cpp) |  |
 82 | | 0074 | 参数解析 | [Accepted](huawei/0074.cpp) |  |
 83 | | 0075 | 公共字串计算 | [Accepted](huawei/0075.cpp) | [最长公共子串]( )、 |
 84 | | 0076 | 尼科彻斯定理 | [Accepted](huawei/0076.cpp) |  |
 85 | | 0077 | 火车进站 | [Accepted](huawei/0077.cpp) | [堆栈]( )、 |
 86 | | 0078 | 超长正整数相加 | [Accepted](huawei/0078.cpp) | [模拟加法]( )、 |
 87 | | 0079 | 计算字符串的相似度 | [Accepted](huawei/0079.cpp) | [levenshtein距离]( )、 |
 88 | | 0080 | 整形数组合并 | [Accepted](huawei/0080.cpp) |  |
 89 | | 0081 | 字符串匹配 | [Accepted](huawei/0081.cpp) |  |
 90 | | 0082 | 将真分数分解为埃及分数 | [Accepted](huawei/0082.cpp) |  |
 91 | | 0083 | 二维数组操作 | [Accepted](huawei/0083.cpp) |  |
 92 | | 0083 | 统计大写字母个数 | [Accepted](huawei/0084.cpp) |  |
 93 | | 0086 | 求最大连续bit数 | [Accepted](huawei/0086.cpp) |  |
 94 | | 0087 | 密码强度等级 | [Accepted](huawei/0087.cpp) |  |
 95 | | 0088 | 扑克牌大小 | [Accepted](huawei/0088.cpp) |  |
 96 | | 0089 | 24点运算 | [Accepted](huawei/0089.cpp) |  |
 97 | | 0090 | 合法IP | [Accepted](huawei/0090.cpp) |  |
 98 | | 0091 | 201301 JAVA 题目2-3级 | [Accepted](huawei/0091.cpp) |  |
 99 | | 0092 | 在字符串中找出连续最长的数字串 | [Accepted](huawei/0092.cpp) |  |
100 | | 0093 | 201301 JAVA题目0-1级 | [Accepted](huawei/0093.cpp) |  |
101 | | 0094 | 记票统计 | [Accepted](huawei/0094.cpp) |  |
102 | | 0095 | 人民币转换 | [Accepted](huawei/0095.cpp) |  |
103 | | 0096 | 表示数字 | [Accepted](huawei/0096.cpp) |  |
104 | | 0097 | 记负均正 | [Accepted](huawei/0097.cpp) |  |
105 | | 0098 | 自动售货系统 | [Accepted](huawei/0098.cpp) |  |
106 | | 0099 | 自守数 | [Accepted](huawei/0099.cpp) |  |
107 | | 0100 | 等差数列 | [Accepted](huawei/0100.cpp) |  |
108 | | 0101 | 输入整型数组和排序标识，对其元素按照升序或降序进行排序 | [Accepted](huawei/0101.cpp) |  |
109 | | 0102 | 字符统计 | [Accepted](huawei/0102.cpp) |  |
110 | | 0103 | Redraiment的走法 | [Accepted](huawei/0103.cpp) | [最长上升子序列]( )、 |
111 | | 0104 | 字符串分割 | [Accepted](huawei/0104.cpp) |  |
112 | | 0105 | 记负均正II | [Accepted](huawei/0105.cpp) |  |
113 | | 0106 | 字符逆序 | [Accepted](huawei/0106.cpp) |  |
114 | | 0107 | 求解立方根 | [Accepted](huawei/0107.cpp) | [牛顿迭代法]( )、 |
115 | | 0108 | 求最小公倍数 | [Accepted](huawei/0108.cpp) |  |
116 | 
117 | 


--------------------------------------------------------------------------------