├── .gitignore
├── README.md
├── binomial_coefficient.cpp
├── eliminate_vector_elements.cpp
├── first_second.cpp
├── multi_dimensional_array.cpp
├── palindromic_number.cpp
├── print_circulant_matrix.cpp
└── subset_binary_representation.cpp


/.gitignore:
--------------------------------------------------------------------------------
1 | # ignore vscode config
2 | .vscode/
3 | .DS_Store
4 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | #### 代码分分钟
 2 | 
 3 | X Minutes of Code
 4 | 
 5 | :pencil2: 谢勰 (微博/微信公众号: 算法时空)
 6 | 
 7 | ---
 8 | 
 9 | 几分钟讲完的简单代码，视频发布在微信公众号“算法时空”，欢迎关注。
10 | 
11 | ---
12 | 
13 | 
14 | 


--------------------------------------------------------------------------------
/binomial_coefficient.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | int main()
 6 | {
 7 |   uint64_t n, k, value;
 8 |   cin >> n >> k;
 9 |   if (n < k)
10 |     return 0;
11 |   if (k > n / 2)
12 |     k = n - k;
13 |   value = 1;
14 |   for (uint64_t i = 1; i <= k; ++i)
15 |     value = (value * (n - k + i)) / i;
16 |   cout << value << endl;
17 |   value = 1;
18 |   uint64_t d = n - k + 1;
19 |   for (uint64_t i = 1; i <= k; ++i)
20 |     value = (value * d++) / i;
21 |   cout << value << endl;
22 |   return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/eliminate_vector_elements.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | int main()
 6 | {
 7 |   vector<int> V {17, 62, 43, 52, 73};
 8 |   size_t r = 0;
 9 |   for (size_t i = 0; i < V.size(); ++i)
10 |     if (V[i] % 2 == 1)
11 |       V[r++] = V[i];
12 |   V.resize(r);
13 |   for (const auto& x : V)
14 |     cout << x << ' ';
15 |   cout << endl;
16 |   return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/first_second.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <utility>
 4 | 
 5 | using namespace std;
 6 | 
 7 | template <typename T>
 8 | void first_second(const vector<T>& V)
 9 | {
10 |   if (V.size() < 2)
11 |     return;
12 |   pair<size_t, size_t> largest {0, 1};
13 |   if (V[0] < V[1])
14 |     largest = {1, 0};
15 |   for (size_t i = 2; i < V.size(); ++i)
16 |     if (V[largest.first] < V[i])
17 |       largest = {i, largest.first};
18 |     else if (V[largest.second] < V[i])
19 |       largest.second = i;
20 |   cout << V[largest.first] << endl << V[largest.second] << endl;
21 | }
22 | 
23 | int main()
24 | {
25 |   vector<int> A {17, 42, 23, 42, 13};
26 |   first_second(A);
27 |   vector<int> B {1, 4, 3, 2, 5};
28 |   first_second(B);
29 |   return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/multi_dimensional_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | 
 4 | using namespace std;
 5 | 
 6 | size_t mixed_radix(const vector<size_t> B, const vector<size_t> V)
 7 | {
 8 |   size_t value = 0;
 9 |   size_t n = V.size();
10 |   for (size_t i = 0; i < n - 1; ++i)
11 |     value = (value + V[i]) * B[i + 1];
12 |   value += V[n - 1];   // A += V.back();
13 |   return value;
14 | }
15 | 
16 | int main()
17 | {
18 |   vector<size_t> B {10, 10, 6, 10, 6, 10};
19 |   vector<size_t> V {1, 0, 1, 2, 1, 8};
20 |   cout << mixed_radix(B, V) << endl;
21 |   return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/palindromic_number.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | // 适用于其他进制, 这里取10进制.
 6 | const int64_t b = 10;
 7 | 
 8 | bool palindromic_number(int64_t n)
 9 | {
10 |   if (n < 0)
11 |     return false;
12 |   else if (n < b)
13 |     return true;
14 |   int64_t h = n;
15 |   int64_t r = 0;
16 |   while (h >= b)
17 |   {
18 |     int64_t t = h / b;
19 |     r = r * b + (h - t * b);
20 |     h = t;
21 |   }
22 |   if (r <= numeric_limits<int64_t>::max() / b && r * b == n - h)
23 |     return true;
24 |   return false;
25 | }
26 | 
27 | int main()
28 | {
29 |   cout << "max is " << numeric_limits<int64_t>::max() << endl;
30 |   int64_t n;
31 |   cin >> n;
32 |   cout << (palindromic_number(n) ? "Y" : "N") << endl;
33 |   return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/print_circulant_matrix.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | 
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |   vector<int> V {1, 2, 3, 4, 5};
 9 |   size_t n = V.size();
10 |   for (size_t i = 0; i < n; ++i)
11 |   {
12 |     for (size_t j = n - i; j < n; ++j)
13 |       cout << V[j] << ' ';
14 |     for (size_t j = 0; j < n - i; ++j)
15 |       cout << V[j] << ' ';
16 |     cout << endl;
17 |   }
18 |   return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/subset_binary_representation.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <cmath>
 4 | 
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |   vector<int> V {1, 2, 3};
10 |   size_t n = V.size();
11 |   size_t m = pow(2, n);
12 |   vector<bool> B(n + 1, false);
13 |   for (size_t i = 0; i < m; ++i)
14 |   {
15 |     for (size_t k = 0; k < n; ++k)
16 |       if (B[k])
17 |         cout << V[k] << ' ';
18 |     cout << endl;
19 |     size_t k = 0;
20 |     while (k < n && B[k])
21 |       B[k++] = false;
22 |     B[k] = true;
23 |   }
24 |   return 0;
25 | }
26 | 


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