精华内容
下载资源
问答
  • python求和函数sum()详解

    万次阅读 多人点赞 2019-04-06 21:32:44
    python求和函数sum()详解 今天在学习的过程中,误用sum()函数,我又去查了查python sum()函数才恍然大悟。 我本来想算几个Int值相加的和,本以为很简单的事情,结果却很悲伤,例: >>>sum = sum(1,2,3) #...

    python求和函数sum()详解

    今天在学习的过程中,误用sum()函数,我又去查了查python sum()函数才恍然大悟。

    我本来想算几个Int值相加的和,本以为很简单的事情,结果却很悲伤,例:

    >>>sum = sum(1,2,3)         #结果很明显出现问题报错
    TypeError: sum expected at most 2 arguments, got 3
    

    傻乎乎的我以为只能算前两个数的和等于3,就又试了一下

    >>>sum = sum(1,2)           #结果还是报错
    TypeError: 'int' object is not iterable
    

    其实,我们所了解sum()函数语法是这样的
    sum(iterable[, start])

    其中

    • iterable – 可迭代对象,如:列表(list)、元组(tuple)、集合(set)、字典(dictionary)。

    • start – 指定相加的参数,如果没有设置这个值,默认为0。

    也就是说sum()最后求得的值 = 可迭代对象里面的数加起来的总和(字典:key值相加) + start的值(如果没写start的值,则默认为0) 所以,我所求的几个int值的和可以写成这样

    >>>sum = sum([1,2,3])             # in list
    6
    

    如果我们加上start的话,应该是这样的

    >>> sum = sum([1,2,3],5)          #in list +start
    11
    >>> sum = sum((1,2,3))            #in tuple
    6
    >>> sum = sum({1,2,3})            #in set
    6
    >>> sum = sum({1:5,2:6,3:7})      #in dictionary key
    6
    >>> sum = sum(range(1,4))         #in range()
    6      
    

    学习这些过后,我们就可以正确的运用sum()函数了。

    别指望着看一遍就能记住和整掌握什么 – 请看第二遍,第三遍。

    展开全文
  • Prefix Sum 总结

    千次阅读 2020-03-23 14:41:54
    Interval Sum Given an integer array (index from 0 to n-1, where n is the size of this array), and an query list. Each query has two integers[start, end]. For each query, calculate the sum number bet....

    注意:prefixsum一般都是用PrefixSum[n+1]的数组,prefix[0] = 0; 那么

    因为i, j 是A里面的坐标,而prefixsum比A多了1;所以原来的sum[j] - sum[i-1]变成了

    sum(i~j) = prefixsum(j + 1) - prefixsum(i);

    Interval Sum 思路:因为这个题目不需要modify数组操作,所以用prefix sum array就可以解决,O(N + M) N是数组大小,M是query次数;

    /**
     * Definition of Interval:
     * public classs Interval {
     *     int start, end;
     *     Interval(int start, int end) {
     *         this.start = start;
     *         this.end = end;
     *     }
     * }
     */
    
    public class Solution {
        /**
         * @param A: An integer list
         * @param queries: An query list
         * @return: The result list
         */
        public List<Long> intervalSum(int[] A, List<Interval> queries) {
            List<Long> list = new ArrayList<>();
            int n = A.length;
            long[] prefixsum = new long[n + 1];
            prefixsum[0] = 0;
            for(int i = 1; i <= n; i++) {
                prefixsum[i] = prefixsum[i - 1] + A[i - 1];
            }
            
            for(Interval interval: queries) {
                list.add(prefixsum[interval.end + 1] - prefixsum[interval.start]);
            }
            return list;
        }
    }

     Subarray Sum 用prefixsum, A[i ~ j] = 0; 相当于 S[i-1] == S[j],也就是在数组里面找相等的数;hashmap, 存 S[i], i 就可以了;一定要存index;注意用hashmap put(0,0)因为是为了如果有sum直接== 0, 那么length应该是i - 0 = i;

    public class Solution {
        /**
         * @param nums: A list of integers
         * @return: A list of integers includes the index of the first number and the index of the last number
         */
        public List<Integer> subarraySum(int[] nums) {
            List<Integer> res = new ArrayList<>();
            if(nums == null || nums.length == 0) {
                return res;
            }
            int n = nums.length;
            int[] prefixSum = new int[n + 1];
            prefixSum[0] = 0;
            for(int i = 1; i <= n; i++) {
                prefixSum[i] = prefixSum[i - 1] + nums[i - 1];
            }
    
            HashMap<Integer, Integer> hashmap = new HashMap<>();
            hashmap.put(0, 0);
    
            for(int i = 1; i <= n; i++) {
                if(hashmap.containsKey(prefixSum[i])) {
                    // -1:prefixsum的index都要-1,才能map到原来的array index上;
                    // +1:A[i...j] == 0 -> sum[j] == sum[i - 1]; 求i, 所以要+1;
                    res.add(hashmap.get(prefixSum[i] - 1 + 1));
                    res.add(i - 1);
                }
                hashmap.put(prefixSum[i], i);
            }
            return res;
        }
    }

    Subarray Sum II

    思路:固定右边界aj, 问题转换为找左边的两个边界,

    XXXVVVVVVVVXXXXX aj

    .....ai .................ak ........ aj

         <=end        >=start 

    这两个区间都是可以用双指针来计算得到的,O(N)

    Prefix Sum 现在用n+1数组来求;

    public class Solution {
        /**
         * @param A: An integer array
         * @param start: An integer
         * @param end: An integer
         * @return: the number of possible answer
         */
        public int subarraySumII(int[] A, int start, int end) {
            if(A == null || A.length == 0) {
                return 0;
            }
            int n = A.length;
            int[] prefixSum = new int[n + 1];
            prefixSum[0] = 0;
            for(int i = 1; i <= n; i++) {
                prefixSum[i] = prefixSum[i - 1] + A[i - 1];
            }
    
            int res = 0;
            /**
            XXXXXXVVVVVVVVVXXXXXX j
              >end         <start
              left          right
            */
            int left = 0, right = 0;
            for(int j = 1; j <= n; j++) {
                while(right < j && prefixSum[j] - prefixSum[right] >= start) {
                    right++;
                }
                while(left < j && prefixSum[j] - prefixSum[left] > end) {
                    left++;
                }
                res += (right - left);
            }
            return res;
        }
    }

    Subarray Sum Closest 思路:将prefixsum的array,排序,然后比较相邻的两个sum,如果求diff最小的,注意;如果prefixsum == 0,则不用找了,找了个最佳答案,否则看最相近的;

    public class Solution {
        /*
         * @param nums: A list of integers
         * @return: A list of integers includes the index of the first number and the index of the last number
         */
        private class Node {
            public int index;
            public int sum;
            public Node(int index, int sum) {
                this.index = index;
                this.sum = sum;
            }
        }
        
        public int[] subarraySumClosest(int[] nums) {
            int[] res = new int[2];
            if(nums == null || nums.length == 0) {
                return res;
            }
            int n = nums.length;
            int[] sum = new int[n + 1];
            sum[0] = 0;
            List<Node> list = new ArrayList<Node>();
            for(int i = 1; i <= n; i++) {
                sum[i] = sum[i - 1] + nums[i - 1];
                if(sum[i] == 0) {
                    res[0] = 0;
                    res[1] = i - 1;
                    return res;
                }
                list.add(new Node(i, sum[i]));
            }
            Collections.sort(list, (a, b) ->(a.sum - b.sum));
            
            int diff = Integer.MAX_VALUE;
            for(int i = 0; i < list.size() - 1; i++) {
                int curdiff = list.get(i + 1).sum - list.get(i).sum;
                if(curdiff < diff) {
                    diff = curdiff;
                    // sum[i, j] = S[j] - S[i - 1], 所以真正的区间是: [i + 1, j]
                    if(list.get(i).index < list.get(i + 1).index) {
                        res[0] = list.get(i).index;
                        res[1] = list.get(i + 1).index - 1;
                    } else {
                        res[0] = list.get(i + 1).index;
                        res[1] = list.get(i).index - 1;
                    }
                }
            }
            return res;
        }
    }

    Submatrix Sum 用prefixsum,代表是从(0,0) 到(i,j) 的区域sum。然后固定上边界和下边界,然后扫描j,用hashmap来找有没有重复的区域,如果有就找到了区域为0的,然后记录答案,注意,因为prefixsum是+1了的index,所以,最后右下角的点需要减去1,左上角的点因为默认+1,所以不用减去1了。 O(N^3); Space O(N^2);

    public class Solution {
        /*
         * @param matrix: an integer matrix
         * @return: the coordinate of the left-up and right-down number
         */
        public int[][] submatrixSum(int[][] matrix) {
            int[][] res = new int[2][2];
            if(matrix == null || matrix.length == 0 || matrix[0].length == 0) {
                return res;
            }
            int m = matrix.length;
            int n = matrix[0].length;
    
            int[][] prefixSum = new int[m + 1][n + 1];
            for(int i = 0; i <= m; i++) {
                for(int j = 0; j <= n; j++) {
                    if(i == 0 || j == 0) {
                        prefixSum[i][j] = 0;
                    } else {
                        prefixSum[i][j] = prefixSum[i - 1][j] + prefixSum[i][j - 1] - prefixSum[i - 1][j - 1] + matrix[i - 1][j - 1];
                    }
                }
            }
            
            for(int x1 = 0; x1 < m; x1++) {
                for(int x2 = x1 + 1; x2 <= m; x2++) {
                    // 记住,这里每次循环都要新建一个hashmap;
                    HashMap<Integer, Integer> hashmap = new HashMap<>();
                    for(int j = 0; j <= n; j++) {
                        int area = prefixSum[x2][j] - prefixSum[x1][j];
                        if(hashmap.containsKey(area)) {
                            int k = hashmap.get(area);
                            res[0][0] = x1;
                            res[0][1] = k;
                            res[1][0] = x2 - 1;
                            res[1][1] = j - 1;
                        } else {
                            hashmap.put(area, j);
                        }
                    }
                }
            }
            return res;
        }
    }

    Lintcode: Continuous Subarray Sum 思路:

    思路:用prefixsum来做,求最大,那么就跟股票那题一样,存一个最小,然后每次跟最小比差,如果大,记录下来。注意prefixsum的index默认是+1了的,所以result是[start, i - 1];

    是因为sum[i, j] = S[j] - S[i - 1], = prefixsum[j + 1] - prefixsum[i], prefixsum里面的index是原来数组的index + 1所形成。所以在prefixsum的index要还原成原来array的index都要减去1,然而,S[j] - S[i - 1] == Sum[i,j],所以求i的范围,需要把start +1,这样start + 1 - 1=start, end - 1,就是对应原来数组的index了;

    public class Solution {
        /*
         * @param A: An integer array
         * @return: A list of integers includes the index of the first number and the index of the last number
         */
        public List<Integer> continuousSubarraySum(int[] A) {
            List<Integer> list = new ArrayList<Integer>();
            if(A == null || A.length == 0) {
                return list;
            }
            int sum = 0;
            int minsum = 0;
            int max = Integer.MIN_VALUE;
            int start = 0, end = 0;
            list.add(start); 
            list.add(end);
            int n = A.length;
            for(int i = 1; i <= n; i++) {
                sum += A[i - 1];
                if(sum - minsum > max) {
                    max = sum - minsum;
                    list.set(0, start);
                    list.set(1, i - 1);
                }
                if(sum < minsum) {
                    minsum = sum;
                    start = i;
                }
            }
            return list;
        }
    }

    [LeetCode Continuous Subarray Sum] 思路:这题算法是根据(a + n*k) % k == a % k, 所以 [23,2,6,4,7] k = 6, the running sum is [23,25,31,35,42] and the remainders are [5,1,1,5,0]. We got remainder 5 at index 0 and at index 3. That means, in between these two indexes we must have added a number which is multiple of the k.  也就是跟two sum类似,如果存 ( cursum % k )余数和index,那么如果我又遇见了同样的余数,那么代表中间肯定有个subarray 和是n * k. 注意这题tricky的地方是: [0,0] 0 或者[6,6] 6 这种,如果map.put(0,0)会返回false,处理的方法就是map.put(0,-1)这样代表余数是0的情况可以有1 个,我遇见的下一个,肯定可以判断是len > 1 从而返回true

    class Solution {
        public boolean checkSubarraySum(int[] nums, int k) {
            if(nums == null || nums.length == 0) {
                return false;
            }
            HashMap<Integer, Integer> hashmap = new HashMap<>();
            // value = -1 is due to the fact that the size of the subarray is required to be least two
            // 因为key 是sum,value是index,题目要求array at least 2.所以,如果找到一个sum,另外一个index 减去current index,就必须 > 1; 所以存-1;
            hashmap.put(0, -1); 
            int cursum = 0;
            for(int i = 0; i < nums.length; i++) {
                cursum += nums[i];
                if(k != 0) {
                    cursum = cursum % k;
                }
                Integer pre = hashmap.get(cursum);
                if(pre != null) {
                    if(i - pre > 1) {
                        return true;
                    }
                } else {
                    hashmap.put(cursum, i);
                }
            }
            return false;
        }
    }

    Range Sum Query - Immutable Prefix 模板,Sum[i, j] = prefixsum[j + 1] - prefixsum[i]; 

    class NumArray {
        private int[] prefixsum;
        public NumArray(int[] nums) {
            int n = nums.length;
            this.prefixsum = new int[n + 1];
            for(int i = 1; i <= n; i++) {
                prefixsum[i] = prefixsum[i - 1] + nums[i - 1];
            }
        }
        
        public int sumRange(int i, int j) {
            return prefixsum[j + 1] - prefixsum[i];
        }
    }
    
    /**
     * Your NumArray object will be instantiated and called as such:
     * NumArray obj = new NumArray(nums);
     * int param_1 = obj.sumRange(i,j);
     */

    Subarray Sum Equals K 思路:用prefixsum prefixsum[j+1] - prefixsum[i] = k,  O(N^2) 优化就是:类似2sum,用hashmap优化,注意先判断是否含有,再加入,否则会有重复计算;O(N) Space O(N);

    class Solution {
        public int subarraySum(int[] nums, int k) {
            if(nums == null || nums.length == 0) {
                return 0;
            }
            int n = nums.length;
            int cursum = 0;
            
            //       sum      frequency;
            HashMap<Integer, Integer> hashmap = new HashMap<>();
           
            int count = 0;
            for(int i = 0; i < nums.length; i++) {
                cursum += nums[i];
                if(cursum == k) {
                    count++;
                }
                // 存prefixsum - k, 也就是之前的比较小的数,这样在后面一旦碰见,那么就表示相吻合,a - b = k;
                // count已经加过1了,那么这里只需要加入之前的频率。
                if(hashmap.containsKey(cursum - k)) {
                    count += hashmap.get(cursum - k);
                }
                // hashmap里面的频率要+1;
                hashmap.put(cursum, hashmap.getOrDefault(cursum, 0) + 1);
            }
            return count;
        }
    }

    Number of Submatrices That Sum to Target   这类矩阵的题目,就矩阵和,都是prefixsum的思路,这里比较巧妙的是,用每一行的prefixsum来求解,i, j 是start col, end col, k是row,相当于从右往左投影计算array[k], 把j往左投影,然后array 其实是一个竖着的矩阵往左投影sum的结果。问题就变成了560. Subarray Sum Equals K , 注意hashmap每次都要重新生成,因为i, j  变化了,那么相当于每次生成一个新的array了,所以每次都是一次新的计算; Time : O(col ^2 * row);

    class Solution {
        public int numSubmatrixSumTarget(int[][] matrix, int target) {
            int n = matrix.length;
            int m = matrix[0].length;
            int[] array = new int[n];
            
            int res = 0;
            for(int i = 0; i < m; i++) {
                Arrays.fill(array, 0);
                for(int j = i; j < m; j++) {
                    for(int k = 0; k < n; k++) { // j每次增加一格,k从上到下,都要加入对应的array[k];
                        array[k] += matrix[k][j]; // 把每一行k, [i,j] sum起来;
                    }
                    res += subarraySum(array, target);
                }   
            }
            return res;
        }
        
         public int subarraySum(int[] nums, int k) {
            if(nums == null || nums.length == 0) {
                return 0;
            }
            HashMap<Integer, Integer> hashmap = new HashMap<>();
            int sum = 0;
            int count = 0;
            for(int i = 0; i < nums.length; i++) {
                sum += nums[i];
                if(sum == k) {
                    count++;
                }
                if(hashmap.containsKey(sum - k)) {
                    count += hashmap.get(sum - k);
                }
                hashmap.put(sum, hashmap.getOrDefault(sum, 0) + 1);
            }
            return count;
        }
    }

    Find Pivot Index 思路:prefixsum的模板,注意index可以是最后一个,因为整个array sum == 0,也是可以的;

    class Solution {
        public int pivotIndex(int[] nums) {
            if(nums == null || nums.length == 0) {
                return -1;
            }
            int n = nums.length;
            int[] prefixsum = new int[n + 1];
            prefixsum[0] = 0;
            for(int i = 1; i <= n; i++) {
                prefixsum[i] = prefixsum[i - 1] + nums[i - 1];
            }
            
            for(int i = 1; i <= n; i++) {
                int leftsum = prefixsum[i - 1];
                int rightsum = prefixsum[n] - prefixsum[i];
                if(leftsum == rightsum) {
                    return i - 1;
                }
            }
            return -1;
        }
    }

    Split Array with Equal Sum 思路:先固定j,然后左边分两半,sum相等就存入hashset,然后右边分两半,sum相等,就看sum在不在hashset里面;这里presum用0开始的index,这样写prefixsum好写。严格按照// 0 < i, i + 1 < j, j + 1 < k < n - 1; 这个提示来写。

    class Solution {
        public boolean splitArray(int[] nums) {
            if(nums == null || nums.length == 0) {
                return false;
            }
            int n = nums.length;
            int[] prefixsum = new int[n];
            prefixsum[0] = nums[0];
            for(int i = 1; i < n; i++) {
                prefixsum[i] = prefixsum[i - 1] + nums[i];
            }
            
            // 0 < i, i + 1 < j, j + 1 < k < n - 1
            for(int j = 3; j < n - 3; j++) {
                HashSet<Integer> set = new HashSet<>();
                for(int i = 1; i + 1 < j; i++) {
                    if(prefixsum[i - 1] == prefixsum[j - 1] - prefixsum[i]) {
                        set.add(prefixsum[i - 1]);
                    }
                }
                
                for(int k = j + 2; k < n - 1; k++) {
                    if(prefixsum[k - 1] - prefixsum[j] == prefixsum[n - 1] - prefixsum[k]) {
                        if(set.contains(prefixsum[n - 1] - prefixsum[k])) {
                            return true;
                        }
                    }
                }
            }
            return false;
        }
    }

    Product of the Last K Numbers  思路:prefix product array,注意默认的第一位是个1,然后往后面加 list.get( list.size() - 1) * num;最后,k == n的时候,因为前面有1,所以return 0,超过了输入num的个数范围;

    class ProductOfNumbers {
    
        private ArrayList<Integer> list;
        public ProductOfNumbers() {
            list = new ArrayList();
            list.add(1); // 跟prefix一样,第一个元素add为1;
        }
        
        public void add(int num) {
            if(num == 0) {
                list.clear();
                list.add(1);
            } else {
                list.add(list.get(list.size() - 1) * num);
            }
        }
        
        public int getProduct(int k) {
            int n = list.size();
            //因为前面加了默认1,跟prefixsum一样,所以k == n 相当于k 大于了元素个数了,直接return 0;
            if(k >= n) { 
                return 0;
            } else {
                return list.get(n - 1) / list.get(n - 1 - k);
            }
        }
    }
    
    /**
     * Your ProductOfNumbers object will be instantiated and called as such:
     * ProductOfNumbers obj = new ProductOfNumbers();
     * obj.add(num);
     * int param_2 = obj.getProduct(k);
     */

    Find Two Non-overlapping Sub-arrays Each With Target Sum 这题很类似于560. Subarray Sum Equals K, 不同在于要找两个不同的subarray,那么如何找两个array就是利用dp[i]来找,dp[i]存的物理意义是,到目前subarry sum为target的最小的length,如果pre != -1 && dp[pre] != Integer.MAX_VALUE代表找到了第二array,之前还有一个array和为target;因为dp[i] = dp[i - 1];所以只有一个的话,dp[pre]会一直是integer.MAX_VALUE;

    注意:计算prefixsum的index,必须加入-1,因为前几个数和就是target,如果要算length,就是i - (-1) = i + 1;因为i是0开头的;560. Subarray Sum Equals K 那个题是用hashmap存prefixsum , frequency. 计算频率,就(0,1)如果计算index或者长度就是(0,-1)。

    class Solution {
        public int minSumOfLengths(int[] arr, int target) {
            if(arr == null || arr.length == 0) {
                return -1;
            }
            HashMap<Integer, Integer> hashmap = new HashMap<>();
            // 计算prefixsum的index,必须加入-1,因为前几个数和就是target,如果要算length,就是i - (-1) = i + 1;因为i是0开头的;
            hashmap.put(0, -1);
            int n = arr.length;
            int[] dp = new int[n];
            int res = Integer.MAX_VALUE;
            int cursum = 0;
            for(int i = 0; i < arr.length; i++) {
                cursum += arr[i];
                dp[i] = i > 0 ? dp[i - 1] : Integer.MAX_VALUE;
                
                if(hashmap.containsKey(cursum - target)) {
                    int pre = hashmap.get(cursum - target);
                    dp[i] = Math.min(dp[i], i - pre);
                    
                    // 如何求得两个区间,就是用dp[i] 记录到目前为止,cursum == target的array的最小的length;
                    // 如果 pre == -1 或者dp[pre] == Integer.MAX_VALUE,代表之前只找到一个区间;如果不是,那么就是之前已经找到一个区间,现在找到了第二个区间;
                    if(pre != -1 && dp[pre] != Integer.MAX_VALUE) {
                        res = Math.min(res, dp[pre] + i - pre);
                    }
                }
                hashmap.put(cursum, i);
            }
            return res == Integer.MAX_VALUE ? -1 : res;
        }
    }

    Max Sum of Rectangle No Larger Than K 核心思想就是:每列column,从左向右投影,left, right, 是左右边界,然后sums[n] 是长度为row的投影sum,也就是prefixsum。每次移动left, right,计算出sums array之后,问题就转换为,在一个array里面,找subarray sum最接近K的sum;这里用了treeset ceiling是第一个大于input的value,num >= currsum - k; currsum - num <= k; 每次update这个currsum - num  就可以了。currsum 是累加的sum;

    注意:currusm - num 代表的就是下面的block的matrix;set.add(0); // 需要padding,是为了解决只有一个row value的情况;比如说cursum = 10, k = 10,那么就只有一个sum的话,就是要返回10,如果没有0,就会返回null,得不到sum就等于k的情况;

    class Solution {
        public int maxSumSubmatrix(int[][] matrix, int k) {
            if(matrix == null || matrix.length == 0 || matrix[0].length == 0) {
                return 0;
            }
            
            int n = matrix.length;
            int m = matrix[0].length;
            int result = Integer.MIN_VALUE;
            
            for(int left = 0; left < m; left++) {
                int[] arr = new int[n];
                for(int right = left; right < m; right++) {
                    for(int i = 0; i < n; i++) {
                        arr[i] += matrix[i][right];
                    }
                    
                    TreeSet<Integer> treeset = new TreeSet<>();
                    // 需要padding,是为了解决只有一个row value的情况;
                    // 比如说cursum = 10, k = 10,那么就只有一个sum的话,就是要返回10,如果没有0,就会返回null,得不到sum就等于k的情况;
                    treeset.add(0);
                    int cursum = 0;
                    
                    for(int prefixsum: arr) {
                        cursum += prefixsum;
                        // num >= cursum - k;
                        // k >= cursum - num;
                        Integer num = treeset.ceiling(cursum - k);
                        if(num != null) {
                            // k >= cursum - num;
                            // currusm - num 代表的就是下面的block的matrix;
                            result = Math.max(result, cursum - num);
                        }
                        treeset.add(cursum);
                    }
                }
            }
            return result;
        }
    }

    Shortest Subarray with Sum at Least K  思路:这题跟Minimum Size Subarray Sum 很相似,不同的是,加入了负数,使得问题变复杂了。思路就是:求区间和,很容易想到prefixsum,这个很好求出,但是怎么扫描去求sum>=k的最小区间长度,sum[i] .... sum[j].... sum[k] 如果sum[i] > sum[j], sum[k] - sum[i] >=k, 那么sum[k] - sum[j] 更加>=k,同时j > i,那么j到k区间会更小,那么sum[i]就没必要存,发现这个性质那么就是单调栈,前面的数sum[i], 比当前的数sum[j]要大,就没必要存,那么栈里面就是单调递增的,我们要保持里面是递增的,那么后面进来的数,如果比last要小,则踢掉前面的数,为什么?是因为如果存了,last > i, future - last >= k, 那么future - i 更加>= k, 所以 last比i大,没必要存;

    More detailed on this, we always add at the LAST position
    B[d.back] <- B[i] <- ... <- B[future id]
    B[future id] - B[d.back()] >= k && B[d.back()] >= B[i]
    B[future id] - B[i] >= k too

    前后都要进出,那么用deque可以满足要求。这里要注意一点,长度是 i - deque.peekFirst()。为什么,是因为sum[j] - sum[i] ,subarray的长度其实是i + 1,...j,那么就是j - i + 1 - 1 = j - i;

    class Solution {
        public int shortestSubarray(int[] A, int K) {
            if(A == null || A.length == 0) {
                return -1;
            }
            int n = A.length;
            int[] prefixsum = new int[n + 1];
            prefixsum[0] = 0;
            for(int i = 1; i <= n; i++) {
                prefixsum[i] = prefixsum[i - 1] + A[i - 1];
            }
            Deque<Integer> arrayDeque = new ArrayDeque<Integer>();
            int res = Integer.MAX_VALUE;
            for(int i = 0; i <= n; i++) {
                while(!arrayDeque.isEmpty() && prefixsum[i] - prefixsum[arrayDeque.peekFirst()] >= K) {
                    res = Math.min(res, i - arrayDeque.peekFirst());
                    arrayDeque.pollFirst();
                }
                while(!arrayDeque.isEmpty() && prefixsum[i] <= prefixsum[arrayDeque.peekLast()]) {
                    arrayDeque.pollLast();
                }
                arrayDeque.offer(i);
            }
            return res == Integer.MAX_VALUE ? -1 : res;
        }
    }

    Maximum Side Length of a Square with Sum Less than or Equal to Threshold  思路:build 矩阵的prefixsum ,记住建立的时候是 sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1] + mat[i - 1][j - 1];

    利用prefixsum求正方形的时候是:sum[i][j] - sum[i - len][j] - sum[i][j - len] + sum[i - len][j - len]

    建立好prefixsum之后,在0,math.min(n,m)之间做binary search, T: n * m * log(min(n,m));

    生成prefixsum的时候,是从上到下生成,计算区间的时候,是相减的;不要记忆公式,逻辑推理就行;

    class Solution {
        public int maxSideLength(int[][] mat, int threshold) {
            int n = mat.length;
            int m = mat[0].length;
            int[][] sum = new int[n + 1][m + 1];
            for(int i = 1; i <= n; i++) {
                for(int j = 1; j <= m; j++) {
                    sum[i][j] = sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1] + mat[i - 1][j - 1];
                }
            }
            
            int start = 0; int end = Math.min(n, m);
            while(start + 1 < end) {
                int mid = start + (end - start) / 2;
                if(canhave(mat, mid, threshold, sum)) {
                    start = mid;
                } else {
                    end = mid;
                }
            }
            
            if(canhave(mat, end, threshold, sum)) {
                return end;
            }
            if(canhave(mat, start, threshold, sum)) {
                return start;
            }
            return 0;
        }
        
        private boolean canhave(int[][] mat, int len, int threshold, int[][] sum) {
            for(int i = len; i <= mat.length; i++) {
                for(int j = len; j <= mat[0].length; j++) {
                    if(sum[i][j] - sum[i - len][j] - sum[i][j - len] + sum[i - len][j - len] <= threshold) {
                        return true;
                    }
                }
            }
            return false;
        }
    }

    思路2:这个比较巧妙,就是在建立prefixsum 矩阵的时候,一起判断,是否有比len更大的合法正方形,有就len++;O(m * n);

    class Solution {
        public int maxSideLength(int[][] mat, int threshold) {
            if(mat == null || mat.length == 0 || mat[0].length == 0) {
                return 0;
            }
            int n = mat.length;
            int m = mat[0].length;
            int[][] prefixsum = new int[n + 1][m + 1];
            int len = 1;
            int res = 0;
            for(int i = 1; i <= n; i++) {
                for(int j = 1; j <= m; j++) {
                    prefixsum[i][j] = prefixsum[i - 1][j] + prefixsum[i][j - 1] - prefixsum[i - 1][j - 1] + mat[i - 1][j - 1];
                    if(i - len >= 0 && j - len >= 0
                      && prefixsum[i][j] - prefixsum[i - len][j] - prefixsum[i][j - len] + prefixsum[i - len][j - len] <= threshold) {
                        res = len;
                        len++;
                    }
                }
            }
            return res;
        }
    }

    Maximum Size Subarray Sum Equals k 思路:prefixsum,这里可以不用array存,直接sum加起来,用hashmap就变成了<Integer, Integer> sum, index 只要查sum - target 是否存在就可以,存在就是当前index - i,0...i ...j 长度就是j - i; O(N)

    class Solution {
        public int maxSubArrayLen(int[] nums, int k) {
            if(nums == null || nums.length == 0) {
                return 0;
            }
            int res = 0;
            int cursum = 0;
            //       cursum   0 based index
            HashMap<Integer, Integer> hashmap = new HashMap<>();
            hashmap.put(0, -1); // 是为了array刚好 0...j 元素和是target,那么长度是j - (-1) = j + 1用的;
            for(int i = 0; i < nums.length; i++) {
                cursum += nums[i];
                if(hashmap.containsKey(cursum - k)) {
                    res = Math.max(res, i - hashmap.get(cursum - k));
                }
                // 这行很关键,就是之前有,就不要存,因为是找最大的length,所以前面的不要覆盖掉;
                if(!hashmap.containsKey(cursum)) {
                    hashmap.put(cursum, i);
                }
            }
            return res;
        }
    }

    Matrix Block Sum 思路:这题其实考点就是个prefixSum,Sum[i..j] = PrefixSum[j] - PrefixSum[i-1],注意这里是i - 1;

    // 这个点是i - k + 1的上面一个点,根据prefixSum 定义
    // Sum[i, j] = PrefixSum[j] - PrefixSum[i-1];
    // i - 1,也就是这个点;所以这里r1, c1没有+1;

    r1 c1

                  r2 c2

    r1, c1 的点,其实是区域范围 (i - k + 1, j - k  + 1)的上一个点;

    class Solution {
        public int[][] matrixBlockSum(int[][] mat, int k) {
            if(mat == null || mat.length == 0 || mat[0].length == 0) {
                return mat;
            }
            int m = mat.length;
            int n = mat[0].length;
            int[][] prefixSum = new int[m + 1][n + 1];
            for(int i = 0; i <= m; i++) {
                for(int j = 0; j <= n; j++) {
                    if(i == 0 || j == 0) {
                        prefixSum[i][j] = 0;
                    } else {
                        prefixSum[i][j] = prefixSum[i - 1][j] + prefixSum[i][j - 1] - prefixSum[i - 1][j - 1]
                                          + mat[i - 1][j - 1];
                    }
                }
            }
            
            int[][] res = new int[m][n];
            for(int i = 0; i < m; i++) {
                for(int j = 0; j < n; j++) {
                    int r1 = Math.max(0, i - k);
                    int c1 = Math.max(0, j - k);
                    
                    int r2 = Math.min(m, i + k + 1);
                    int c2 = Math.min(n, j + k + 1);
                    
                    res[i][j] = prefixSum[r2][c2] - prefixSum[r1][c2] - prefixSum[r2][c1] + prefixSum[r1][c1];
                }
            }
            return res;
        }
    }

    Maximum Sum of 3 Non-Overlapping Subarrays  思路:这个题目还是比较巧妙的,要求三段的和最大,核心算法就是:固定中间的一段subarry,分别用O(1)的时间去求左边部分的最大的subarry和,右边部分的最大的subarry的和。怎么用O(1)的时间去求subarry,很简单,prefixsum。但是怎么O(1)的去求一个大区间里面,哪一段的subarry是最大的,这个点就要用dp来pre compute,用leftdp记录到目前为止,从左往右看,到第i为止的最大的k size的subarry的起点index,同理:rightdp记录从右往左看 k size最大和的起点;这样有了这两个array,我就可以一口气算出

    [0, i] [i, i + k -1] [i + k, n - 1] 三个区间段里面,哪三段的和最大,左边和右边可以O(1)算出来,中间的i在动,但是也可以O(1)计算出来;

    prefixsum index的推倒,要熟练;

    sum[i, j] = prefixsum[j] - prefixsum[i - 1] 由于 array +1了,所以 prefixsum[j + 1] - prefixsum[i] 

    i 跟j之间有k,那么  j = i + k - 1 <==>  i = j - k + 1;

    从左往右计算,是j在移动,所以消除 i,prefixsum[j + 1] - prefixsum[j - k + 1];

    从右往左计算,是i在移动,所以消除 j,prefixsum[i + k - 1 + 1] - prefixsum[i] = prefixsum[i + k] - prefixsum[i];

    class Solution {
        public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
            int n = nums.length;
            int[] presum = new int[n + 1];
            for(int i = 0; i < n; i++) {
                presum[i + 1] = presum[i] + nums[i];
            }
            
            // 记录到目前i为止的,从左往右看,最大的subarry的和的起始位子;
            int[] leftdp = new int[n];
            // 记录到目前i为止的,从右往左看,最大的subarry的和的起始位子;
            int[] rightdp = new int[n];
            
            leftdp[k] = 0;
            for(int j = k, total = presum[k] - presum[0]; j < n; j++) {
                if(presum[j + 1] - presum[j - k + 1] > total) {
                    total = presum[j + 1] - presum[j - k + 1];
                    leftdp[j] = j - k + 1;
                } else {
                    leftdp[j] = leftdp[j - 1];
                }
            }
            
            rightdp[n - k] = n - k;
            for(int i = n - k - 1, total = presum[n] - presum[n - k]; i >= 0; i--) {
                if(presum[i + k] - presum[i] >= total) {
                    total = presum[i + k] - presum[i];
                    rightdp[i] = i;
                } else {
                    rightdp[i] = rightdp[i + 1];
                }
            }
            
            // left,     middle,        right;
            // [0, i], [i, i + k - 1], [i + k, n - 1];
            int[] res = {-1,-1,-1};
            int maxsum = 0;
            // 左边最起码要有k个,所以start = k,右边也是要有k个,那么起点就是倒数第二个k个,也就是 n - 2*k;
            // 核心算法:就是固定中间的subarry,然后一口气算出各个subarry的和,怎么算,
            // 也就是pre calculate的leftdp, rightdp, 
            // 然后用leftdp 和rightdp O(1)去算各个subarry的和;
            for(int i = k; i <= n - 2 * k; i++) {
                int l = leftdp[i - 1];
                int r = rightdp[i + k];
                int cursum = (presum[l + k] - presum[l]) 
                            + (presum[i + k] - presum[i]) 
                            + (presum[r + k] - presum[r]);
                if(cursum > maxsum) {
                    maxsum = cursum;
                    res[0] = l;
                    res[1] = i;
                    res[2] = r;
                }
            }
            return res;
        }
    }
    展开全文
  • sum(-1)、sum(1)、sum(0)、sum()与axis=-1,1,0

    千次阅读 2021-07-13 10:15:52
    np.sum() 一、axis 一句话解释:设axis=i,则沿着第i个下标变化的方向进行操作(忽略该下标,其他下标相同的为一组,然后再对该组进行操作) axis是将矩阵进行分组,然后再操作。而分组则意味着会降维,则每axis...

    目录

    一、axis

     实例:

    axis=0:

    以axis=-1:

    2. 对axis的理解

    np.sum()


    一、axis

    一句话解释:设axis=i,则沿着第i个下标变化的方向进行操作(忽略该下标,其他下标相同的为一组,然后再对该组进行操作)

    axis是将矩阵进行分组,然后再操作。而分组则意味着会降维,则每axis一次,维度就降低1(例如原来为三维矩阵, 现在对它进行操作,就会变为二维的)

    当numpy函数不指定axis的值时,表示函数对所有元素进行操作;

    当numpy函数指定axis的值时,表示函数沿着指定的axis轴方向进行操作;

    axis=0:可以理解为按照行顺序,对列进行操作

    axis=1:可以理解为按照列顺序,对行进行操作

    >>> import numpy as np
    
    >>> a=np.array([[1,2],
                    [3,4],
                    [5,6]])
    
    >>> a.mean(axis=0)#按照行顺序,对每一列求均值
    array([3., 4.])
    >>> a.mean(axis=1)#按照列顺序,对每一行求均值
    array([1.5, 3.5, 5.5]) 
    

     实例:

    
    import numpy as np
    
    np.random.seed(1234)
    embeddings  = np.random.randint(0, 10, size=[3, 3, 5])
    print(embeddings )
    
    a = np.max(embeddings ,axis=-1)
    b = np.max(embeddings ,axis=0)
    c = np.max(embeddings ,axis=1)
    
    print(a)
    print(b)
    print(c)
    
    

    [[[3 6 5 4 8]
      [9 1 7 9 6]
      [8 0 5 0 9]]

     [[6 2 0 5 2]
      [6 3 7 0 9]
      [0 3 2 3 1]]

     [[3 1 3 7 1]
      [7 4 0 5 1]
      [5 9 9 4 0]]]

    结果为:

    [[8 9 9]
     [6 9 3]
     [7 7 9]]

    [[6 6 5 7 8]
     [9 4 7 9 9]
     [8 9 9 4 9]]

    [[9 6 7 9 9]
     [6 3 7 5 9]
     [7 9 9 7 1]]

    刚刚的矩阵写成下标表示就是:

    embeddings = [[[a000,a001,a002,a003,a004],
                              [a010,a011,a012,a013,a014],
                              [a020,a021,a022,a023,a024],              
                              [a030,a031,a032,a033,a034]]
                  
                             [[a100,a101,a102,a103,a104],
                              [a110,a111,a112,a113,a114],
                              [a120,a121,a122,a123,a124],              
                              [a130,a131,a132,a133,a134]]
                  
                             [[a200,a201,a202,a203,a204],
                              [a210,a211,a212,a213,a214],
                              [a220,a221,a222,a223,a224],              
                              [a230,a231,a232,a233,a234]]       

    axis=0:

    以axis=0为例,则沿着第0个下标(最左边的下标)变化的方向进行操作,也就是将除了第0个下标外,其他两个下标都相同的部分分成一组,然后再进行操作。具体分组如下(省略了一些组):

    从上图可以看出,每3个数分成一组,所以现在总共是分了4*5个组(所以最终返回的结果也是一个shape=[4,5]的矩阵),对每个组都执行一次 max操作,将每个组的三个数中数值最大的数构成矩阵。

    以axis=-1:

    his means that the index that will be returned by argmax will be taken from the last axis.

    这里需要特别说明一下axis=-1的操作,可能对python不熟悉的人会不理解这里的-1是哪个维度。在pyhton中,-1代表倒数第一个,也就是说,假如你的矩阵shape=[3,4,5],那么对这个矩阵来说,axis=-1,其实也就等于axis=2。因为这是个三维矩阵,所以axis可能的取值为0,1,2,所以最后一个就是2。你可以自己试试看两个取值结果是否相同。

    2. 对axis的理解

    通过上面的例子,你可能已经发现了,axis是将矩阵进行分组,然后再操作。而分组则意味着会降维

    以刚刚的例子,原始矩阵的shape=[3,4,5],取axis=0再进行操作后,得到的矩阵shape=[4,5]。同样的,取axis=1再进行操作后,得到的矩阵shape=[3,5]。取axis=-1(axis=2)再操作后,shape=[3,4]。掌握这一点,能有利于你在神经网络中的变换或是数据操作中明确矩阵变换前后的形状,从而加快对模型的理解。

    np.sum()

    函数原型:

    np.sum(a, axis=None, dtype=None, out=None, keepdims=False)

    函数作用:

    求给定的axis轴上的数组元素之和

    import numpy as np
    
    A = np.array([[1,2],
                  [3,4]])
    sum0 = np.sum(A, axis=0)    #沿着0轴求和 ,也就是与0轴平行的方向求和(按列求和)
    sum1 = np.sum(A, axis=1)    #沿着1轴求和,也就是与1轴平行的方向求和(按行求和)
    sum2 = np.sum(A)
    
    print("输入矩阵:")
    print(A)
    
    print("沿着0轴求和(按列,axis = 0):",sum0)
    print("沿着1轴求和(按行,aixs = 1):",sum1)
    print("所有元素的和(axis = none):",sum2)
    

    结果:

    输入矩阵:

    [[1 2] [3 4]]

    沿着0轴求和(按列,axis = 0): [4 6]

    沿着1轴求和(按行,aixs = 1): [3 7]

    所有元素的和(axis = none): 10

    展开全文
  • 解密中国人自己的操作系统DIM-SUM

    千次阅读 2020-07-28 17:30:02
    如果说DIM-SUM操作系统是一个完美的操作系统,那无疑是一个谎言。如果说DIM-SUM操作系统只是大家茶余饭后的谈资,那无疑是另一个谎言。 在国产基础软件大发展的历史背景下,自研国产操作系统显得十分迫切和必要。...

    如果说DIM-SUM操作系统是一个完美的操作系统,那无疑是一个谎言。如果说DIM-SUM操作系统只是大家茶余饭后的谈资,那无疑是另一个谎言。

    在国产基础软件大发展的历史背景下,自研国产操作系统显得十分迫切和必要。2018年DIM-SUM第一个版本:HOT-POT操作系统诞生。业界同人亲切地将这个系统称为火锅操作系统。

    实际上,DIM-SUM仅仅是一个快速原型操作系统,它可以运行在ARM 64 的QEMU模拟器中。用户可以随便找一台机器,通过QEMU模拟器将它运行起来。在这个原型操作系统中,实现了同步与互斥、调度、内存、中断、定时器、块设备、文件系统模块,并且有一个简单的命令行控制台。

    “自研操作系统是一件极富挑战性也很难成功的事情,宝友同学敢于在这方面进行积极有益的尝试,值得支持和鼓励。加油,努力!”

    —— 阿里巴巴经济体技术委员会主席、阿里云总裁、阿里巴巴合伙人行癫对本文作者及其在过去几年中实现的一个操作系统DIM-SUM所做的评价。

    DIM-SUM实现的功能

    开源软件运动,已经为实现操作系统提供了现实可能性。首先,像Linux这样的开源操作系统提供了很好的基础,这样可以从开源软件中学习到不少的技能、方法、设计思路。其次,开源软件允许分散在全球各地的开发者协同工作、集思广益。我在Linux社区中,作为ARM/ZTEARCHITECTURE的Maintainer,对此深有体会。

    操作系统是IT行业的“核武器”。到目前为止,我们还处于“缺芯少魂”的状态,其中的“魂”就是操作系统。真正核心的软件,需要一代人,甚至几代人耐心地雕琢,而不能寄希望于短时间内产生立竿见影的效果。换句话说,要用“板凳一坐十年冷”的心态来做这件事。有了这样的心态,就不会觉得难。

    从另一角度来说:万古长空,一朝风月。任何难事,一旦想要去做,就需要把握当下。空谈误国,实干方能兴邦。即使这件事情很难,但是不动手永远不会有任何结果。况且,我喜欢有挑战性的事情,例如:写一个可用于生产环境的,能够替代Linux的服务器操作系统!

    目前,DIM-SUM已经实现了如下功能:

    • ARM 64 QEMU小系统,含内存|时钟初始化。

    • 全局优先级调度模块,调度算法类似于Linux实时调度。

    • 内存管理模块,包含页面管理、Beehive分配器。

    • 兼容Linux Ext3的LEXT3文件系统。

    • 块设备层实现。

    • 集成了LWIP网络协议栈。

    • 移植了常用的内核态C库API。

    • 实现了一个粗糙的命令行控制台。

    总之,我认为HOT-POT是DIM-SUM操作系统的良好起点。在DIM-SUM后续的开发过程中,我怀着热切的心情,期待你参与到它的开发中来。

    ▊ DIM-SUM欢迎什么

    任何建设性、对抗性建议、稳定“优雅”的代码、BUG报告、测试、社区建设等,都是DIM-SUM欢迎的!

    ▊ DIM-SUM不欢迎什么

    我们不欢迎空谈和只会抱怨的人。虽然我们知道DIM-SUM并不完善,你有很多指责它的理由,可以指出DIM-SUM的不足,但是请同时拿出能优化DIM-SUM、可以正常运行的代码贡献给DIM-SUM。

    *获得源代码   *

    Paul E.Mckenney曾经说过:If you want to do cool things,it is necessary to invest large amounts of time learning and (especially!)practicing.

    诚哉斯言!

    请读者相信我这个20年传奇工匠程序员的经验:要深刻地理解像Linux操作系统中源代码这样的复杂代码,必须动手实践,对着源代码看书!

    本书尽量少粘贴DIM-SUM源代码,我保证会对本书中出现的源代码进行逐行分析。这是故意为之的,目的是尽量使读者下载源代码并对照源代码阅读本书。

    要获得本书配套源代码,有以下两种方式:

    • 直接通过网页下载。

    • 通过Git获取源代码。

    ▊ 通过网页下载源代码

    通过网页下载源代码,是最简单、快捷的方式。下载好DIM-SUM的源代码之后,将下载的源代码包命名为dim-sum.20200616.tar.bz2。为了防止在下载过程中,由于网络原因导致文件损坏,可以验证源代码包的MD5值。在ubuntu16.04系统中,可以通过在命令行控制台上输入如下命令,来得到源代码包的MD5值:md5sum dim-sum.20200616.tar.bz2

    正确的MD5值应当是:

    9248ca8c21f3a4988ddba6426c4fdf60

    关于DIM-SUM操作系统的最新消息,也会通过博客发布,有兴趣的读者可以看看。

    通过网页下载源代码,可以满足阅读本书的要求。但是,它满足不了你如下的要求:

    1. 获得DIM-SUM操作系统最新的源代码。

    2. 查阅DIM-SUM操作系统的补丁记录。

    下一步将讨论如何通过Git获得源代码,这也是我推荐的方式。

    ▊ 通过Git获取源代码

    无论怎样强调Git在开源项目中的重要性都不过分。我甚至推荐读者找一本Git简明手册仔细阅读。

    如系统已安装Git工具,就可以通过gitclone命令获取DIM-SUM操作系统的源代码。DIM-SUM源代码将托管到码云服务器。

    这个命令会在当前目录中创建一个名为dim-sum的子目录,并将DIM-SUM操作系统的代码下载到本地。

    当然,对于大多数读者来说,不仅仅想对照着源代码阅读本书,他们还希望:

    • 跟踪DIM-SUM的最新版本。

    • 查阅DIM-SUM的补丁记录,明白每一个补丁的作用,与补丁的作者联系。

    • 给DIM-SUM提交补丁。

    • 在DIM-SUM中添加自己的代码。

    • 在PC上调试DIM-SUM的代码。 

    本文节选自博文视点新书《自研操作系统:DIM-SUM设计与实现》

    谢宝友 著

    本书作者从零开始完成的DIM-SUM操作系统,具备很多现代操作系统的先进特性,比如高效的内存管理、进程管理、虚拟文件系统、LEXT3文件系统等。更加难能可贵的是,他不但公开了源代码,还把自研DIM-SUM操作系统的设计心得和体会总结成册,给国内从事基础软件开发的技术人员提供了宝贵的一手资料。

    ▶ 内容简介

    本书详细阐述了自研操作系统DIM-SUM的设计与实现,提供了在ARM 64虚拟机中动手实践DIM-SUM及参与DIM-SUM开发的方法。针对DIM-SUM操作系统的同步与互斥、调度、内存、中断与定时器、块设备、文件系统模块进行了详细的分析,包括这些模块的设计思路、数据结构定义、关键API说明。最重要的是,本书对各个模块的主要函数进行了逐行解释,有助于读者深刻理解如何实现一款实用的操作系统。最后,本书还展望了接下来10年DIM-SUM操作系统的发展目标,希望最终其能发展为可以在服务器系统、桌面系统中实用的自研操作系统。

    本书适合于对操作系统研发有兴趣的大学生、研究生,以及从事操作系统相关工作的一线工程师。对于Linux操作系统工程师,本书也极具实用价值。

    ▶ 本书特点

    ● 详细阐述了自研操作系统DIM-SUM的设计与实现,提供了在ARM 64虚拟机中动手实践DIM-SUM及参与DIM-SUM开发的方法。

    ● 针对DIM-SUM操作系统的各个模块进行了详细的分析,包括这些模块的设计思路、数据结构定义、关键API说明。

    ● 对各个模块的主要函数进行了逐行解释,这样有助于读者深刻理解如何实现一款实用的操作系统。

    ▶ 作者简介

    谢宝友

    曾任中兴嵌入式实时操作系统技术总工(该系统获第四届中国工业大奖);他曾获中兴通讯2010年度金银奖、阿里集团2019年度安全生产之星金奖、2018年和2019年阿里集团“双11”卓越贡献奖获得者;《深入理解并行编程》译者;Linux ZTE架构维护者;DIM-SUM自研操作系统发起者和创始人。

    更多科技资讯请见微信公众号:博文视点Broadview(微信号:bvbooks)

    展开全文
  • 【算法】2SUM/3SUM/4SUM问题

    万次阅读 2017-04-26 01:21:50
    之前就总结过一些Leetcode上各种sum问题,今天再拿出来完整得总结一番。 nSUM问题是指,在一个数组中,找出n个数相加和等于给定的数,这个叫做nSUM问题。 常见的有2SUM,3SUM,4SUM问题,还有各种SUM问题的变种....
  • 谈谈go.sum

    千次阅读 2020-02-11 10:58:00
    众所周知,Go 在做依赖管理时会创建两个文件,go.mod 和 go.sum。相比于 go.mod,关于 go.sum 的资料明显少得多。自然,go.mod 的重要性不言而喻,这个文件几乎提供了依赖版本的全部信息。而 go.sum 看上去就是 go ...
  • sha1sum for windows

    热门讨论 2011-11-24 15:23:49
    在命令行模式下使用,校验数据用,语法:“sha1sum 需要校验的文件名”
  • sql sum语句_SQL Sum语句示例说明

    千次阅读 2020-08-13 15:21:17
    sql sum语句 SQL中的Sum语句是什么? (What is the Sum statement in SQL?) This is one of the aggregate functions (as is count, average, max, min, etc.). They are used in a GROUP BY clause as it ...
  • python sum_Python sum()

    千次阅读 2020-07-11 05:24:52
    python sumPython sum() function is used to get the sum of numbers of an iterable. Python sum()函数用于获取可迭代数的总和。 Python sum() (Python sum()) Python sum() function syntax is: Python sum...
  • SQL sum函数

    千次阅读 2020-09-25 21:25:59
    SQL sum函数用于统计某一列的和; 原表; 统计paynum列的和; sql对字段可以使用别名,语法是: as xxx;使用别名后如下; 全部运行一下; select * from mempays select SUM(paynum) from mempays...
  • 习题4.5 在键盘上输入数n,编程计算sum=1−12!+13!−...(−1)n−11n!。sum=1-\frac{1}{2!}+\frac{1}{3!}-...(-1)^{n-1}\frac{1}{n!}。sum=1−2!1​+3!1​−...(−1)n−1n!1​。 代码块: package App; import java....
  • Numpy中sum函数(Python自带sum函数)的作用是对元素求和。 无参时,所有全加; axis=0,按列相加; axis=1,按行相加; 下边通过例子来说明其用法: #!/usr/bin/env python # -*- coding:utf-8 -*- from numpy...
  • python中sum函数详解

    千次阅读 2019-09-11 14:48:38
    python3中sum的用法 python内置的sum函数 对象是列表,元组,集合,可以混合起来使用 >>>sum([1,2,3],2) 8 >>>sum((1,2,3)) 6 >>>sum({1,2,3}) 6 >>>sum(range(5)) ...
  • md5sum 和 sha256sum用于 验证软件完整性 https://www.cnblogs.com/xuyaowen/p/md5sum_sha256_usages.html md5sum 和 sha256sum 都用来用来校验软件安装包的完整性,本次我们将讲解如何使用两个命令进行软件安装包...
  • elasticsearch es sum求和统计用法

    千次阅读 2021-03-05 09:57:06
    sum 有多种方法都可以实现: 用 stats ,其中 “query” 是我自己需要想要查询出的记录,query 部分是我的查询标准,大家在用的时候需要根据业务修改。 my_stats 就是个名字,随便起都行。stats、field 不能修改...
  • MAX-SUM算法

    千次阅读 2020-12-10 21:34:38
    本文的主要目的就是使用MAX-SUM算法在无线传感器网络中使系统的应用获得最佳的性能,一个无线传感器网络的主要结构如下所示: 图2.2 无线传感器网络的基本结构 从图2.2可以看到,无线传感器网络的基本组成可以...
  • ES 根据查询条件求和sum

    千次阅读 2020-11-18 15:45:41
    最简单的查询求和,类似于SQL: select sum(XX) from table where ; 不需要group by. 也就不需要TermsAggregationBuilder dsl: GET /index/base_info/_search { "aggs": { "query_amount": { "sum": { ...
  • Python NumPy中sum()函数详解 axis与keepdims图解

    千次阅读 多人点赞 2019-10-17 13:40:40
    numy.sum()函数定义与说明 代码示例、说明及输出 axis = 0 或axis = -3 axis = 1 或 axis = -2 axis = 2或axis = -1 axis = (0, 2) axis = (0, 2),keepdims=True 总结与扩展 经常使用NumPy的小伙伴会遇到...
  • GO: go.mod go.sum

    千次阅读 2020-11-02 01:09:35
    执行上述命令之后,其实你已经可以开发编译运行此项目了,比如我们随便使用github上的一个包,在终端打印一下 运行一下,会看到输出结果: { false false false} ,同时项目目录下多出了一个文件 go.sum 。...
  • Linq Sum用法

    千次阅读 2019-09-03 16:04:19
    Linq Sum用法 代码 List<MES_ProcessCompleteEntity> mpc = BaseRepository().FindList<MES_ProcessCompleteEntity>(t => t.F_OrderProcessId == keyValue).AsList(); decimal? F_Qua...
  • SUM(half_hour_overtime_num) AS half_hour_overtime_num, SUM(two_hour_overtime_num) AS two_hour_overtime_num, SUM(six_hour_overtime_num) AS six_hour_overtime_num, SUM(half_day_overtime_...
  • 终于弄懂tf.reduce_sum()函数和tf.reduce_mean()函数

    万次阅读 多人点赞 2019-08-07 16:54:31
    怎么肥事,对于萌新小白首先想到的就是找度娘,结果找到的方法都不行,然后开始查函数,终于发现了原因,问题就出在reduce_sum()函数上,哈哈哈,然后小白又叕叕叕开始找博客学习reduce_sum()顺带学下reduce_mean(),...
  • Spark_Hive 累加统计函数 sum() over()

    万次阅读 2019-04-09 12:44:59
    select pcode,event_date,sum(duration) over (partition by pcode order by event_date asc rows between unbounded preceding and current row) as sum_duration from userlogs_date Window.partitionBy("pcode")....
  • sum(-1)和sum(1) 用途:求数组每一列的和,等价于 sum(axis=1) #关于axis的理解可以参考博主的另一篇文章【python】axis的理解 >>> import numpy as np >>> x = np.array([[0, 1], [1, 1], [2...
  • MySQL中sum和count用法总结

    千次阅读 2020-05-26 10:57:34
    MySQL中sum和count用法总结1.sum2.count例子:要求:查询出2门及2门以上不及格者的平均成绩。3、MySQL 分组之后如何统计记录条数 gourp by 之后的 count()例子4、sum mysql select 横向展示例子1纵向展示横向展示...
  • numpy的sum函数的axis和keepdim参数详解

    千次阅读 多人点赞 2021-03-10 15:31:41
    也就是对第二层括号里面的进行求和 sum=np.sum(b,axis=0,keepdims=True) print(sum) 运行结果: [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11]] b中的元素之和: 66 [[ 6 8 10 12 14 16]] 最后一个输出指定axis=0,keepdim=True,...
  • EXCEL中SUM函数的8种用法

    千次阅读 2020-07-23 15:34:38
    和函数Sum,应该是Excel中接触最早的函数之一呢,但是,你真的会用Sum吗? 一、Sum函数:累计求和。 目的:对销售额按天累计求和。 方法: 在目标单元格中输入公式:=SUM(C$3:C3)。 解读: 累计求和的关键...
  • Mysql按条件求和Sum函数

    万次阅读 2019-04-16 12:02:23
    首先在写这博客的初衷是因为在工作开发过程中遇到了数据汇总问题,并且有的还是按条件汇总,这就有点小麻烦,然而学会使用sum函数之后,这些问题就迎刃而解了。是不是很Nice。好记性不如烂笔头!再此,希望能帮到...
  • matlab中sum函数的使用

    千次阅读 2021-04-20 16:47:15
      现在介绍matlab中常用的sum函数:sum函数有两种用法 1)向量的相加: b=sum(a); a表示行向量,b表示行向量求和的值。 例子如下: >>a=[1 2 3 4 5]; >>b=sum(a); b= 15 2)矩阵加法 生成一个...
  • sql 语句sum if

    千次阅读 2018-09-28 16:58:57
    SELECT room,COUNT(aid) num,sum(if(DATE_FORMAT(dzsj,'%d')='1',1,0)) num1,sum(if(DATE_FORMAT(dzsj,'%d')='2',1,0)) num2,sum(if(DATE_FORMAT(dzsj,'%d')='3',1,0)) num3,sum(if(DATE_FORMAT(dzsj,'%d')='4',1,0)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,068,059
精华内容 827,223
关键字:

sum