Java 如何将随机运算符（例如&x2B；或-）放在数字前面？

我想知道回答求和问题的最小数字

*1*2*3*4…*n=k

（

*

表示

+

或

-

）。例如：

• 对于

  k=0

  ：

  +1+2-3=0

  ，最小的答案是

  3

• 对于

  k=4

  ：

  -1+2+3=4

  ，因此最小的答案是

  3

• 对于

  k=12

  ：

  -1+2+3+4+5+6-7=12

  ，因此最小的答案是

  7

  。 //4=-1+2+3

  // 5 = +1-2-3+4-5
  // 6 = +1+2+3
  
  // 7 = -1+2-3+4+5
  // 8 = -1+2+3+4
  // 9 = -1-2+3+4+5
  
  // 10 = +1+2+3+4
  // 11 = +1-2+3+4+5
  
  // 12 = -1+2+3+4+5+6-7
  // 13 = -1+2-3+4+5+6
  // 14 = -1+2+3+4+5
  

有什么算法可以做到这一点吗

import java.util.Random;
import java.util.Scanner;

public class EX_03 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int Case = sc.nextInt();
        int arr[] = new int[Case];
        int sum[] = new int[Case];
        int k = 0;
        int count = 0;

        for (int i = 0; i < Case; i++) {
            arr[i] = sc.nextInt();
        }

        for (int i = 0; i < Case; i++) {
            while (true) {
                ++k;
                if(count==0){
                sum[i] += k;
                count++;}
                else{
                    sum[i] -= k;
                }
                if(sum[i] == arr[i]) break;

            }
        }
        // 0 = +1+2-3
                // 1 = +1
                // 2 = +1-2+3
                // 3 = +1+2

        // 4 = -1+2+3

        // 5 = +1-2-3+4-5
        // 6 = +1+2+3

        // 7 = -1+2-3+4+5
        // 8 = -1+2+3+4
        // 9 = -1-2+3+4+5

        // 10 = +1+2+3+4
        // 11 = +1-2+3+4+5

        // 12 = -1+2+3+4+5+6-7
        // 13 = -1+2-3+4+5+6
        // 14 = -1+2+3+4+5

        // 15 = 123456

        /*
         * Random operatorChoice = new Random(); int operator =
         * operatorChoice.nextInt(2);
         * 
         * while (k >= 0) { ++k; for (int i = 0; i < Case; i++) { switch
         * (operator) { case 0: sum[i] += k; break; case 1: sum[i] -= k; break;
         * default: break; } if(sum[i] == arr[i]) break; else continue; } }
         */

        for (int i = 0; i < Case; i++) {
            System.out.println(k);
        }

    }

}

该输入的预期输出：

7 2701

使用这个想法（samgak建议）：

更改其中一个数字的符号始终会更改偶数的总和

那么，你需要多少个数字才能得到9的和？它必须是奇数（

*1*2*3

或

*1*2*3*4*5

或

*1*2*3*4*5*6*7

或…），这是您需要注意的第一件事

---

然后，考虑最大和：

+1+2+3+...+n

计算这个总数很容易（我忘了答案，但很容易）

---

然后（这是最重要的一步），尝试改变符号并检查总和发生了什么：

+1+2+3+4+5 = 10
-1+2+3+4+5 = ? (the sum is smaller by an even number)
+1-2+3+4+5 = ? (the sum is smaller by another even number)
+1+2-3+4+5 = ? (the sum is smaller by another even number)
+1+2+3-4+5 = ? (the sum is smaller by another even number)
+1+2+3+4-5 = ? (the sum is smaller by another even number)

---

从这里开始，制作算法就很容易了。请记住，您实际上不需要打印表达式（sum）本身，只需要证明它存在。因此，无需在上面的列表中找到您的目标编号的确切位置，只需找到该列表的长度。

您可以尝试改进使用递归性的代码

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 *
 * @author Aroniaina
 */
public class RandomOperator {

    public static HashMap<Integer, List<Integer>> possibilities(Integer current) {
        //Return -1 and 1 if current si equal to 1
        if (current == 1) {
            HashMap<Integer, List<Integer>> result = new HashMap<>();
            //Add positive possibility
            List<Integer> list1 = new ArrayList<>();
            list1.add(current);
            result.put(current, list1);
            //Add negative possibility
            List<Integer> list2 = new ArrayList<>();
            list2.add(-1 * current);
            result.put(-1 * current, list2);
            return result;
        } else {
            HashMap<Integer, List<Integer>> previous = possibilities(current - 1);
            HashMap<Integer, List<Integer>> temp = new HashMap<>();
            temp.putAll(previous);
            for (Integer prev : previous.keySet()) {
                if (previous.get(prev).size() == (current - 1)) {
                    //Add positive possibility                
                    List<Integer> list1 = new ArrayList<>();
                    list1.addAll(previous.get(prev));
                    list1.add(current);
                    temp.put(current + prev, list1);
                    //Add negative possibility
                    List<Integer> list2 = new ArrayList<>();
                    list2.addAll(previous.get(prev));
                    list2.add(-1 * current);
                    temp.put(-1 * current + prev, list2);
                }
            }
            return temp;
        }
    }

    public static void main(String args[]) {
        for (int i = 0; i < 20; i++) {
            Integer toVerify = i;
            int current = 1;
            while (true) {
                HashMap<Integer, List<Integer>> result = possibilities(current);
                if (result.keySet().contains(toVerify)) {
                    System.out.print(toVerify + " = ");
                    for (Integer e : result.get(toVerify)) {
                        System.out.print(e > 0 ? ("+" + e) : (e));
                    }
                    break;
                }
                current++;
            }
            System.out.println("");
        }
    }
}

---

关于

n

？也许我完全错了，但是你的标题似乎与你的问题不匹配嗨，欢迎来到SO！那作业是偶然做的吗？[input]12-3646397[output]7 2701提示：更改其中一个数字的符号总是会将总和更改为偶数。多谢分析。但我不明白“改变其中一个数字的符号总是改变一个偶数的总和”，而且我的英语说得不是很好。。。所以，如果你展示一些代码，我会读的！我想我答案的第三部分（带问号的部分）是你需要的。试着计算总和（用数字替换问号），你就会明白我想说什么。注意：我不想提供代码，因为问题要求的是算法，而不是代码。这个问题更有用，也更有趣，因为这种方式代码需要很多注释和算法的描述。。。谢谢你，伙计。你是最好的程序员。我可以学到很多东西。我将进一步学习。非常感谢你的代码。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 *
 * @author Aroniaina
 */
public class RandomOperator {

    public static HashMap<Integer, List<Integer>> possibilities(Integer current) {
        //Return -1 and 1 if current si equal to 1
        if (current == 1) {
            HashMap<Integer, List<Integer>> result = new HashMap<>();
            //Add positive possibility
            List<Integer> list1 = new ArrayList<>();
            list1.add(current);
            result.put(current, list1);
            //Add negative possibility
            List<Integer> list2 = new ArrayList<>();
            list2.add(-1 * current);
            result.put(-1 * current, list2);
            return result;
        } else {
            HashMap<Integer, List<Integer>> previous = possibilities(current - 1);
            HashMap<Integer, List<Integer>> temp = new HashMap<>();
            temp.putAll(previous);
            for (Integer prev : previous.keySet()) {
                if (previous.get(prev).size() == (current - 1)) {
                    //Add positive possibility                
                    List<Integer> list1 = new ArrayList<>();
                    list1.addAll(previous.get(prev));
                    list1.add(current);
                    temp.put(current + prev, list1);
                    //Add negative possibility
                    List<Integer> list2 = new ArrayList<>();
                    list2.addAll(previous.get(prev));
                    list2.add(-1 * current);
                    temp.put(-1 * current + prev, list2);
                }
            }
            return temp;
        }
    }

    public static void main(String args[]) {
        for (int i = 0; i < 20; i++) {
            Integer toVerify = i;
            int current = 1;
            while (true) {
                HashMap<Integer, List<Integer>> result = possibilities(current);
                if (result.keySet().contains(toVerify)) {
                    System.out.print(toVerify + " = ");
                    for (Integer e : result.get(toVerify)) {
                        System.out.print(e > 0 ? ("+" + e) : (e));
                    }
                    break;
                }
                current++;
            }
            System.out.println("");
        }
    }
}

0 = -1-2+3
1 = +1
2 = +1-2+3
3 = +1+2
4 = -1+2+3
5 = +1+2+3+4-5
6 = +1+2+3
7 = -1+2-3+4+5
8 = -1+2+3+4
9 = -1-2+3+4+5
10 = +1+2+3+4
11 = +1-2+3+4+5
12 = -1+2+3+4+5+6-7
13 = -1+2+3+4+5
14 = +1+2+3+4+5+6-7
15 = +1+2+3+4+5
16 = +1+2+3+4+5-6+7
17 = +1-2+3+4+5+6
18 = +1+2+3+4-5+6+7
19 = -1+2+3+4+5+6