Java学习---程序设计

180813 补全没有的答案！

0、数组排序大全[冒泡/选择/快速/插入]

 package com.ftl;

 import java.io.BufferedReader;

 import java.io.IOException;

 import java.io.InputStreamReader;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collections;

 import java.util.Iterator;

 import java.util.List;

 /**

  * 排序算法复习

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  * 【更多参考】 https://blog.csdn.net/snow_5288/article/details/60140265

  */

 public class Test2018 {

     public static void main(String[] args) throws IOException {

         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

         List<Double> l = null;

         System.out.println("[eg.]请输入数据，如:1,12,32,2,3");

         String input = br.readLine();

         //方案一： 多数排序

         check(input);

         //方案二： 冒泡排序

         check2(input);

         //方案三： 快速选择排序

         check3(input);

         //方案四： 插入排序

         check4(input);

         //方案五： 快速排序

         check5(input);

     }

     //方案一： list排序：利用Collections工具类实现

     public static void check(String str){

         String[] s = str.split(",");

         int[]  ch = new int[s.length];

         List<Integer> list = new ArrayList<Integer>();

         for(int i = 0; i < s.length; i++){

             ch[i] = Integer.parseInt(s[i]);

             list.add(ch[i]);

         }

         Collections.sort(list);

         System.out.println("【方案一】list排序 ：" + list);

     }

     //方案二： 冒泡排序： 相邻2个数字比较，一次排序后最大/最小的数字排列最后

     /**

      *  比较相邻的元素。如果第一个比第二个大，就交换他们两个。

         对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

         针对所有的元素重复以上的步骤，除了最后一个。

         持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

         冒泡排序需要n-1（i）趟冒泡，每趟冒泡需要比较n-1-i(j)次比较，总共的比较次数为(n-1)+(n-2)+……+1,

         所以冒泡排序算法最坏情况和平均复杂度是O(n²)。

         由于占用空间有限，冒泡排序的空间复杂度为O(1)。

      */

     public static void check2(String str){

         String[] s = str.split(",");

         int[]  ch = new int[s.length];

         for(int i = 0; i < s.length; i++){

             ch[i] = Integer.parseInt(s[i]);

         }

         for(int i = 1; i < ch.length; i++){

             for(int j = 0; j < ch.length; j++){

                 if(ch[i] < ch[j]){

                     int tmp = ch[i];

                     ch[i] = ch[j];

                     ch[j] = tmp;

                 }

             }

         }

         System.out.println("【方案二】冒泡排序后：" + Arrays.toString(ch));

     }

     //方案三： 快速选择排序： 第一个数字依次跟后面的数字比较大小

     /**

      *  是直观的排序，通过确定一个Key最大或最小值，再从带排序的的数中找出最大或最小的交换到对应位置。再选择次之

      *  双重循环时间复杂度为O(n^2)

      */

     public static void check3(String str){

         String[] s = str.split(",");

         int[]  ch = new int[s.length];

         for(int i = 0; i < s.length; i++){

             ch[i] = Integer.parseInt(s[i]);

         }

         for(int i = 0; i < ch.length; i++){

             for(int j = i+1; j < ch.length ; j++){

                 if(ch[i] > ch[j]){

                     int tmp = ch[i];

                     ch[i] = ch[j];

                     ch[j] = tmp;

                 }

             }

         }

         System.out.println("【方案三】选择排序后：" + Arrays.toString(ch));

     }

     //方案四： 插入排序：往前比较，如果当前数比前一个小则进行第二个循环操作，反之则直接进入下次外层循环

     //比冒泡更优秀一点，冒泡是无论大小都会继续比较，这里是如果当前数字比前面的小，交换位置[降序则反之即可]

         public static void check4(String str){

             String[] s = str.split(",");

             int[]  ch = new int[s.length];

             for(int i = 0; i < s.length; i++){

                 ch[i] = Integer.parseInt(s[i]);

             }

             for(int i = 1; i < ch.length; i++){

                 int tmp = ch[i];

                 // 升序： 如果前面的数字比当前的tmp大，则交换位置

                 for(int j = i - 1; j >=0 && tmp < ch[j]; j--){

                     ch[j+1] = ch[j];

                     ch[j] = tmp;

                 }

             }

             System.out.println("【方案四】插入排序后：" + Arrays.toString(ch));

         }

         //方案五：快速排序：选择一个基准，大于该值放在右侧，小于则放在左侧

         /**

          *  选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边（一般是无序的）。一般选择序列的第一个元素。

             一次循环：从后往前比较，用基准值和最后一个值比较，如果比基准值小的交换位置，如果没有继续比较下一个，直到找到第一个比基准值小的值才交换。找到这个值之后，又从前往后开始比较，如果有比基准值大的，交换位置，如果没有继续比较下一个，直到找到第一个比基准值大的值才交换。直到从前往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值来说，左右两边就是有序的了。

             接着分别比较左右两边的序列，重复上述的循环。

             快速排序是一种快速的分而治之的算法，它是已知的最快的排序算法，其平均运行时间为O(N*1ogN) 。它的速度主要归功于一个非长紧凑的并且高度优化的内部循环。但是他也是一种不稳定的排序，当基准数选择的不合理的时候他的效率又会编程O(N*N)。

             快速排序的最好情况：  快速排序的最好情况是每次都划分后左右子序列的大小都相等，其运行的时间就为O(N*1ogN)。

             快速排序的最坏情况：  快速排序的最坏的情况就是当分组重复生成一个空序列的时候，这时候其运行时间就变为O(N*N)

             快速排序的时间复杂度为O(N*lgN),快速排序的空间复杂度为O(lgN).

          */

         public static void check5(String str){

             String[] s = str.split(",");

             int[]  ch = new int[s.length];

             for(int i = 0; i < s.length; i++){

                 ch[i] = Integer.parseInt(s[i]);

             }

             if(ch.length  <=1) return ;

             int start = 0;

             int end = ch.length-1;

             check5sort(ch, start, end);

             System.out.println("【方案五】快速排序后：" + Arrays.toString(ch));

         }

         public static void check5sort(int[] a,int low,int high){

              int start = low;

              int end = high;

              int key = a[low];   // 设定基准为第一个数字

              while(end>start){

                  //从后往前比较

                  while(end>start&&a[end]>=key)  //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较

                      end--;

                  if(a[end]<=key){

                      int temp = a[end];

                      a[end] = a[start];

                      a[start] = temp;

                  }

                  //从前往后比较

                  while(end>start&&a[start]<=key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置

                     start++;

                  if(a[start]>=key){

                      int temp = a[start];

                      a[start] = a[end];

                      a[end] = temp;

                  }

              //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用

              }

              //递归

              if(start>low) check5sort(a,low,start-1); //左边序列。第一个索引位置到关键值索引-1

              if(end<high) check5sort(a,end+1,high);   //右边序列。从关键值索引+1到最后一个

          }

 }

[排序算法更多参考] https://blog.csdn.net/snow_5288/article/details/60140265

[排序算法更多参考] 值得收藏的十大经典排序算法

0、实现会员注册，要求用户名长度不小于3，密码长度不小于6，注册时两次输入密码必须相同

 package com.ftl;

 import java.io.BufferedReader;

 import java.io.IOException;

 import java.io.InputStreamReader;

 // 实现会员注册，要求用户名长度不小于3，密码长度不小于6，注册时两次输入密码必须相同

 public class Test2018 {

     public static void main(String[] args) {

         Boolean flag = true ;

         while(flag){

             try {

                 System.out.println("请输入姓名:");

                 String name = new BufferedReader(new InputStreamReader(System.in)).readLine();

                 if(name == null || "".equals(name)){

                     System.out.println("输入为空，请重新输入！");

                     continue;

                 }

                 if(name.length() < 3){

                     System.out.println("输入用户名长度不得小于3，请重新输入！");

                     continue;

                 }

                 System.out.println("请输入密码:");

                 String passwd = new BufferedReader(new InputStreamReader(System.in)).readLine();

                 if(passwd == null || "".equals(passwd)){

                     System.out.println("输入为空，请重新输入！");

                     continue;

                 }

                 if(passwd.length() < 6){

                     System.out.println("输入密码长度不得小于6，请重新输入！");

                     continue;

                 }

                 System.out.println("请再次输入密码:");

                 String passwd2 = new BufferedReader(new InputStreamReader(System.in)).readLine();

                 if(passwd2 == null || "".equals(passwd2)){

                     System.out.println("输入为空，请重新输入！");

                     continue;

                 }

                 if(passwd.length() == passwd2.length() && passwd.equals(passwd2)){

                     System.out.println("注册成功，欢迎您！");

                     flag = false;

                     break;

                 }else{

                     System.out.println("2次输入的密码不一致，请重新注册！");

                     continue;

                 }

             } catch (IOException e) {

                 // TODO Auto-generated catch block

                 e.printStackTrace();

             }

         }

     }

 }

1、一个景区根据游人的年龄收取不同价格的门票。请编写游人类，根据年龄段决定能够购买的门票价格并输出，然后写出测试类测试该类

 package com.ftl;

 import java.io.BufferedReader;

 import java.io.IOException;

 import java.io.InputStreamReader;

 import java.util.ArrayList;

 import java.util.List;

 // 实现会员注册，要求用户名长度不小于3，密码长度不小于6，注册时两次输入密码必须相同

 public class Test2018 {

     public static void main(String[] args) {

         Boolean flag = true;

         String name = null;

         String info = null;

         List<String> list = new ArrayList<>();

         int price = 120;

         int age = 0;

         while (flag) {

             try {

                 System.out.println("请输入游客的姓名:");

                 name = new BufferedReader(new InputStreamReader(System.in)).readLine();

                 if (name == null || "".equals(name)) {

                     System.out.println("输入为空，请重新输入！");

                     continue;

                 }

                 System.out.println("请输入游客的年龄:");

                 age = Integer.parseInt(new BufferedReader(new InputStreamReader(System.in)).readLine());

                 if (age < 0 || age > 100) {

                     System.out.println("输入错误，请从新输入");

                     continue;

                 }

             info = "游客信息: 姓名[" + name + "]" + ", age[" + age + "]";

             if(age < 18 ){

                 int pri = price / 2;

                 info = info + ",门票：" + pri;

             }else if(age < 60){

                 int pri = price;

                 info = info + ",门票：" + pri;

             }else{

                 info = info + ",门票：" + "免费";

             }

             list.add(info);

             System.out.println("是否继续售票[Y/N] ?");

             String con = new BufferedReader(new InputStreamReader(System.in)).readLine();

             if(con.toUpperCase().equals("Y") || con.equals("Y")){

                 flag = true;

             }else{

                 flag = false;

                 for (String string : list) {

                     System.out.println(string);

                     System.out.println("------------------------------");

                 }

             }

             } catch (IOException e) {

                 e.printStackTrace();

             }

         }

     }

 }

2、编写一个Java程序，用if-else语句判断某年份是否为闰年

 // Programme Name LeapYear.java

 public class LeapYear{

 public static void main(String args[]){

 int year=2010; 

 if(args.length!=0)

   year=Integer.parseInt(args[0]);

 if((year%4==0 && year%100!=0)||(year%400==0))

  System.out.println(year+" 年是闰年。");

 else

  System.out.println(year+" 年不是闰年。");

    }

  }//if-else语句

3、编写一个Java程序在屏幕上输出1！+2！+3！+……+10！的和

 public class ForTest { 

 public static void main( String args[] ) {

   int  i,j,mul,sum=0;

 for(i=1;i<=10;i++) {

 mul=1;

 for(j=1,j<=i;j++) {

 mul=mul*j;

 }

       sum=sum+mul;

 }

 System.out.println(“1！+2！+3！+……+10！= ”+sum);

 }

 }

5、编写一个Java应用程序，从键盘读取用户输入两个字符串，并重载3个函数分别实现这两个字符串的拼接、整数相加和浮点数相加。要进行异常处理，对输入的不符合要求的字符串提示给用户，不能使程序崩溃

 import java.io.*;

 public class Strinput

 {

   public static void main(String args[]) {

    String s1,s2,ss,si,sf;

        int i1,i2;

        float f1,f2;

        BufferedReader strin=new  BufferedReader(new InputStreamReader(System.in));

        try{System.out.print ("输入第一个字符串：" );

 s1= strin.readLine();

            System.out.print ("输入第二个字符串：" );

 s2= strin.readLine();}

 catch(Exception e){ System.out.println(e.getMessage());}

 i1 = Integer.parseInt(s1);

        i2 = Integer.parseInt(s2);

        f1 = Float.parseFloat(s1);

        f2 = Float.parseFloat(s2);

        ss = strAdd(s1,s2);

        si = strAdd(i1,i2);

        sf = strAdd(f1,f2);

        System.out.println ("输入的二个字符串相加结果为："+ss );

        System.out.println ("输入字符串转换为整数相加结果为："+si );

        System.out.println ("输入字符串转换为浮点数相加结果为："+sf );

  }

    String strAdd(String str1,String str2) {

 return str1+str2;

 }

 String strAdd(int int1,int int2) {

 return  String.valueOf(int1+int2);

 }

 String strAdd(float flt1,float flt2) {

 return  String.valueOf (flt1+flt2);

 }

  }

6. 应用FileInputStream类，编写应用程序，从磁盘上读取一个Java程序，并将源程序代码显示在屏幕上。（被读取的文件路径为：E:/myjava/Hello.java）

 import java.io.*;

   public class FISDemo {

   public static void main(String args[]) {

     byte[] buf=new byte[2056];

     try{

      FileInputStream fileIn=new FileInputStream("e:/myjava/Hello.java");

      int bytes=fileIn.read(buf,0,2056);

      String str=new String(buf,0,bytes);

      System.out.println(str);

 }catch(Exception e){

  e.printStackTrace( );

 }

 }

7、编写一个Java程序将当100,101,102,103,104,105个数以数组的形式写入到Dest.txt文件中，并以相反的顺序读出显示在屏幕上

  import java.io.*;

   public class IODemo {

   public static void main( String args[] ) {

     int data[] = {100,101,102,103,104,105};

 int t;

 try

 { DataOutputStream out = new  DataOutputStream (new  FileOutputStream(“dest.txt”));

   for(int i=0;i<data.length;i++) 

     out.WriteInt(data[i]);

   out.close();

  DataInputStream in = new  DataInputStream (new  FileInputStream(“dest.txt”));

  for(int i= data.length-1;i>= 0;i--) {

     t=in.readInt(data[i]);

 System.out.print(“ ”+t);

     }

   System.out.println( );

   in.close();

 }catch(IOException e)

 { System.out.println(e.getMessage());}

   }

 }

9、编写一个Java程序实现多线程，在线程中输出线程的名字，隔300毫秒输出一次，共输出20次。

  // 声明一个子线程类Threaddemo;

  class ThreadDemo extends Thread {

   public ThreadDemo(String str) {

 super(str);

 }

   public void run() {

     for(int i=0;i<20;i++){

 System.out.print(“ ”+this.getName());

 Try {

 Sleep(300);

 }catch(InterruptedException e){

 System.out.println(e.getMessage());

 Return;

 }

 }

 System.out.println(“  /end”);

 }

 }

 public class TestThread {

 public static void main( String args[] ) {

    ThreadDemo thread1=new ThreadDemo(“T1”);

    ThreadDemo thread2=new ThreadDemo(“T2”);

    ThreadDemo thread3=new ThreadDemo(“T3”);

    thread1.start();

    thread2.start();

    thread3.start();

  }

 }

10. 编写程序，在屏幕上显示带标题的窗口，并添加一个按钮。当用户单击按钮时，结束程序。

 import javax.swing.*;

 import java.awt.event.*;

 public class ButtonEventDemo extends JPanel implements ActionListener{

 protected JButton b1; //声明一个按钮对象

 public ButtonEventDemo() { //构造方法

 ImageIcon ButtonIcon = new ImageIcon("images/green.png");  //创建按钮的图标对象

   b1 = new JButton("退出按钮", ButtonIcon);   //生成按钮对象

 b1.setMnemonic(KeyEvent.VK_E);   //设置b1的助记符是Alt+E

         b1.setToolTipText("这是退出按钮。"); // 设置按钮提示条

         this.add(b1);   //往面板对象中加载按钮

         b1.addActionListener(this);  //本类对象注册为按钮的事件监听器

      }

 public void actionPerformed(ActionEvent e){ //按钮事件响应方法

 System.exit(0);   //按b1则退出主程序        

 }

     private static void createGUI() { //创建窗体

         JFrame.setDefaultLookAndFeelDecorated(true); //设置java隐含观感

         JFrame frame = new JFrame("按钮测试"); //生成应用程序主窗体

         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //设置关闭时隐含操作

  ButtonEventDemo CPane = new ButtonEventDemo();  //生成主类对象--面板

         CPane.setOpaque(true);    //面板要求不透明

         frame.setContentPane(CPane); //设置主类对象为主窗体的内容面板

         frame.pack(); //主窗体紧缩显示

         frame.setVisible(true);  //设置主窗体可见

     }

     public static void main(String[] args) {  //将createGUI（）列入线程

         javax.swing.SwingUtilities.invokeLater(new Runnable() {

             public void run() {

                 createGUI(); 

             }

         });

     }

 }

11、定义一个表示学生信息的类Student，要求如下：

（1）类Student的成员变量：

sNO　表示学号；sName表示姓名；sSex表示性别；sAge表示年龄；sJava：表示Java课程成绩。

（2）类Student带参数的构造方法：

在构造方法中通过形参完成对成员变量的赋值操作。

（3）类Student的方法成员：

getNo（）：获得学号；

getName（）：获得姓名；

getSex（）：获得性别；

getAge（）获得年龄；

getJava（）：获得Java 课程成绩

（4）根据类Student的定义，创建五个该类的对象，输出每个学生的信息，计算并输出这五个学生Java语言成绩的平均值，以及计算并输出他们Java语言成绩的最大值和最小值。

 public class Student {

 String sNO,sName,sSex;

 int sAge,sJava;

 public Student(String XH,String XM,String XB,int NL,int XF) {

 super();

 sNO=XH;

 sName=XM;

 sSex=XB;

 sAge=NL;

 sJava=XF;

 }

 public String getNO() {

 return sNO;

 }

 public String getName() {

 return sName;

 }

 public String getSex() {

 return sSex;

 }

 public int getAge() {

 return sAge;

 }

 public int getJava() {

 return sJava;

 }

 public static void main(String[] args) {

 Student[] st=new Student[5];

 st[0]=new Student("09zc01","张三","男",19,94);

 st[1]=new Student("09zc02","李四","男",20,85);

 st[2]=new Student("09zc03","王五","女",18,96);

 st[3]=new Student("09zc04","赵六","男",17,90);

 st[4]=new Student("09zc05","杨七","女",21,88);

 int max=0,min=100,sum=0;

     System.out.println("    学生信息：");

 for (int i=0;i<st.length;i++) {

 if (st[i].sJava < min)

 min=st[i].sJava;

 if (st[i].sJava > max)

 max=st[i].sJava;

 sum=sum+st[i].sJava;

 System.out.println("学生编号："+st[i].getNO()+"， 姓名："+st[i].getName()+"， 性别："+st[i].getSex()+"， 年龄："+st[i].getAge()+"，  Java课学分："+st[i].getJava());

     }

     System.out.println();

     System.out.println("    共有学生："+st.length+"， 平均成绩："+sum/st.length);

     System.out.println("    最小学分："+min+"， 最大学分："+max);

 }

 }

12. 100~200内的素数判断

 package com.ftl;

 import java.util.ArrayList;

 import java.util.List;

 /**

     判断101-200之间有多少个素数，并输出所有素数。

  *1.程序分析：判断素数的方法：用一个数分别去除2~sqrt(n)或者2~n/2,常用2~n/2，

  *因为一个数的一半的平方大于其本身是从5开始的，解方程：n/2的平方>n .如果能被整除【取余运算】，

  *则表明此数不是素数，反之是素数。

  *

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  *

  */

 public class Test2018 {

     public static void main(String[] args) {

         List<Integer> list = new ArrayList<Integer>();

         for(int i = 100; i < 200; i++){

             if(isPrimeNumber(i)){

                 list.add(i);

             }

         }

         System.out.println("100~200 共有" + list.size() + "个数字");

         System.out.println(list);

     }

     public static boolean isPrimeNumber(int num){

         boolean flag = true;

         if(num == 2) return flag;

         for(int i = 2; i <= num/2; i++){

             if(num % i == 0){

                 flag = false;

                 return flag;

             }

         }

         return flag;

     }

 }

13. 水仙花问题

 package com.ftl;

 import java.util.ArrayList;

 import java.util.List;

 /**

   题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：

     153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。

     1.程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。

  *

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  *

  */

 public class Test2018 {

     public static void main(String[] args) {

         // 方案一

         List<Integer> list = new ArrayList<Integer>();

         for(int i = 100; i < 999; i++){

             if(i == isPrimeNumber(i)){

                 list.add(i);

             }

         }

         System.out.println("【方案一】100~999 共有" + list.size() + "个水仙花");

         System.out.println(list);

         System.out.println("-------------------------------------------");

         // 方案二：

         List<Integer> list2 = new ArrayList<Integer>();

         for(int i = 100; i < 999; i++){

             if(i == isPrimeNumber2(i)){

                 list2.add(i);

             }

         }

         System.out.println("【方案二】100~999 共有" + list2.size() + "个水仙花");

         System.out.println(list2);

         System.out.println("-------------------------------------------");

         // 方案三：

                 List<Integer> list3 = new ArrayList<Integer>();

                 for(int i = 100; i < 999; i++){

                     if(i == isPrimeNumber2(i)){

                         list3.add(i);

                     }

                 }

                 System.out.println("【方案三】100~999 共有" + list3.size() + "个水仙花");

                 System.out.println(list2);

     }

     // 方案一: 直接拆分数字

     public static int isPrimeNumber(int num){

         int sum = 0;

         int bai = num / 100;

         int shi  = num /10 % 10;

         int ge  = num % 10;

         sum = (int) (Math.pow(bai, 3) + Math.pow(shi, 3) + Math.pow(ge, 3));

         return sum;

     }

     // 方案二： 利用String来切割数字

     public static int isPrimeNumber2(int num){

         String sth = String.valueOf(num);

         int sum = 0;

         int bai = Integer.parseInt(String.valueOf(sth.charAt(0)));

         int shi  = Integer.parseInt(String.valueOf(sth.charAt(1)));

         int ge  = Integer.parseInt(String.valueOf(sth.charAt(2)));

         sum = (int) (Math.pow(bai, 3) + Math.pow(shi, 3) + Math.pow(ge, 3));

         //System.out.println("百" + bai + "十" + shi + "个" + ge);

         return sum;

     }

     // 方案三： 数字计算的优化

         public static int isPrimeNumber3(int num){

             String sth = String.valueOf(num);

             int sum = 0;

             for(int i = 0; i < sth.length(); i++){

                 sum += Math.pow(Integer.parseInt(String.valueOf(sth.charAt(i))), 3);

             }

             //System.out.println("百" + bai + "十" + shi + "个" + ge);

             return sum;

         }

 }

14.分解质因数

 package com.ftl;

 import java.util.ArrayList;

 import java.util.List;

 /**

 题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。

 程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：

 (1)运用两层循环。

 (2)外循环得到2~n之间的所有质数，内循环将n循环除以质数，知道不能整除。

 (3)要是内循环n等于1了就说明n被完全整除了。

  *

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  *

  */

 public class Test2018 {

     public static void main(String[] args) {

         check(180);

     }

  public static boolean isPrimeNumber(int n){

         if(n == 2) return true;

         for(int i=2; i<=n/2; i++){

             if(n % i == 0) return false;

         }

         return true;

     }

     public static void check(int num){

         StringBuffer sb = new StringBuffer();

         sb.append(num+"=");

         // 这里一定是小于等于，耗时30mins+

         for(int i = 2; i <= num; i++){

 //            System.out.print("质数：" + i+"\t");

             if(isPrimeNumber(i)){

                 while(num%i==0){

                     sb.append(i);

                     num = num / i;

                     if(num == 1) break;

                     sb.append("*");

                 }

             }else{

                 continue;

             }

         }

         System.out.println("\n" + sb);

     }

 }

15. 求s=a+aa+aaa+aaaa+aa...a的值,其中a是一个数字

 package com.ftl;

 import java.util.Scanner;

 /**

  * 求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加有键盘控制。

  * 2  = 2 * 10^0

  * 22 = 2 * 10^1 + 2

  * 222= 2 * 10^2 + 22

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  *

  */

 public class Test2018 {

     public static void main(String[] args) {

         int n = 0;      // 中间

         int num = 0;      // 键盘输入的数字

         int sum = 0;      // 求和

         int fac = 0;      // 中间值

         int roate = 0;    // 循环次数

         boolean flag = true;

         while(flag){

             Scanner scan = new Scanner(System.in);

             System.out.println("请输入一个数组[0-9]:");

             num = scan.nextInt();

             if(num < 0 || num > 9){

                 System.out.println("输入错误，请重新输入");

                 continue;

             }

             System.out.println("请输入循环次数[10以内]:");

             roate = scan.nextInt();

             if(roate >= 10 || roate <=0 ){

                 System.out.println("输入错误，请重新输入");

                 continue;

             }

             flag = false;

         }

         StringBuffer sb = new StringBuffer();

             for(int j = 0; j < roate; j++){

                 n = (int)Math.pow(10, j) * num;

                 fac += n;

                 sb.append(fac).append("+");

                 sum += fac;

             }

         System.out.println(sum + "=" + sb.substring(0, sb.length()-1));

     }

 }

16. 求完数，数字=因子之和

 package com.ftl;

 import java.util.Scanner;

 /**

     题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程 找出1000以内的所有完数。

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  *

  */

 public class Test2018 {

     public static void main(String[] args) {

         for(int i=1; i<1000; i++){

             if(isWanShu(i)){

                 System.out.print(i + ",");

             }

         }

     }

     private static boolean isWanShu(int a) {

         int cup = 0;

         for(int i=1; i<a; i++){

             if(a%i == 0)

                 cup = cup + i;

         }

         return (cup == a);

     }

 }

17. 弹球高度计算

 package com.ftl;

 import java.util.Scanner;

 /**

     一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

     1 100

     2 50

     3 25

     4 12.5

     5 6.25

     6 3.125

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  *

  */

 public class Test2018 {

     public static void main(String[] args) {

         // 方案一： 直接计算

         int sum = 0;

         double height= 100;

         for(int i = 2; i < 11 ; i++){

             // 因为第一次是100米，第二次50米，

             sum += height;

             height = height/2;

         }

         System.out.println("第十次：" + height);

         System.out.println("总路程：" + sum);

         // 方案二： 递归解决

         System.out.println(height(100, 10));

     }

         public static double height(double h, int n){

             if(n==2)  return h/2;

             else return height(h/2,n-1);

         }

 }

18. 排列组合[互不相同且无重复数字的三位数]

 package com.ftl;

 import java.util.List;

 import java.util.Vector;

 /**

     题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？ 

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  *

  */

 public class Test2018 {

     public static void main(String[] args) {

         int[] arr = {1,2,3,4};

         int tmp = 0;

         List<Integer> list = new Vector<>();

         for(int i = 0; i < 4; i++){

             for(int j = 0; j < 4; j++){

                 if(arr[i] != arr[j]){

                     for(int k = 0; k < 4; k++){

                         if(arr[i] != arr[k] && arr[j] != arr[k]){

                             tmp = 100 * arr[i] + 10 * arr[j] + arr[k];

                             list.add(tmp);

                         }

                     }

                 }

             }

         }

         System.out.println("共有：" + list.size());

         for(int i = 0; i < list.size(); i++){

             if(i % 7 != 0){

                 System.out.print(list.get(i) + "\t");

             }else{

                 System.out.println();

             }

         }

     }

 }

19. 完全平方数

 package com.ftl;

 /**

     一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？

     1. 任何数对1取余数都是0

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  *

  */

 public class Test2018 {

     public static void main(String[] args) {

         for(int i = 0; i < 1000; i++){

              if(Math.sqrt(i + 100) % 1 == 0 && Math.sqrt(i + 268) % 1 == 0){

                 System.out.println(i);

             }

         }

     }

 }

20. 输出9*9口诀

 package com.ftl;

 /**

  * 输出9*9口诀

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  */

 public class Test2018 {

     public static void main(String[] args)  {

         for(int i = 1; i <=9; i++){

             for(int j = 1; j <=i; j++){

                 System.out.print(i + "*" + j + "=" + (i * j)+"\t");

             }

             System.out.println();

         }

     }

 }

21. 猴子偷桃

 package com.ftl;

 /**

  *猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个 第二天早上又将剩下的桃子吃掉一半，又多吃了一个。

  *以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。

  1.程序分析：采取逆向思维的方法，从后往前推断(递归)

      day1: 1

      day2: (1+1)*2 = 4

      day3: (4+1)*2 = 10

      day4: (10+1)*2 = 22

      day5: (22+1)*2 = 46

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  */

 public class Test2018 {

     public static void main(String[] args)  {

         // 方案一： 循环解决

         int n = 1;

         int sum = 1;

         for(int i = 2; i <= 5; i++){

             n = ( n + 1 ) * 2;

         }

         System.out.println("方案一：" + n);

         //方案二： 递归

         System.out.println("方案二：" + getNum(5));

     }

     public static int getNum(int d){

         int sum = 0;

         if(d==1) return 1;

         // 这里实际上就是题目说的，前一天的量吃完一半后还余一个的算法

         else return (getNum(d-1) + 1) * 2;

     }

 }

22. 乒乓球比赛名单

 package com.ftl;

 /**

     两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。

     已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  */

 public class Test2018 {

     public static void main(String[] args)  {

         char[] a = {'a', 'b', 'c'};

         char[] b = {'x', 'y', 'z'};

         // 方案一：

         for(int i = 0; i < 3; i++){

             for(int j = 0; j < 3; j++){

                 if(a[i] == 'a' && b[j] != 'x'){

                     System.out.println(a[i] + "--->" + b[j]);

                 }else if(a[i] == 'c' && b[j] != 'x' && b[j] != 'z'){

                     System.out.println(a[i] + "--->" + b[j]);

                 }else if(a[i] == 'b' ){

                     System.out.println(a[i] + "--->" + b[j]);

                 }

             }

         }

         System.out.println("==============");

         // 方案二：

         for(int i = 0; i < 3; i++){

             for(int j = 0; j < 3; j++){

                 if(a[i] == 'a' && b[j] == 'x'){

                     continue;

                 }else if(a[i] == 'c' &&( b[j] == 'x' || b[j] == 'z')){

                     continue;

                 }else{

                     System.out.println(a[i] + "--->" + b[j]);

                 }

             }

         }

         System.out.println("==============");

         // 方案三：

         for(int i=0; i<3; i++){

             for(int j=0; j<3; j++){

                 if(i == 0 && j == 0)//a说他不和x比

                     continue;

                 else if(i == 2 && (j == 0 || j == 2))

                     continue;//c说他不和x,z比

                 else{

                     System.out.println(a[i] + "<-->" + a[j]);

                 }

             }

         }

     }

 }

23. 打印菱形

 package com.ftl;

 /**

     打印出如下图案（菱形）

          *

         ***

        *****

       *******

        *****

         ***

          *

          程序分析：先把图形分成两部分来看待，前四行一个规律，后三行一个规律，利用双重 for循环，第一层控制行，第二层控制列。

          n=4

                 0    1    2    3    4    5    6

        0       空        空    空      *   空      空    空

        1       空        空    *   *   *   空    空

        2       空         *    *   *   *   *    空

        3   *    *    *   *   *   *   *

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  */

 public class Test2018 {

     public static void print(int n){

         int i = 0;

         int j = 0;

         for(i=0; i<n; i++){//前四行

             for(j=0; j<n+i;j++){

                 if(j < n-i-1)

                     System.out.print(" ");

                 else

                     System.out.print("*");

             }

             System.out.println();

         }

         for(i=1; i<n; i++){//后三行

             for(j=0; j<(2*n-i-1); j++){

                 if(j < i)

                     System.out.print(" ");

                 else

                     System.out.print("*");

             }

             System.out.println();

         }

     }

     public static void main(String[] args) {

         print(4);

     }

 }

23. 分数计算

 package com.ftl;

 /**有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。

     1.程序分析：请抓住分子与分母的变化规律。

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  */

 public class Test2018 {

     public static void main(String[] args) {

         double fenmu = 2;

         double fenzi = 1;

         double num = 0;

         double sum = 0;

         for(int i = 0; i < 20; i++){

             num = fenmu / fenzi;

             double tmp = fenmu;

             fenmu = fenzi + tmp;

             fenzi = tmp;

 //            System.out.println(fenmu + "\t" + fenzi + "\t" + num);

             sum += num;

         }

         System.out.println(sum);

     }

 }

24. 阶乘计算

 package com.ftl;

 import org.omg.Messaging.SyncScopeHelper;

 /**

     题目：求1+2!+3!+...+20!的和

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  */

 public class Test2018 {

     public static void main(String[] args) {

         // 方案一：循环

         long sum = 0;

         for(int i = 1; i <=20; i++){

             long fac = 1;

             for(int j = 1; j <=i; j++){

                 fac *= j;

             }

             sum += fac;

         }

         System.out.println(sum);

         // 方案二： 阶乘

         long ans = 0;

         for(int i=1; i<=20; i++){

             ans = ans + jieCheng(i);

         }

         System.out.println(ans);

     }

     public static long jieCheng(int num){

         if(num == 1) return 1;

         else return jieCheng(num-1) * num;

     }

 }

25. 年龄递归计算

 package com.ftl;

 /**

         有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。

         问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  */

 public class Test2018 {

     public static void main(String[] args) {

         int num = 5;

         System.out.println(jieCheng(num));

     }

     public static int jieCheng(int num){

         if(num == 1) return 10;

         else return jieCheng(num-1) + 2;

     }

 }

26. 分解数字和数字反转

 package com.ftl;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.Iterator;

 import java.util.List;

 /**

         有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。

         问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  */

 public class Test2018 {

     public static void main(String[] args) {

         String str = "1234567";

         // 方案一： 直接反转计算

         System.out.println("反转前：" + str);

         List<String> list = new ArrayList<String>();

         for(int i = 0; i < str.length(); i++){

             list.add(String.valueOf(str.charAt(i)));

         }

         Collections.reverse(list);

         System.out.println("【方案一】反转后：" + list + "，共有" + list.size() + "个数字");

         // 方案二： 分解数字

         Iterator<Integer> iter = explodeNumber(Integer.parseInt(str)).iterator();

         while(iter.hasNext()){

             System.out.print(iter.next());

         }

     }

     public static  List<Integer> explodeNumber(int n){

         List<Integer> li = new ArrayList<Integer>();

         int count = 0;

         while(n != 0){

             li.add((int)n%10);

             count++;

             n = n / 10;

         }

         System.out.print("【方案二】：");

         System.out.println("共有" + count + "个数字");

         return li;

     }

 }

27. 数列： 1,1,2,3,5,8,13,21...

 package com.ftl;

 import java.io.BufferedReader;

 import java.io.IOException;

 import java.io.InputStreamReader;

 /**

  *  数列： 1,1,2,3,5,8,13,21...

  *    ==> 0,1,1,2,3,5,8,13,21...

  *

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  *

  */

 public class Test2018 {

     public static void main(String[] args) {

         int first = 0;

         int second = 1;

         int sum = 0;

         int month = 0;

         try {

             BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));

             System.out.println("请输入月份：");

             month = Integer.parseInt(buf.readLine());

         } catch (NumberFormatException e) {

             // TODO Auto-generated catch block

             e.printStackTrace();

         } catch (IOException e) {

             // TODO Auto-generated catch block

             e.printStackTrace();

         }

         for(int i = 1; i < month; i++){

             sum = first + second;

             first = second;

             second = sum;

         }

         System.out.println("5个月后：" + sum);

     }

 }

28. 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

 package com.ftl;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collections;

 import java.util.List;

 import java.util.Scanner;

 /**

        输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

  * @author 小a玖拾柒

  * Date:   2018年8月18日

  */

 public class Test2018 {

     public static void sort(int[] a){//类似冒泡排序

         int cup = 0;

         int l = a.length-1;

         for(int i=1; i<a.length-1; i++){

             if(a[i] > a[0]){

                 cup = a[i];

                 a[i] = a[0];

                 a[0] = cup;

             }

             if(a[i] < a[l]){

                 cup = a[i];

                 a[i] = a[l];

                 a[l] = cup;

             }

         }

     }

     public static void printArray(int[] a){

         for(int i=0; i<a.length; i++){

             System.out.print(a[i]+" ");

         }

         System.out.println();

     }

     public static void main(String[] args) {

         int[] a = new int[]{2,3,5,1,2,34,1,0,24};

         printArray(a);

         sort(a);

         printArray(a);

     }

 }

【更多学习参考】

链接：https://pan.baidu.com/s/1Xm4Qt6eWD5cE2t_ZpKk-ow 密码：z6qh

巴特西

Java学习---程序设计_基础题[1]

最新文章

热门文章