算法题（1）

java算法题（1）

---

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

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
public class Main {
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in));
        String words = null;
        while((words = br.readLine()) != null){
          //  System.out.println( 7ms 9212kb
          //      new  StringBuilder(words).reverse().toString());
          //7 ms 9232kb
            char [] wws = words.toCharArray();
            int len = words.length();
            for(int i= len - 1; i>=0; i--){
                System.out.print(wws[i]);
            }
             System.out.println();
        }

        //Scanner scan = new Scanner(System.in);
        // 24ms 10922kb 吃内存
        //while(scan.hasNext()){} words = scan.nextLine();
    }
}

2：【15分】 标题：句子逆序 | 时间限制：1秒 | 内存限制：32768K

将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
接口说明
/**
 * 反转句子
 * 
 * @param sentence 原句子
 * @return 反转后的句子
 */
public String reverse(String sentence);

输入描述:
将一个英文语句以单词为单位逆序排放。
输出描述:
得到逆序的句子
示例1
输入
I am a boy
输出
boy a am I

public class Main {
    public static void main (String[] args) throws IOException{
        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in));
        String word = null;
        while((word = br.readLine()) != null ){
            String[] words =  word.split(" ");
            StringBuilder sb = new StringBuilder();
            int len = words.length;
            //1：倒序追加
            for(int i = len -1 ; i > 0;i--){
                //sb.append(words[i] + " ");
                System.out.print(words[i] + " ");//13ms
            }
            //2：清零插入 10ms 
            for(int i = 0 ; i < len;i++){
                sb.insert(0,words[i] + " ");
            }
            //3：转为字符数组插入 10ms  9196kb
            int index = 0;
            char[]  ss = word.toCharArray();
            len = ss.length;
            for(int i = 0 ; i < len;i++){
               if (ss[i] == ' ')  {
                   sb.insert(0,ss[i]);
                   index = 0;
               } else {
                 sb.insert(index,ss[i]);
                 index ++;
               }
            }

            //System.out.println(words[0]);
            System.out.println(sb.toString().trim()); //8 ms
           // Character.isLetter();
        }
    }
}

3：【15分】 标题：空格替换 | 时间限制：3秒 | 内存限制：32768K

请编写一个方法，将字符串中的空格全部替换为“%20”。假定该字符串有足够的空间存放新增的字符，并且知道字符串的真实长度(小于等于1000)，同时保证字符串由大小写的英文字母组成。
给定一个string iniString 为原始的串，以及串的长度 int len, 返回替换后的string。
测试样例：
"Mr John Smith”,13
返回："Mr%20John%20Smith"
”Hello World”,12
返回：”Hello%20%20World”

public class Solution {
    public String replaceSpace(StringBuffer str) {
      if (str == null || str.length() == 0 ) return "";
      char [] strss = str.toString().toCharArray();
      //str.delete(0,strss.length); //追加和插入

      int i=0;
      for(int j = 0; j < strss.length; j++ ){
          if (strss[j] == ' '){
              //str.append("%20"); //追加 12ms 9836kb
              str.deleteCharAt(i); //插入 13 ms 9756kb
              str.insert(i,"%20");
              //str.replace(i,i+1,"%20"); //替换 14ms 10036kb
              i = i+3;
          } else {
              //str.append(strss[j]);
              i++;
          }
      }
      return str.toString();
    }
}

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

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

    public static void main (String[] sasa) throws IOException{
        BufferedReader br =new BufferedReader(
            new InputStreamReader(System.in));
        String temp = null;
        while((temp = br.readLine()) != null){
            String cons = br.readLine();
            // System.out.println(temp.replaceAll("[" + cons + "]","")); 8ms 9472kb
            char[] css = temp.toCharArray();
            for(int i =0 ; i< css.length ; i++){
                if(!cons.contains("" + css[i])) System.out.print(css[i]); //7ms 9052kb
            }
            System.out.println();
        }
    }

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

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

6；【15分】 标题：字符集合 | 时间限制：1秒 | 内存限制：32768K
输入一个字符串，求出该字符串包含的字符集合
输入描述:
每组数据输入一个字符串，字符串最大长度为100，且只包含字母，不可能为空串，区分大小写。
输出描述:
每组数据一行，按字符串原有的字符顺序，输出字符集合，即重复出现并靠后的字母不输出。
示例1
输入
abcqweracb
输出
abcqwer

    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in));
        String words = null;
        while((words = br.readLine()) != null){
            char [] chs = words.toCharArray();
            //int[] chsc = new  int[256];
            int len = words.length();
            StringBuilder sb = new StringBuilder("");
            Set<Character> chsset = new HashSet<Character>();
            Map<Character,Integer> chsmap = new HashMap<Character,Integer>();
            for(int i=0; i < len ; i++){
                //1: sb
                if (!sb.toString().contains("" + chs[i])){
                    sb.append(chs[i]);
                }
                //2: set
                if(chsset.add(chs[i])){
                 // System.out.print(chs[i]);
                  sb.append(chs[i]);
                }

                //3:map
                if(!chsmap.containsKey(chs[i])){
                    chsmap.put(chs[i],0);
                    //System.out.print(chs[i]);
                    sb.append(chs[i]);
                }

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

7:【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) {
       
        //int value = K;
        //int countcc = n;
        //Arrays.sort(a);
        //return a[countcc -value];
        return findK(a, 0,a.length-1,K);
    }
    
    public int findK(int[] arr, int leftpos,int rightpos,int  k) {
        int indexpos = position(arr,leftpos,rightpos);
        
        if(k == indexpos + 1 - leftpos){
            return arr[indexpos];
        }else if (k > indexpos + 1 - leftpos){
            return findK(arr,indexpos + 1,rightpos,k - 1 - indexpos + leftpos);
        }else
            return findK(arr, leftpos, indexpos - 1, k);
    }
    
    public int position(int[] arr, int startpos,int endpos){
        int key = arr[startpos];

        while(startpos < endpos){
            while(startpos < endpos && key >= arr[endpos]) 
                endpos --;
            arr[startpos] = arr[endpos];
            while(startpos < endpos && key <= arr[startpos]) 
                startpos ++;
            arr[endpos] = arr[startpos];
        }

        arr[startpos] = key;
        return startpos;
    }
    
}

8:【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 br = new BufferedReader(
            new InputStreamReader(System.in));
        String words = null;
        while((words = br.readLine()) != null){
            String regx = "[^A-Z]+";// [^\w\d\D\W+]
            // 9ms 9300kb
            System.out.println(words.replaceAll("[^A-Z]+","").length());
            char [] wws = words.toCharArray();
            int len = words.length();
            int c =0;
            for(int i= 0; i< len; i++){
                //7MS 9264KB
               if(wws[i] >= 'A' && wws[i] <= 'Z'){
                   c ++;//isUpperCase 大写Character.isUpperCase(wws[i])
               }else if (Character.isLowerCase(wws[i])){
                   //isLowerCase 小写
               }else if (Character.isLetter(wws[i])){
                   //isLetter 字母 isLetterOrDigit
               }else if (Character.isWhitespace(wws[i])){
                   //isSpaceChar()|isSpace 空白
                   //isWhitespace 空格和空白
               }else if (Character.isDigit(wws[i])){
                   //数字
               }else {
                   //其他字符
               }
            }
            System.out.println(c);
        }
    }

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

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

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
public class Main {
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in));
        String words = null;
        while((words = br.readLine()) != null){
            int c =0;
            int n = Integer.parseInt(words);
            //1: 转为Integer.toBinaryString 9ms 9332kb
            //c = Integer.toBinaryString(n).replaceAll("0","").length();
            //2: &运算 10ms 9312kb
            while(n> 0){
                c += n&1;
                n >>>= 1;
            }
            //3：转toCharArray，判断‘1’个数 7ms 9268kb
            char[] chs = Integer.toBinaryString(n).toCharArray();
            for(char ch : chs){
                if ( ch == '1') c ++;
            }
            System.out.println(c);
        }
    }
}

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

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

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
public class Main {
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in));
        String words = null;
        while((words = br.readLine()) != null){
            int max = -1;
            //1: 使用正则split 8ms 9336kb
            String [] ss = words.split("[\D]+"); //"[^0-9]+"
            for(String ch : ss){
                if ( ch.length() > max ) max = ch.length() ;
            }
            for(String ch : ss){
                if ( ch.length() == max ) System.out.print(ch);
            }

            //2: 转toCharArray（） 8ms 9224kb
            char [] chss = words.toCharArray();
            int c = 0,len = words.length();
            StringBuilder sb = new StringBuilder("");

            for( int i = 0; i <len ; i++){
               char chr = chss[i];
               if (Character.isDigit(chr)){ 
                   c ++;
               }
               else {
                  if (c >0 && c >= max) {
                     if (c > max) {
                        max = c; 
                        sb.delete(0,sb.length());
                     }
                     sb.append(words.substring(i - max,i));
                  }
                  c = 0;
               }
            }
            if (c >= max) {
                if (c > max) {
                    max = c;
                    sb.delete(0,sb.length());
                }
                sb.append(words.substring(len - c,len));
            }

            System.out.println(sb.toString() +"," + max);
        }
    }
}

11：【15分】 标题：约瑟夫问题I | 时间限制：3秒 | 内存限制：32768K

约瑟夫问题是一个非常著名的趣题，即由n个人坐成一圈，按顺时针由1开始给他们编号。然后由第一个人开始报数，数到m的人出局。现在需要求的是最后一个出局的人的编号。
给定两个int n和m，代表游戏的人数。请返回最后一个出局的人的编号。保证n和m小于等于1000。
测试样例：
5 3
返回：4

    public int getResult(int n, int m) {
        if (n < 0 || m < 0) {
            return -1;
        }
        int last = 0;
        for(int i=2;i<=n;++i){
            last = (last+m)%i;
        }
        // 因为实际编号为(1~n)
        return (last+1);
    }

12：【15分】 标题：上台阶 | 时间限制：3秒 | 内存限制：32768K

	，刚开始时你在第一级，若每次只能跨上一级或者二级，要走上n级，共有多少走法？注：规定从一级到一级有0种走法。

给定一个正整数int n，请返回一个数，代表上楼的方式数。保证n小于等于100。为了防止溢出，请返回结果Mod 1000000007的值。
测试样例：
3
返回：2

    int countWays(int n) {
        // write code here
        if(n==1) return 1;
        int f0=1;
        int f1=1;
        for(int i=3;i<=n;i++)
        {
            int tmp=f1;
            f1=(f1+f0)%(1000000007);
            f0=tmp;
        }
        return f1;
    }
    //递归
   public static int f(int n){
    if(n<=2) return n;
    int x = f(n-1)+f(n-2);
    return x;
   }
   //迭代递推
   public static int f(int n){
    if(n<=2) return n;
    if first=1,second=2;
    int third=0;
    for(int i=3;i<=n;i++){
        third = first+second;
        first = second;
        second = third;
    }
    return third;
   }
   //动态规划
   public static int[] A = new int[100];
   public static int f(int n){
       if(n<=2){
           A[n] = n;
       }
       if(A[n]>0){
           return A[n];
       } else {
           A[n] = f(n-1)+f(n-2);
           return A[n];
       }
   }