class Solution {
    public boolean isPalindrome(String s) {
        if(s.length() == 0)
             return true;
        int l = 0, r = s.length() - 1;
        while(l < r){
            //确定指定的字符是否为字母或数字
            if(!Character.isLetterOrDigit(s.charAt(l))){
                l++;
            }else if(!Character.isLetterOrDigit(s.charAt(r))){
                r--;
            }else{
                if(Character.toLowerCase(s.charAt(l)) != Character.toLowerCase(s.charAt(r)))
                    return false;
                l++;
                r--;
            } 
        }
        return true;
    }
}

class Solution {
    List<List<String>> res = new ArrayList<>();

    public List<List<String>> partition(String s) {
        if(s==null||s.length()==0)
            return res;
        dfs(s,new ArrayList<String>(),0);
        return res;
    }

    public void dfs(String s,List<String> remain,int left){
        if(left==s.length()){  //判断终止条件
            res.add(new ArrayList<String>(remain));  //添加到结果中
            return;
        }
        for(int right=left;right<s.length();right++){  //从left开始，依次判断left->right是不是回文串
            if(isPalindroom(s,left,right)){  //判断是否是回文串
                remain.add(s.substring(left,right+1));   //添加到当前回文串到list中
                dfs(s,remain,right+1);  //从right+1开始继续递归，寻找回文串
                remain.remove(remain.size()-1);  //回溯，从而寻找更长的回文串
            }
        }
    }
    /**
    * 判断是否是回文串
    */
    public boolean isPalindroom(String s,int left,int right){
        while(left<right&&s.charAt(left)==s.charAt(right)){
            left++;
            right--;
        }
        return left>=right;
    }
}

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        int n = s.length();
        int max_length=0;
        for(String temp:wordDict){
            max_length = temp.length() > max_length ? temp.length() : max_length;
        }
        // memo[i] 表示 s 中以 i - 1 结尾的字符串是否可被 wordDict 拆分
        boolean[] memo = new boolean[n + 1];
        memo[0] = true;
        for (int i = 1; i <= n; i++) {
            for (int j = i-1; j >= 0 && max_length >= i - j; j--) {
                if (memo[j] && wordDict.contains(s.substring(j, i))) {
                    memo[i] = true;
                    break;
                }
            }
        }
        return memo[n];
    }
}

class Solution {
public:
    string reverseString(string s) {
        int i = 0, j = s.size() - 1;
        while (i < j){
            swap(s[i],s[j]);
            i++;
            j--;
        }
        return s;
    }
};

public class Solution {
    public int StrToInt(String str) {
    if (str == null || str.length() == 0)
        return 0;
    boolean isNegative = str.charAt(0) == '-';
    int ret = 0;
    for (int i = 0; i < str.length(); i++) {
        char c = str.charAt(i);
        if (i == 0 && (c == '+' || c == '-'))  /* 符号判定 */
            continue;
        if (c < '0' || c > '9')                /* 非法输入 */
            return 0;
        ret = ret * 10 + (c - '0');
    }
    return isNegative ? -ret : ret;
  }
}

# encoding: utf-8
"""
责任链模式
使多个对象都以机会处理请求, 从而避免请求的发送者和接受者之间的耦合关系
将这个对象连成一条链, 沿着这条链传递请求, 直到有一个对象处理它为止
- 可以随意增加或修改处理一个请求的链式结构
"""

from abc import ABCMeta, abstractmethod


class Handler(object):
    """
    定义一个处理请求的接口
    """
    __metaclass__ = ABCMeta

    def __init__(self):
        self.__successor = None

    @property
    def successor(self):
        return self.__successor

    @successor.setter
    def successor(self, value):
        self.__successor = value

    @abstractmethod
    def handle_request(self, request):
        pass


class ConcreteHandlerA(Handler):
    """
    具体处理类, 处理它所负责的请求
    如果可以处理该请求, 处理之, 否则转给后继者
    """

    def handle_request(self, request):
        if 0 <= request < 10:
            print "%s process %s" % (self.__class__.__name__, request)
        else:
            self.successor.handle_request(request)


class ConcreteHandlerB(Handler):
    """
    具体处理类, 处理它所负责的请求
    如果可以处理该请求, 处理之, 否则转给后继者
    """

    def handle_request(self, request):
        if 10 <= request < 20:
            print "%s process %s" % (self.__class__.__name__, request)
        else:
            self.successor.handle_request(request)


class ConcreteHandlerC(Handler):
    """
    具体处理类, 处理它所负责的请求
    如果可以处理该请求, 处理之, 否则转给后继者
    """

    def handle_request(self, request):
        if 20 <= request < 30:
            print "%s process %s" % (self.__class__.__name__, request)
        else:
            self.successor.handle_request(request)


if __name__ == '__main__':
    h1 = ConcreteHandlerA()
    h2 = ConcreteHandlerB()
    h3 = ConcreteHandlerC()

    h1.successor = h2
    h2.successor = h3

    for req in [2, 14, 22]:
        print req
        h1.handle_request(req)

## Sanic源码阅读：基于0.1.2

`Sanic`是一个可以使用`async/await`语法编写项目的异步非阻塞框架，它写法类似于`Flask`，但使用了异步特性，而且还使用`uvloop`作为事件循环，其底层使用的是`libuv`，从而使 `Sanic`的速度优势更加明显。

本章，我将和大家一起看看`Sanic`里面的运行机制是怎样的，它的`Router Blueprint`等是如何实现的。

如果你有以下的需求：

- 想深入了解Sanic，迫切想知道它的运行机制
- 直接阅读源码，做一些定制
- 学习

将Sanic-0.1.2阅读完后的一些建议，我觉得你应该有以下基础再阅读源码才会理解地比较好：

- 理解[装饰器](https://github.com/howie6879/Sanic-For-Pythoneer/blob/master/docs/part2/%E9%99%84%E5%BD%95%EF%BC%9A%E5%85%B3%E4%BA%8E%E8%A3%85%E9%A5%B0%E5%99%A8.md)，见附录
- 理解协程

Sanic-0.1.2 的核心文件如下：
``` shell
.
├── __init__.py
├── blueprints.py
├── config.py
├── exceptions.py
├── log.py
├── request.py
├── response.py
├── router.py
├── sanic.py
├── server.py
└── utils.py

git clone https://github.com/howie6879/sanic_annotation
cd sanic_annotation/sanic_0_1_2/examples/