howardlau1999

//
//                       _oo0oo_
//                      o8888888o
//                      88" . "88
//                      (| -_- |)
//                      0\  =  /0
//                    ___/`---'\___
//                  .' \\|     |// '.
//                 / \\|||  :  |||// \
//                / _||||| -:- |||||- \

howardlau1999

#include <iostream>

struct TrueType {
    constexpr static bool value = true;
};

struct FalseType {
    constexpr static bool value = false;
};

howardlau1999

#include <iostream>

struct TrueType {
    constexpr static bool value = true;
};

struct FalseType {
    constexpr static bool value = false;
};

howardlau1999

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <cmath>
#include <cctype>
#include <stdexcept>

using namespace std;

howardlau1999

#include <iostream>
using namespace std;

template <class K, class V>
struct AVLNode {
    K key;
    V value;
    AVLNode *left, *right;

    AVLNode(K key, V value) : key(key), value(value), left(NULL), right(NULL) {}

howardlau1999

#include <iostream>

enum Color { RED, BLACK };

template <class K, class V>
class RBTree {
    struct RBNode {
        K key;
        V value;
        size_t N;

howardlau1999

// g++ -rdynamic -o main main.c -ldl
#include <dlfcn.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <iostream>
using namespace std;

typedef int (*calc_func)(int, int);
const char *LIB_PATH = "./libctest.so";

howardlau1999

import edu.princeton.cs.algs4.*;

public class HeapSort {
	private static int currentSinking;
	public static void sink(int[] heap, int k, int N) {
		while (2 * k <= N) {
			int j = 2 * k;
			if (j < N && heap[j] < heap[j + 1]) j++;
			if (heap[k] > heap[j]) break;// already ordered
			exch(heap, k, j);

howardlau1999

use std::env;
use std::fs::File;
use std::io::prelude::*;
use std::io::BufWriter;
use std::ops::Add;
use std::ops::Div;
use std::ops::Mul;
use std::ops::Neg;
use std::ops::Sub;

howardlau1999

#include <iostream>

int main() {
    auto result = [](auto&& g) {
        return [](auto&& f) {
            return f(f);
        }([&g](auto&& f) { return g([&f](auto&& x) { return f(f)(x); }); });
    }([](auto&& f) {
        return [&f](auto&& x) -> int { return x == 0 ? 1 : x * f(x - 1); };
    })(5);