-------------新版块第一期答题活动---------------

夜默

本帖最后由张智文于 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: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 · panningwjr

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:18 编辑

已经做完，请审核！！！

xscn · xscn

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

复制代码

xx_lee · xx_lee

[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]

逆袭的风 · 逆袭的风

完成如下:

/*
设计一个程序是求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();
}
}

复制代码

输出如图:

夜空闪亮 · 夜空闪亮

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

复制代码

程序运行结果截图如下：

黑马李昂 · 黑马李昂

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

复制代码

牛牛 · 牛牛

/**
* 设计一个程序是求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 · lvjayj

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 · jrry

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

复制代码

熊纪达 · 熊纪达

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

复制代码

白堇翎 · 白堇翎

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 · EYE_SEE_YOU

这不是代码，代码我还写不出来，这里我就表达一下菜鸟的思路
设自身数变量为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

李江 · 李江

本帖最后由 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("");
}
}
}
}

复制代码

肥猪 · 肥猪

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 · liye20110

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 · taotao

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 · breaveheart

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

复制代码

帐号		自动登录	找回密码
密码			加入黑马

-------------新版块第一期答题活动---------------

点评

评分

33 个回复

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

黑马骑士勋章