java算法题2

java算法题2

---

1.【15分】 标题：字符逆序 | 时间限制：1秒 | 内存限制：32768K

将一个字符串str的内容颠倒过来，并输出。str的长度不超过100个字符。 如：输入“I am a student”，输出“tneduts a ma I”。
输入参数：
inputString：输入的字符串
返回值：
输出转换好的逆序字符串

输入描述:
输入一个字符串，可以有空格
输出描述:
输出逆序的字符串
示例1
输入
I am a student
输出
tneduts a ma I

    /**
     * 反转字符串
     * @param str string字符串
     * @return string字符串
     */
    public String solve (String str) {
        char[] a = str.toCharArray();
        for (int i = 0, j = str.length()-1; j >= i; j--, i++ ) {
            char c = a[i];
            a[i] = a[j];
            a[j] = c;
        }
       //return ""+ new StringBuffer(str).reverse();
       return String.valueOf(a);
    }
  
    /**
     *翻转数字-321 -》  -123
     * @param x int整型
     * @return int整型
     */
    public int reverse (int x) {
        String bb = new StringBuffer(Math.abs(x)+"").reverse().toString();
        try{
            return x>0? Integer.parseInt(bb): 0-Integer.parseInt(bb);
        }catch(Exception o){
            return 0;
        }
    }

    public static void main(String[] args) throws IOException{
      BufferedReader b=  new BufferedReader(new InputStreamReader(System.in));
      String br =null;
      while((br = b.readLine()) != null){
          //System.out.println(new StringBuffer(br).reverse().toString()); //8ms
          char[] ss =br.toCharArray();
          StringBuffer sb= new StringBuffer();
          for(int i= ss.length-1;i>=0;i--){
              sb.append(ss[i]);
          }

          System.out.println(sb.toString());//9ms
      }
    }

2.【15分】 标题：字符串替换 | 时间限制：3秒 | 内存限制：32768K

请你实现一个简单的字符串替换函数。原串中需要替换的占位符为"%s",请按照参数列表的顺序一一替换占位符。若参数列表的字符数大于占位符个数。则将剩下的参数字符添加到字符串的结尾。
给定一个字符串A，同时给定它的长度n及参数字符数组arg，请返回替换后的字符串。保证参数个数大于等于占位符个数。保证原串由大小写英文字母组成，同时长度小于等于500。
测试样例：
"A%sC%sE",7,['B','D','F']
返回："ABCDEF"

    public String formatString(String A, int n, char[] arg, int m) {
        char[] s0 = A.toCharArray();
        //if( A.length()> 500 || s0.length < m+1) return ""+s0.length;
        StringBuilder sb = new StringBuilder();
        int c=0;
        for(int i=0;i<s0.length;i++){
            if((i+1)< s0.length && s0[i] == '%' && s0[i+1] == 's'){
                 sb.append(arg[c]);
                 c++;
                 ++i;
            }else sb.append(s0[i]);
           
        }

        for(;c<arg.length;c++){
             sb.append(arg[c]);
        }
        return sb.toString();
    }

【15分】 标题：删除公共字符 | 时间限制：1秒 | 内存限制：32768K

输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.”
输入描述:
每个测试输入包含2个字符串
输出描述:
输出删除后的字符串
示例1
输入
They are students. 
aeiou
输出
Thy r stdnts.

      public static void main(String[] args) throws IOException{
          BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
          String s = null;
          while((s = br.readLine()) != null){
              //char[] s0= br.readLine().toCharArray();
              String s0= br.readLine();
              char[] s1 =s.toCharArray();
              //StringBuilder sb =new StringBuilder();
              for(int i=0;i<s1.length;i++){
                  if(!s0.contains(String.valueOf(s1[i]))){
                       System.out.print(s1[i]);
                  }
              }
              System.out.println();
          }
      }

6.【15分】 标题：字符串的旋转 | 时间限制：3秒 | 内存限制：32768K

对于一个字符串，和字符串中的某一位置，请设计一个算法，将包括i位置在内的左侧部分移动到右边，将右侧部分移动到左边。
给定字符串A和它的长度n以及特定位置p，请返回旋转后的结果。
测试样例：
"ABCDEFGH",8,4
返回："FGHABCDE"

import java.util.*;
public class StringRotation {
    public String rotateString(String A, int n, int p) {
        
        if(p==n-1){
            return A;
        }else{
             return A.substring(p+1,n)+A.substring(0,p+1);
        }    
    }
}

7.【15分】 标题：字符集合 | 时间限制：1秒 | 内存限制：32768K

输入一个字符串，求出该字符串包含的字符集合
输入描述:
每组数据输入一个字符串，字符串最大长度为100，且只包含字母，不可能为空串，区分大小写。
输出描述:
每组数据一行，按字符串原有的字符顺序，输出字符集合，即重复出现并靠后的字母不输出。
示例1
输入
abcqweracb
输出
abcqwer

    public static String singleChar(String string){
        int[] chars = new int[256];
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < string.length(); i++){
            if (chars[string.charAt(i)] == 0){
                stringBuffer.append(string.charAt(i));
            }
                chars[string.charAt(i)]++;
        }
        return stringBuffer.toString();
    }

【返回最长回文子串的长度】

import java.io.*;

public class Main{
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = br.readLine();
      //  while((str = br.readLine()) != null){
            int max = 0;
            int len = str.length();
            for(int i = 0; i < len; i++){
                int l = i - 1;
                int r = i;
                while(l >= 0 && r < len && str.charAt(l) == str.charAt(r)){
                   if(r - l + 1 > max){
                       max = r - l + 1;
                   }
                    l--;
                    r++;
                }
                l = i - 1;
                r = i + 1;
                while(l >= 0 && r < len && str.charAt(l) == str.charAt(r)){
                    if(r - l + 1 > max){
                        max = r - l + 1;
                    }
                    l--;
                    r++;
                }
            }
            System.out.println(max);
       // }
    }
}

#### 【给定两个只包含小写字母的字符串，计算两个字符串的最大公共子串的长度。
注：子串的定义指一个字符串删掉其部分前缀和后缀（也可以不删）后形成的字符串。】
```java
import java.io.*;
public class Main{
    public static void main(String[] args)throws Exception{
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String str1 = "";
        String str2 = "";
 
        while((str1 = bf.readLine())!= null && (str2 = bf.readLine())!= null){
            int max = 0;
            char[] cha1 = str1.toCharArray();
            char[] cha2 = str2.toCharArray();
            for(int i = 0; i < str1.length(); i++){
                for(int j = 0; j < str2.length(); j++){
                    int t1 = i;
                    int t2 = j;
                    int count = 0;
                    while(cha1[t1] == cha2[t2]){
                        t1++;
                        t2++;
                        count++;
                        max = Math.max(count,max);
                        if(t1 == cha1.length || t2 == cha2.length) break;
                    }
                }
            }
            System.out.println(max);
        }
    }
}

8.【15分】 标题：字符串变形 | 时间限制：1秒 | 内存限制：32768K

对于一个给定的字符串，我们需要在线性(也就是O(n))的时间里对它做一些变形。首先这个字符串中包含着一些空格，就像"Hello World"一样，然后我们要做的是把着个字符串中由空格隔开的单词反序，同时反转每个字符的大小写。比如"Hello World"变形后就变成了"wORLD hELLO"。
输入描述:
给定一个字符串s以及它的长度n(1≤n≤500)
输出描述:
请返回变形后的字符串。题目保证给定的字符串均由大小写字母和空格构成。
示例1
输入
"This is a sample",16
输出
"SAMPLE A IS tHIS"

    public String trans(String s, int n) {
       //if(s.equals(" ")||s.isEmpty()|| s.isBlank() ) return s;
       char[] arr = s.toCharArray();
       StringBuffer sb=new StringBuffer();
       int pos=0;
       for(int i=0;i < arr.length;i++){
           char temp= arr[i];
           if(Character.isLowerCase(temp)) {
               sb.insert(pos,Character.toUpperCase(temp));
               pos++;
           }else if(Character.isUpperCase(temp)) {
               sb.insert(pos,Character.toLowerCase(temp));
               pos++;
           }else if(Character.isWhitespace(temp)){
               pos=0;
               sb.insert(pos,temp);
          };
       }
       return sb.toString();
    }

9.【15分】 标题：寻找第K大 | 时间限制：3秒 | 内存限制：32768K

有一个整数数组，请你根据快速排序的思路，找出数组中第K大的数。
给定一个整数数组a,同时给定它的大小n和要找的K(K在1到n之间)，请返回第K大的数，保证答案存在。
测试样例：
[1,3,5,2,2],5,3
返回：2

public class Solution {
    public int findKth(int[] a, int n, int K) {
        //....
    }
   
}

10.【15分】 标题：统计大写字母个数 | 时间限制：1秒 | 内存限制：32768K

找出给定字符串中大写字符(即'A'-'Z')的个数
接口说明
原型：int CalcCapital(String str);
返回值：int

注意：测试数据需要考虑循环输入
输入描述:
输入一个String数据
输出描述:
输出string中大写字母的个数
示例1
输入
add123#$%#%#O
输出
1

    public static void main(String[] args) throws IOException {
       BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
       String br=null;
       while((br=b.readLine()) != null){
           //System.out.println(br.replaceAll("[^A-Z]+","").length()); 13ms
          char[] ss=br.toCharArray();
          int count=0;
          for(int i=0;i<ss.length;i++){
              //if(ss[i]>= 'A' && ss[i]<= 'Z') count++; //13ms
              if(Character.isUpperCase(ss[i])) count++; //9ms
          }
          System.out.println(count);
       }
    }

//一个字符串，为不同字母出现次数的降序表示。若出现次数相同，则按ASCII码的升序输出。【字符统计】
    public static void main(String[] args) throws IOException{
       BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
       String ss=null;
       while((ss=b.readLine()) !=null){
           char[] s= ss.toCharArray();
           int[] asc= new int[123];

           for(int i=0;i<s.length;i++){
               asc[s[i]]++;
           }

           int max =0;
           for(int j=0;j<asc.length;j++){
              if(max < asc[j]) max = asc[j];
           }

           StringBuffer sb = new StringBuffer();
           while(max != 0){
              for(int k=0;k<asc.length;k++){
                if(max == asc[k]) sb.append((char)k);
              }
              max--;
           }

           System.out.println(sb.toString());
       }
    }

【字符分割 [123456789 -> 12345678,900000000]】

    public static void main(String[] args)throws IOException{
       BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       String s = null;
       while((s= br.readLine()) != null){
           int count = s.length();
           StringBuilder sb=new StringBuilder();
           int pos=0;
           while(count >= 8){
              //sb.append(s.substring(pos,pos+8)+"
");
              System.out.println(s.substring(pos,pos+8));
              count -= 8;
              pos += 8;
           }

           if(count >0 ) {
              //sb.append(s.substring(pos));
              //sb.append((Math.round(Math.pow(10,8-count))+"").substring(1));
              System.out.print(s.substring(pos));
              System.out.println((Math.round(Math.pow(10,8-count))+"").substring(1));
           }

       }
    }

11.【15分】 标题：查找输入整数二进制中1的个数 | 时间限制：1秒 | 内存限制：32768K

请实现如下接口
     public   static   int  findNumberOf1( int num)
    {
         /*  请实现  */
         return  0;
    } 譬如：输入5 ，5的二进制为101，输出2
 
涉及知识点：
输入描述:
输入一个整数
输出描述:
计算整数二进制中1的个数
示例1
输入
5
输出
2

public class Solution {
    public int NumberOf1(int n) {
         int res = 0;
         while(n!=0){
             res += n&1;
             n >>>= 1;
         }
         return res;
    }

  public static void main(String[] args) throws IOException{
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String b = null;
      while((b=br.readLine()) != null){
          int count=0,max=0;
          int n=Integer.parseInt(b);
          while(n != 0){
            if((n&1)> 0){ 
                count++;
            }else {
                max = max < count ?count : max;
                count=0;
            }
            n >>>=1;
          }

          //count=Integer.toBinaryString(Integer.parseInt(b)).replaceAll("0","").length();
          System.out.println(max < count ?count : max);
      }
  }
}

12.【15分】 标题：字符串中找出连续最长的数字串 | 时间限制：1秒 | 内存限制：32768K

读入一个字符串str，输出字符串str中的连续最长的数字串
输入描述:
个测试输入包含1个测试用例，一个字符串str，长度不超过255。
输出描述:
在一行内输出str中里连续最长的数字串。
示例1
输入
abcd12345ed125ss123456789
输出
123456789

    public static void main(String[] args) throws IOException{
       BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
       String ss=null;
       while((ss=b.readLine()) !=null){
           String[] s = ss.split("[^0-9]+");
           int max = 0;
           for(int i=0;i<s.length;i++){
              if(s[i].length() ==0 ) continue;
              if(max < s[i].length()) max = s[i].length();
           }
           StringBuilder sb=new StringBuilder();
           for(int i=0;i<s.length;i++){
              if(max == s[i].length()) sb.append(s[i]);
           }
           System.out.println(sb +","+ max);
       }
    }

13.【15分】 标题：找出字符串中第一个只出现一次的字符(题面已经更新) | 时间限制：1秒 | 内存限制：32768K

找出字符串中第一个只出现一次的字符
输入描述:
输入几个非空字符串
输出描述:
输出第一个只出现一次的字符，如果不存在输出-1
示例1
输入
asdfasdfo
aabb
输出
o
-1

    public int FirstNotRepeatingChar(String str) {
        if(str.length()==1){
            return 0;
        }
 
        for(int i=0;i<str.length();i++){
            if(str.indexOf(str.charAt(i))== str.lastIndexOf(str.charAt(i))){
                return i;
            }
        }
 
        return -1;
    }
#### 【找出字符串中第一个只出现一次的字符】
    public static void main(String[] args)throws IOException{
       BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       String str = null;
       while ((str = br.readLine()) != null) {
           char[] s0 =str.toCharArray();
           for(int i=0;i<s0.length;i++){
               char c= s0[i];
               if(str.indexOf(c)==str.lastIndexOf(c)){
                   System.out.println(c);
                   break;
               }
               if(i == (s0.length-1)) System.out.println(-1);
               
           }
          
       }
    }

【数组中只出现一次的数（其它数出现k次）】

public class Solution {
    /**排序
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * @param arr int一维数组 
     * @param k int 
     * @return int
     */
public int foundOnceNumber (int[] arr, int k) {
        // 每个二进制位求和，如果某个二进制位不能被k整除，那么只出现一次的那个数字在这个二进制位上为1。
        int[] binarySum = new int[32];
        for(int i = 0; i< 32; i++){//求每个二进制位的和
            int sum = 0;
            for(int num : arr){
                sum += (num >>i & 1);//依次右移num，同1相与，计算每一位上1的个数
            }
            binarySum[i] = sum;
        }
        int res = 0;
        for (int i = 0; i< 32; i++){
            if(binarySum[i]%k!=0){
                res += 1<<i;//左移恢复
            }
        }
        return res;
    }
}

//位运算
public int foundOnceNumber (int[] arr, int k) {
        // 每个二进制位求和，如果某个二进制位不能被k整除，那么只出现一次的那个数字在这个二进制位上为1。
        int[] binarySum = new int[32];
        for(int i = 0; i< 32; i++){//求每个二进制位的和
            int sum = 0;
            for(int num : arr){
                sum += (num >>i & 1);//依次右移num，同1相与，计算每一位上1的个数
            }
            binarySum[i] = sum;
        }
        int res = 0;
        for (int i = 0; i< 32; i++){
            if(binarySum[i]%k!=0){
                res += 1<<i;//左移恢复
            }
        }
        return res;
    }

//hashmap
public int foundOnceNumber (int[] arr, int k) {
        // write code here
        HashMap<Integer, Boolean> map = new HashMap<>();//key存数字，value表示是否出现过
        for(int num: arr){
            if(map.containsKey(num)){
                map.put(num, true);
            }else{
                map.put(num, false);
            }
        }
        Set<Integer> set = map.keySet();
        for(int num : set){
            if(map.get(num) == false){
                return num;
            }
        }
        return 0;
    }

public int foundOnceNumber (int[] arr, int k) {
        // write code here
        HashMap<Integer, Integer> map = new HashMap<>();//key存数字，value表示是否出现过
        for(int num: arr){
            if(map.containsKey(num)){
                map.put(num, map.get(num)+1);
            }else{
                map.put(num, 1);
            }
        }
        Set<Integer> set = map.keySet();
        for(int num : set){
            if(map.get(num) == 1){
                return num;
            }
        }
        return 0;
    }

14.对于一个字符串，请设计一个高效算法，计算其中最长回文子串的长度。

给定字符串A以及它的长度n，请返回最长回文子串的长度。
输入
"abc1234321ab",12
返回值
7

    public int getLongestPalindrome(String A, int n) {
        char[] ch = A.toCharArray();
        int res = 0;
        for(int i = 0; i < n; i++){
            int l = i, r = i, sameR = i;
            //定位左右两边,避免abba和aba
            while(l - 1 >= 0 && ch[l - 1] == ch[i]) l--;
            while(r + 1 < n && ch[r + 1] == ch[i]) r++;
            sameR = r;
             
            while(l - 1 >= 0 && r + 1 < n && ch[l - 1] == ch[r + 1]){
                l--;
                r++;
            }
             
            res = Math.max(res, r - l + 1);
             
            //优化
            i = sameR;
        }
        return res;
    }

15.给定一个数组arr，返回arr的最长无的重复子串的长度(无重复指的是所有数字都不相同)。

示例1
输入
[2,3,4,5]
返回值
4

    /**
     * @param arr int整型一维数组 the array
     * @return int整型
     */
    public int maxLength (int[] arr) {
        // write code here
        //int[] lastPos = new int[100000];
        int len = arr.length;
        int[] lastPos = new int[len];
        int start = 0;
        int res = 0;
        for(int i =0;i<len;i++){
            int now = arr[i];
            start = Math.max(start,lastPos[now]);
            res = Math.max(res,i-start+1);
            lastPos[now] = i+1;
        }
         
        return res;
    }

16.大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。

public int Fibonacci(int n) {
    if(n==0){
        return 0;
    }else if(n==1 || n==2){
        return 1;
    }else if(n==3){
        return 2;
    }
    int f2 =1,sum=2;
    while(n>3){
        int temp=sum;
        sum =f2 + sum;
        f2=temp;
        n--;
    }
    return sum;
}

17.请实现有重复数字的升序数组的二分查找

给定一个 元素有序的（升序）整型数组 nums 和一个目标值 target ，
写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1
[1,2,4,4,5],4
返回值
2

    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 如果目标值存在返回下标，否则返回 -1
     * @param nums int整型一维数组 
     * @param target int整型 
     * @return int整型
     */
    public int search (int[] nums, int target) {
        if(nums==null||nums.length==0) return -1;
        int first = 0;
        int last = nums.length-1;
        while(first<last){
            int middle = (first +last)/2;
            if(nums[middle]>target){
                last = middle-1;
            }else if(nums[middle]<target){
                first=middle+1;
            }else{
                last=middle;
            }
        }
        if(nums[first]==target) return first;
        return -1;
    }

18.数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。

由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
示例1
输入
[1,2,3,2,2,2,5,4,2]
返回值
2

    public int MoreThanHalfNum_Solution(int [] array) {
        int len=array.length;
        if(len==0) return 0;
        int ret=0,res=array[0],count=1;
        for(int i=1;i<len;i++){
            if(count==0){
                res=array[i];
                count++;
                continue;
            }
            if(array[i]!=res){
                count--;
            }else count++;
        }
        for(int num:array){
            if(num==res) ret++;
        }
        return ret>(len>>1)?res:0;
    }

19.用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        stack1.push(node);
    }
    
    public int pop(){
      if(stack2.empty()){
        while(!stack1.empty()){
            stack2.push(stack1.pop());
        }
        return stack2.pop();
      }else{
          return stack2.pop();
      }
      
    }
}

20.【ACM编程题】标题：组队竞赛|时间限制：1秒|内存限制：32768K

示例1:
输入
2
5 2 8 5 1 5

输入的第一行为一个正整数n(1≤n≤10^5)
第二行包括3*n个整数a_i(1≤a_i≤10^9),表示每个参赛选手的水平值.
输入描述：
输出一个整数表示所有队伍的水平值总和最大值.
null
输出描述：
10

    public static void main(String[] args){
        Scanner scanner =new Scanner(System.in);
        int n = scanner.nextInt();
        int len = 3 * n;
        int[] as= new int[len];

        for(int j=0;j<len;j++){
            as[j] = scanner.nextInt();
        }
        Arrays.sort(as);// 1 2 5 5 5 8
        long sum=0;
        //1:从数组递减的形式递减统计
        for(int j = len - 2;j >= n;j -= 2){
            sum += as[j];
        }
        //2：从队列数递增的形式统计
        for(int j=0;j < n;j ++){
            sum += as[len - 2*(j+1)];
        }
        System.out.println(sum);
   }