如何将for循环每次迭代的结果存储到java中的数组中

Question

计分器（100分）

Praveen正在学校找一份计算机科学教师的工作。他多次被不同的学校拒绝，但这次他决心得到这份工作。他去找圣玛丽学校的校长。

校长说他的学校有等级和学分制。有N个科目，每个科目都有一个学分

A = 10, 
A(minus) = 9, 
B = 8, 
B(minus) = 7, 
C = 6, 
C(minus) = 5 

现在，如果有3个科目的学分分别为4、3和2，并且某个学生在这3个科目中的分数分别为a（负）、B和C，那么他的分数计算如下：总分=每个科目的分数和相应学分的乘积之和。

= ( (9*4) + (3*8) + (2*6) ) = 72.

他希望Praveen通过给每个科目分配不同的分数，来告诉一个学分为N个科目的学生可能得到的不同总分。

输入格式您的函数包含一个参数——一个由N个元素组成的一维整数数组，其中每个元素表示该主题的信用。输入的第一行包含一个整数N，表示数组的大小。接下来N行输入，每行包含一个整数，表示第i个主题的信用Ci

Constraints
1 <= N <= 100
1 <= Ci <= 5

输出格式您必须返回一个整数，表示可能给出的分数总数。

Sample TestCase 1
Input

2
1
2
Output

16

现在我正在写这样的代码

package javaapplication1;

import java.util.Scanner;

public class CandidateCode {
    private static void possibleCombination(int input) {
        int i=0;
        int[] a=new int[Grades.length];

        a[i]=input;
        System.out.println("the a is "+a[i]);
    }

    private static final int[] Grades = new int[]{10, 9, 8, 7, 6, 5, 4, 3, 2, 1};

    public static void main(String[] args) {
        int i=0,j,totalSummation=0;
        Scanner uInput = new Scanner(System.in);
        System.out.println("Enter length of Array:");
        int index = uInput.nextInt();
        int[] Credit = new int[index];
        for (i = 0; i <= Credit.length-1; i++) {
            Credit[i] = uInput.nextInt();
            System.out.println("credit is" + Credit[i]);
            for ( j = 0; j <= Grades.length - 1; j++) {
                totalSummation = +(Grades[j] * Credit[i]);
                possibleCombination(totalSummation);
                // System.out.println("total sum is " + totalSummation);
            }
        } 
    }
}

现在我想存储每次迭代计算的值。。。意思是迭代第一次的值是10,9,8,7,6,5,4,3,2,1迭代第二次的值是20,18,16,14,10,8,6,4,2

我想将第一次迭代的每个值与第二次迭代的所有值相加。i，e10 20, 10 18, 10 16, 10 14, 10 10, 10 8, 10 6, 10 4, 10 29,8,7,6,5,4,3,2,1

为了实现这一点，我需要存储每次迭代的值，但我被困在这里，请大家帮我摆脱这个问题谢谢你提前。

Answer 1

好的，按照我们在评论中的讨论：你不需要两个for循环。

for i = 0; i < array.size(); i++ {
    sum += grade[i]*credit[i]
 }

抱歉，这是一种通用的编码风格。这是你想要的吗？

Answer 2

如果您不想存储在多维数组中，那么您需要将每个迭代存储在单维数组中，如下所示。但是这段代码只适用于两个学分。

public class CandidateCode {

        private static int possibleCombination(int input)
        {   int i=0;
            int[] a=new int[Grades.length];
             a[i]=input;
              return a[i];

        }
        private static final int[] Grades = new int[]{10, 9, 8, 7, 6, 5, 4, 
                           3, 2, 1};

        public static void main(String[] args) {
            int i=0,j,totalSummation=0;
            Scanner uInput = new Scanner(System.in);
            System.out.println("Enter length of Array:");
            int index = uInput.nextInt();             
            int[] Credit = new int[index];
            int[] creditarr = new int[10];
            int[] credit1 = new int[10];
            int[] credit2 = new int[10];
            for (i = 0; i <= Credit.length-1; i++) {
                Credit[i] = uInput.nextInt();

                System.out.println("credit is" + Credit[i]);
                for ( j = 0; j <= Grades.length - 1; j++) {
                    totalSummation = +(Grades[j] * Credit[i]);
                     creditarr[j]=possibleCombination(totalSummation);
                     if(Credit[i]==1) {
                     credit1[j]=creditarr[j];  
                     }
                     if(Credit[i]==2){
                     credit2[j]=creditarr[j];
                     }
                    }
                }

            for(int k=0;k<credit1.length;k++) {
                for(int l=0;l<credit2.length;l++) {
                    int final_no=credit1[k]+credit2[l];
                    System.out.println("final_no :"  +final_no);
                }
            }
            }

         }

这就是你想要的吗？

我想下面的代码将是最好的解决方案。这个代码将适用于你提到的学分。

public class Candidate {
 private static final int[] Grades = new int[]{10, 9, 8, 7, 6, 5};

public static void main(String[] args) {
    // TODO Auto-generated method stub
    int i=0,score=0,totalsummation=0;
    Scanner uInput = new Scanner(System.in);
    System.out.println("Enter length of Array:");
    int arraylength = uInput.nextInt();             
    int[] credits= new int[arraylength];
    ArrayList<Integer> combination = new ArrayList<Integer>();
    for (i = 0; i <credits.length; i++) {
        credits[i] = uInput.nextInt();  
    }
    switch(credits.length) {
    case 1:
        for(int c1=10;c1>=5;c1--) {
            totalsummation = c1*credits[0];
            combination.add(totalsummation);
        }
        break;

    case 2:
        for(int g:Grades) {
            for(int c2=10;c2>=5;c2--) {
                totalsummation=g*credits[0]+c2*credits[1];
                combination.add(totalsummation);
            }
        }
        break;

    case 3:
            for(int g:Grades) {
            for(int c3=10;c3>=5;c3--) {
                totalsummation=g*credits[0]+c3*credits[1]+c3*credits[2];
                combination.add(totalsummation);
            }
        }
            break;
    case 4:
        for(int g:Grades) {
            for(int c4=10;c4>=5;c4--) {
                totalsummation=g*credits[0]+c4*credits[1]+c4*credits[2]+c4*credits[3];
                combination.add(totalsummation);    
            }
        }
        break;

    case 5:
        for(int g:Grades) {
            for(int c5=10;c5>=5;c5--) {
                totalsummation=g*credits[0]+c5*credits[1]+c5*credits[2]+c5*credits[3]+c5*credits[4];
                combination.add(totalsummation);
            }
        }
        break;

        default:
            System.out.println("Invalid Input");
    }



 ArrayList<Integer> distinctnos =(ArrayList<Integer>) combination.stream().distinct().collect(Collectors.toList());
     System.out.println(distinctnos.size());            }
}

希望这回答了你的问题。

Answer 3

    import java.io.*;
    import java.util.*;
    import java.util.stream.Collectors;
    public class Sample {
        public static void main(String args[] ) throws Exception {

            Scanner scan = new Scanner(System.in);
            int nValue = scan.nextInt();
            if(nValue<1 || nValue>100){
                System.out.println("Array Value cannot be less than 1 or greater than 100");
            }
            int[] inputCredits = new int[nValue];
            for( int i=0 ; i < nValue ; i++){
                inputCredits[i]=scan.nextInt();
                if(inputCredits[i]<1 || inputCredits[i]>5){
                    System.out.println("Credit Value cannot be less than 1 or greater than 5");
                }
            }
            List<Integer> list1 = Arrays.stream(inputCredits).boxed().collect(Collectors.toList());
            List<Integer> list2 = Arrays.asList(5,6,7,8,9,10);
//checked for basic constraints up till this point
//Next what we multiply all the inputted Credits with the possible grades and 
// store in the list where x input Credits will produce a list of x*6 entries 
// where first six entries are the possibilities for the first Credit, next 6 
// entries for the 2nd credit and so on, having this knowledge we loop through // the list to get all the possible scores 
            List<Integer> permutedList = list1.stream().flatMap(i -> list2.stream().map(j -> i*j)).collect(Collectors.toList());

            List<Integer> listForDistinctSet= new ArrayList<Integer>();
            for(int i=0; i<6 ; i++){
                listForDistinctSet.add(permutedList.get(i));
            }
            Set<Integer> distinctSet = new HashSet<Integer>();

            for(int j=6,k=j+6;k<=permutedList.size();j=k,k=k+6){
                Set<Integer> newSet = new HashSet<Integer>();
                for(int i=0; i<listForDistinctSet.size(); i++){

                    for(; j<k ; j++){
                        int sum = listForDistinctSet.get(i) + permutedList.get(j);
                        newSet.add(sum);
                    }
                    j=k-6;
                }
                distinctSet=newSet;
                listForDistinctSet = new ArrayList<>(distinctSet);
            }
            System.out.println(distinctSet.size());

       }
    }