位运算做加减乘除

位运算做加法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
//1、递归形式实现
int add(int a ,int b){
    if (b == 0)
        return a;
    else{
        int carry = (a & b) << 1;
        a = a ^b;
        return add(a,carry);
    }
}
 
//非递归形式实现
int add2(int a ,int b){
    int carry;
    while (b != 0){
        carry = (a & b) << 1;
        a = a ^ b;
        b = carry;
    }
    return a;
}

位运算做减法

1
2
3
4
int subtraction(int a ,int b){
     b = ~b+1;
     return this.add(a,b);
}

位运算做乘法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
//a 被乘数，b 乘数
int multiplication(int a,int b){
    int i = 0;
    int res = 0;
    //乘数不为0
    while (b != 0){
        //处理当前位
        //当前位是1
       if ((b & 1) == 1){
           res += (a << i);
           b = b >> 1;
           //记录当前是第几位
           i++;
       }else {
           //当前位是0
           b = b >> 1;
           i++;
       }
   }
   return res;
}

位运算做除法

1
2
3
4
5
6
7
8
9
10
 
int division(int a,int b){
    int res;
    if(a<b){
        return 0;
    }else{
        res=division(subtraction(a, b), b)+1;
    }
    return res;
}

展开全文 >>

队列的最大值 

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
请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。

若队列为空，pop_front 和 max_value 需要返回 -1

示例 1：

输入: 
["MaxQueue","push_back","push_back","max_value","pop_front","max_value"]
[[],[1],[2],[],[],[]]
输出: [null,null,null,2,1,2]
示例 2：

输入: 
["MaxQueue","pop_front","max_value"]
[[],[],[]]
输出: [null,-1,-1]
 

限制：

1 <= push_back,pop_front,max_value的总操作数 <= 10000
1 <= value <= 10^5
通过次数48,113提交次数101,452

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/dui-lie-de-zui-da-zhi-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

因为求队列的最大值不会改变队列中的元素的数量，所以只需要维护一个双端辅助队列

辅助队列中维护最大值的递减序列，当插入一个元素时：

  • 如果这个元素之前的元素都小于他，那么这个元素在他前面的元素弹出之前，都是最大值，所以在最大值队列中，当前插入值之前的元素都可以删除了。
  • 如果这个元素小于队列中之前的最后一个元素，那么将其插入，当他前面的元素被弹出时，他就是最大的元素。

如果需要查询最大元素，那么只需要查询队头的元素。
当真正维护所有元素的队列中的某个元素删除时，只需要判断当前删除的元素是不是最大值队列中的第一个元素就可以继续维护最大元素。

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
35
36
37
38
39
class MaxQueue {
    Queue<Integer> queue;
    Deque<Integer> maxQueue;
    public MaxQueue() {
        queue = new LinkedList<>();
        maxQueue = new LinkedList<>();
    }

    public int max_value() {
        if (maxQueue.isEmpty()) return -1;
        return maxQueue.peek();
    }

    public void push_back(int value) {
        while (!maxQueue.isEmpty() && maxQueue.peekLast() < value) {
            maxQueue.pollLast();
        }
        maxQueue.offerLast(value);
        queue.offer(value);
    }

    public int pop_front() {
        if (queue.isEmpty()) return -1;

        int res = queue.poll();
        if (res == maxQueue.peekFirst()) {
            maxQueue.pollFirst();
        }
        return res;
    }
}

/**
 * Your MaxQueue object will be instantiated and called as such:
 * MaxQueue obj = new MaxQueue();
 * int param_1 = obj.max_value();
 * obj.push_back(value);
 * int param_3 = obj.pop_front();
 */

参考文献

作者：LeetCode-Solution 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

展开全文 >>

滑动窗口的最大值 

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
给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。

示例:

输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7] 
解释: 

  滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7
 

提示：

你可以假设 k 总是有效的，在输入数组不为空的情况下，1 ≤ k ≤ 输入数组的大小。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
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
35
36
37
38
39
40
41
42
43
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length == 0)return new int[]{};
        if (nums.length < k) return new int[]{};
        int[] res = new int[nums.length - k + 1];
        int n = nums.length - 1;
        int windowEnd = Math.min(k, n);

        int maxIndex = getMaxIndex(nums, 0, Math.min(k, n));    //计算开始时滑动窗口的最大值的index

        for (int i = 0; i <= n - k + 1; i++) {
            windowEnd = Math.min(i + k - 1, n);                 //计算滑动窗口的右边的index

            if (maxIndex >= i && maxIndex <= windowEnd) {       //判断当前的最大值是否过期
                if (nums[windowEnd] > nums[maxIndex]) {         //如果滑动窗口的最右边的值大于当前的最大值，那么替换最大值的index
                    maxIndex = windowEnd;
                    res[i] = nums[windowEnd];
                } else {                                        //如果滑动窗口的最大值不小于最右边新进来的值，并且当前的最大值没有过期
                    res[i] = nums[maxIndex];
                }
            } else {                                            //如果滑动窗口过期了，重新查找最大值的index
                maxIndex = getMaxIndex(nums, i, windowEnd);
                res[i] = nums[maxIndex];
            }
        }

        return res;
    }

    //获取一个窗口中的最大值的index
    public int getMaxIndex(int[] nums, int start, int end) {
        if (end <= start) return start;
        int max = Integer.MIN_VALUE, index = start;
        for (int i = start; i <= end; i++) {
            if (nums[i] > max) {
                index = i;
                max = nums[i];
            }
        }
        return index;
    }
}

使用双端队列维护窗口中的最大值

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
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
         if (nums.length == 0) return new int[]{};
        int[] result = new int[nums.length - k + 1];

        Deque<Integer> maxQueue = new LinkedList<>();

        for (int i = 0; i < k; i++) {                                                       //维护最大值队列
            while (!maxQueue.isEmpty() && nums[maxQueue.peekLast()] < nums[i]) {            //如果在一个窗口中，队列前面的某个值小于当前加入队列的值，那么窗口中目前的最大值一定是当前加入队列的值，就可以把前面的值删掉
                maxQueue.pollLast();
            }
            maxQueue.offerLast(i);                                                          //如果当前加入的值小于队列最后的值，那么他就补在最后，等他前面的最大值过期后，他有可能变成窗口中的最大值
        }

        result[0] = nums[maxQueue.peekFirst()];
        for (int i = 1; i < nums.length - k + 1; i++) {
            int windowEnd = i + k - 1;                                                      //计算窗口的最右端位置
            while (!maxQueue.isEmpty() && nums[maxQueue.peekLast()] < nums[windowEnd]) {
                maxQueue.pollLast();
            }
            maxQueue.offerLast(windowEnd);
            if (maxQueue.peekFirst() < i) {                                                 //最大值队列中的元素过期
                maxQueue.pollFirst();                                                       //删除最大值队列中过期的元素
            }
            result[i] = nums[maxQueue.peekFirst()];                                         //当前的最大值
        }

        return result;
    }
}

展开全文 >>

数组中数字出现的次数2

剑指 Offer 56 - II. 数组中数字出现的次数 II

难度中等122收藏分享切换为英文接收动态反馈

在一个数组 nums 中除一个数字只出现一次之外，其他数字都出现了三次。请找出那个只出现一次的数字。

示例 1：

1
2
输入：nums = [3,4,3,3]
输出：4

示例 2：

1
2
输入：nums = [9,1,7,9,7,9,7]
输出：1

限制：

  • 1 <= nums.length <= 10000
  • 1 <= nums[i] < 2^31

求每一位的数字

一个数组中某个元素只出现一次，其余数字出现m次，只需对每个数字的每一位求和，然后对每一位模m即可得到的每一位是只出现一次数字的每一位的数字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Solution {
    public int singleNumber(int[] nums) {
        int[] count = new int[32];              //保存每一位数字的和的结果

        for (int num : nums) {                  //对于每个数字，求其每一位的和到count数组
            for (int i = 0; i < 32; i++) {
                count[i] += num & 1;
                num = num >>> 1;
            }
        }
        int res = 0, m = 3;
        for (int i = 0; i < 32; i++) {          //对每一位的数字求模m，得到单独出现的那个数字的每一位的数字
            res <<= 1;
            res |= count[31 - i] % m;           //恢复原来的只出现一次的数字
        }
        return res;
    }
}

参考文献

面试题56 - II. 数组中数字出现的次数 II（位运算 + 有限状态自动机，清晰图解）Krahets发布于 2020-04-23

展开全文 >>

数组中数字出现的次数(重要题型)

剑指 Offer 56 - I. 数组中数字出现的次数

难度中等

一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。

示例 1：

1
2
输入：nums = [4,1,4,6]
输出：[1,6] 或 [6,1]

示例 2：

1
2
输入：nums = [1,2,10,4,1,4,3,3]
输出：[2,10] 或 [10,2]

限制：

  • 2 <= nums.length <= 10000

如果一个数组中除了一个数字以外，其他数字都出现了两次，那么如何找到出现一次的数字？

对全部数字异或操作即可得到结果，原因如下：

对于两个操作数的每一位，相同的时候结果位0，不同的时候结果为1.那么在计算的过程中，成对出现的数字的所有位会两两抵消为0，最终得到的结果就是那个在数组中只出现一次的数字。

如果可以把所有的数字分成两组，使得：

  • 两个只出现一次的数字分在不同的组中；
  • 出现两次的数字分在相同的组中；

那么这个问题就可以解决。

avatar

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Solution {
    public int[] singleNumbers(int[] nums) {
        int ret = 0;
        for (int i = 0; i < nums.length; i++) {
            ret = ret ^ nums[i];
        }

        int index = 1;
        while ((index & ret) == 0) {
            index = index << 1;
        }

        int number1 = 0, number2 = 0;

        for (int num : nums) {
            if ((num & index) == 0) number1 ^= num;
            else number2 ^= num;
        }

        return new int[]{number1, number2};
    }
}

参考文献

作者：LeetCode-Solution
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

展开全文 >>

分发糖果 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。

你需要按照以下要求，帮助老师给这些孩子分发糖果：

每个孩子至少分配到 1 个糖果。
相邻的孩子中，评分高的孩子必须获得更多的糖果。
那么这样下来，老师至少需要准备多少颗糖果呢？

示例 1:

输入: [1,0,2]
输出: 5
解释: 你可以分别给这三个孩子分发 2、1、2 颗糖果。
示例 2:

输入: [1,2,2]
输出: 4
解释: 你可以分别给这三个孩子分发 1、2、1 颗糖果。
     第三个孩子只得到 1 颗糖果，这已满足上述两个条件。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/candy
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
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
35
class Solution{
    public static int candy(int[] ratings) {
        if (ratings.length == 0) return 0;
        if (ratings.length < 2) return 1;

        int[] candy = new int[ratings.length];
        Arrays.fill(candy, 1);                                  //每个孩子必须有一颗糖

        if (ratings[0] > ratings[1]) {                               //第0个孩子，边界条件
            candy[0]++;
        }

        for (int i = 1; i < ratings.length; i++) {                   //从前往后，如果后面的孩子的得分大于当前的孩子的得分，后面的孩子的糖比当前孩子多一个
            if (ratings[i] > ratings[i - 1]) {
                candy[i] = candy[i - 1] + 1;
            }
        }
        for (int i = ratings.length - 1; i > 0; i--) {               //从后往前，如果前面的孩子的得分大于后面的孩子，
                                                                     //那么要看前面孩子的糖的数量是否已经大于后面的孩子，
                                                                     //如果已经大于了，那么只需要再分给他一块，
                                                                     //如果没有大于，直接把后面孩子糖的数量加1给前面的孩子（原来的糖收回）
            if (ratings[i - 1] > ratings[i]) {
                if (candy[i - 1] <= candy[i]) {
                    candy[i - 1] = Math.max(candy[i - 1] + 1, candy[i] + 1);
                }
            }
        }

        int sum = 0;
        for (int i = 0; i < candy.length; i++) {                    //统计分发的糖的数量
            sum += candy[i];
        }
        return sum;
    }
}
  • 如果当前同学比上一个同学评分高，说明我们就在最近的递增序列中，直接分配给该同学 pre+1 个糖果即可。
  • 否则我们就在一个递减序列中，我们直接分配给当前同学一个糖果，并把该同学所在的递减序列中所有的同学都再多分配一个糖果，以保证糖果数量还是满足条件。

    • 我们无需显式地额外分配糖果，只需要记录当前的递减序列长度，即可知道需要额外分配的糖果数量。

    • 同时注意当当前的递减序列长度和上一个递增序列等长时，需要把最近的递增序列的最后一个同学也并进递减序列中。

    这样，我们只要记录当前递减序列的长度dec，最近的递增序列的长度inc 和前一个同学分得的糖果数量pre 即可。

    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 {
        public int candy(int[] ratings) {
            int n = ratings.length;
            int ret = 1;
            int inc = 1, dec = 0, pre = 1;
            for (int i = 1; i < n; i++) {
                if (ratings[i] >= ratings[i - 1]) {
                    dec = 0;                                            //递减序列的长度
                    pre = ratings[i] == ratings[i - 1] ? 1 : pre + 1;   //前一个同学得分的糖果数量
                    ret += pre;
                    inc = pre;                                          //递增序列的长度
                } else {
                    dec++;
                    if (dec == inc) {
                        dec++;
                    }
                    ret += dec;
                    pre = 1;
                }
            }
            return ret;
        }
    }


    参考文献

    作者：LeetCode-Solution 来源：力扣（LeetCode）著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

    展开全文 >>

    圆圈中最后剩下的数字 

    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
    0,1,,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字。求出这个圆圈里剩下的最后一个数字。

    例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。

     

    示例 1：

    输入: n = 5, m = 3
    输出: 3
    示例 2：

    输入: n = 10, m = 17
    输出: 2
     

    限制：

    1 <= n <= 10^5
    1 <= m <= 10^6
    通过次数59,060提交次数92,866

    来源：力扣（LeetCode）
    链接：https://leetcode-cn.com/problems/yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-lcof
    著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

    我们有n个数，下标从0到n-1，然后从index=0开始数，每次数m个数，最后看能剩下谁。我们假设能剩下的数的下标为y，则我们把这件事表示为

    f(n,m) = y
    这个y到底表示了啥呢？注意，y是下标，所以就意味着你从index=0开始数，数y+1个数，然后就停，停谁身上谁就是结果。

    行了，我们假设f(n-1,m)=x，然后来找一找f(n,m)和f(n-1,m)到底啥关系。

    f(n-1,m)=x意味着啥呢？意味着有n-1个数的时候从index=0开始数，数x+1个数你就找到这结果了。那我不从index=0开始数呢？比如我从index=i开始数？那很简单，你把上面的答案也往后挪i下，就得到答案了。当然了，你要是挪到末尾了你就取个余，从头接着挪。

    于是我们来思考f(n,m)时考虑以下两件事：

    有n个数的时候，要划掉一个数，然后就剩n-1个数了呗，那划掉的这个数，下标是多少？
    划完了这个数，往后数，数x+1个数，停在谁身上谁就是我们的答案。当然了，数的过程中你得取余
    问题一：有n个数的时候，划掉了谁？下标是多少？

    因为要从0数m个数，那最后肯定落到了下标为m-1的数身上了，但这个下标可能超过我们有的最大下标（n-1）了。所以攒满n个就归零接着数，逢n归零，所以要模n。

    所以有n个数的时候，我们划掉了下标为(m-1)%n的数字。

    问题二：我们划完了这个数，往后数x+1下，能落到谁身上呢，它的下标是几？

    你往后数x+1，它下标肯定变成了(m-1)%n +x+1，和第一步的想法一样，你肯定还是得取模，所以答案为[(m-1)%n+x+1]%n，则

    1
    f(n,m)=[(m-1)%n+x+1]%n

    其中x=f(n-1,m)

    定理一：两个正整数a，b的和，模另外一个数c，就等于它俩分别模c，模完之后加起来再模。

    1
    (a+b)%c=((a%c)+(b%c))%c

    定理二：一个正整数a，模c，模一遍和模两遍是一样的。

    1
    a%c=(a%c)%c

    所以

    1
    2
    3
    4
    5
    f(n,m)=[(m-1)%n+x+1]%n
          =[(m-1)%n%n+(x+1)%n]%n
          =[(m-1)%n+(x+1)%n]%n
          =(m-1+x+1)%n
          =(m+x)%n

    递归

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class Solution {
        public int lastRemaining(int n, int m) {
            return f(n, m);
        }

        public int f(int n, int m) {
            if (n == 1) {
                return 0;
            }
            int x = f(n - 1, m);
            return (m + x) % n;
        }
    }

    自底向上

    1
    2
    3
    4
    5
    6
    7
    8
    9
    class Solution {
        public int lastRemaining(int n, int m) {
            int last = 0;                       //当n==0时，结果是0
            for (int i = 2; i <= n; i++) {
                last = (last + m) % i;          //自底向上时，前面的计算结果就是后面的(m + x) % n;中的x的值
            }
            return last;
        }
    }

    参考文献

    Lucien的评论

    圆圈中最后剩下的数字:著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

    展开全文 >>

    和为s的连续正数序列 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。

    序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。

    示例 1：

    输入：target = 9
    输出：[[2,3,4],[4,5]]
    示例 2：

    输入：target = 15
    输出：[[1,2,3,4,5],[4,5,6],[7,8]]

    限制：

    1 <= target <= 10^5

    通过次数71,225提交次数102,616

    来源：力扣（LeetCode）
    链接：https://leetcode-cn.com/problems/he-wei-sde-lian-xu-zheng-shu-xu-lie-lcof
    著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

    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
    class Solution{
        public static int[][] findContinuousSequence(int target) {
            //终止条件，target/2+1
            int left = 1, right = 0;
            int end = target / 2 + 1;

            List<int[]> resList = new ArrayList<>();

            int sum = 0;
            while (right <= end) {

                if (sum < target) {                                     //和小于target，向右移
                    right++;
                    sum += right;
                } else if (sum > target) {                              //和大于target，左边的右移
                    sum -= left;
                    left++;
                } else {
                    int[] res = new int[right - left + 1];
                    for (int i = 0; i + left <= right; i++) {
                        res[i] = left + i;
                    }
                    resList.add(res);
                    sum -= left;                                        //本次结束，左边的先移动，先把左边的值减去
                    left++;                                             
                }

            }

            return resList.toArray(new int[resList.size()][]);
        }
    }

    展开全文 >>

    两数之和 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。

    示例 1：

    输入：nums = [2,7,11,15], target = 9
    输出：[2,7] 或者 [7,2]
    示例 2：

    输入：nums = [10,26,30,31,47,60], target = 40
    输出：[10,30] 或者 [30,10]

    限制：

    1 <= nums.length <= 10^5
    1 <= nums[i] <= 10^6
    通过次数59,220提交次数90,115

    来源：力扣（LeetCode）
    链接：https://leetcode-cn.com/problems/he-wei-sde-liang-ge-shu-zi-lcof
    著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

    双指针

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class Solution {
        public int[] twoSum(int[] nums, int target) {
            int left = 0, right = nums.length - 1;
            while (left < right) {
                if (target - nums[left] < nums[right]) right--;
                else if (target - nums[left] > nums[right]) left++;
                else return new int[]{nums[left], nums[right]};
            }
            return new int[]{};
        }
    }

    展开全文 >>

    tag:

      缺失模块。
      1、请确保node版本大于6.2
      2、在博客根目录（注意不是yilia根目录）执行以下命令：
      npm i hexo-generator-json-content --save

      3、在根目录_config.yml里添加配置： 

        jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

    我是一只<br>又水又笨又菜的<br>菜狗子<br>希望有一天被领走