精华内容
下载资源
问答
  • 本文主要介绍通过excel的规划求解和sumproduct函数,来计算任意几个数相加后等于一个。但是规划求解只能取得一个解,即使有多个解。

              本文主要介绍通过excel的规划求解和sumproduct函数,来计算任意几个数相加后等于一个数。但是规划求解只能取得一个解,即使有多个解。

    例:

    以下多个数中,哪几个数相加的和是38481

     

    展开全文
  • n个数任意个数相加求和的个数

    千次阅读 2015-11-10 17:04:01
    //有若干个给定的(都小于N),问从中任意几个数相加,可以得到多少个不同的结果. //处理这种类似背包的时候,注意内层循环一定要memcpy重建一个副本,不然会陷入死循环并越界。如题,j = 0, 当0 + 1记录在re
    // MicroSofrInterviewProblem2.cpp : Defines the entry point for the console application.
    //有若干个给定的数(都小于N),问从中任意取几个数相加,可以得到多少个不同的结果.
    //处理这种类似背包的时候,注意内层循环一定要memcpy重建一个副本,不然会陷入死循环并越界。如题,j = 0, 当0 + 1记录在record[1],下一次record[1]也是1了就那么reocrd[2]也会赋值为1,直到循环结束,这样程序就挂了。
    //类似的一共有多少种可能性的问题,都会出现类似的问题。需要注意。
    
    #include "stdafx.h"
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <memory.h>
    #define MAX 100
    
    int poscount(int* input, int len) {
        if (input == NULL || len == 0) return 0;
        int count = 1;
        char record[MAX] = { 0 };
        record[0] = 1;
        printf("0 ");
        int i = 0;
        for (; i<len; i++) {
            int j;
            char tmp[MAX];
            memcpy(tmp, record, MAX);
            for (j = 0; j<MAX; j++) {
                if ((record[j] == 1) && (record[j + input[i]] == 0)) {
                    tmp[j + input[i]] = 1;
                    printf("%d ", j + input[i]);
                    count++;
                }
            }
            memcpy(record, tmp, MAX);
        }
        printf("\ncount = %d \n", count);
        return count;
    }
    
    int main() {
        int input[] = { 1,2,3,5 };
        poscount(input, sizeof(input) / sizeof(int));
        while (1);
    }
    展开全文
  • 函数是在项目偶然使用写出来的,使用在给出一组商品的价格,需要找出这组商品所有的组合情况,方法一是所有结果为一固定值,方法二是一范围。 方法一: public class Test { public static void main(String...

    该函数是在项目偶然使用写出来的,使用在给出一组商品的价格,需要找出这组商品所有的组合情况,方法一是所有结果为一个固定值,方法二是一个范围。

    方法一:

    public class Test {
        public static void main(String[] args) {
            String str = "36,60,50,15,35,17,18,44,72,12";
            int sum = 100;
            diguiSum(str, sum);
        }
    
        public static void diguiSum(String str, int sum) {
            String[] x = str.split(",");
            int[] array = arrayTransform(x);
            for (int i = 0; i < 10; i++) {
                int[] cache = new int[i + 1];
                int ceng = -1;
                int cengQuit = i;
                int startPiont = 0;
                cir(ceng, cengQuit, startPiont, array, cache, sum);
            }
        }
    
        // 递归求结果
        public static void cir(int ceng, int cengQuit, int startPiont, int[] array, int[] cache, int sum) {
            ceng++;
            for (int i = startPiont; i < array.length; i++) {
                cache[ceng] = array[i];
                if (ceng == cengQuit) {
                    if (getSum(cache) == sum) {
                        printcache(cache);
                    }
                    if (getSum(cache) > sum) {
                        break;
                    }
                }
                if (ceng < cengQuit) {
                    startPiont = i;
                    cir(ceng, cengQuit, startPiont, array, cache, sum);
                }
            }
        }
    
        // 获取组合数字之和
        public static int getSum(int[] cache) {
            int sum = 0;
            for (int i = 0; i < cache.length; i++) {
                sum = sum + cache[i];
            }
            return sum;
        }
    
        // 打印组合的可能
        public static void printcache(int[] cache) {
            for (int i = 0; i < cache.length; i++) {
                System.out.print(cache[i] + ",");
            }
            System.out.println();
        }
    
        // 转换数组类型 且为提高效率做准备
        public static int[] arrayTransform(String[] strArray) {
            int length = 0;
    
            int[] array = new int[strArray.length];
            for (int i = 0; i < strArray.length; i++) {
                array[i] = Integer.valueOf(strArray[i]);
            }
            Arrays.sort(array);
            for (int i = 0; i < array.length; i++) {
                if (array[i] > 100) {
                    length = i;
                    break;
                }
            }
            int[] dest = new int[length];
            if(length == 0){
                return array;
            }
            System.arraycopy(array, 0, dest, 0, length);
            return dest;
        }
    }

    输出:

    50,50,
    12,44,44,
    15,35,50,
    12,17,35,36,
    12,18,35,35,
    15,15,35,35,
    15,17,18,50,
    12,12,15,17,44,
    12,17,17,18,36,
    12,17,18,18,35,
    15,15,17,17,36,
    15,15,17,18,35,
    12,12,12,12,17,35,
    12,17,17,18,18,18,
    15,15,17,17,18,18,
    15,17,17,17,17,17,
    12,12,12,12,17,17,18,
    12,12,12,15,15,17,17,


    方法二:

    public class Test {
        public static void main(String[] args) {
            List<Double> str1 = new ArrayList<>();
            str1.add(20.21);
            str1.add(99.25);
            str1.add(120.0);
            str1.add(74.05);
            str1.add(34.5);
            str1.add(50.00);
    
            Double min = 100.00;
            Double max = 150.00;
            diguiSum(arrayTransform(str1,max),min,max);
        }
    
        public static void diguiSum(List<Double> str,Double min,Double max) {
            for (int i = 0; i < 50; i++) {
                //System.out.println(str.get(i));
                Double[] cache = new Double[i + 1];
                int ceng = -1;
                int cengQuit = i;
                int startPiont = 0;
                cir(ceng, cengQuit, startPiont, str, cache, min,max);
            }
        }
    
        // 递归求结果
        public static void cir(int ceng, int cengQuit, int startPiont, List<Double> array, Double[] cache, Double min,Double max) {
            ceng++;
            for (int i = startPiont; i < array.size(); i++) {
                cache[ceng] = array.get(i);
                if (ceng == cengQuit) {
                    if ((getSum(cache) >= min) && (getSum(cache) <= max)) {
                        printcache(cache);
                    }
                    if ((getSum(cache) < min) || (getSum(cache) > max)) {
                        continue;
                    }
                }
                if (ceng < cengQuit) {
                    startPiont = i;
                    cir(ceng, cengQuit, startPiont, array, cache,min,max);
                }
            }
        }
    
        // 获取组合数字之和
        public static Double getSum(Double[] cache) {
            Double sum = 0.00;
            for (int i = 0; i < cache.length; i++) {
                sum = sum + cache[i];
            }
            return sum;
        }
    
        // 打印组合的可能
        public static void printcache(Double[] cache) {
            for (int i = 0; i < cache.length; i++) {
                System.out.print(cache[i] + ",");
            }
            System.out.println();
        }
        public static List<Double> arrayTransform(List<Double> strArray,Double max) {
            for (int i = 0; i < strArray.size() - 1; i++) {
                for (int j = 1; j < strArray.size() - i; j++) {
                    Double a;
                    if ((strArray.get(j - 1)).compareTo(strArray.get(j)) > 0) { // 比较两个整数的大小
                        a = strArray.get(j - 1);
                        strArray.set((j - 1), strArray.get(j));
                        strArray.set(j, a);
                    }
                }
            }
            for (int i = 0; i < strArray.size(); i++) {
                if (strArray.get(i) > max) {
                    strArray.remove(i);
                }
            }
            return strArray;
        }
    }

    输出:

    120.0,
    20.21,99.25,
    20.21,120.0,
    34.5,74.05,
    34.5,99.25,
    50.0,50.0,
    50.0,74.05,
    50.0,99.25,
    74.05,74.05,
    20.21,20.21,74.05,
    20.21,20.21,99.25,
    20.21,34.5,50.0,
    20.21,34.5,74.05,
    20.21,50.0,50.0,
    20.21,50.0,74.05,
    34.5,34.5,34.5,
    34.5,34.5,50.0,
    34.5,34.5,74.05,
    34.5,50.0,50.0,
    50.0,50.0,50.0,
    20.21,20.21,20.21,50.0,
    20.21,20.21,20.21,74.05,
    20.21,20.21,34.5,34.5,
    20.21,20.21,34.5,50.0,
    20.21,20.21,34.5,74.05,
    20.21,20.21,50.0,50.0,
    20.21,34.5,34.5,34.5,
    20.21,34.5,34.5,50.0,
    34.5,34.5,34.5,34.5,
    20.21,20.21,20.21,20.21,20.21,
    20.21,20.21,20.21,20.21,34.5,
    20.21,20.21,20.21,20.21,50.0,
    20.21,20.21,20.21,34.5,34.5,
    20.21,20.21,20.21,34.5,50.0,
    20.21,20.21,34.5,34.5,34.5,
    20.21,20.21,20.21,20.21,20.21,20.21,
    20.21,20.21,20.21,20.21,20.21,34.5,
    20.21,20.21,20.21,20.21,34.5,34.5,
    20.21,20.21,20.21,20.21,20.21,20.21,20.21,

    方法三,封装成传入list<Double>的工具类,便于项目使用:

    public class ProductPriceGroupUtil {
        public static List<Map<String,Object>> getProductPriceGroup(List<Double> str1, Double min, Double max) {
            List<Map<String,Object>> pds = new ArrayList<>();
            diguiSum(arrayTransform(str1,max),min,max,pds);
            return pds;
        }
    
        public static void diguiSum(List<Double> str, Double min, Double max,List<Map<String,Object>> pds) {
            for (int i = 0; i < 10; i++) {
                Double[] cache = new Double[i + 1];
                int ceng = -1;
                int cengQuit = i;
                int startPiont = 0;
                cir(ceng, cengQuit, startPiont, str, cache, min,max,pds);
            }
        }
    
        // 递归求结果
        public static void cir(int ceng, int cengQuit, int startPiont, List<Double> array, Double[] cache, Double min,Double max,List<Map<String,Object>> pds) {
            ceng++;
            for (int i = startPiont; i < array.size(); i++) {
                cache[ceng] = array.get(i);
                if (ceng == cengQuit) {
                    if ((getSum(cache) >= min) && (getSum(cache) <= max)) {
                        pds.add(printcache(cache));
                    }
                    if ((getSum(cache) < min) || (getSum(cache) > max)) {
                        continue;
                    }
                }
                if (ceng < cengQuit) {
                    startPiont = i;
                    cir(ceng, cengQuit, startPiont, array, cache,min,max,pds);
                }
            }
        }
    
        // 获取组合数字之和
        public static Double getSum(Double[] cache) {
            Double sum = 0.00;
            for (int i = 0; i < cache.length; i++) {
                sum = sum + cache[i];
            }
            return sum;
        }
    
        // 打印组合的可能
        public static Map<String,Object> printcache(Double[] cache) {
            Map<String,Object> pd = new HashedMap();
            Double sum = 0.00;
            String s = "";
            for (int i = 0; i < cache.length; i++) {
                if(i != cache.length - 1){
                    s += (cache[i] + ",");
                    sum += cache[i];
                }else{
                    s += cache[i];
                    sum += cache[i];
                }
            }
            pd.put("price_sum",sum);
            pd.put("price_group",s);
            pd.put("group_size",cache.length);
            return pd;
        }
        public static List<Double> arrayTransform(List<Double> strArray,Double max) {
            for (int i = 0; i < strArray.size() - 1; i++) {
                for (int j = 1; j < strArray.size() - i; j++) {
                    Double a;
                    if ((strArray.get(j - 1)).compareTo(strArray.get(j)) > 0) { // 比较两个整数的大小
                        a = strArray.get(j - 1);
                        strArray.set((j - 1), strArray.get(j));
                        strArray.set(j, a);
                    }
                }
            }
            for (int i = 0; i < strArray.size(); i++) {
                if (strArray.get(i) > max) {
                    strArray.remove(i);
                }
            }
            return strArray;
        }
    }

    调用测试:

    public class Test {
        public static void main(String[] args) {
            List<Double> str1 = new ArrayList<>();
            str1.add(20.21);
            str1.add(99.25);
            str1.add(120.0);
            str1.add(74.05);
            str1.add(34.5);
            str1.add(50.00);
    
            Double min = 100.00;
            Double max = 150.00;
            List<Map<String,Object>> result = ProductPriceGroupUtil.getProductPriceGroup(str1,min,max);
            for(Map<String,Object> map : result){
                System.out.println(map.get("price_group"));
            }
        }
    }

    结果一致。
    展开全文
  • 编写一个函数 :实现计算任意个数的各位数的和 function fnSum(num){ var sum = 0; while( num != 0 ){ sum += num % 10; //取出位数 num = parseInt( num/10 ); } retur...

    编写一个函数 :实现计算任意一个数的各个位数的和

       const num = parseInt(prompt('请输入一个数'))
        function fnSum (num) {
          let sum = 0
          while (num != 0) {
            sum += num % 10 // 取出个位数
            num = parseInt(num / 10)
          }
          return sum
        }
        alert(fnSum(num))
    
    展开全文
  • 求数组中多个数相加等于某一值

    万次阅读 2016-07-29 19:41:36
    顾名思义,求数组中3个数相加等于某一特定的自己写了一似乎是O(n^2) 汗颜 在Two Sum的引导下,我成功使用了unordered_map 然而在run code的时候就发现了一无法解决的问题: Your input [-1,0,1,2,-1,-4] ...
  • c语言实现两超大相加(超长数据)

    万次阅读 多人点赞 2018-11-28 23:00:07
    超大的怎么保存和相加呢,计算机的整形32位的最大也就4294967296,超过这个数就计算不了了哇 然后就想动手实践一下 思路: 1.超长数据怎么存呢。脑子一拍,巨长的肯定用字符数组来存哇,没毛病。 2.要...
  • Linux环境下,C语言中整数类型最长的是long long类型,占8个字节,即使如此,其能表示的仍是有限的。...下面我罗列几个需要注意的点:1、输入的问题,2、是否是数字,3、对齐的问题,4、进位的问题。
  • 种常见的激活函数

    万次阅读 多人点赞 2016-09-30 13:16:21
    作者从数学的角度上也证明了这结论,即只需2maxout节点就可以拟合任意的凸函数了(相减),前提是”隐含层”节点的个数可以任意多。 How to choose a activation function? 怎么选择激活函数呢? 我觉得这种问题...
  • Python_计算任意个数的数字之和

    千次阅读 2020-01-19 20:59:25
    星号形参的应用,在函数内接收参数形成元组 def add(*args): sum = 0 for i in args: sum += i return sum print(add(1, 2, 3, 4, 5)) 运行结果 15
  • public class DoubleOperationUtil {   //默认除法运算精度   private static final int DEF_DIV_SCALE = 10;  //这类不能实例化   private DoubleOperationUtil(){   }
  • 数字电路的作用是用来表达一现实的逻辑命题,实现逻辑功能。但是,从 逻辑功能中简单概括得出的逻辑函数,往往不是最简表达式,根据这样的非最简式来实现电路,系统会过于复杂,成本过高,同时,电路运行的安全性...
  • Python给函数传递不定个数的参数

    千次阅读 2018-09-12 20:38:34
    在Python中常常看到有这样的函数,它们的入口参数的个数是不定的。比如有如下代码   In: print zip([1, 2],[3, 4]) Out: [(1, 3), (2, 4)] In: print zip([1, 2],[3, 4],[5, 6]) Out: [(1, 3,...
  • c语言字符串 数字转换函数大全

    千次阅读 2016-08-20 09:54:33
    atof(将字符串转换成浮点型) atoi(将字符串转换成整型) atol(将字符串转换成长整型) strtod(将字符串转换成浮点数) strtol(将字符串转换成长整型) strtoul(将字符串转换成无符号长整型) toascii...
  • 种常用的激活函数

    千次阅读 2018-08-30 11:13:35
    sigmod函数曾经是比较流行的,它可以想象成一神经元的放电率,在中间斜率比较大的地方是神经元的敏感区,在两边斜率很平缓的地方是神经元的抑制区。 当然,流行也是曾经流行,这说明函数本身是有一定的缺陷的。 ...
  • C语言字符串 数字转换函数大全

    千次阅读 2012-05-27 16:59:00
    atof(将字符串转换成浮点型)  atoi(将字符串转换成整型)  atol(将字符串转换成长整型)  strtod(将字符串转换成浮点数)  strtol(将字符串转换成长整型)  strtoul(将字符串转换成无符号长整型) ...
  • 从数组中取出任意个数,求和为指定值的解 PHP <?php $cc = array(1,9,34,56,10,7,3,28,9); function demo($cc,$val){ for ($i = 1; $i < 1 << count($cc); $i++) { $sum = 0; $temp = ""; ...
  • 运算符重载 对于面向对象的程序设计来说,运算符重载可以完成两对象之间的复杂操作...为了重载运算符,首先要定义运算符重载函数,它通常是类的非静态成员函数或者友元函数,运算符的操作通常也应为对象。 定...
  • c语言字符串 数字转换函数大全转

    千次阅读 2009-07-03 18:29:00
    atof(将字符串转换成浮点型)atoi(将字符串转换成整型)atol(将字符串转换成长整型)strtod(将字符串转换成浮点数)strtol(将字符串转换成长整型)strtoul(将字符串转换成无符号长整型)toascii(将整型转换成...
  • 假设要找到列表中两元素之和等于4的两元素的位置。 代码如下: if __name__ == '__main__': a=[1,7,9,4,5] s=8 for index,i in enumerate(a): for index2,j in enumerate(a[index+1:]): if i+j == s: ...
  • 广义相加模型(GAM)及R实现

    万次阅读 多人点赞 2019-03-25 21:41:57
    GAM采用模型中的每预测变量并将其分成多部分(由'结'​​分隔),然后将多项式函数分别拟合到每部分。GAM的原理是最小化残差(拟合优度)同时最大化简约性(最低可能自由度)。回归模型中部分或全部的自变量...
  • C语言提供了几个标准库函数,可以将任意类型(整型、长整型、浮点型等)的数字转换为字符串,下面列举了各函数的方法及其说明。 ● itoa():将整型值转换为字符串。 ● ltoa():将长整型值转换为字符串。 ● ultoa()
  • 数相加组成,如何用最少的循环次数确认出它由哪几个数组成?如:9 由 1、8 组成(如何通过两次循环得出结论来:2^0 + 2^3 , 最终结果包含0 和 3)又如:521 由 1、8、512 组成(如何通过三次循环得出结论来:2^0 ...
  • 数据结构之多项式相加

    千次阅读 多人点赞 2019-03-21 22:05:43
    【问题描述】编写一程序用单链表存储多项式,并实现两一元多项式A与B相加函数。A,B刚开始是无序的,A与B之和按降序排列。例如: 多项式A: 1.2X^0 2.5X^1 3.2X^3 -2.5X^5 多项式B: -1.2X^0 2.5X^1 3.2X^3 ...
  • 一元多项式相加

    千次阅读 2015-08-06 10:35:00
    程序运行结果如下: , Helvetica, sans-serif;">;"># include<stdio.h></span> # include ... printf("将两多项式相加:\n"); head=addpoly(head1,head2); disppoly(head); deletepoly(head); }
  • 【Python学习之路】函数

    万次阅读 2019-12-15 20:56:04
    函数 定义函数 函数function,通常接受输入参数,并有返回值。 它负责完成某项特定任务,...函数通常有一下几个特征: 使用 def 关键词来定义一个函数。 def 后面是函数的名称,括号中是函数的参数,不同的参数用 ,...
  • python常用函数总结

    万次阅读 多人点赞 2018-04-23 11:40:49
    print()函数可以同时输出多字符串,用逗号“,”隔开 print(&quot;hello&quot;,&quot;how&quot;,&quot;are&quot;,&quot;you&quot;) print()会依次打印每字符串,遇到逗号“,
  • Oracle数据库常用函数

    万次阅读 多人点赞 2017-10-01 17:15:12
    1.字符函数: upper('字符串'|列名称)将输入的字符串转换成大写 lower('字符串'|列名称)将输入的字符串转换成小写 initcap('字符串'|列名称),首字母大写 length('字符串'|列名称);字符串长度 replace('字符串'|列...
  • #include int ismax(int a,int b); int main(int argc, const char * argv[]) {   int a,b;   scanf("%d",&a);   scanf("%d",&b);   int s=ismax(a,b);   printf("%d",s);...ret

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,177
精华内容 14,470
关键字:

任意几个数相加的函数