Given a string containing only digits, restore it by returning all possible valid IP address combinations.

For example:
Given "25525511135",

return ["255.255.11.135", "255.255.111.35"]. (Order does not matter)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Solution(object):
    def restoreIpAddresses(self, s):
        """
        :type s: str
        :rtype: List[str]
        """
        ans = []
        self.dfs(ans,s,4,[])
        return ['.'.join(x) for x in ans]
    def dfs(self,ans,s,k,temp):
        if len(s) > 3*k:
            return []
        if k == 0:
            ans.append(temp[:])
        else:
            for i in range(min(3,len(s)-k+1)):
                if i == 2 and int(s[:3]) > 255 or i > 0 and int(s[0]) == 0:
                    continue
                self.dfs(ans,s[i+1:],k-1,temp+[s[:i+1]])

vi/vim 按键说明

第一部份：一般模式可用的光标移动、复制粘贴、搜索替换等

移动光标的方法

• h 或 向左箭头键(←) 光标向左移动一个字符
• j 或 向下箭头键(↓) 光标向下移动一个字符
• k 或 向上箭头键(↑) 光标向上移动一个字符

• l 或 向右箭头键(→) 光标向右移动一个字符

  如果你将右手放在键盘上的话，你会发现 hjkl 是排列在一起的，因此可以使用这四个按钮来移动光标。 如果想要进行多次移动的话，例如向下移动 30 行，可以使用 “30j” 或 “30↓” 的组合按键， 亦即加上想要进行的次数(数字)后，按下动作即可！

• [Ctrl] + [f] 屏幕『向下』移动一页，相当于 [Page Down]按键 (常用)
• [Ctrl] + [b] 屏幕『向上』移动一页，相当于 [Page Up] 按键 (常用)
• [Ctrl] + [d] 屏幕『向下』移动半页
• [Ctrl] + [u] 屏幕『向上』移动半页
• [+] 光标移动到非空格符的下一行
• [-] 光标移动到非空格符的上一行
• n 那个 n 表示『数字』，例如 20 。按下数字后再按空格键，光标会向右移动这一行的 n 个字符。例如 20 则光标会向后面移动 20 个字符距离。
• 0 或功能键[Home] 这是数字『 0 』：移动到这一行的最前面字符处 (常用)
• $ 或功能键[End] 移动到这一行的最后面字符处(常用)
• H 光标移动到这个屏幕的最上方那一行的第一个字符
• M 光标移动到这个屏幕的中央那一行的第一个字符
• L 光标移动到这个屏幕的最下方那一行的第一个字符
• G 移动到这个档案的最后一行(常用)
• nG n 为数字。移动到这个档案的第 n 行。例如 20G 则会移动到这个档案的第 20 行(可配合 :set nu)
• gg 移动到这个档案的第一行，相当于 1G 啊！ (常用)

• n n 为数字。光标向下移动 n 行(常用)

  搜索替换

• /word 向光标之下寻找一个名称为 word 的字符串。例如要在档案内搜寻 vbird 这个字符串，就输入 /vbird 即可！ (常用)
• ?word 向光标之上寻找一个字符串名称为 word 的字符串。
• n 这个 n 是英文按键。代表重复前一个搜寻的动作。举例来说， 如果刚刚我们执行 /vbird 去向下搜寻 vbird 这个字符串，则按下 n 后，会向下继续搜寻下一个名称为 vbird 的字符串。如果是执行 ?vbird 的话，那么按下 n 则会向上继续搜寻名称为 vbird 的字符串！

• N 这个 N 是英文按键。与 n 刚好相反，为『反向』进行前一个搜寻动作。 例如 /vbird 后，按下 N 则表示『向上』搜寻 vbird 。

  使用 /word 配合 n 及 N 是非常有帮助的！可以让你重复的找到一些你搜寻的关键词！

• :n1,n2s/word1/word2/g n1 与 n2 为数字。在第 n1 与 n2 行之间寻找 word1 这个字符串，并将该字符串取代为 word2 ！举例来说，在 100 到 200 行之间搜寻 vbird 并取代为 VBIRD 则：
  『:100,200s/vbird/VBIRD/g』。(常用)
• :1,$s/word1/word2/g 从第一行到最后一行寻找 word1 字符串，并将该字符串取代为 word2 ！(常用)

• :1,$s/word1/word2/gc 从第一行到最后一行寻找 word1 字符串，并将该字符串取代为 word2 ！且在取代前显示提示字符给用户确认 (confirm) 是否需要取代！(常用)

  删除、复制与贴上

• x, X 在一行字当中，x 为向后删除一个字符 (相当于 [del] 按键)， X 为向前删除一个字符(相当于 [backspace] 亦即是退格键) (常用)
• nx n 为数字，连续向后删除 n 个字符。举例来说，我要连续删除 10 个字符， 『10x』。
• dd 删除游标所在的那一整行(常用)
• ndd n 为数字。删除光标所在的向下 n 行，例如 20dd 则是删除 20 行 (常用)
• d1G 删除光标所在到第一行的所有数据
• dG 删除光标所在到最后一行的所有数据
• d$ 删除游标所在处，到该行的最后一个字符
• d0 那个是数字的 0 ，删除游标所在处，到该行的最前面一个字符
• yy 复制游标所在的那一行(常用)
• nyy n 为数字。复制光标所在的向下 n 行，例如 20yy 则是复制 20 行(常用)
• y1G 复制游标所在行到第一行的所有数据
• yG 复制游标所在行到最后一行的所有数据
• y0 复制光标所在的那个字符到该行行首的所有数据
• y$ 复制光标所在的那个字符到该行行尾的所有数据
• p, P p 为将已复制的数据在光标下一行贴上，P 则为贴在游标上一行！ 举例来说，我目前光标在第 20 行，且已经复制了 10 行数据。则按下 p 后， 那 10 行数据会贴在原本的 20 行之后，亦即由 21 行开始贴。但如果是按下 P 呢？ 那么原本的第 20 行会被推到变成 30 行。 (常用)
• J 将光标所在行与下一行的数据结合成同一行
• c 重复删除多个数据，例如向下删除 10 行，[ 10cj ]
• u 复原前一个动作。(常用)

• [Ctrl]+r 重做上一个动作。(常用)

  这个 u 与 [Ctrl]+r 是很常用的指令！一个是复原，另一个则是重做一次-
  ～ 利用这两个功能按键，你的编辑，嘿嘿！很快乐的啦！

• . 不要怀疑！这就是小数点！意思是重复前一个动作的意思。 如果你想要重复删除、重复贴上等等动作，按下小数点『.』就好了！ (常用)

  第二部份：一般模式切换到编辑模式的可用的按钮说明

  进入输入或取代的编辑模式

• i, I 进入输入模式(Insert mode)：
  i 为『从目前光标所在处输入』， I 为『在目前所在行的第一个非空格符处开始输入』。 (常用)

• a, A 进入输入模式(Insert mode)：
  a 为『从目前光标所在的下一个字符处开始输入』， A 为『从光标所在行的最后一个字符处开始输入』。(常用)
• o, O 进入输入模式(Insert mode)：
  这是英文字母 o 的大小写。o 为『在目前光标所在的下一行处输入新的一行』； O 为在目前光标所在处的上一行输入新的一行！(常用)

• r, R 进入取代模式(Replace mode)：
  r 只会取代光标所在的那一个字符一次；R会一直取代光标所在的文字，直到按下 ESC 为止；(常用)

  上面这些按键中，在 vi 画面的左下角处会出现『–INSERT–』或『–REPLACE–』的字样。 由名称就知道该动作了吧！！特别注意的是，我们上面也提过了，你想要在档案里面输入字符时， 一定要在左下角处看到 INSERT 或 REPLACE 才能输入喔！

• [Esc] 退出编辑模式，回到一般模式中(常用)

  第三部份：一般模式切换到指令行模式的可用的按钮说明

  指令行的储存、离开等指令

• :w 将编辑的数据写入硬盘档案中(常用)

• :w! 若文件属性为『只读』时，强制写入该档案。不过，到底能不能写入， 还是跟你对该档案的档案权限有关啊！
• :q 离开 vi (常用)

• :q! 若曾修改过档案，又不想储存，使用 ! 为强制离开不储存档案。

  注意一下啊，那个惊叹号 (!) 在 vi 当中，常常具有『强制』的意思～

• :wq 储存后离开，若为 :wq! 则为强制储存后离开 (常用)
• ZZ 这是大写的 Z 喔！若档案没有更动，则不储存离开，若档案已经被更动过，则储存后离开！
• :w [filename] 将编辑的数据储存成另一个档案（类似另存新档）
• :r [filename] 在编辑的数据中，读入另一个档案的数据。亦即将 『filename』 这个档案内容加到游标所在行后面
• :n1,n2 w [filename] 将 n1 到 n2 的内容储存成 filename 这个档案。
• :! command 暂时离开 vi 到指令行模式下执行 command 的显示结果！例如
• 『:! ls /home』即可在 vi 当中察看 /home 底下以 ls 输出的档案信息！
  vim 环境的变更
• :set nu 显示行号，设定之后，会在每一行的前缀显示该行的行号

• :set nonu 与 set nu 相反，为取消行号！

  特别注意，在 vi/vim 中，数字是很有意义的！数字通常代表重复做几次的意思！ 也有可能是代表去到第几个什么什么的意思。

  举例来说，要删除 50 行，则是用 『50dd』 对吧！ 数字加在动作之前，如我要向下移动 20 行呢？那就是『20j』或者是『20↓』即可。

vim小技巧

代码自动对齐

自动对齐：（gg=G）

在命令模式下（即非“插入”等编辑模式），先输入gg，这时候光标会移动到第一行第一个字符，然后按 “=” 号之后切换成大写，再按一下G，这时候光标会移到最后一行的第一个字符，这时候就可以看到代码被排得整整齐齐了！

自动补全变量名

ctrl+p

Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each of the two partitions.

For example,

Given 1->4->3->2->5->2 and x = 3,

return 1->2->2->4->3->5.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def partition(self, head, x):
        """
        :type head: ListNode
        :type x: int
        :rtype: ListNode
        """
        head1 = list1 = ListNode(0)
        head2 = list2 = ListNode(0)
        while head:
            if head.val < x:
                list1.next = head
                list1 = list1.next
            else:
                list2.next = head
                list2 = list2.next
            head = head.next
        list2.next = None
        list1.next = head2.next
        return head1.next

Given n non-negative integers representing the histogram’s bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].

The largest rectangle is shown in the shaded area, which has area = 10unit.

For example,
Given heights = [2,1,5,6,2,3],
return 10.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Solution(object):
    def largestRectangleArea(self, heights):
        """
        :type heights: List[int]
        :rtype: int
        """
        heights.append(0)
        stack = [-1]
        ans = 0
        for i in range(len(heights)):
            while heights[i] < heights[stack[-1]]:
                h = heights[stack.pop()]
                w = i - stack[-1] - 1
                ans = max(ans,w*h)
            stack.append(i)
        return ans

Given a 2D binary matrix filled with 0’s and 1’s, find the largest rectangle containing only 1’s and return its area.

For example, given the following matrix:

1
2
3
4

1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0

Return 6.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class Solution(object):
    def maximalRectangle(self, matrix):
        """
        :type matrix: List[List[str]]
        :rtype: int
        """
        if len(matrix) == 0 or len(matrix[0]) == 0:
            return 0
        n = len(matrix[0])#列
        height = [0]*(n+1)
        ans = 0
        for row in matrix:
            for i in range(n):
                if row[i] == '0':
                    height[i] = 0
                else:
                    height[i] += 1
            stack = [-1]
            for i in range(n+1):
                while height[i] < height[stack[-1]]:
                    h = height[stack.pop()]
                    w = i - stack[-1] - 1
                    ans = max(ans,w*h)
                stack.append(i)
        return ans

输出文件的前10行（模拟 head -n 10 ）

1

awk ' NR < 11 '

如前所述，这里省略了动作，即为打印输出。匹配模式是变量NR需要小于11，NR即为当前的行号。这个写法很简单，但是有一个问题，在NR大于10的时候，awk其实还是对每行进行了判断，如果文件很大，比如说有上万行，浪费的时间是无法忽略的。所以，更好的写法是

1

awk '1; NR = 10 { exit }'

第一句对当前行进行输出。第二句判断是不是已经到了第10行，如果是则退出。

输出文件的第一行（模拟 head -n 1 ）

1

awk 'NR > 1 { exit }; 1'

这个例子与前一个很相似，中心思想就是第二行就退出。

输出文件的最后两行（模拟 tail -n 2 ）

1

awk '{ y=x "\n" $0; x=$0}; END { print y }'

的确，这一句看起来确实有些别扭。第一句总是把一个在当前行前面再加上变量x的内容赋值给y，然后用x记录当前行内容。这样的效果是y的内容始终是上一行加上当前行的内容。在最后，输出y的内容。如果仔细看的话，不难发现这个写法是很不高效的，因为它不停的进行赋值和字符串连接，只为了找到最后一行！所以，如果你想要输出文件的最后两行，tail -n 2是最好的选择。

输出文件的最后一行（模拟 tail -n 1 ）

1

awk 'END { print }'

句法方面没什么好说的，print省略参数即是等价于print $0。但是这个语句可能不能被非GNU awk的某些awk版本正常执行，如果为了兼容，下面的写法是最安全的：

1

awk '{ rec = $0 }; END { print rec }'

输出只匹配某些模式的行（模拟 grep ）

1

awk '/regex/'

似乎没什么好说的了。

输出不匹配某些模式的行（模拟 grep -v ）

1

awk '!/regex/'

匹配模式前加“!”就是否定判断结果。

输出匹配模式的行的上一行，而非当前行

1

awk '/regex/ { print x }; { x = $0 }'

变量x总是用来记录上一行的内容，如果模式匹配了当前行，则输出x的内容。

输出匹配模式的下一行

1

awk '/regex/ { getline; print }'

这里使用了getline函数取得下一行的内容并输出。getline的作用是将$0的内容置为下一行的内容，并同时更新NR，NF，FNR变量。如果匹配的是最后一行，getline会出错，$0不会被更新，最后一行会被打印。

输出匹配AA或者BB或者CC的行

1

awk '/AA|BB|CC/'

没什么好说的，正则表达式。如果有看不懂的朋友，请自行学习正则表达式。

输出长过65个字符的行

1

awk 'length > 64'

length([str])返回字符串的长度，如果参数省略，即是以$0作为参数，括号也可以省略了。

输出短于65个字符的行

1

awk 'length < 65'

和上例基本一样。

输出从匹配行到最后一样的内容

1

awk '/regex/,0'

这里使用了“pattern1,pattern2”的形式来指定一个匹配的范围，其中pattern2这里为0，也就是false，所以一直会匹配到文件结束。

从第8行输出到第12行

1

awk 'NR==8,NR==12'

同上例，这也是个范围匹配。

输出第52行

1

awk 'NR==52'

如果想要少执行些不必要的循环，就这样写：

1

awk 'NR==52 {print;exit}'

输出两次正则表达式匹配之间的行

1

awk '/regex1/, /regex2/'

删除所有的空行

1

awk NF

NF为真即是非空行。另外一种写法是用正则表达式：

1

awk '/./'

Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).

For example,

S = "ADOBECODEBANC"

T = "ABC"

Minimum window is "BANC".

Note:

If there is no such window in S that covers all characters in T, return the empty string "".

If there are multiple such windows, you are guaranteed that there will always be only one unique minimum window in S.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import sys
class Solution(object):
    def minWindow(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: str
        """
        m = collections.Counter(t)
        start = 0
        min_start = 0
        end = 0
        counter = len(t)
        min_len = sys.maxsize
        while end < len(s):
            if m[s[end]] > 0:
                counter -= 1
            m[s[end]] -= 1
            end += 1
            while counter == 0:
                if end - start < min_len:
                    min_len = end - start
                    min_start = start
                m[s[start]] += 1
                if m[s[start]] > 0:
                    counter += 1
                start += 1
        if min_len == sys.maxsize:return ''
        return s[min_start:min_start+min_len]

遍历字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

int sepcharbydh(char *in, char caOut[200][256])
{
    char *p, *p2;
    long lCount;
    long m = 0;
    lCount = 0;
    if (strlen(in) == 0)
        return 0;
    p = in;
    memset(caOut, 0, 200 * 256);
    while (*p)
    {
        if (*p == ',')
        {
            caOut[lCount][m] = '\0';

            m = 0;
            p++;
            lCount++;
            if (lCount >= 200)
                return lCount;
        }
        else
        {
            if (m < 35)
            {
                caOut[lCount][m] = *p;
                p++;
                m++;
            }
        }
    }
    return lCount + 1;
}

原文地址https://github.com/mqyqingfeng/Blog

函数上下文

在函数上下文中，我们用活动对象(activation object, AO)来表示变量对象。
活动对象和变量对象其实是一个东西，只是变量对象是规范上的或者说是引擎实现上的，不可在 JavaScript 环境中访问，只有到当进入一个执行上下文中，这个执行上下文的变量对象才会被激活，所以才叫 activation object 呐，而只有被激活的变量对象，也就是活动对象上的各种属性才能被访问。

活动对象是在进入函数上下文时刻被创建的，它通过函数的 arguments 属性初始化。arguments 属性值是 Arguments 对象。
执行过程
执行上下文的代码会分成两个阶段进行处理：分析和执行，我们也可以叫做：
进入执行上下文
代码执行
进入执行上下文
当进入执行上下文时，这时候还没有执行代码，
变量对象会包括：

函数的所有形参 (如果是函数上下文)

由名称和对应值组成的一个变量对象的属性被创建
没有实参，属性值设为 undefined

函数声明

由名称和对应值（函数对象(function-object)）组成一个变量对象的属性被创建
如果变量对象已经存在相同名称的属性，则完全替换这个属性

变量声明

由名称和对应值（undefined）组成一个变量对象的属性被创建；
如果变量名称跟已经声明的形式参数或函数相同，则变量声明不会干扰已经存在的这类属性
举个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

function foo(a) {
 
  var b = 2;
 
  function c() {}
 
  var d = function() {};


  b = 3;

}
}


foo(1);

在进入执行上下文后，这时候的 AO 是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

AO = {
 
    arguments: {
 
        0: 1,
 
        length: 1
    },
 
    a: 1,
 
    b: undefined,
 
    c: reference to function c(){},
 
    d: undefined
}
}

代码执行
在代码执行阶段，会顺序执行代码，根据代码，修改变量对象的值
还是上面的例子，当代码执行完后，这时候的 AO 是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

AO = {
 
    arguments: {
 
        0: 1,
 
        length: 1
    },
 
    a: 1,
 
    b: 3,
 
    c: reference to function c(){},
 
    d: reference to FunctionExpression "d"
}
}

到这里变量对象的创建过程就介绍完了，让我们简洁的总结我们上述所说：

• 全局上下文的变量对象初始化是全局对象

• 函数上下文的变量对象初始化只包括 Arguments 对象

• 在进入执行上下文时会给变量对象添加形参、函数声明、变量声明等初始的属性值

• 在代码执行阶段，会再次修改变量对象的属性值

1.使用create table xx as select

1

create table testtable as select distinct username,mname,college,mobno,cid from swdaydetail where sdate>='20171101' and sdate<'20171130';

2.使用MySQL的SELECT INTO OUTFILE 、Load data file

LOAD DATA INFILE语句从一个文本文件中以很高的速度读入一个表中。当用户一前一后地使用SELECT … INTO OUTFILE 和LOAD DATA
INFILE 将数据从一个数据库写到一个文件中，然后再从文件中将它读入数据库中时，两个命令的字段和行处理选项必须匹配。否则，LOAD DATA INFILE 将不能正确地解释文件内容。
假设用户使用SELECT … INTO OUTFILE 以逗号分隔字段的方式将数据写入到一个文件中：

1

SELECT * INTO OUTFILE 'data.txt' FIELDS TERMINATED BY ',' FROM table2;

为了将由逗号分隔的文件读回时，正确的语句应该是：

1
2
3
4
5
6

```

如果用户试图用下面所示的语句读取文件，它将不会工作，因为命令LOAD DATA INFILE 以定位符区分字段值：

```sql
LOAD DATA INFILE 'data.txt' INTO TABLE table2 FIELDS TERMINATED BY '\t';

下面是用来导入导出的命令：

1
2

select * into outfile 'ddd.txt' fields terminated by ',' from dn_location;  
load data infile 'ddd.txt' into table dn_location2  FIELDS TERMINATED BY ',';

3.使用mysqldump ，source

1
2
3

mysqldump -u root -p -q -e -t  webgps4 dn_location2 > dn_location2.sql  
mysqldump -u root -p -q -e -t --single-transaction  webgps4 dn_location2 > dn_location2.sql  
source dn_location2.sql

以上是导入导出数据的语句，该方法15分钟导出1.6亿条记录，导出的文件中平均7070条记录拼成一个insert语句，通过source进行批量插入，导入1.6亿条数据耗时将近5小时。平均速度：3200W条/h。后来尝试加上–single-transaction参数，结果影响不大。另外，若在导出时增加-w参数，表示对导出数据进行筛选，那么导入导出的速度基本不变，筛选出的数据量越大，时间越慢而已。对于其中的参数这里进行说明：

• –quick，-q
  该选项在导出大表时很有用，它强制 mysqldump 从服务器查询取得记录直接输出而不是取得所有记录后将它们缓存到内存中。

• –extended-insert, -e
  使用具有多个VALUES列的INSERT语法。这样使导出文件更小，并加速导入时的速度。默认为打开状态，使用–skip-extended-insert取消选项。

• –single-transaction
  该选项在导出数据之前提交一个BEGIN SQL语句，BEGIN 不会阻塞任何应用程序且能保证导出时数据库的一致性状态。它只适用于多版本存储引擎，仅InnoDB。本选项和–lock-tables 选项是互斥的，因为LOCK TABLES 会使任何挂起的事务隐含提交。要想导出大表的话，应结合使用–quick 选项。在本例子中没有起到加快速度的作用
  mysqldump -uroot -p –host=localhost –all-databases –single-transaction

• -t 仅导出表数据，不导出表结构

转载自http://blog.csdn.net/xiaobaismiley/article/details/41015783