0

我正在使用如下所示的列表：-

List<Integer> integerlist = new ArrayList<Integer>();

integerlist=primeFactors(numberToBERadical);

当我 sysOut 时，primeFactors 方法返回一些数字：-

System.out.println("integer list=="+integerlist);
integer list==[2, 2, 2, 3, 5]

我的问题是我想计算每个数字出现多少次，这样我就可以像这样显示：-

2^3 * 3 * 5
4

5 回答 5

3

您需要将每个因素与其出现的次数（指数）相关联。

为此，比 List 更好的数据结构是Map<Integer,Integer>.

假设您仍然List从您的primeFactors(numberToBERadical);（假设您无法更改或出于某种原因不想更改）。

您可以执行以下操作：

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();

    list.add(2);
    list.add(2);
    list.add(2);
    list.add(3);
    list.add(3);
    list.add(5);

    Map<Integer, Integer> factors = new HashMap<>();
    for(Integer fact: list){
        if(!factors.containsKey(fact)) { factors.put(fact, 1);}
        else {
            Integer value = factors.get(fact);
            factors.put(fact, ++value);
        }
    }
    System.out.println(factors);
}

印刷：{2=3, 3=2, 5=1}

于 2013-02-19T12:03:28.417 回答
2

如果数组已排序，您可以像这样计算它们：

int count = 0;
int last = 0; // zero is not possible for prime-factors
for(int i=0;i<list.size();i++) {
    if(i == 0 || last == list.get(i)) count++;
    else {
        if(last > list.get(0)) {
            System.out.print(" * ");
        }

        System.out.print(last + (count > 1 ? "^" + count: ""));
        count = 1;
    }
    last = list.get(i);
}
//print last sequence.
if(last > 0) {
    if(last > list.get(0)) {
        System.out.print(" * ");
    }

    System.out.print(last + (count > 1 ? "^" + count: ""));
}
于 2013-02-19T12:02:21.397 回答
1

一种可能但不是最简单的解决方案：

public Map<Integer, AtomicInteger> primeFactors(List<Integer integerList) {
  final Map<Integer, AtomicInteger> count = new HashMap<Integer, AtomicInteger>();

  for (final Integer number : integerlist) {
    if (count.containsKey(number)) {
      count.get(number).incrementAndGet();
    } else {
      count.put(number, new AtomicInteger(1));
    }
  }

  return count;
}
于 2013-02-19T12:01:24.317 回答
1

您需要使用一个Map<Integer, Integer>可以覆盖该put方法的方法来计算每个Integer.

final Map<Integer, Integer> myStringMap = new HashMap<>(){
 @override
 public String put(final Integer key, final Integer value) {
   if(contains(key)) {
     return put(key, get(key) + 1);
   } else {
     return put(key, 1);
   } 
 }
};

您甚至可以使用 aTreeMap按大小对主要因素进行排序。我在这里回答了一个非常相似的问题。只需循环您的List并将其转储到地图中

for(final Integer integer : myList) {
  myCountingMap.put(integer, 1);
}

更好的是更改您的因式分解方法以返回 aMap开始。

于 2013-02-19T12:01:28.560 回答
1 
List<Integer> inputList = new ArrayList<Integer>();

    inputList.add(2);
    inputList.add(2);
    inputList.add(2);
    inputList.add(3);
    inputList.add(3);
    inputList.add(4);

    Map<Integer, Integer> resultMap = new HashMap<Integer, Integer>();

    boolean flag = false;

    for(int val : inputList)
    {
        if(resultMap.get(val) == null)
        {
            resultMap.put(val, 1);
        }
        else
        {
            resultMap.put(val, (resultMap.get(val).intValue())+1);
        }
    }

    for(int key : resultMap.keySet())
    {
        if(resultMap.get(key) == 1)
        {
            if(!flag)
            {
                System.out.print(key);
                flag = true;
            }
            else
            {
                System.out.print("*"+key);
            }
        }
        else
        {
            if(!flag)
            {
                System.out.print(key+"^"+resultMap.get(key));
                flag = true;
            }
            else
            {
                System.out.print("*"+key+"^"+resultMap.get(key));
            }
        }
    }

    System.out.println();
于 2013-02-19T13:07:02.807 回答