bool isPalindrome(const string& str) {

    int len = str.length();
    if (len <=0) {
	return false;
    }

    int head = 0;
    int tail = len - 1;

    while (head < tail) {
	if (str[head] != str[tail]) {
	    return false;
	}

	++head;
	--tail;
    }

    return true;
}

string longestPalindrome(string s) {

    string ans = "";

    for (size_t i=0; i < s.length(); ++i) {
	for (size_t j=s.length()-i; j != 0; --j) {
	    if (ans.length() >= j) {
		continue;
	    }

	    string temp = s.substr(i, j);
	    if (ans.length() < temp.length()
		&& isPalindrome(temp)) {
		ans = temp;
	    }
	}
    }

    return ans;
}

string longestPalindrome(string s) {

    string ans = "";

    for (size_t i=0; i < s.length(); ++i) {

	// 如何确定初始的边界很重要
	size_t j = i;
	size_t k = i;

	// 向两边拓展边界
	while (j-1>=0 && s[j-1]==s[i]) {
	    --j;
	}

	while (k+1<s.length() && s[k+1]==s[i]) {
	    ++k;
	}

	while (j-1>=0
	       && k+1<s.length()
	       && s[j-1]==s[k+1]) {
	    --j;
	    ++k;
	}

	if (k-j+1 > ans.length()) {
	    ans = s.substr(j, k-j+1);
	}
    }

    return ans;
}

public String longestPalindrome(String s) {
    if (s == null || s.length() < 1) return "";
    int start = 0, end = 0;
    for (int i = 0; i < s.length(); i++) {
	int len1 = expandAroundCenter(s, i, i);
	int len2 = expandAroundCenter(s, i, i + 1);
	int len = Math.max(len1, len2);
	if (len > end - start) {
	    start = i - (len - 1) / 2;
	    end = i + len / 2;
	}
    }
    return s.substring(start, end + 1);
}

private int expandAroundCenter(String s, int left, int right) {
    int L = left, R = right;
    while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
	L--;
	R++;
    }
    return R - L - 1;
}

public String longestPalindrome(String s) {
  int n = s.length();
  String res = null;

  boolean[][] dp = new boolean[n][n];

  for (int i = n - 1; i >= 0; i--) {
    for (int j = i; j < n; j++) {
      dp[i][j] = s.charAt(i) == s.charAt(j) && (j - i < 3 || dp[i + 1][j - 1]);

      if (dp[i][j] && (res == null || j - i + 1 > res.length())) {
	res = s.substring(i, j + 1);
      }
    }
  }

  return res;
}

bool isStringWithUniqueString(const string& str)
{
    // 用于判断字符串是否是具有唯一字符的
    set<char> setChar;
    for (size_t i = 0; i<str.length(); ++i)
    {
	if (setChar.find(str[i]) != setChar.end())
	{
	    return false;
	}

	setChar.insert(str[i]);
    }
    return true;
}

int lengthOfLongestSubstring(string s)
{
    int lengthMax = 0;

    for (size_t i=0; i<s.length(); ++i)
    {
	for (size_t j=i+1; j<=s.length(); ++j)
	{
	    // get sub-string
	    string strTemp = s.substr(i, j-i);
	    if (isStringWithUniqueString(strTemp))
	    {
		lengthMax = max(lengthMax, (int)strTemp.length());
	    }
	}
    }

    return lengthMax;
}

int lengthOfLongestSubstring(string s)
{
    int lengthMax = 0;

    for (size_t i=0; i<s.length(); ++i)
    {
	// 这个循环目的是，验证从i到j的字符串是否满足条件
	set<char> setChar;

	for (size_t j=i; j<s.length(); ++j)
	{
	    char ch = s[j];
	    if (setChar.find(ch) != setChar.end())
	    {
		break;
	    }
	    else
	    {
		lengthMax = max(lengthMax, int(j - i + 1));
	    }

	    setChar.insert(ch);
	}
    }

    return lengthMax;
}

int lengthOfLongestSubstring(string s)
{
    int lengthMax = 0;

    map<char, size_t> mapPos;

    for (size_t i=0, j=0; j<s.length(); ++j)
    {
	char ch = s[j];
	map<char, size_t>::iterator it = mapPos.find(ch);
	if (it != mapPos.end())
	{
	    // 这里说明找到了字符上一次出现的位置
	    if (it->second + 1>= i)
	    {
		i = it->second + 1;
	    }
	}

	lengthMax = max(lengthMax, int(j - i + 1));

	mapPos[ch] = j;
    }

    return lengthMax;
}

Lorem ipsum dolor sit amet
      ^ Cursor


      Point
      |
      Mark
      |
Lorem ipsum dolor sit amet
      ^ C-spc


      Mark          Point
      | ----region--|
      |             |
Lorem ipsum dolor sit amet
	 move       ^
	 forward ->


      Mark          Point
      | ----region--|
      |             |
Lorem ipsum dolor sit amet
		    ^
		    C-x C-x


      Point         Mark
      | ----region--|
      |             |
Lorem ipsum dolor sit amet

Point and mark interchanged

class
      ^ C-spc => Activate mark

class Foo
	  ^ M-w => Foo has now been killed (copied)

class Foo extends React.Component<
				  ^ C-spc => Activate mark

class Foo extends React.Component<
				  ^ C-y => Yank (paste) Foo

class Foo extends React.Component<FooProps
					  ^ M-w => FooProps has now been killed (copied)

class Foo extends React.Component<FooProps>

// Later
interface
	   ^ C-y => Yank FooProps

interface FooProps {}

ls . 1> ls-output.txt

ls . 2> ls-error.txt

ls . 2>&1 ls-output-and-error.txt

ls . &> ls-output-and-error.txt

program > /dev/null

echo test >> file-output.txt

union un1 {
    int n1;
    struct {
	int nn1 : 4;
	int : 0;
	int nn2 : 16;
    } st;
};

union un1 u1;
u1.st.nn1 = 1;
u1.st.nn2 = 1;
printf("union u1.n1=0x%08x sizeof(un1)=%zu\n", u1.n1, sizeof(un1));

union un1.n1=0x00000001 sizeof(un1)=8

union un1 {
    int n1;
    struct {
	int nn1 : 4;
	char : 0;
	int nn2 : 16;
    } st;
};

union un1.n1=0x00000101 sizeof(un1)=4

union un1 {
    int n1;
    struct {
	int nn1 : 4;
	short : 0;
	int nn2 : 16;
    } st;
};

union un1.n1=0x00010001 sizeof(un1)=4

union un1 {
    int n1;
    struct {
	int nn1 : 8;
	char : 0;
	int nn2 : 16;
    } st;
};

union un1.n1=0x00000101 sizeof(un1)=4

int aio_read(struct aiocb* aiocbp);

int aio_write(struct aiocb* aiocbp);

int aio_return(struct aiocb* aiocbp);

int aio_error(struct aiocb* aiocbp);

int io_setup(unsigned nr, aio_context_t* ctxp);

int io_destroy(aio_context_t ctx);

int io_submit(aio_context_t ctx, long nr, struct iocb** iocbpp);

int io_getevents(aio_context_t ctx, long min_nr, long max_nr,
		 io_event* events, struct timespec* timeout);