string RandIntString(int len) { default_random_engine gen((random_device())()); string ret; if (len == 0) { return {"0"}; } uniform_int_distribution<int> pos_or_neg(0, 1); if (pos_or_neg(gen)) { ret.push_back('-'); } uniform_int_distribution<int> num_dis('1', '9'); ret.push_back(num_dis(gen)); while (--len) { uniform_int_distribution<int> dis('0', '9'); ret.push_back(dis(gen)); } return ret; }
int main(int argc, char* argv[]) { small_test(); default_random_engine gen((random_device())()); // Random test 10000 times. for (int times = 0; times < 10000; ++times) { vector<int> A, B; int n, m, k; if (argc == 3) { n = atoi(argv[1]), m = atoi(argv[2]); uniform_int_distribution<int> k_dis(1, n + m); k = k_dis(gen); } else if (argc == 4) { n = atoi(argv[1]), m = atoi(argv[2]), k = atoi(argv[3]); } else { uniform_int_distribution<int> dis(1, 10000); n = dis(gen), m = dis(gen); uniform_int_distribution<int> k_dis(1, n + m); k = k_dis(gen); } uniform_int_distribution<int> dis(0, 99999); for (size_t i = 0; i < n; ++i) { A.emplace_back(dis(gen)); } for (size_t i = 0; i < m; ++i) { B.emplace_back(dis(gen)); } sort(A.begin(), A.end()), sort(B.begin(), B.end()); /* for (int i = 0; i < A.size(); ++i) { cout << A[i] << ' '; } cout << endl; for (int j = 0; j < B.size(); ++j) { cout << B[j] << ' '; } cout << endl; */ int ans = find_kth_in_two_sorted_arrays(A, B, k); cout << k << "th = " << ans << endl; assert(ans == check_answer(A, B, k)); A.clear(), B.clear(); } return 0; }
int main(int argc, char* argv[]) { default_random_engine gen((random_device())()); for (int times = 0; times < 1000; ++times) { int n; if (argc == 2) { n = atoi(argv[1]); } else { uniform_int_distribution<int> dis(1, 10000); n = dis(gen); } vector<int> A; for (size_t i = 0; i < n; ++i) { uniform_int_distribution<int> dis(-1000000, 1000000); A.emplace_back(dis(gen)); } assert(n_2_check(A) == count_inversions(A)); } return 0; }
int main(int argc, char* argv[]) { if (argc == 3) { unsigned int x = atoi(argv[1]), y = atoi(argv[2]); unsigned int res = multiply_no_operator(x, y); assert(res == x * y); cout << "PASS: x = " << x << ", y = " << y << "; prod = " << res << endl; } else { default_random_engine gen((random_device())()); // Random test, only works if the product is not greater than 2^32 - 1. for (int i = 0; i < 100000; ++i) { uniform_int_distribution<int> dis(0, 65534); unsigned int x = dis(gen), y = dis(gen); unsigned int prod = multiply_no_operator(x, y); assert(prod == x * y); cout << "PASS: x = " << x << ", y = " << y << "; prod = " << prod << endl; } } return 0; }
int main(int argc, char *argv[]) { default_random_engine gen((random_device())()); int N; if (argc == 2) { N = atoi(argv[1]); } else { uniform_int_distribution<int> dis(1, 50); N = dis(gen); } vector<vector<int>> A(N, vector<int>(N)); int x = 1; for (size_t i = 0; i < N; ++i) { for (size_t j = 0; j < N; ++j) { A[i][j] = x++; } } PrintMatrixInSpiralOrder(A); return 0; }
int main(int argc, char* argv[]) { SmallTest(); default_random_engine gen((random_device())()); vector<int> weight, value; int n, W; if (argc == 1) { uniform_int_distribution<int> n_dis(1, 100); n = n_dis(gen); uniform_int_distribution<int> W_dis(1, 1000); W = W_dis(gen); weight = RandVector(n), value = RandVector(n); } else if (argc == 2) { n = atoi(argv[1]); uniform_int_distribution<int> W_dis(1, 1000); W = W_dis(gen); weight = RandVector(n), value = RandVector(n); } else { n = atoi(argv[1]); W = atoi(argv[2]); for (int i = 0; i < n; ++i) { weight.emplace_back(atoi(argv[3 + i])); } for (int i = 0; i < n; ++i) { value.emplace_back(atoi(argv[3 + i + n])); } } cout << "Weight: "; for (int i = 0; i < n; ++i) { cout << weight[i] << ' '; } cout << endl << "Value: "; for (int i = 0; i < n; ++i) { cout << value[i] << ' '; } cout << endl; vector<Item> items; for (int i = 0; i < weight.size(); ++i) { items.emplace_back(Item{weight[i], value[i]}); } cout << "Knapsack size = " << W << endl; cout << "all value = " << Knapsack(W, items) << endl; return 0; }
int main(int argc, char* argv[]) { default_random_engine gen((random_device())()); for (int times = 0; times < 1000; ++times) { int num, k; if (argc == 2) { num = stoi(argv[1]); uniform_int_distribution<int> dis(1, num); k = dis(gen); } else if (argc == 3) { num = stoi(argv[1]); k = stoi(argv[2]); } else { uniform_int_distribution<int> num_dis(1, 10000); num = num_dis(gen); uniform_int_distribution<int> k_dis(1, num); k = k_dis(gen); } vector<Star> stars; // Randomly generate num of stars. uniform_real_distribution<double> dis(0, 100000); for (int i = 0; i < num; ++i) { stars.emplace_back(Star{i, dis(gen), dis(gen), dis(gen)}); } string s; for (int i = 0; i < num; ++i) { stringstream ss; ss << stars[i].ID_ << ',' << stars[i].x_ << ',' << stars[i].y_ << ',' << stars[i].z_ << endl; s += ss.str(); // cout << stars[i].ID_ << ' ' << stars[i].Distance() << endl; } istringstream sin(s); vector<Star> closest_stars(FindClosestKStars(k, &sin)); vector<Star> selected_stars(SelectK(stars, k)); sort(selected_stars.begin(), selected_stars.end()); sort(stars.begin(), stars.end()); cout << "k = " << k << endl; // assert(stars[k - 1].ID_ == closest_stars[0].ID_); assert(stars[k - 1].Distance() == selected_stars.back().Distance()); } return 0; }
string RandString(int len) { string ret; if (!len) { ret += '0'; } else { default_random_engine gen((random_device())()); uniform_int_distribution<int> positive_or_negative(0, 1); if (positive_or_negative(gen)) { ret += '-'; } uniform_int_distribution<int> dis(1, 9); ret += dis(gen) + '0'; --len; while (len--) { uniform_int_distribution<int> dis(0, 9); ret += dis(gen) + '0'; } } return ret; }
// @include int find_k_th_largest(vector<int> A, int k) { int left = 0, right = A.size() - 1; while (left <= right) { default_random_engine gen((random_device())()); // Generates random int in [left, right]. uniform_int_distribution<int> dis(left, right); int p = partition(left, right, dis(gen), &A); if (p == k - 1) { return A[p]; } else if (p > k - 1) { right = p - 1; } else { // p < k - 1. left = p + 1; } } // @exclude throw length_error("no k-th node in array A"); // @include }
int main(int argc, char* argv[]) { default_random_engine gen((random_device())()); string A, B; // Wiki example (http://en.wikipedia.org/wiki/Levenshtein_distance) A = "Saturday", B = "Sunday"; assert(3 == Levenshtein_distance(A, B)); A = "kitten", B = "sitting"; assert(3 == Levenshtein_distance(A, B)); if (argc == 3) { A = argv[1], B = argv[2]; } else { uniform_int_distribution<int> dis(1, 100); A = rand_string(dis(gen)); B = rand_string(dis(gen)); } cout << A << endl << B << endl; cout << Levenshtein_distance(A, B) << endl; return 0; }
int main(int argc, char* argv[]) { vector<int> A; default_random_engine gen((random_device())()); if (argc == 1) { generate_n(back_inserter(A), uniform_int_distribution<int>(1, 10000)(gen), [&] { return uniform_int_distribution<int>()(gen); }); } else { generate_n(back_inserter(A), atoi(argv[1]), [&] { return uniform_int_distribution<int>(4, 4)(gen); }); } string ret = encode(A); cout << ret << endl; vector<int> res = decode(ret); assert(A.size() == res.size()); for (int i = 0; i < A.size(); ++i) { assert(res[i] == A[i]); } return 0; }
int main(int argc, char* argv[]) { default_random_engine gen((random_device())()); for (int times = 0; times < 1000; ++times) { int n; vector<int> A; if (argc == 2) { n = atoi(argv[1]); } else { uniform_int_distribution<int> dis(0, 100000); n = dis(gen); } for (int i = 0; i < n; ++i) { uniform_int_distribution<int> dis(0, n - 1); A.emplace_back(dis(gen)); } EliminateDuplicate(&A); CheckAns(A); } return 0; }
int main(int argc, char *argv[]) { default_random_engine gen((random_device())()); int n = 40, k = 4; // random tests for n = 40, k = 4 for 100 times/ for (int times = 0; times < 100; ++times) { vector<int> A; uniform_int_distribution<int> dis(0, 99); for (int i = 0; i < n; ++i) { A.emplace_back(dis(gen)); } cout << "n = " << n << ", k = " << k << endl; cout << max_k_pairs_profits(A, k) << endl; assert(check_ans(A, k) == max_k_pairs_profits(A, k)); } if (argc == 2) { n = atoi(argv[1]); uniform_int_distribution<int> dis(1, n >> 1); k = dis(gen); } else if (argc == 3) {
int main(int argc, char *argv[]) { default_random_engine gen((random_device())()); for (int times = 0; times < 1000; ++times) { int n; if (argc == 2) { n = atoi(argv[1]); } else { uniform_int_distribution<int> dis(1, 10000); n = dis(gen); } vector<int> A; uniform_int_distribution<int> dis(0, numeric_limits<int>::max()); for (int i = 0; i < n; ++i) { A.emplace_back(dis(gen)); } cout << find_battery_capacity(A) << endl; assert(check_ans(A) == find_battery_capacity(A)); } return 0; }
int main(int argc, char *argv[]) { SimpleTest(); for (int times = 0; times < 1000; ++times) { string s1, s2; if (argc == 3) { s1 = argv[1], s2 = argv[2]; } else { default_random_engine gen((random_device())()); uniform_int_distribution<int> dis(0, 19); s1 = RandString(dis(gen)), s2 = RandString(dis(gen)); } string res = Multiply(s1, s2); cout << s1 << " * " << s2 << " = " << res << endl; string command = "bc <<<" + s1 + "*" + s2; string result = execute_shell(command); cout << "answer = " << result; assert(res.compare(result.substr(0, result.size() - 1)) == 0); } return 0; }
int main(int argc, char* argv[]) { default_random_engine gen((random_device())()); for (int times = 0; times < 1000; ++times) { int k; if (argc == 2) { k = atoi(argv[1]); } else { uniform_int_distribution<int> dis(1, 10000); k = dis(gen); } vector<Num> ans(generate_first_k(k)); for (int i = 0; i < ans.size(); ++i) { cout << ans[i].a << ' ' << ans[i].b << ' ' << ans[i].val << endl; if (i > 0) { assert(ans[i].val >= ans[i - 1].val); } } return 0; } }
int main(int argc, char* argv[]) { default_random_engine gen((random_device())()); for (int times = 0; times < 1000; ++times) { int n, m; if (argc == 3) { n = atoi(argv[1]), m = atoi(argv[2]); } else { uniform_int_distribution<int> dis(1, 10); n = dis(gen); m = dis(gen); } cout << "n = " << n << ", m = " << m << ", number of ways = " << number_of_ways(n, m) << endl; assert(check_ans(n + m - 2, m - 1) == number_of_ways(n, m)); if (argc == 3) { break; } } return 0; }
int main(int argc, char* argv[]) { default_random_engine gen((random_device())()); for (int times = 0; times < 1000; ++times) { int size; if (argc == 2 || argc == 3) { size = atoi(argv[1]); } else { uniform_int_distribution<int> dis(1, 10000); size = dis(gen); } int k; if (argc == 3) { k = atoi(argv[2]); } else { uniform_int_distribution<int> dis(1, size); k = dis(gen); } vector<Person> people; uniform_int_distribution<int> k_dis(0, k - 1); uniform_int_distribution<int> len_dis(1, 10); for (int i = 0; i < size; ++i) { people.emplace_back(Person{k_dis(gen), rand_string(len_dis(gen))}); } unordered_set<int> key_set; for (const Person& p : people) { key_set.emplace(p.key); } counting_sort(&people); // Check the correctness of sorting. int diff_count = 1; for (int i = 1; i < people.size(); ++i) { if (people[i].key != people[i - 1].key) { ++diff_count; } } assert(diff_count == key_set.size()); } return 0; }
int main(int argc, char *argv[]) { default_random_engine gen((random_device())()); for (int times = 0; times < 10000; ++times) { shared_ptr<node_t<int>> F = shared_ptr<node_t<int>>(nullptr), L = shared_ptr<node_t<int>>(nullptr); int n, m; if (argc == 3) { n = atoi(argv[1]), m = atoi(argv[2]); } else if (argc == 2) { n = atoi(argv[1]), m = atoi(argv[1]); } else { uniform_int_distribution<int> dis(0, 99); n = dis(gen), m = dis(gen); } for (int i = n; i > 0; --i) { shared_ptr<node_t<int>> temp = shared_ptr<node_t<int>>(new node_t<int>{i, nullptr}); temp->next = F; F = temp; } for (int j = m; j > 0; --j) { shared_ptr<node_t<int>> temp = shared_ptr<node_t<int>>(new node_t<int>{j, nullptr}); temp->next = L; L = temp; } shared_ptr<node_t<int>> sorted_head = merge_sorted_linked_lists(F, L); int count = 0; int pre = numeric_limits<int>::min(); while (sorted_head) { assert(pre <= sorted_head->data); pre = sorted_head->data; sorted_head = sorted_head->next; ++count; } // Make sure the merged list have the same number of nodes as F and L. assert(count == n + m); } return 0; }
// @include vector<int> ReservoirSampling(istringstream* sin, int k) { int x; vector<int> R; // Stores the first k elements. for (int i = 0; i < k && *sin >> x; ++i) { R.emplace_back(x); } // After the first k elements. int element_num = k; while (*sin >> x) { default_random_engine gen((random_device())()); // Random num generator. // Generate a random int in [0, element_num]. uniform_int_distribution<int> dis(0, element_num++); int tar = dis(gen); if (tar < k) { R[tar] = x; } } return R; }
int main(int argc, char* argv[]) { default_random_engine gen((random_device())()); for (int times = 0; times < 1000; ++times) { vector<int> A; int n; if (argc == 2) { n = atoi(argv[1]); } else { uniform_int_distribution<int> dis(1, 1000); n = dis(gen); } for (int i = 0; i < n; ++i) { A.emplace_back(i); } unique_ptr<BSTNode<int>> root = unique_ptr<BSTNode<int>>(BuildBSTFromSortedArray(A)); int target = 0; TraversalCheck<int>(root, &target); } return 0; }
int main(int argc, char* argv[]) { default_random_engine gen((random_device())()); if (argc == 2) { cout << StringToInt(argv[1]) << endl; } else { for (int times = 0; times < 10000; ++times) { uniform_int_distribution<int> dis(numeric_limits<int>::min(), numeric_limits<int>::max()); int x = dis(gen); string str = IntToString(x); cout << x << " " << str << endl; assert(x == stoi(str)); uniform_int_distribution<int> len_dis(0, 9); str = RandIntString(len_dis(gen)); x = StringToInt(str); cout << str << " " << x << endl; assert(x == stoi(str)); } } return 0; }
int main(int argc, char* argv[]) { default_random_engine gen((random_device())()); int n; if (argc == 2) { n = atoi(argv[1]); } else { uniform_int_distribution<int> dis(1, 100); n = dis(gen); } vector<int> waiting_time; for (int i = 0; i < n; ++i) { uniform_int_distribution<int> dis(0, 999); waiting_time.push_back(dis(gen)); } for (int i = 0; i < n; ++i) { cout << waiting_time[i] << ' '; } cout << endl; cout << MinimumWaitingTime(waiting_time) << endl; return 0; }
int main(int argc, char* argv[]) { // input a list in reverse order. default_random_engine gen((random_device())()); shared_ptr<node_t<int>> head = nullptr; int n; if (argc > 2) { for (size_t i = 1; i < argc; ++i) { auto curr = make_shared<node_t<int>>(node_t<int>{atoi(argv[i]), nullptr}); curr->next = head; head = curr; } } else { if (argc == 2) { n = atoi(argv[1]); } else { uniform_int_distribution<int> dis(1, 1000); n = dis(gen); } for (int i = n - 1; i >= 0; --i) { auto curr = make_shared<node_t<int>>(node_t<int>{i, nullptr}); curr->next = head; head = curr; } } shared_ptr<node_t<int>> ans = even_odd_merge(head); int x = 0; while (ans) { if (argc <= 2) { assert(x == ans->data); x += 2; if (x >= n) { x = 1; } } cout << ans->data << endl; ans = ans->next; } return 0; }
int main(int argc, char* argv[]) { default_random_engine gen((random_device())()); for (int times = 0; times < 1000; ++times) { int n, m; vector<int> T, S; if (argc == 3) { n = atoi(argv[1]), m = atoi(argv[2]); } else { uniform_int_distribution<int> dis(1, 100); n = dis(gen), m = dis(gen); } for (int i = 0; i < n; ++i) { uniform_int_distribution<int> dis(1, 5); T.emplace_back(dis(gen)); } for (int i = 0; i < m; ++i) { uniform_int_distribution<int> dis(1, 10); S.emplace_back(dis(gen)); } cout << "T = "; copy(T.cbegin(), T.cend(), ostream_iterator<int>(cout, " ")); cout << endl; cout << "S = "; copy(S.cbegin(), S.cend(), ostream_iterator<int>(cout, " ")); cout << endl; vector<deque<bool>> res = find_feasible_job_assignment(T, S); if (!res.empty()) { // there is a feasible answer. cout << "found feasible assignment!" << endl; for (int i = 0; i < res.size(); ++i) { copy(res[i].cbegin(), res[i].cend(), ostream_iterator<int>(cout, " ")); cout << endl; } check_answer(T, S, res); } else { // TODO(THL): find a way to verify there is no assignment. cout << "no feasible assignment" << endl; } } return 0; }
int main(int argc, char* argv[]) { if (argc == 4) { string input(argv[1]); cout << convert_base(input, atoi(argv[2]), atoi(argv[3])) << endl; assert(input == convert_base(convert_base(input, atoi(argv[2]), atoi(argv[3])), atoi(argv[3]), atoi(argv[2]))); } else { default_random_engine gen((random_device())()); for (int times = 0; times < 100000; ++times) { uniform_int_distribution<int> len_dis(1, 9); string input = rand_int_string(len_dis(gen)); uniform_int_distribution<int> base_dis(2, 16); int base = base_dis(gen); cout << "input is " << input << ", base1 = 10, base2 = " << base << ", ans = " << convert_base(input, 10, base) << endl; assert(input == convert_base(convert_base(input, 10, base), base, 10)); } } return 0; }
int main(int argc, char *argv[]) { default_random_engine gen((random_device())()); for (int times = 0; times < 1000; ++times) { cout << times << endl; int n; if (argc == 2) { n = atoi(argv[1]); } else { uniform_int_distribution<int> dis(1, 10000); n = dis(gen); } unique_ptr<BinaryTreeNode<int>> root = generate_rand_binary_tree<int>(n, true); vector<int> pre = generate_preorder(root); vector<int> in = generate_inorder(root); auto res = unique_ptr<BinaryTreeNode<int>>(reconstruct_pre_in_orders(pre, in)); assert(is_two_binary_trees_equal<int>(root, res)); delete_binary_tree(&root); delete_binary_tree(&res); } return 0; }
int main(int argc, char* argv[]) { default_random_engine gen((random_device())()); vector<int> C; if (argc >= 2) { for (int i = 1; i < argc; ++i) { C.emplace_back(atoi(argv[i])); } } else { uniform_int_distribution<int> dis(1, 1000); C.resize(dis(gen)); for (int i = 0; i < C.size(); ++i) { uniform_int_distribution<int> dis(0, 99); C[i] = dis(gen); } } for (size_t i = 0; i < C.size(); ++i) { cout << C[i] << ' '; } cout << endl; cout << PickUpCoins(C) << endl; return 0; }
int main(int argc, char *argv[]) { default_random_engine gen((random_device())()); for (int times = 0; times < 1000; ++times) { string str; if (argc >= 2) { str += argv[1]; for (int i = 2; i < argc; ++i) { str += ' '; str += argv[i]; } } else { uniform_int_distribution<int> dis(0, 9999); str = rand_string(dis(gen)); } string original_str(str); cout << str << endl; reverse_words(&str); cout << str << endl; check_answer(original_str, &str); } return 0; }
int main(int argc, char* argv[]) { default_random_engine gen((random_device())()); // Random test 1000 times. for (int times = 0; times < 1000; ++times) { cout << times << endl; int n; if (argc == 2) { n = atoi(argv[1]); } else { uniform_int_distribution<int> dis(1, 10000); n = dis(gen); } unique_ptr<BinaryTreeNode<int>> root = generate_rand_binary_tree<int>(n); vector<int*> p; GenPreorderWithNull(root, &p); auto x = unique_ptr<BinaryTreeNode<int>>(ReconstructPreorder(p)); assert(is_two_binary_trees_equal(root, x)); delete_binary_tree(&root); delete_binary_tree(&x); } return 0; }