Question

JAVA 求2~1000中的所有亲密数对(亲密数对是指:如果A的因子和等于B,B的因子和等于A

Answer 1

public class QinMi {

private int a[] = new int[999];//存储2-1000的每个数的因子和
private int duiShui = 0;//亲密数的对数

public int[] jiSuan() {
for (int i = 2; i <= 1000; i++) {//外层循环是从2-1000
int sum = 0;
for (int j = 1; j < i; j++) {//判断该数是不是可以被整除、排除本身
if (i % j == 0) {
sum += j;//计算该数的因子和
}
a[i - 2] = sum;//存储到容器中
}
}

return a;
}

public void howMany() {//计算有多少对
for (int i = 0; i < a.length - 1; i++) {//用的是选择排序的思想
for (int j = i + 1; j < a.length; j++) {
if (a[i] == a[j]) {//如果相等对数就增加一次
duiShui++;
}
}
}
System.out.println(duiShui);

}

public static void main(String[] args) {
QinMi a = new QinMi();
a.jiSuan();
a.howMany();

}

Answer 2

package test;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class RelationNumUtils {
/**
* 定义一个保存亲密数的map
*/
private Map<Integer, Integer> relationNumMap = null;

/**
* 给定数字范围的开始
*/
private int startNum;

/**
* 给定数字范围的结束
*/
private int endNum;

/**
* 因子的和不在范围内的默认值
*/
private static final int DEFAULT_SUM_NUM_WHIOUT_RELATION = 0;

/**
* 构造方法
*
* @param startNum 给定数字范围的开始
* @param endNum 给定数字范围的结束
*/
public RelationNumUtils(int startNum, int endNum) {
relationNumMap = new ConcurrentHashMap<Integer, Integer>();
this.startNum = startNum;
this.endNum = endNum;
}

/**
* 对外暴漏的方法，提供得到对数
* @return 返回map
*/
public Map<Integer, Integer> getNumMap() {
ThreadGroup numGroup = new ThreadGroup("numGroup");
for (int i = startNum; i <= endNum; i++) {
final int indexNum = i;
new Thread(numGroup, new Runnable() {
@Override
public void run() {
putRelationNumToMap(indexNum);
}
}).start();
}
return relationNumMap;
}

/**
* 讲符合规则的对数放入map中
* @param num
*/
private void putRelationNumToMap(int num) {
int sumNum = getSumNum(num);
if (DEFAULT_SUM_NUM_WHIOUT_RELATION != sumNum) {
relationNumMap.put(num, sumNum);
}
}

/**
* 得到因数的和，如果和不在制定范围，返回默认值
* @param num 求和的数字
* @return 求得的和
*/
private int getSumNum(int num) {
int result = DEFAULT_SUM_NUM_WHIOUT_RELATION;
for (int i = 1; i <= num; i++) {
if (canDivided(num, i)) {
result += i;
}
}
if (startNum > result || endNum < result)
{
return DEFAULT_SUM_NUM_WHIOUT_RELATION;
}
return result;
}

/**
* 能否被整除，能返回true，否则false
*
* @param numerator 除数
* @param denominator 被除数
*/
private boolean canDivided(int numerator, int denominator) {
return numerator % denominator == 0;
}

public static void main(String[] args) {
RelationNumUtils rnu = new RelationNumUtils(2, 1000);
Map<Integer, Integer> resultMap = rnu.getNumMap();
for (Map.Entry<Integer, Integer> entry : resultMap.entrySet()) {
System.out.println(entry.getKey() + "=====" + entry.getValue());
}
}
}