黑马程序员技术交流社区

标题: -------------新版块第一期答题活动--------------- [打印本页]

作者: 张智文 时间: 2013-8-7 12:25
标题: -------------新版块第一期答题活动---------------
本帖最后由张智文于 2013-8-10 21:04 编辑

设计一个程序是求9999以内的“自身数”，并打印出其所有约数。所谓自身数是指这样的自然数：它的各个约数(不包括该数自身)之和等于该数自身。
如28=1+2+4+7+14就是一个完全数。要求：打印需满足以下格式。

            A：约数1  约数2  约数3...... 例如 6： 1 2 3
            B：约数1  约数2  约数3......       28： 1 2 4 7 14
            C：约数1  约数2  约数3......       496： 1 2 4 8 16 31 62 124 248

本题由实习版主-张智文提供，大家快点答题哦！

作者: 李政 时间: 2013-8-7 13:43
本帖最后由李政于 2013-8-7 13:51 编辑

class Demo
{
public static void main(String[] args)
{
for(int x =1;x<=9999;x++){//对1~9999之间作循环判断
int y = yueshu(x);
if(x==y){
StringBuilder sb = new StringBuilder();//为打印规则服务
int count = 1;
while(count<x){
if(x%count == 0)
sb = sb.append("数"+new Integer(count).toString()+" ");
count++;
}
System.out.println(x+" "+sb.toString());
}
}
}
public static int yueshu(int i){//检测这个数是否是自身数
int count = 1;
int sum = 0;
while(count < i){
if(i%count == 0){
sum = sum +count;
}
count++;
}
return sum;
}
}
//简单写了下，有待改进，可以把StringBuilder方法和约数方法合并起来

复制代码

作者: panningwjr 时间: 2013-8-7 15:40
import java.util.ArrayList;

/*
* 设计一个程序是求9999以内的“自身数”，并打印出其所有约数。所谓自身数是指这样的自然数：它的各个约数(不包括该数自身)之和等于该数自身
* */
public class Rhythm {

public static void main(String[] args) {
int num = 9999;
// 循环遍历9999以内的所有数
for (int i = 1; i < num; i++) {
// 定义集合，将所有约数装入集合中
ArrayList<Integer> alist = new ArrayList<Integer>();
// 循环遍历求出指定数的所有约数
for (int j = 1; j < i; j++) {
if (i % j == 0) {
alist.add(j);
}
}
// 循环遍历集合，求出所有约数和，判断是否和原来的数相等
int sum = 0;
for (int approximate : alist) {
sum += approximate;
}
// 如果是自然数，就按指定格式打印
if (sum == i) {
System.out.println(i + ":" + alist.toString());
}
}
}
}

作者: 哪颗最亮的星星 时间: 2013-8-7 17:15
本帖最后由哪颗最亮的星星于 2013-8-7 17:18 编辑

已经做完，请审核！！！

Demo.rar

548 Bytes, 阅读权限: 100, 下载次数: 0

源代码

作者: xscn 时间: 2013-8-7 17:21

import java.util.*;
public class ZiRanShu{
public static void main(String[] args) {
for (int i = 1; i <=9999; i++)
{
List list = GongYueShu(i);
Iterator it = list.iterator();
int sum = 0;
while (it.hasNext()) {
sum += (Integer) it.next();//累加所有约数
}
if (sum == i)
{
sop(list, i);
}
}
}
//用List集合存储这个数的所有公约数
public static List GongYueShu(int num) {
List list = new ArrayList();
for (int i = 1; i < num; i++){
if (num % i == 0) {
list.add(i);
}
}
return list;
}
//制表打印
public static void sop(List l, int i)
{
Iterator it = l.iterator();
if(i<1000)
System.out.print(i+"\t:"+it.next()+"\t");
else
System.out.print(i+":"+it.next()+"\t");
while (it.hasNext())
{
System.out.print(it.next()+"\t");
}
System.out.println();
}
}

复制代码

屏幕截图.jpg (16.65 KB, 下载次数: 74)

作者: xx_lee 时间: 2013-8-7 20:07

[code]
import java.util.*;
class ZiShen
{
public static void main(String[] args)
{
for(int i=2;i<=9999;i++)
{
LinkedList<Integer> lt = new LinkedList<Integer>();
int sum=0;
for(int j=1;j<i;j++)
{
if(i%j==0)
{
sum+=j;
lt.add(j);
}
}
if(i==sum)
{
sop(i+":");
Iterator<Integer> it=lt.iterator();
while(it.hasNext())
{
sop(it.next());
}
System.out.println();
}
}
}
public static void sop(Object obj)
{
System.out.print(obj+" ");
}
}

复制代码

[/code]

0$(MH46PYD6]$)9I1{20)5X.jpg (8.37 KB, 下载次数: 74)

作者: 逆袭的风 时间: 2013-8-7 21:15
完成如下:

/*
设计一个程序是求9999以内的“自身数”，并打印出其所有约数。所谓自身数是指这样的自然数：它的各个约数(不包括该数自身)之和等于该数自身。
要求：打印需满足以下格式。
A：约数1 约数2 约数3...... 例如 6： 1 2 3
B：约数1 约数2 约数3...... 28： 1 2 4 7 14
C：约数1 约数2 约数3...... 496： 1 2 4 8 16 31 62 124 248
*/
class PanDuan
{
public static void ziShenShu()
{
for (int i=2;i<=9999 ;i++ )
{
int sum=0;
for (int j=1;j<=i/2 ;j++ )//一个数的约数最大为其自身的一半
{
if (i%j==0)
{
sum+=j;
}
else
{
continue;
}
}
if (sum==i)//如果是自身数则按规定打印
{
System.out.print(i+": ");//先打印这个数 i:
for (int j=1;j<=i/2 ;j++ )
{
if (i%j==0)
{
System.out.print(j+" ");//打印每个因子
}
}
System.out.println();//当每个数打完后换行
}
}
}
}
class ZiShenShu
{
public static void main(String[] args)
{
PanDuan a=new PanDuan();
a.ziShenShu();
}
}

复制代码

输出如图:

Unnamed.png (50.69 KB, 下载次数: 56)

作者: 夜空闪亮 时间: 2013-8-7 22:12
求9999以内的所有自身数的代码如下：

class SearchItselfNumber
{
public static void main(String[] args)
{
for(int i = 2;i<10000;i++)
{
searchNum(i);
}
}
//寻找自身数并打印输出
public static void searchNum(int num)
{
int sum = 0;
for(int i = 1;i<num;i++)
if(num%i==0)
{
sum+=i;
}
if(sum==num)
{
System.out.print(num+" : ");
for(int i = 1;i<num;i++)
if(num%i==0)
System.out.print(i+" ");
System.out.println();
}
}
}

复制代码

程序运行结果截图如下：

自身数.jpg (15.1 KB, 下载次数: 67)

作者: 黑马李昂 时间: 2013-8-7 23:53

package heima;
/*
* 需求：
* 设计一个程序是求9999以内的“自身数”，并打印出其所有约数。
* 所谓自身数是指这样的自然数：它的各个约数(不包括该数自身)之和等于该数自身。
* 如28=1+2+4+7+14就是一个完全数。要求：打印需满足以下格式。
A：约数1 约数2 约数3...... 例如 6： 1 2 3
B：约数1 约数2 约数3...... 28： 1 2 4 7 14
C：约数1 约数2 约数3...... 496： 1 2 4 8 16 31 62 124 248
*/
public class MathDemo {
public static void main(String[] args) {
System.out.print("9999以内的自身数有：");
for(int i=1;i<9999;i++){
if(perfert(i)!=0)//调用perfert方法
System.out.print(" "+perfert(i));
}
}
//将判断为自身数的条件封装成一个方法
public static int perfert(int m){
int num=0;
for(int i=1;i<m;i++){
if(m%i==0)
num=num+i;
}
if(num==m)
return m;
else
return 0;
}
}

复制代码

作者: 牛牛 时间: 2013-8-8 09:37

/**
* 设计一个程序是求9999以内的“自身数”，并打印出其所有约数。所谓自身数是指这样的自然数：它的各个约数(不包括该数自身)之和等于该数自身。
如28=1+2+4+7+14就是一个完全数。要求：打印需满足以下格式。

            A：约数1  约数2  约数3...... 例如 6： 1 2 3
            B：约数1  约数2  约数3......       28： 1 2 4 7 14
            C：约数1  约数2  约数3......       496： 1 2 4 8 16 31 62 124 248

* @author Administrator
*
*/
public class Exercise_5 {

public static void main(String[] args) {
getAllApproximate(6);
System.out.println();
getAllApproximate(28);
System.out.println();
getAllApproximate(496);
System.out.println();
}
/**
   * 获得num的约数(不包括该数自身)
   * @param num
   */
public static void getAllApproximate(int num){
System.out.print(num+":");
for (int i = 1; i <= num/2; i++) {
if(num%i==0){
System.out.print(i+"\t");
}
}
}

}

作者: lvjayj 时间: 2013-8-8 11:29

import java.util.ArrayList;
public class test {
public static void main(String[] args) {
int num;
int i;
for(num=1;num<=9999;num++) //循环9999内的整数
{
int sum = 0; //用于求和
ArrayList<Integer> list = new ArrayList<Integer>(); //用于存放约数
for(i=1;i<=num/2;i++) //循环判断
{
if(num%i==0) //是否为约数
{
list.add(i); //如果是加到list中
sum=sum+i; //累加
}
}
if(sum == num) //如果是自身数，则输出
{
System.out.print(num+":"); //输出自身数
for(int j = 0;j < list.size(); j ++) //输出约数
{
System.out.print(list.get(j)+" ");
}
System.out.println();
}
}
}
}

复制代码

输出结果：
6:1 2 3
28:1 2 4 7 14
496:1 2 4 8 16 31 62 124 248
8128:1 2 4 8 16 32 64 127 254 508 1016 2032 4064

作者: jrry 时间: 2013-8-8 12:02

import java.util.ArrayList;
import java.util.List;
/**
* 求9999以内的“自身数”，并打印出其所有约数。所谓自身数是指这样的自然数：它的各个约数(不包括该数自身)之和等于该数自身。
*
* @author jerry
*
* 思路：求一个数的所有约数：因为一个数的所有约数在1和这个数本身之间（
* 包括1和这个数本身），所以1到这个数之间的所有数取余为0的数为这个数的约数，
* 先求出一个数的所有约数，如果这个数的所有约数之和减去这个数本身等于这个数，则此数为自身数，
*/
public class GetSelfNum {
public static void main(String[] args) {
// 有思路中分析可知0和1不是自身数
for (int i = 2; i < 9999; i++) {
isSelfNum(i);
}
}
/**
* 判断一个数是否为自身数，如果是则打印出来，并打印它的约数
*
* @param num
* 需要判断的数
* @return true Or false
*/
public static boolean isSelfNum(int num) {
// boolean标记记录是否是自身数作为返回值
boolean flag = false;
// 一个数的除了本身外的所有约数的和，初始化为0
int sum = 0;
// 定义一个集合，存放一个数的除了本身外的所有约数
List<Integer> list = new ArrayList<Integer>();
for (int i = 1; i < num; i++) {
// 循环判断获取这个数的约数
if (num % i == 0) {
// 除了这个数本身外的所有约数相加的和赋给sum
sum = sum + i;
// 存入集合
list.add(i);
}
// 判断是否为自身数
if (num == sum)
flag = true;
}
if (!flag)
return flag;
System.out.print(sum + " : ");
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
System.out.println();
return flag;
}
}

复制代码

作者: 熊纪达 时间: 2013-8-8 12:05

import java.util.*;
class Demo
{
public static void main(String[] args)
{
TreeSet<Integer> ts=new TreeSet<Integer>();
int sum=0;
boolean flag=false;
for (int i=1;i<10000;i++ )
{
for (int j=1;j<=(i/2) ;j++ )
{
if((i%j)==0)
ts.add(j);
}
if(ts.isEmpty())
continue;
else
{
for(Integer x :ts)
{
sum+=x;
}
if(sum==i)
{
System.out.print(i+": ");
for(Integer x:ts)
{
System.out.print(x+" ");
}
System.out.println("");
}
sum=0;
ts.clear();
}
}
}
}

复制代码

作者: 白堇翎 时间: 2013-8-8 12:19

package day16;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
* 需求:
* 设计一个程序是求9999以内的“自身数”，并打印出其所有约数。所谓自身数是指这样的自然数：它的各个约数(不包括该数自身)之和等于该数自身。
* 如28=1+2+4+7+14就是一个完全数。要求：打印需满足以下格式。
*
* A：约数1 约数2 约数3...... 例如 6： 1 2 3
* B：约数1 约数2 约数3...... 28： 1 2 4 7 14
* C：约数1 约数2 约数3...... 496： 1 2 4 8 16 31 62 124 248
*
逻辑分析:
1.首先要知道该数字的约数是哪几个数字
2.做一次判断,判断约数之和是否为这个数字本身.若是,打印
功能分析:
1.新建一个类,此类中共有3个私有方法.和一个公共方法
2.方法1用来获取用户输入的数字.
2.1用正则判断该数字是否符合标准,若为否,则提示用户重新输入
3.方法2用来获取该数字的所有约数,并存入集合
3.1可以让该数%2,%3,%4,依次类推,若为零,则往集合添加.
4.方法3用来迭代集合求和
5.方法4对外提供以上所有方法
*/
public class ActTest2 {
public static void main(String[] args) {
getNum get = new getNum();
get.run();
}
}
class getNum {
public void run(){
showUnum(GetList(GetNum()), num);
}
private int num = 0;
private int GetNum() {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String buf = null;
String regex = "[1-9][0-9]{0,3}";
try {
System.out.println("请输入一个数字");
while ((buf = br.readLine()) != null) {
if(buf.matches(regex))
return num = Integer.parseInt(buf);
System.out.println("输入了一个非法数字,请重新输入");
}
} catch (Exception e) {
// TODO Auto-generated catch block
System.out.println("发生了一个错误,请检查");
}
finally{
try {
br.close();
} catch (IOException e) {
// TODO Auto-generated catch block
System.out.println("关闭流失败");
}
}
return -1;
}
private List GetList(int num){
List list = new ArrayList();
int temp = num - 1;
while(temp > 0){
if(num%temp == 0)
list.add(temp);
temp--;
}
return list;
}
private void showUnum(List list,int num){
Iterator it = list.iterator();
int temp = 0;
int buf = 0;
String str = "";
String buff = "";
while(it.hasNext()){
buf = (int)it.next();
temp = temp + buf;
str = str+buf+"*";
}
str = str.substring(0, str.length()-1)+"="+num;
System.out.println(str);
if(temp == num)
System.out.println(num+"是一个自身数");
else
System.out.println(num+"不是一个自身数");
}
}

复制代码

作者: EYE_SEE_YOU 时间: 2013-8-8 13:11
这不是代码，代码我还写不出来，这里我就表达一下菜鸟的思路
设自身数变量为int y=6//因为6是0-9999以内的第一个自身数，我就直接从这里开始好了
设约数变量为int x=1
设一个数组int []arg=int [9999]
两个控制数组的变量 int i=0，int j=0
数组和的变量int sum =0

首先来个外循环，当y<=9999的时候就进入循环，整个循环后y++
接着内循环，x<y的时候进入循环，循环后x++
   进行判断y%x==0，如果为真就用数组[i]记住x，数组和+=数组[i]，i++
      最后再判断是否数组和于y相等，如果相等，就换行打印y并进入最后一个输出循环
            每当j<=i就输出数组[j]\t

作者: 李江 时间: 2013-8-8 14:36
本帖最后由 graspDN 于 2013-8-8 14:39 编辑

class yueshu
{
public static void main(String[] args)
{
for(int i=1;i<=9999;i++)
{
int[] arr = new int[i/2];
int m=0;
for(int j=1;j<i;j++)
{
if(i%j==0)
{
arr[m++]=j;
}
}
int sum = 0;
for(int k=0;k<arr.length;k++)
{
sum+=arr[k];
}
if(sum == i)
{
System.out.print(i+": ");
for(int k=0;k<arr.length;k++)
{
if(arr[k]==0)
break;
System.out.print(arr[k]+" ");
}
System.out.println("");
}
}
}
}

复制代码

作者: 肥猪 时间: 2013-8-8 17:29

import java.util.ArrayList;
import java.util.Iterator;
/*
* 设计一个程序是求9999以内的“自身数”，并打印出其所有约数。所谓自身数是指这样的自然数：它的各个约数(不包括该数自身)之和等于该数自身。
如28=1+2+4+7+14就是一个完全数。要求：打印需满足以下格式。
A：约数1 约数2 约数3...... 例如 6： 1 2 3
B：约数1 约数2 约数3...... 28： 1 2 4 7 14
C：约数1 约数2 约数3...... 496： 1 2 4 8 16 31 62 124 248
*/
public class Second {
public static void main(String[] args) {
for(int x= 1;x<9999;x++) //给number方法传值
number(x);
}
public static void number(int num)
{
ArrayList<Integer> arr = new ArrayList<Integer>(); //ArrayList集合用来存放约数
int sum=0;//约数的和
for(int x=1;x<num;x++) //判断是否是约数
{
if(num % x==0)
arr.add(x); //如果是添加到集合中
}
Iterator<Integer> it = arr.iterator(); //迭代器
while(it.hasNext()) //遍历
{
sum = sum +it.next(); //求和
//System.out.print(it.next()+" ");
}
it=arr.iterator(); //更新迭代器
if(sum == num) //如果是自身数则打印该数及其约数
{
System.out.print(num+": ");
while(it.hasNext())
{
System.out.print(it.next()+" ");
}
System.out.println();
}
arr.clear();//清空集合
}
}

复制代码

作者: liye20110 时间: 2013-8-8 18:11

public class Wanshu {
public static void main(String[] args) {
//定义一个int型变量，用来表示约数和
int sum;
//循环遍历1到9999以内的数
for(int num=1;num<9999;num++){
//每遍历一个数都要将约数和置0，否则下一个数的约数和会在加上上一个和
sum=0;
for(int i=1;i<num;i++){
//求出num的约数
if(num%i==0)
//求约数和
sum+=i;
}
//如果该数的约数和等于他本身，就将他的约数打印
if(sum==num){
System.out.print(num+":");
for(int j=1;j<num;j++){
if(num%j==0)
System.out.print(j+" ");
}
System.out.println();
}
}
}
}

复制代码

结果：

作者: taotao 时间: 2013-8-8 18:39

class hehe
{
public static void main(String[] args)
{
for(int i=2;i<10000;i++)
{
int a = 0;
for(int j=1;j<i;j++)
{
if(i%j==0)
a+=j;
}
if(a==i)
{
System.out.print(i+" : ");
for(int j=1;j<i;j++)
{
if(i%j==0)
System.out.print(j+" ");
}
System.out.println(" ");
}
}
}
}

复制代码

作者: breaveheart 时间: 2013-8-8 20:08

class WanQuanShu
{
public static void main(String[] args)
{
int b;
for (int a=2; a<=9999; a++)
{
int sum = 0;
for (b=1; b<a; b++)
{
if (a%b==0)
sum = sum + b;
}
if (a==sum)
{
System.out.print(a+": ");
for (b=1; b<a; b++)
{
if (a%b==0)
System.out.print(b+" ");
}
System.out.println();
}
}
}
}

复制代码

作者: 钟佩桓 时间: 2013-8-9 01:12

package test;
/*
* 设计一个程序是求9999以内的“自身数”，并打印出其所有约数。所谓自身数是指这样的自然数：它的各个约数(不包括该数自身)之和等于该数自身。
如28=1+2+4+7+14就是一个完全数。要求：打印需满足以下格式。
A：约数1 约数2 约数3...... 例如 6： 1 2 3
B：约数1 约数2 约数3...... 28： 1 2 4 7 14
C：约数1 约数2 约数3...... 496： 1 2 4 8 16 31 62 124 248
* */
public class JavaTest {
/**
* 思路：1，求自身数这个数必须是2的倍数
* 2，自身数要等于自己的约数和那么将这个数除以2 将除以得到的数相加如果等于这个数那么这个数就自身数
* 3，得到自身数后用一个for循环来打印它的约数约数即是这个数除以2得到的数前提是这个数能整除2
* 4,1也是一个自身数 1的约数是1
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("10以内的自身数和它的约数为：");
getMyNumber();
}
//获取9999以内的自身数以及它的约数
public static void getMyNumber(){
System.out.println(1+":"+1);
for(int x=2;x<=9999;x++){
int sum =0;
for(int y=2;y<=x;y++){
if(x%y==0){
sum += x/y;
}
}
if(sum==x){
System.out.print(x+":");
for(int i=2;i<=x;i++){
if(x%i==0)
System.out.print(x/i+" ");
}
System.out.println("");
}
}
}
}

复制代码

作者: 黄兴旺 时间: 2013-8-9 01:26

public class wzs {
public static void main(String[] args){
int sum=0;
for(int i=1;i<9999;i++){
sum=0;
for(int j=1;j<=i/2;j++){
if(i%j==0){
sum+=j;
}
}
if(sum==i){
System.out.print(i+":"+"\t");
for(int j=1;j<=i/2;j++){
if(i%j==0){
System.out.print(j+" ");
}
}
System.out.println();
}
}
}
}

复制代码

QQ截图20130809012404.jpg (12.54 KB, 下载次数: 30)

作者: 茶念小手 时间: 2013-8-9 04:44

import java.util.ArrayList;
import java.util.List;
public class Number {
/**
* @param args
*/
public static void main(String[] args) {
int sum = 0;
List<Integer> arr= new ArrayList<Integer>(); ;
for(int i =1; i < 10000;i++)
{
for (int j = 1; j <= i; j++) {
if (i % j ==0) {
arr.add(j);
}
}
for (int s =0; s<arr.size()-1;s++) {
sum+=arr.get(s);
}
if (sum==i&& i!=0) {
System.out.print(sum+":");
for (int s =0; s<arr.size()-1;s++) {
System.out.print(" "+arr.get(s));
}
System.out.println();
}
sum = 0;
arr.clear();
}
}
}

复制代码

作者: gudao20080 时间: 2013-8-9 12:35

package com.itcast.mapTest;
import java.util.*;
public class CollSelfNum {
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
* A：约数1 约数2 约数3...... 例如 6： 1 2 3
*/
for(int k = 2 ; k <= 9999; k++){
prinSelfArr(k);
}
}
public static void prinSelfArr(int num){
Set<Integer> arrSet = new TreeSet<Integer>();//建立TreeSet集合，用来存放整数
for(int i = 1; i < num; i++){
for(int j = i+1; j <= num; j++){
if(num == i*j ){ //判断两个数之积是否满足条件
arrSet.add(i);
arrSet.add(j);
}
}
}
arrSet.remove(num); //移除 num这个数，方便计算其它所有数的和
//计算所有除去num后的约数之和
int sum = 0;
for(Integer x: arrSet){
//System.out.print(x+" ");
sum += x;
}
if(sum == num){ //判断约数之和与num是否相等
System.out.print(num+": ");
for(Integer x: arrSet){ //for循环输出集合中num的约数
System.out.print(x+" ");
}
System.out.print(num+"\r\n");
}
}
}

复制代码

作者: 黄兴旺 时间: 2013-8-9 13:14

黄兴旺发表于 2013-8-9 01:26

老田..你还是实习版主？

作者: 陈贺 时间: 2013-8-9 17:08
本帖最后由陈贺于 2013-8-9 17:13 编辑

<p> </p><div class="blockcode"><blockquote>package com.itheima;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
for(long i=6;i<9999;i++){
long x = 0;
for(long y=1;y<i;y++){
if(i%y==0){
x+=y;
}
}
if(x==i){
System.out.print(i+":");
for(long y=1;y<i;y++){
if(i%y==0){
System.out.print(" "+y);
}
}
System.out.println();
}
}
}
}

复制代码

作者: 罗广伟 时间: 2013-8-9 17:31
本帖最后由罗广伟于 2013-8-9 17:33 编辑

import java.util.*;
public class SelfNumber {
public static void main(String[] args)
{
for(int x=1;x<9999;x++)//遍历0-9999
{
List<Integer> al=new ArrayList<Integer>();//定义集合用于存储x的约数
for(int y=1;y<x;y++)//取出x的约数，并存到集合
{
if(x%y==0)
al.add(y);
}
int sum=0;
for(int z=0;z<al.size();z++)//将x约数进行相加
{
sum=sum+al.get(z);
}
if(x==sum)//判断约数和和自身是否相等
{
System.out.println(x+":"+getElements(al));
}
}
}
public static StringBuffer getElements(List al)//将中括号去掉
{
Iterator<Integer> it=al.iterator();
StringBuffer sb=new StringBuffer();
while(it.hasNext())
{
sb.append(" "+it.next());
}
return sb;
}
}

复制代码

作者: 六石_01 时间: 2013-8-9 18:14
import java.util.*;
public class ZiShenShu
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();

for (int i=2;i<10000 ;i++ )
{
int tmp=0;
for(int j=1;j<i;j++)
{
if (i%j==0)
tmp+=j;
}
if(i==tmp)
{
al.add(new Integer(i));
}
}
Iterator it = al.iterator();
while(it.hasNext())
{
Integer intObj=(Integer)it.next();
int c=intObj.intValue();
System.out.print(c+":"+"\t");
for (int j=1;j<c ;j++ )
{
if(c%j==0)
System.out.print(j+" ");
}
System.out.println();
}
}
}

作者: 捌年 时间: 2013-8-9 18:23

/**
1、在循环中找出自身数
2、打印自身数及其约数
*/
public class Demo
{ //找出自身数
public static void findNum()
{
for(int j = 2 ; j<=9999 ; j++)
{
int temp = 0 ;
for(int i = 1 ; i<j ; i++)
{
if(j%i == 0)
temp += i ;
}
if(temp == j)
print(j) ;
}
}
//按照格式打印自身数
public static void print(int x)
{
System.out.print(x + ": ") ;
for(int i = 1 ; i<x ; i++)
{
if(x%i == 0 )
System.out.print(i + " ") ;
}
System.out.println() ;
}
public static void main(String[] args)
{
findNum() ;
}
}

复制代码

作者: lvjayj 时间: 2013-8-9 20:19

import java.util.ArrayList;
public class test {
public static void main(String[] args) {
int num;
int i;
for(num=1;num<=9999;num++) //循环9999内的整数
{
int sum = 0; //用于求和
ArrayList<Integer> list = new ArrayList<Integer>(); //用于存放约数
for(i=1;i<=num/2;i++) //循环判断
{
if(num%i==0) //是否为约数
{
list.add(i); //如果是加到list中
sum=sum+i; //累加
}
}
if(sum == num) //如果是自身数，则输出
{
System.out.print(num+":"); //输出自身数
for(int j = 0;j < list.size(); j ++) //输出约数
{
System.out.print(list.get(j)+" ");
}
System.out.println();
}
}
}
}

复制代码

作者: 米中之玉 时间: 2013-8-9 22:01

package others;
public class FreeNumber {
public static void main(String[] args) {
// TODO 自动生成方法存根
//声明max为所要求的最大值范围。
int max = 9999;
// 调用函数，并打印结果。
getFreeNumber(max);
}
//定义函数，求得所给范围内的“自身数”。
public static void getFreeNumber(int max) {
for (int m = 2; m <= max; m++) {
String str = m + ":\t";
int sum = 0;
int mid = m/2 +1;
//因为一个数肯定不能被他的一半mid以后的数整除，所以循环到mid就可以。
for (int n = 1; n < mid; n++) {
if (m % n == 0) {
sum += n;
str = str + n + "\t";
}
}
if (m == sum)
System.out.println(str);
}
}
}

复制代码

作者: 木偶_freedom 时间: 2013-8-10 14:34

class Test
{
public static void main(String[] args)
{
for(int i=1; i<9999; i++)
{
int sum=0;
int j;
for(j=1; j<i; j++)
{
if(i%j==0) //判断出约数
{
sum += j; //求出约数之和
}
}
if(sum == i) //判断约数之和是否与数字本身相同
{
System.out.print(sum + ":" );//打印自身数
for(int z=1; z<=sum/2; z++)//打印约束
{
if(sum%z==0)
{
System.out.print(z + " ");
//System.out.println();
}
}
System.out.println();
}
}
}
}

复制代码

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2