java编程综合题

package step1;



import java.util.*;



public class Main {

    public static void main(String[] args) {

        // -- write your code here --



        //声明Scanner类的实例对象in

        Scanner in = new Scanner(System.in);

        String str1 = in.nextLine();

        String str2 = in.nextLine();

     String[] strarr1 =  str1.substring(str1.indexOf("[") + 1,str1.indexOf("]")).split(",");

     String[] strarr2 =  str2.substring(str2.indexOf("[") + 1,str2.indexOf("]")).split(",");

     

     int arr1[] = new int[strarr1.length];

     int arr2[] = new int[strarr2.length];

     

        //获取数据：分别输入两个数组arr1和arr2

        int i;

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

         String num = strarr1[i].trim();

         arr1[i] = Integer.parseInt(num);

     }

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

         String num = strarr2[i].trim();

         arr2[i] = Integer.parseInt(num);

     }

      

        //声明Solution类的实例对象

       Solution solution = new Solution();



        //调用Solution类的方法equalityOfArrays判断两个数组是否相等并输出结果

      boolean res = solution.equalityOfArrays(arr1,arr2);

          if(res) System.out.println("The arrays arr1 and arr2 are equal.");

          else System.out.println("The arrays arr1 and arr2 are not equal.");

      



        //关闭输入流对象

        in.close();

            



    }

} 



  

package step2;



import java.util.*;



class Solution {

    /**

     * @param str: 非空字符串

     * @return 按照字典序的降序排列的字符串

     */

    public String handle(String str) {

        // --write your code here--

      char[] arr = str.toCharArray();

      Character[] arr2 = new Character[arr.length];

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

         arr2[i] = arr[i];

     }

     Arrays.sort(arr2,new Comparator<Character>(){

            public int compare(Character o1,Character o2){

                return o2 - o1;

            }



     });

        return Arrays.toString(arr2);

    }

}



public class Main {

    public static void main(String[] args) {

        // --write your code here--



        //声明Scanner类的实例对象in

    Scanner in = new Scanner(System.in);

        //输入一行字符串

   String str = in.nextLine();

        //声明Solution类的实例对象

Solution solution = new Solution();

        //调用Solution类的handle方法，并输出结果

       String res = solution.handle(str);

       System.out.print(res);

        //关闭输入流对象

        in.close();

    }

}  

  

package step3;



public class Student implements Comparable {



    private String name;

    private int score;



    public Student(String name, int score) {

        this.name = name;

        this.score = score;

    }



    public String getName() {

        return this.name;

    }



    public int getScore() {

        return this.score;

    }



    @Override

    public int compareTo(Object s) {

        // --write your code here--

        Student stu =(Student)s;

        if(this.score>stu.score){

              return -1;

        }

      

        else if(this.score<stu.score){

               return 1;

        }

     

        else{

            return this.getName().compareTo(stu.getName());

        }

    }



    @Override

    public String toString() {

        return this.name + " " + this.score;

    }

} 
package step3;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // --write your code here

        //创建Scanner类的实例对象in
        Scanner in = new Scanner(System.in);
        
     List<Student> list = new ArrayList<>();
        // 读取数据并存入List集合
      while(in.hasNextLine()){
          String str = in.nextLine();
           String[] strarr = str.trim().split(" ");
            String name = strarr[0];
            int score = Integer.parseInt(strarr[1]);
            list.add(new Student(name,score));
      }

        //排序：成绩从高到低，成绩相等时安装姓名字典序
        Collections.sort(list);

        //输出排序后的结果
  for(Student student:list){
      System.out.println(student);
  }
        //关闭输入流对象in
        in.close();
    }
} 




package step4;



import java.util.*;

import java.io.*;



/**

 * 最大的k个数。

 */

public class Main {



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

        //使用File类读入目录"src/step4/"下的文件"0.in"

        File file = new File("src/step4/0.in");




        //声明Scanner类的实例对象in, 从File类的对象中读入多行数据

        Scanner in = new Scanner(file);



        //循环读入多组数据

        while (in.hasNextLine()) {

            // 读入一组数据，解析数据，存入数组

            String str = in.nextLine();

            String kk = in.nextLine();

            int k = Integer.parseInt(kk);

            String[] nums = str.substring(str.indexOf("[")+1,str.indexOf("]")).trim().split(", ");

            Integer arr[] = new Integer[nums.length];

             int i;

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

                 arr[i] = Integer.parseInt(nums[i]);

             }

             Arrays.sort(arr,Comparator.reverseOrder());

            //输出最大的k个数

           

            System.out.print("[");

            for(i=0;i<k;i++){

                if(i==k-1){

                    System.out.print(arr[i]);

                }

                

                else {System.out.print(arr[i]+", ");}

            }

          System.out.println("]");

            

        }



        in.close();

    }

}



package step5;

import java.util.Scanner;

import java.util.*;

import java.io.*;



public class Main {

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

        //使用File类读入目录"src/step5/"下的文件"0.in"

        File file = new File("src/step5/0.in");

        //声明Scanner类的实例对象in, 从File类的对象中读入多行数据

        Scanner in = new Scanner(file);

        //循环读入多组数据

        while (in.hasNextLine()) {

            // 读入一组数据，解析数据，存入数组

            String str = in.nextLine();

            String nums[] = str.substring(str.indexOf("[")+1, str.indexOf("]")).trim().split(", ");

            int n = Integer.parseInt(nums[0]);

            int key = Integer.parseInt(nums[1]);



            int[] arr = new int[nums.length-2];



            for(int i=0;i<nums.length-2;i++){

                arr[i] = Integer.parseInt(nums[i+2]);

            }

            // 调用折半查找函数

            bs(arr,key);

        }

        //关闭输入流

        in.close();

    }

    /**

     * 折半查找函数bs：在数组arr中查找关键字key。

     * 输出关键字key在数组中的索引值和查找次数。

     * 如果数组中找不到关键字key，则输出Not Found

     */

    public static void bs(int[] arr, int key) {

        int s=0,e=arr.length-1;

        int mid,count=0;

        while(s<=e){

            mid = s+(e-s)/2;

            count++;

            if(key == arr[mid]){

               System.out.println(mid + " " + count);

               return;

            }else if(key>arr[mid]){

                 s = mid + 1;

            }

            else if(key < arr[mid]){

                 e = mid - 1;

            }

        }

        if(s>e) 

            System.out.println("Not Found");

    }

}



package step6;



import java.util.*;



public class Main {

    public static void main(String[] args) {

        //创建Scanner类的实例对象

         Scanner sc = new Scanner(System.in);




        //读入n a b c

        

  int n =sc.nextInt();

  int a =sc.nextInt();

  int b =sc.nextInt();

  int c =sc.nextInt();



        //创建Solution类的实例对象

        Solution solution = new Solution();



        //调用Solution类的fun方法，统计[a, b]内c出现的次数并输出

       System.out.println(solution.fun(n,a,b,c));



        //关闭输入流对象

        sc.close();

    }

}



class Solution {

    /**

     * 由n构建字符串，在构建的字符串的[a, b]区间内统计c出现的次数并返回。

     */

    public int fun(int n, int a, int b, int c) {

        StringBuilder sb = new StringBuilder();

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

            sb.append(i);

        } 

        String str = sb.toString();

        String re = sb.substring(a,b+1);

        int cnt = 0;

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

            if(Integer.parseInt(re.charAt(i)+"")==c)

            cnt++;

        }

        System.out.print(str.length()+" ");

        return cnt;

    }

}





package step7;



import java.util.Scanner;



public class Main {

    public static void main(String[] args) {

        //创建Scanner类的实例对象sc

        Scanner sc = new Scanner(System.in);



        //读入一行仅由字母和*组成的字符串c

        String c = sc.nextLine();



        //h定位到字符串c第一个字母，p定位到字符串c的最后一个字母

        int h = 0,p = c.length() - 1;



        //调用函数fun完成*的删除

        fun(c, h, p);



        //关闭输入流对象

        sc.close();

    }



    /**

     * 功能 ：删除字符串中间位置的*

     * 参数c：传入的字符串

     * 参数h：字符串第一个字符的索引

     * 参数p：字符串最后一个字符的索引

     */

    private static void fun(String c, int h, int p) {

        //************** code begin **************//

        char[] str = new char[c.length()];

        while(c.charAt(h)=='*'){

            str[h++] = '*';

        }

        while(c.charAt(p)=='*'){

            p--;

        }

        int k = h;

        for(int i=h;i<=p;i++){

            if(c.charAt(i)!='*')

            str[k++] = c.charAt(i);

        }

        for(int i=p+1;i<c.length();i++)

        {

            str[k++] = '*';

        }

      System.out.print(new String(str));




        // ************** code end ****************//

    }

}





package step8;



import java.util.*;

import java.io.*;



public class Solution {

    public static void main(String[] args) {

        int b;

        byte[] s = new byte[1024];

        try {

            b = System.in.read(s);

        } catch (IOException e) {

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

        }



        // 请在此添加代码

        /*************** Begin **************/

        //创建Solution类的实例对象

        Solution solution = new Solution();



        //调用Solution类的extractNum方法，返回一个集合对象。

         List<Character> list = solution.extractNum(s);

    

        //将集合中存储的数字打印出来

        int flag= 0;

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

            if(list.get(i).equals('0')){

                if(flag!=0){

                    System.out.print(list.get(i));

                }

            }

            else{

                    System.out.print(list.get(i));

                    flag = 1;

                }

        }



        /*************** End ***************/

    }



    // 函数extractNum：选出str指向的字符串中的数字

    // 参数：str-指向字符串

    public List<Character> extractNum(byte[] str) {

        // 请在此添加代码，实现函数extractNum

        /*************** Begin **************/

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

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

           if(Character.isDigit(str[i])){

               list.add((char)str[i]);

           }

       }

       return list;

        

        /*************** End ***************/

    }

}






package step9;



import java.util.*;



/**

 *  输入: source = "abcde", target = "cdeab"

 *  输出: true

 */

class Solution {

    public boolean rotateString(String s, String target) {

        //在下面编写代码

        //************************Begin**********************//

        return s.length() == target.length() && (s + s).contains(target);




        //*************************End***********************//

    }

}



public class Main {

    public static void main(String[] args) {

        //在下面编写代码

        //************************Begin**********************//

        //声明Scanner类实例对象cin

        Scanner cin = new Scanner(System.in);

     

        //输入源字符串source

        String source = cin.next();



        //输入目标字符串target

        String target = cin.next();



        //创建Solution类实例对象

        Solution solution = new Solution();



        //调用Solution类的方法rotateString，判断target是否可以由source旋转得到。

        //如果可以，输出true；否则输出false

        

       System.out.println(solution.rotateString(source,target));



        //*************************End***********************//



        cin.close();

    }

} 



package step10;



import java.util.*;

import java.math.*;



class Solution {

    public  int isPrefixOfWord(String sentence, String searchWord) {

        /***********************Begin**************************/

           String words[] = sentence.trim().split(" ");

          

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

           {

               boolean flag = words[i].startsWith(searchWord);

               if(flag==true)

               {

                  return i+1;

                

                  

               }

              

           }

           

         return -1;

           

        /*************************End**************************/

    }



} 



package step10;



import java.util.*;

import java.math.*;

import java.io.*;



public class Main {

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

        //读入目录src/step10下面的文件0.in

     File file = new File("src/step10/0.in");

        //声明Scanner类的实例对象cin，从文件0.in中读入数据进行处理。

       Scanner cin = new Scanner(file);

       while(cin.hasNextLine()){

            String sentence = cin.nextLine();

            String searchWord = cin.nextLine();

        //声明Solution类的实例对象，并调用Solution类的方法isPrefixOfWord，返回结果并打印。

            Solution solution = new Solution();

            System.out.println(solution.isPrefixOfWord(sentence,searchWord));

       }

           

        cin.close();  //关闭输入流对象

    }

}



package step11;



import java.util.*;



public class Solution {

    //统计数组元素之和并返回

    public int getSum(int arr[]) {

        //******Begin*******//

      Set<Integer> set = new HashSet<>();

      for(int x:arr){

          set.add(x);

      }



      int sum = 0;

      Iterator<Integer> it = set.iterator();

      while(it.hasNext()){

          sum += it.next();

      }

      return sum;

        //******End*******//

        

    }

}



package step11;



import java.io.*;

import java.util.*;



public class Main {

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

        //读入src/step11/下的文件0.in，创建File类的实例对象file

          File file = new File("src/step11/0.in");



        //根据File类的实例对象file，创建Scanner类的实例对象in

           Scanner in = new Scanner(file);

           

        //循环读入多行

        while (in.hasNextLine()) {

            // 读取一行数据并处理

            String str = in.nextLine();

            String[] m = str.substring(str.indexOf("[")+1,str.indexOf("]")).trim().split(", ");

            int[] cin = new int[m.length];

            int i;

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

                cin[i] = Integer.parseInt(m[i]);

                    

            }

            //创建Solution类的实例对象

            Solution solution = new Solution();



            //调用Solution类的方法getSum，传入参数，获取返回值

            int n = solution.getSum(cin);

            //输出返回结果

            System.out.println(n);



        }

        in.close();  //关闭输入流

    }

}



package step12;



import java.util.*;



public class Solution {

    /**

     * @param arr: Any int array, and not an empty array

     * @return Non-repetitive and ordered arrays

     */

    public Integer[] deDuplicationAndSort(Integer[] arr) {

        // write your code here

        Set<Integer> set = new HashSet<>();

        for(int x:arr){

            set.add(x);

        }

        Integer[] ans = new Integer[set.size()];

        Iterator it = set.iterator();

        int i=0;

        while(it.hasNext()){

            ans[i++] = (Integer)it.next();

        }

         Arrays.sort(ans);

         return ans;

        

        

    }

}



package step12;



import java.io.*;

import java.util.*;



public class Main {

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

        //使用File类读入目录"src/step12/"下的文件"0.in"

         File file = new File("src/step12/0.in");



        //声明Scanner类的实例对象in, 从File类的对象中读入多行数据

           Scanner in = new Scanner(file);

     

        //循环读入多行数据

        while (in.hasNextLine()) {

            // 读入一行数据，解析数据，存入数组

            String str = in.nextLine();

            String[] arr = str.substring(str.indexOf("[")+1,str.indexOf("]")).trim().split(", ");

            Integer[] nums = new Integer[arr.length];

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

                nums[i] = Integer.parseInt(arr[i]);

            }

            //声明Solution类的实例对象solution

            Solution solution = new Solution();



            //调用Solution类的方法deDuplicationAndSort

           Integer[] an = solution.deDuplicationAndSort(nums);



            //按照指定格式[1, 2, 3, 4]这种形式打印去除重复元素并排序后的数据

         System.out.print("[");

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

             if(i!=an.length-1){

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

             }

             else System.out.print(an[i]);

         }

         System.out.println("]");

            

        }

        in.close();  //关闭输入流

    }

}



package step13;



import java.util.*;

import java.io.*;

import java.math.*;



public class Main {

    public static void main(String[] args) {

        //在下面编写代码

        //**************Begin**************//

        //创建Scanner类实例对象cin

         Scanner cin = new Scanner(System.in);



        //输入整数n

     int n = cin.nextInt();

        

        //创建数组nums

        int nums[] = new int[n];

        

        //输入n个整数，存入数组nums

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

            nums[i] = cin.nextInt();

        }

        int[] arr = new int[1000];

        //统计只出现一次的元素之和并打印

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

             arr[nums[i]]++;

        }

         int sum = 0;

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

             if(arr[i]==1)

              sum += i;

         }

         System.out.print(sum);

        //关闭输入流对象

        cin.close();



        //***************End***************//

    }

}



package step14;



import java.util.*;



class Solution {

    /**

     * 求两个数组的交集。

     */

    Set<Integer> jointSet(int[] nums1, int[] nums2) {

        //write your coder here

        //********************Begiin*****************//

       Arrays.sort(nums1);

       Arrays.sort(nums2);

        int i=0,j;

        for(j=1;j<nums1.length;j++){

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

                i++;

                nums1[i] = nums1[j];

            }

        }

        int len1 = i+1;

        i=0;

        for(j=1;j<nums2.length;j++){

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

                i++;

                nums2[i] = nums2[j];

            }

        }

       int len2 = i+1;

       Set<Integer> list = new TreeSet<>();

       int m=0,k=0;

        while(m<len1 && k<len2)

        {

           if(nums1[m]==nums2[k])

           {

               list.add(nums1[m]);

               m++;k++;

           }

           else if(nums1[m]<nums2[k]) m++;

           else k++;

       }

       return list;



        //*********************End******************//

    }

}



public class Main {

    public static void main(String[] args) {

        //write your coder here

        //********************Begiin*****************//

        //定义Scanner类的实例对象cin

        Scanner cin = new Scanner(System.in);



        //输入n和n个整数

        int n;

        n = cin.nextInt();

        int[] arr1 = new int[n];

        for(int i=0;i<n;i++)

        {

            arr1[i] = cin.nextInt();

        }

        //输入k和k个整数

        int k;

        k = cin.nextInt();

        int[] arr2 = new int[k];

        for(int i=0;i<k;i++)

        {

            arr2[i] = cin.nextInt();

        }

        //定义Solution类的实例对象

        Solution sol = new Solution();



        //调用Solution类的方法jointSet方法求两个数组的交集

        Set<Integer> set = sol.jointSet(arr1,arr2);

        



        //输出交集的大小

        System.out.println(set.size());



        //输出交集的元素

        if(set.size()==0)

        {

            System.out.println("null");

        }

        else{

            for(int x:set)

            {

                System.out.print(x+" ");

            }

        }

        //*********************End******************//

        //关闭输入流对象cicn

        cin.close();

    }

}