Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8
Explanation: 342 + 465 = 807.

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

class Solution(object):
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        carry = 0
        root = n = ListNode(0)
        while l1 or l2 or carry:
            v1 = v2 = 0
            if l1:
                v1 = l1.val
                l1 = l1.next
            if l2:
                v2 = l2.val
                l2 = l2.next
            carry, val = divmod(v1+v2+carry, 10)
            n.next = ListNode(val)
            n = n.next
        return root.next

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        for i in range(len(nums)-1, -1, -1):
            if nums[i] == val:
                nums.pop(i)
        return len(nums)

#!/usr/bin/env python
# -*- coding: utf-8 -*-
def add(a, b):
    return a+b

def test_add():
    res = add(1, 2)
    assert res == 3

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import pytest
@pytest.mark.parametrize(
    "test_input,expected",
    [("3+5", 8), ("2+4", 6), ("6*9", 42)],
)
def test_eval(test_input, expected):
    assert eval(test_input) == expected

========== test session starts ===========
platform darwin -- Python 3.6.8, pytest-4.4.1, py-1.8.0, pluggy-0.9.0
rootdir: /mock_test
collected 3 items 
pytest_test.py ..F            [100%]

================ FAILURES ================
___________ test_eval[6*9-42] ____________

test_input = '6*9', expected = 42

    @pytest.mark.parametrize(
        "test_input,expected",
        [("3+5", 8), ("2+4", 6), ("6*9", 42)],
    )
    def test_eval(test_input, expected):
>       assert eval(test_input) == expected
E       AssertionError: assert 54 == 42
E        +  where 54 = eval('6*9')

pytest_test.py:16: AssertionError
======= 1 failed, 2 passed in 0.07 seconds ===================

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import pytest
class TestRunAll():

    def setup_method(self, method):
        """ 
        setup any state tied to the execution of the given 
        method in a class.  setup_method is invoked for every
        test method of a class.
        """
        pass

    def teardown_method(self, method):
    """ 
    teardown any state that was previously setup with a
    setup_method call.
    """
        pass

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from unittest.mock import patch


class A(object):
     def judge(self, a, b):
         return a+b
def use_a(type=None):
    a = A()
    if type=='A':
        a.judge(1, 3)
    else:
        a.judge(2, 4)
        
@patch.object(A, 'judge', return_value=4)
def test_use(judge_mock):
    use_a()
    judge_mock.assert_called_with(2, 4)
    use_a('A')
    judge_mock.assert_called_with(1, 3)

patch.object(target, attribute, new=DEFAULT, spec=None, 
create=False, spec_set=None, autospec=None, new_callable=None,
**kwargs)

assert_called(*args, **kwargs) 
# 断言该mock至少被调用过一次

assert_called_once(*args, **kwargs)
# 断言该mock仅被调用过一次

assert_called_with(*args, **kwargs)
# 断言该mock以指定的参数(*args, **kwargs)被调用

assert_called_once_with(*args, **kwargs)
#断言该mock以指定的参数(*args, **kwargs)被调用过一次

assert_any_call(*args, **kwargs)
# 断言该mock以指定的参数(*args, **kwargs)被调用过，不同于
# assert_called_with、assert_called_once_with判断的是最近一次的调用，
# assert_any_call判断的是mock有被调用过。

assert_has_calls(calls, any_order=False)
# 断言该mock按calls设置的方式被调用，如果any_order为False，则mock的调用
# 顺序必须与calls设置一致；如果any_order为True，则需要calls设置的方式必须
# 被调用过。

assert_not_called()
# 断言该mock没有被调用过

Input: ["flower","flow","flight"]
Output: "fl"

Input: ["dog","racecar","car"]
Output: ""
Explanation: There is no common prefix among the input strings.

All given inputs are in lowercase letters a-z.

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        res = ""
        if not strs: return res
        min_len = min([len(s) for s in strs])
        for i in range(min_len):
            temp = set([s[i] for s in strs])
            if len(temp) == 1:
                res+=strs[0][i]
            else:
                break
        return res

grep -ri "test" -l /test

find /test | xargs grep -ri "test" -l

Given nums = [1,1,2],

Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.

It doesn't matter what you leave beyond the returned length.

Given nums = [0,0,1,1,1,2,2,3,3,4],

Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively.

It doesn't matter what values are set beyond the returned length.

Confused why the returned value is an integer but your answer is an array?

Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.

Internally you can think of this:s

// nums is passed in by reference. (i.e., without making a copy)
int len = removeDuplicates(nums);

// any modification to nums in your function would be known by the caller.
// using the length returned by your function, it prints the first len elements.
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        for i in range(len(nums)-1, 0, -1):
            if nums[i] == nums[i-1]:
                nums.pop(i)
        return len(nums)

rabbitmq-plugins enable rabbitmq_management
rabbitmq-server

rabbitmqctl add_user test test
rabbitmqctl set_user_tags test administrator
rabbitmqctl set_permissions -p / test ".*" ".*" ".*"

Input: 121
Output: true

Input: -121
Output: false
Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.

Input: 10
Output: false
Explanation: Reads 01 from right to left. Therefore it is not a palindrome.

class Solution(object):
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        return str(x) == str(x)[::-1]

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime

from business_rules.variables import BaseVariables
from business_rules.variables import numeric_rule_variable, string_rule_variable, select_rule_variable
from business_rules.actions import BaseActions, rule_action
from business_rules.fields import FIELD_NUMERIC, FIELD_SELECT
from business_rules import run_all


class ProductVariables(BaseVariables):

    def __init__(self, product):
        self.product = product

    @numeric_rule_variable
    def current_inventory(self):
        return self.product.current_inventory

    @numeric_rule_variable(label='Days until expiration')
    def expiration_days(self):
        last_order = self.product.orders[-1]
        return (last_order.expiration_date - datetime.date.today()).days

    @string_rule_variable()
    def current_month(self):
        return datetime.datetime.now().strftime("%B")



class ProductActions(BaseActions):

    def __init__(self, product):
        self.product = product

    @rule_action(params={"sale_percentage": FIELD_NUMERIC})
    def put_on_sale(self, sale_percentage):
        self.product.price = (1.0 - sale_percentage) * self.product.price
        self.product.save()

    @rule_action(params=[{'fieldType': FIELD_SELECT,
                          'name': 'stock_state',
                          'label': 'Stock state',
                          'options': [
                            {'label': 'Available', 'name': 'available'},
                            {'label': 'Last items', 'name': 'last_items'},
                            {'label': 'Out of stock', 'name': 'out_of_stock'}
                        ]}])
    def change_stock_state(self, stock_state):
        self.product.stock_state = stock_state
        self.product.save()


rules = [
# expiration_days < 5 AND current_inventory > 20
{ "conditions": { "all": [
      { "name": "current_inventory",
        "operator": "greater_than",
        "value": 20,
      },
  ]},
  "actions": [
      { "name": "put_on_sale",
        "params": {"sale_percentage": 0.25},
      },
  ],
},
]
class Product(object):

    def __init__(self):
        self.current_inventory = 100
        self.price = 1

    def save(self):
        print("save....{},{}".format(self.current_inventory, self.price))
        
product = Product()

run_all(rule_list=rules,
        defined_variables=ProductVariables(product),
        defined_actions=ProductActions(product),
        stop_on_first_trigger=True
       )

Input: 123
Output: 321

Input: -123
Output: -321

Input: 120
Output: 21

class Solution(object):
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        neg = False
        if x<0:
            x = x*-1
            neg = True
        s = str(x)[::-1]
        n = int(s)
        if neg:
            n = n*-1
        if abs(n)>(2**31-1):
            return 0
        return n

<template>
  <div id="app">
    <!-- <img src="./assets/logo.png"> -->
      <p v-if="seen">现在你看到我了</p>
      <ol>
        <li v-for="(todo,index) of todos" :key="index" >
          {{ todo.text }}
        </li>
      </ol>
  </div>
</template>

<script>
export default {
  name: 'App',
  data () {
    return {
      seen: true,
      todos: [
        {'text': '测试1'},
        {'text': '测试2'},
        {'text': '测试3'},
        {'text': '测试4'},
        {'text': '测试5'}
      ]
    }
  }
}
</script>

<style>
#app {
  font-family: 'Avenir', Helvetica, Arial, sans-serif;
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
  text-align: center;
  color: #2c3e50;
  margin-top: 60px;
}
</style>

 <template>
    <h3>{{ title }}</h3>
</template>
<script>
export default{
  name: 'vheader',
  data () {
    return {
    }
  },
  props: ['title']
}
</script>

 <template>
  <div id="app">
    <!-- <img src="./assets/logo.png"> -->
      <vhead title="测试组件1"></vhead>
      <vhead title="测试组件2"></vhead>
      <vhead title="测试组件3"></vhead>

  </div>
</template>

<script>
import vhead from './components/vhead'
export default {
  name: 'App',
  components: {vhead}
}
</script>

<style>
#app {
  font-family: 'Avenir', Helvetica, Arial, sans-serif;
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
  text-align: center;
  color: #2c3e50;
  margin-top: 60px;
}
</style>

log_format main 'remote_addr=[$remote_addr] http_x_forward=[$http_x_forwarded_for] time=[$time_local] request=[$request] '
    'status=[$status] byte=[$bytes_sent] elapsed=[$request_time] refer=[$http_referer] body=[$request_body] '
    'upstream_response_time=[$upstream_response_time] ';

$remote_addr    #记录访问网站的客户端地址
$http_x_forwarded_for    #当前端有代理服务器时，设置web节点记录客户端地址的配置，此参数生效的前提是代理服务器也要进行相关的x_forwarded_for设置
$time_local    #记录访问时间与时区
$request   #用户的http请求起始行信息
$status    #http状态码，记录请求返回的状态码
$bytes_sent   #http状态码，记录请求返回的状态码
$request_time   #整个请求的总时间  
$http_referer  #url跳转来源  
$request_body   #请求报文中body内容
$upstream_response_time   #请求过程中，upstream响应时间

access_log  xxxx(path) main;

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        length = len(nums)
        if length <= 1:
            return []
        for i in range(length-1):
             for j in range(i+1, length):
                    if nums[i]+nums[j]==target:
                        return [i,j]
        return []