Java 在预定义的数字之间分配用户输入

我正在尝试用java构建一个简单的输入/输出程序。该程序应从用户处获取输入，然后将其分配到预定义的数字中。例如，假设用户输入452，预定义值为300、200、100、50。程序应该以如下字符串格式给出输出：“1x300、0x200、1x100、1x50，剩余部分为2。”但是，我无法理解代码。

此解决方案应该有效：

int[] values = {300, 200, 100, 50};
int[] multipliers = new int[values.length];

int input = 452;

for(int i = 0; i < values.length; ++i)
{
    if(input < values[i])
    {
        continue;
    }
    else
    {
        multipliers[i] = input / values[i];
        input = input % values[i];
        // It will automatically be an integer because of implict conversion
    }
}

for(int i = 0; i < multipliers.length; ++i)
{
    System.out.println(multipliers[i]+"x"+values[i]);
}

System.out.println("Remainder is "+input);

int[]值={30020010050}；
int[]乘数=新的int[values.length]；
int输入=452；
对于（int i=0；i

说明： 假设值是按降序输入的，我们循环通过

值

，并将乘法器的每个元素设置为

值[i]

可以分割输入的次数。然后我们将输入设置为

值[i]

中的余数（使用模

%

运算符）

---

最后，所有乘法器都将正确设置，输入将等于余数。通常，您应该向我们提供您尝试过的代码，以获得帮助

所以我可以自由地用我的方式思考解决方案

public static void main(String[] args){

    //should be in descending order
    //key represents predef value
    //value represents the count of predef value
    Map<Integer, Integer> predefinedValues = new LinkedHashMap<>();
    predefinedValues.put(300, 0);
    predefinedValues.put(200, 0);
    predefinedValues.put(100, 0);
    predefinedValues.put(50, 0);

    //get lowestPredef
    int lowestPredef = 50;

    //get input
    int input = 655;

    //iterate until input is higher than lowest
    while(input > lowestPredef){

        //iterate all predefined values
        for(Map.Entry<Integer, Integer> entry : predefinedValues.entrySet()){

            int key = entry.getKey();
            int value = entry.getValue();

            //find and stop at first lower value than input
            if(input > key){

                //substract that value from input
                input -= key;

                //count +1 for that value
                predefinedValues.put(key, value + 1);

                //break for-loop
                break;

            }

        }

    }

    //build a string with result
    StringBuilder result = new StringBuilder("");
    for(Map.Entry<Integer, Integer> entry : predefinedValues.entrySet()){

        result.append(entry.getValue())
                .append("x")
                .append(entry.getKey())
                .append(", ");

    }
    result.append("with a remainder of ")
            .append(input);

    System.out.print(result.toString());

}

publicstaticvoidmain（字符串[]args）{
//应该按降序排列
//键表示predef值
//值表示predef值的计数
Map predefinedValues=新建LinkedHashMap（）；
预定义的值。put（300，0）；
预定义的值。put（200，0）；
预定义的值。put（100，0）；
预定义的值。put（50，0）；
//降到最低
int-lowestPredef=50；
//获取输入
int输入=655；
//迭代直到输入高于最低值
while（输入>下限）{
//迭代所有预定义值
for（Map.Entry:predefinedValues.entrySet（））{
int key=entry.getKey（）；
int value=entry.getValue（）；
//在第一个低于输入的值时查找并停止
如果（输入>键）{
//从输入中减去该值
输入-=键；
//计算该值的+1
预定义的值。put（键，值+1）；
//循环中断
打破
}
}
}
//生成一个包含结果的字符串
StringBuilder结果=新的StringBuilder（“”）；
for（Map.Entry:predefinedValues.entrySet（））{
result.append（entry.getValue（））
.附加（“x”）
.append（entry.getKey（））
.附加（“，”）；
}
result.append（“带余数”）
.附加（输入）；
System.out.print（result.toString（））；
}

此代码适用于每个数字

public static void main(String[] args) {
        int value = 452;
        Map<Integer, Integer> listofmultiples = new HashMap();
        listofmultiples.put(300, 0);
        listofmultiples.put(200, 0);
        listofmultiples.put(100, 0);
        listofmultiples.put(50, 0);
        int lastKey = 0;
        lastKey = (int) listofmultiples.keySet().toArray()[0];
        int i = listofmultiples.size();
        int valueforkey = 0;
        while (value > lastKey) {
            int key = (int) listofmultiples.keySet().toArray()[i - 1];
            if (value > key) {
                value %= key;
                valueforkey += 1;
                listofmultiples.put(key, valueforkey);
            }
            else{
                i-=1;
                valueforkey=0;
            }
        }
        System.out.println(listofmultiples.toString());
        System.out.println(value);
    }

publicstaticvoidmain（字符串[]args）{
int值=452；
Map listofmultiples=新HashMap（）；
多重输入列表（300，0）；
多重输入列表（200，0）；
多重输入列表（100，0）；
多重输入列表（50，0）；
int lastKey=0；
lastKey=（int）listofmultiples.keySet（）.toArray（）[0]；
int i=listofmultiples.size（）；
int valueforkey=0；
while（值>最后一个键）{
int key=（int）listofmultiples.keySet（）.toArray（）[i-1]；
如果（值>键）{
value%=键；
valueforkey+=1；
多重输入列表（key，valueforkey）；
}
否则{
i-=1；
valueforkey=0；
}
}
System.out.println（listofmultiples.toString（））；
系统输出打印项次（值）；
}

实际上，如果您喜欢

if（输入>=values[i]）

和

字符串，则条件是无用的。如果您不想存储
乘法器
数组并再次使用循环打印，则可以使用格式
将信息存储为字符串。如果不使用循环，您会怎么做？format仅将信息存储为字符串，但我们需要再次对其进行迭代。