用java递归求一个平均数多少种可能的算法

Question

      在做一个考试系统，用户输入了考试要出多少道题目，和平均难度系数，我想得出根据这个平均系数能产生多少种可能，难度系数是1-5；比如用户选择3道选择题，平均系数为3，应该显示1-3-5、1-4-4、2-2-5、2-3-4，3-3-3，谢了

Answer 1

     //最大难度系数
        int maxNum = 5;
        //最小难度系数
        int minNum = 1;
        //3道选择题  
        int num = 3;
        //平均系数为3
        int avg = 3;
        
        Set<String> set = new TreeSet<String>();
        for (int j = minNum; j <= maxNum; j++)
        {
            
            for (int m = minNum; m <= maxNum; m++)
            {
                for (int n = minNum; n <= maxNum; n++)
                {
                    if (num*avg == (j + n + m))
                    {
                        
                        String[] zz = {String.valueOf(j), String.valueOf(n), String.valueOf(m)};
                        Arrays.sort(zz);
                        set.add(Arrays.asList(zz).toString());
                    }
                }
            }
            
        }
        System.out.println(set);
只适合 3-3

Answer 2

5楼的代码还是很感谢你，但是for这个我明白，但是随着用户输入题目数量的增多for也得跟着加，不适合的，不过还是很谢谢了

Answer 3

    public static void main(String[] args) {
        List<List<Integer>> re = op(1, 5, 3, 3);
        if (re == null) {
            System.out.println("error");
            return;
        }
        for (List<Integer> tl : re) {
            for (Integer n : tl) {
                System.out.print(n + ",");
            }
            System.out.println("");
        }
    }    static List<List<Integer>> op(final int min, final int max, final int age, final int count) {
        List<List<Integer>> tn = new ArrayList<List<Integer>>();
        {//初始化
            int sum = age * count;
            //确定最大边界
            int bmax = sum - min * (count - 1);
            bmax = Math.min(bmax, max);
            //最小边界
            int bmin = sum - max * (count - 1);
            bmin = Math.max(bmin, min);
            if (bmax < bmin) {
                return null;
            }
            for (int i = bmin; i <= bmax; i++) {
                List<Integer> nl = new ArrayList<Integer>();
                nl.add(i);
                tn.add(nl);
            }
        }
        for (int i = 1; i < count; i++) {
            List<List<Integer>> btn = new ArrayList<List<Integer>>();
            for (int j = 0, jm = tn.size(); j < jm; j++) {
                List<Integer> nl = tn.get(j);
                int sum = count * age;
                for (Integer item : nl) {
                    if (item == null) {
                        break;
                    }
                    sum -= item;
                }
                //确定最大边界
                int bmax = sum - min * (count - i - 1);
                bmax = Math.min(bmax, max);
                //最小边界
                int bmin = sum - max * (count - i - 1);
                bmin = Math.max(bmin, min);
                for (int z = bmin; z <= bmax; z++) {
                    List<Integer> bnl = new ArrayList<Integer>();
                    bnl.addAll(nl);
                    bnl.add(z);
                    btn.add(bnl);
                }
            }
            tn = btn;
        }
        //排序
        for (List<Integer> l : tn) {
            Collections.sort(l);
        }
        Collections.sort((List) tn, new Comparator<List<Integer>>() {            public int compare(List<Integer> o1, List<Integer> o2) {
                for (int i = 0; i < o1.size(); i++) {
                    if (!o1.get(i).equals(o2.get(i))) {
                        return o1.get(i) - o2.get(i);
                    }
                }
                return 0;
            }
        });
        //去重复
        for (int i = 1; i < tn.size(); i++) {
            List<Integer> a = tn.get(i - 1);
            List<Integer> l = tn.get(i);
            if (a.get(0).equals(l.get(0))) {
                if (a.containsAll(l) && l.containsAll(a)) {
                    tn.remove(i);
                    i--;
                }
            }
        }
        return tn;
    }

Answer 4

public static void test4(int[] array, int begin, int num, int cVal, int val, List<Integer> result)
{
if (result.size()==num)
{
if (cVal==val)
{
System.out.println(result);
}
return;
}
for (int i = begin; i<array.length; i++)
{

if (cVal<val&&result.size()<num)
{
result.add(array[i]);
cVal += array[i];
test4(array,i+1, num, cVal, val, result);
cVal -= result.remove(result.size()-1);
}
}
} public static void main(String[] args)
{
int[] array = { 1, 2, 3, 4 ,5,6,7,8,9};
test4(array, 0, 3, 0, 11, new ArrayList());
}

Answer 5

没注意，上面的是取不重复的数。 static Set<List> set=new HashSet<List>();
public static void test4(int[] array, int begin, int num, int cVal, int val, List<Integer> result)
{
if (result.size()==num)
{
if (cVal==val)
{
List t =new ArrayList(result);
Collections.sort(t);
set.add(t);
}
return;
}
for (int i = begin; i<array.length; i++)
{
if (cVal<val&&result.size()<num)
{
result.add(array[i]);
cVal += array[i];
test4(array,0, num, cVal, val, result);
cVal -= result.remove(result.size()-1);
}
}
}
//1-3-5、1-4-4、2-2-5、2-3-4，3-3-3
public static void main(String[] args)
{
int[] array = { 1, 2, 3, 4 ,5};
test4(array, 0, 3, 0, 3*3, new ArrayList());
System.out.println(set);
}

Answer 6

/**
 *
 *在做一个考试系统，用户输入了考试要出多少道题目，和平均难度系数，我想得出根据这个平均系数能产生多少种可能，
 *难度系数是1-5；
 *比如用户选择3道选择题，平均系数为3，应该显示1-3-5、1-4-4、2-2-5、2-3-4，3-3-3.
 *
 * @author  xuemingyuan
 * @version  [版本号, Sep 29, 2011]
 * @see  [相关类/方法]
 * @since  [产品/模块版本]
 */
public class TestTools
{
    private static String diffCodeff = "2-8";    public static void main(String[] args)
    {        int num = 30;
        int avgCodeff = 3;
        test(num, avgCodeff);
    }    private static void test(int num, int avgCodeff)
    {
        String[] strArr = diffCodeff.split("-");        //难度系数小于最小,大于最大
        if (avgCodeff < Integer.parseInt(strArr[0]) || avgCodeff > Integer.parseInt(strArr[1]))
        {
            return;
        }        //难度系数1
        if (Integer.parseInt(strArr[0]) == avgCodeff)
        {
            System.out.println("全部题目的难度系数位:" + Integer.parseInt(strArr[0]));
            return;
        }
        //难度系数5
        if (Integer.parseInt(strArr[1]) == avgCodeff)
        {
            System.out.println("全部题目的难度系数位:" + Integer.parseInt(strArr[1]));
            return;
        }        //平均系数与题目积
        int avgNum = num * avgCodeff;
        //集合
        Set<String> set = new TreeSet<String>();
        //随机实例
        Random ra = new Random();
        //自增值
        int n = 0;        //10000此循环 TODO
        while (n < 1000000)
        {
            List<Integer> list = new LinkedList<Integer>();
            for (int i = 0; i < num; i++)
            {
                //TODO
                list.add(ra.nextInt(Integer.parseInt(strArr[1]) + 1));
            }            int sum = 0;
            for (int i = 0; i < num; i++)
            {
                if ((list.get(i) >= Integer.parseInt(strArr[0])))
                {
                    sum += list.get(i);
                }
            }            if (avgNum == sum)
            {
                Object[] tArr = (Object[])list.toArray();
                Arrays.sort(tArr);
                List<Object> ll = Arrays.asList(tArr);                if (!ll.toString().startsWith("[0"))
                {
                    set.add(ll.toString());
                }
            }
            n++;
        }        System.out.println(set);
    }}