Java第一次代码作业汇总

练习题1：（完数问题）

    求100以内的所有完数。（完数：它所有因子之和等于其本身）

 

 方法一：

/*
解体思路：1.先找出每个数的所有因子
          2.比较因子之和是否与其数本身相等
 */

public class wanshu {
    public static void main(String[] args) {
        int sum=0;
        for(int i=1;i<=1000;i++)      //外层for循环用于遍历1-1000的所有数
        {
            for(int j=1;j<i;j++)     //内层for循环用于遍历查找每个数的所有因子
            {                           //注意：j 从1开始，因为分母不能为0！！！
                if(i%j==0)            //如果A可以将B整除，余数为0，则B 为A 的因子
                {
                    sum+=j;           //计算出所有因子之和
                }
            }                           // 比较因子之和是否与其本身相等
            if(sum==i)                 //注意：“比较”要放到内层for循环外，以免出现还没有计算完所有因子，仅当前因子数
            {                          //之和就与其数本身相等，而误被当作完数！！！！
                System.out.println(i+": ");
                for(int j=1;j<i;j++)     //打印完数的所有因子
                {
                    if(i%j==0)
                    {
                        System.out.println(j+" ");
                    }
                }
            }
        }
    }

}

     方法二：

   

 1  /*
 2        解题思路：先找出每个数的所有因子
 3                 然后将其所有因子存储在一个数组里
 4                 如果该数符合完数要求，则打印出数组里的数
 5                 如果该数不符合要求，则将数组清空，用于存放下一个数的所有因子
 6         */
 7 public class wanshu {
 8     public static void main(String[] args) {
 9        int[] arr=new int[1000];
10        int index=0;
11        int sum=0;
12        for(int i=1;i<1000;i++)
13        {
14            for(int j=1;j<i;j++)
15            {
16                if(i%j==0)
17                {
18 
19                    arr[index]=j;
20                    sum+=arr[index];
21                    index++;
22                }
23            }
24            if(sum==i)
25            {
26                System.out.print(i+":");
27              for(int j=0;j<index;j++)
28              {
29                  System.out.print(arr[j] + " ");
30              }
31                System.out.println();
32            }
33 
34            index=0;
35            sum=0;
36 
37        } 
38     }
39 
40 }

 练习题二：

      1. 统计字符串中，字母，数字及其他字符的数量。

      

/*
* 解题思路：先输入一串字符串
*           挨个遍历，判段类型
*           定义三个变量来存储各个类型的数量
*
*
* */


import java.util.*;
public class zifushu {
    public static void main(String[] args) {
        Scanner in=new  Scanner(System.in);
        String text=in.nextLine();       //用来接收字符串
        int number=0;                   //定义三个变量来存储数字，字母，和其他字符的数量
        int string=0;
        int other=0;
         for(int i=0;i<text.length();i++)  //用来遍历整个字符串
         {
             char ch=text.charAt(i);        //引用charAt()方法用来输出指定位置的字符内容
             if(Character.isDigit(ch))       //判断是否为数字
             {
                 number++;
             }else if(Character.isLetter(ch)) //判断是否为字母
             {
                 string++;
             }else{           //否则就为其他类型的字符
                 other++;
             }
         }
        System.out.println("number"+number);
        System.out.println("string"+string);
        System.out.println("other"+other);
    }
}

 练习题三：

      1.用户输入一段字符串，格式如：gdsd    2e3d    23434  v/f#$  dffbd

         请输出这段字符串中的单词数量。

       2.并将单词打印出来。

        /**
         * 解题思路：输入数段个字符串，然后对每段字符串进行遍历，当遇到的不是字母时，则略过此字符串，进行遍历下一个
         *           字符串 ，直到遇到空格前，遍历的都是字母，则该段字符串为单词。
         *           注意：最后一个因为后面没有空格，要另行判断
       */
import java.util.*;
public class zifushu {
    public static void main(String[] args) {
       Scanner in=new Scanner(System.in);
        String text=in.nextLine();
        boolean flag=true;
        int number=0;
        for(int i=0;i<text.length();i++) {   
            char ch = text.charAt(i);
            if (flag && Character.isLetter(ch)) {
                flag = true;
            } else {
                if (ch == ' ' && flag) {
                    number++;
                    flag = true;
                } else if (ch == ' ' && (flag == false)) {
                    flag = true;
                } else {
                    flag = false;
                }

            }
            if(flag)
            {
                number++;
            }

            System.out.println(number);
        }

    }

 }

import java.util.*;
public class zifushu{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String text = in.nextLine();
        boolean flag = true;
        int number = 0;
        int count = 0;
        for (int i = 0; i < text.length(); i++) {
            char ch = text.charAt(i);
            if (flag && Character.isLetter(ch)) {
                flag = true;
                count++;

            } else {
                if (ch == ' ' && flag)
                {
                    number++;
                    System.out.println(text.substring(i - count, i));
                    count = 0;

                    //      System.out.println();
                    flag = true;
                } else if (ch == ' ' && (flag == false)) {
                    flag = true;
                } else {
                    flag = false;
                    // count=0;
                }

            }

        }
        if (flag) {
            number++;
            System.out.println(text.substring(text.length() - count, text.length()));
        }

        System.out.println(number);
    }
}

text.substring(i - count, i)可用来打印字符串中某一截的单词，

             i-count代表所要打印的单词的开始位置，

             i代表所要打印单词的末尾位置

练习题四： （最长路径问题）

 

*    12
    8   9
    11  7   16
    13  9   8    7
可以从每个结点 往下，往左斜下，往右斜下分别遍历，以致找到一条从上到下的最长路径。

/**
 * 解体思路：要使从上往下挑选的路径数值最大，那就考虑从下往遍历，只要保证每次挑选的值最大。
 *          因为最底层无法继续往下遍历，所以首先从倒数第二层开始。
 *          定义三个变量，存放三条路径的值，比较后选出最大值。
 *          所以还要定义一个与arr相同大小的数组brr，来存放各个结点可以选择的三天路径中的最大值
 *
 *
 */

public class lujing {
    public static void main(String[] args) {
        int[][] arr=new int[4][];
        arr[0]=new int[]{12};
        arr[1]=new int[]{8,9};
        arr[2]=new int[]{11,7,16};
        arr[3]=new int[]{13,9,8,7};
        int r1=0;
        int r2=0;
        int r3=0;
        int[][]brr=new int[4][];        //开辟一个大小和arr相等的数组brr来存放每次条选出的最大值
        for(int i=0;i<arr.length;i++)
        {
            brr[i]=new int[i+1];
        }
        for(int i=0;i<arr.length;i++)
        {
            brr[3][i]=arr[3][i];           //因为最后一行不用计算出底下三条路径的值，所以直接将最后一层brr赋值给arr
        }

        for(int i=arr.length-2;i>=0;i--)     //从底下倒数第二层开始往上遍历
        {
            for(int j=0;j<arr[i].length;j++)     //注意此处是i-- 和j++
            {
                if(j>0)
                {
                    r1=arr[i][j]+brr[i+1][j-1];     //计算的是此节点和相同位置中brr数组中的值，以保证计算到最后的那个值
                }                                   //就是所要求的路径中的最大值
                r2=arr[i][j]+brr[i+1][j];
                r3=arr[i][j]+brr[i+1][j+1];
                brr[i][j]=Math.max(r1,Math.max(r2,r3));    //调用Math.max()函数比较大小，
            }                                               //注意一次只能比较两个数
        }
        System.out.println(brr[0][0]);
    }
}