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;
}
