0

私は以下に示すようにリストを使用しています:-

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

integerlist=primeFactors(numberToBERadical);

PrimeFactors メソッドは、次のように sysOut すると、いくつかの数値を返します:-

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

私の問題は、次のように表示できるように、各数字が表示される回数を数えたいことです:-

2^3 * 3 * 5
4

5 に答える 5

3

各要因を発生回数 (指数) に関連付ける必要があります。

そのためには、リストよりも優れたデータ構造は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

考えられる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 
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 に答える
1

それぞれのインスタンスをカウントするにはMap<Integer, Integer>、メソッドをオーバーライドできるを使用する必要があります。putInteger

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);
   } 
 }
};

a を使用TreeMapして素因数をサイズでソートすることもできます。ここで非常によく似た質問に答えました。ループしListてマップにダンプするだけです

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

因数分解方法を変更して、最初に a を返すことをお勧めMapします。

于 2013-02-19T12:01:28.560 に答える