| IMPS None | Dummy ♠ J93 ♥ T9876 ♦ KQJ ♣ 42 | |
| You ♠ AKT ♥ 2 ♦ 2 ♣ AKQJT976 |
| W | N | E | S |
|---|---|---|---|
| 3H | 6C | ||
| all | pass |
| Rubber None | Dummy ♠ AJT9 ♥ AK ♦ K32 ♣ Q932 | |
| You ♠ KQ8 ♥ 432 ♦ Q54 ♣ AJ74 |
| IMPS N/S | Dummy ♠ Q74 ♥ A4 ♦ AK7 ♣ AQ932 | |
| You ♠ AKT962 ♥ J98 ♦ - ♣ K865 |
| W | N | E | S |
|---|---|---|---|
| 1S | |||
| 4D | 4NT | 5D | 6S |
| P | 7S | all | pass |
void print() {
if (printf("%c", 59)) {}
}
int stop(int n){}
int print(int n){
int (*a[2])(int) = { print, stop };
printf("hell%c %c%crld!",111,119 ,111);
n++;
a[n==2014](n);
}
int main(){
print(0);
}
| IMPS None | North ♠ KQT9 ♥ AJT9 ♦ KQT9 ♣ 2 | |
| South ♠ A876 ♥ K2 ♦ A32 ♣ AKQJ |
| IMPS None | Dummy ♠ AT ♥ Kx ♦ AKxxxx ♣ Qxx | |
| You ♠ J ♥ AQJTxx ♦ Jx ♣ xxxx |
| W | N | E | S |
|---|---|---|---|
| P | 2H | ||
| P | 4H | all | pass |
| MPS None | North ♠ T9 ♥ 7542 ♦ 98742 ♣ A3 | |
| South ♠ AK86432 ♥ AK ♦ 5 ♣ K72 |
| IMPS None | North ♠ A73 ♥ T73 ♦ 7643 ♣ Q64 | |
| South ♠ KJ2 ♥ AKQJ4 ♦ J ♣ AKJT |
 |
| Placing two copies of ABC along with DEF results in an equilateral triangle. |
| IMPS None | North ♠ 83 ♥ 963 ♦ AKQJ9 ♣ Q63 | |
| West ♠ KJ9652 ♥ - ♦ 87542 ♣ T8 | Genie ♠ AQT4 ♥ A74 ♦ T63 ♣ KJ7 | |
| South ♠ 7 ♥ KQJT852 ♦ - ♣ A9542 |
| W | N | E | S |
|---|---|---|---|
| 3S | P | 4S | 5H |
| all | pass |
 |
| Tree formed by inserting 4, then 5,1,2,3 in order. |
| IMPS None | North ♠ AQ3 ♥ Q752 ♦ 653 ♣ Q72 | |
| South ♠ 642 ♥ AK ♦ AKQJ98 ♣ K3 |
bool has_sum(const std::vector<int>& a, int target) {
// Technically, the negation is a bug
// and overflow is possible here.
// The range of int in C++ is actually
// [-M-1, M], not [-M, M].
// But, we ignore that...
int sum = -target;
std::vector<int> positives;
std::vector<int> negatives;
int total = 0;
// Collect the positive and negative numbers.
for (auto x : a) {
if (x > 0) {
positives.push_back(x);
total++;
}
if (x < 0) {
negatives.push_back(x);
total++;
}
}
int positives_seen = 0;
int negatives_seen = 0;
// Note: no overflow in the + here :-)
while (positives_seen + negatives_seen < total) {
if (sum < 0) {
// If sum is negative, try to add a positive.
if (positives_seen >= positives.size()) {
break;
}
sum += positives[positives_seen++];
} else if (sum > 0) {
// If sum is positive, try to add a negative.
if (negatives_seen >= negatives.size()) {
break;
}
sum += negatives[negatives_seen++];
} else {
// If sum is zero pick a positive.
if (positives_seen < positives.size()) {
sum += positives[positives_seen++];
} else {
// There is at least one negative left.
sum += negatives[negatives_seen++];
}
}
}
return sum == 0;
}
| IMPS None | North ♠ KQJ97 ♥ 93 ♦ 853 ♣ AQ4 | |
| South ♠ 42 ♥ AQJ4 ♦ AKQ ♣ 6532 |
# traversal_method is a string like "LVLR".
def traverse(tree, traversal_method):
if tree == None:
return
for method in traversal_method:
if method == "L":
traverse(tree.Left, traversal_method)
if method == "R":
traverse(tree.Right, traversal_method)
if method == "V":
Visit(tree.Value)
# traversal_method is a string like "LVLR".
def traverse(tree, traversal_method):
if tree == None:
return
stack = [(tree, traversal_method)]
while len(stack) > 0:
node, traversal_left = stack[-1]
del stack[-1] # pop
if node == None:
continue
# in python L[-1] is the last element of the list.
# and L[1:] is the list without the first element.
if len(traversal_left[1:]) != 0
# push.
stack.append((node, traversal_left[1:]))
if traversal_left[0] == "L":
stack.append(node.Left, traversal_method)
if traversal_left[0] == "R":
stack.append(node.Right, traversal_method)
if traversal_left[0] == "V":
visit(node.Value)
// Determine if two nodes of a binary search tree
// sum to target.
bool has_sum(Tree *tree, int target) {
if (tree == NULL) return false;
Traverser ascending(tree, "LVR");
Traverser descending(tree, "RVL");
Tree *left = ascending.next();
Tree *right = descending.next();
while (left->Value <= right->Value;) {
int sum = left->Value + right->Value;
if (sum == target) {
return true;
}
if (sum > target) {
right = descending.next();
} else {
left = ascending.next();
}
}
return false;
}