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