蓝桥杯刷题文件（包含多道练习题）

1.字符排序

算法是这样的，如果给定N个不同字符，将这N个字符全排列，最终的结果将会是N!种。如：给定 A、B、C三个不同的字符，则结果为：ABC、ACB、BAC、BCA、CAB、CBA一共3!=3*2=6种情况。

package Question1_9;
import java.util.Scanner;
import java.util.Vector;

public class Question1 {
	public static long count=0;
	private void fullPermutation(Vector<Character>sourse, Vector<Character> result) {
		if(sourse.size()==0){
			for (int i = 0; i < result.size(); i++) {
				System.out.print(result.elementAt(i));
			}
			System.out.print("\n");
			count++;
			return;
		}
				for (int i = 0; i < sourse.size(); i++) {
			Vector<Character>tsourse=new Vector<Character>(sourse);
			Vector<Character>tresult=new Vector<Character>(result);
			tresult.add(sourse.elementAt(i));
			tsourse.remove(i);
			new Question1().fullPermutation(tsourse, tresult);
		}
	}
	
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		int n=scanner.nextInt();
		Vector<Character> sourse=new Vector<Character>();
		Vector<Character> result=new Vector<Character>();
		for (int i = 0; i < n; i++) {
			sourse.add((char)('A'+i));
		}
		
		new Question1().fullPermutation(sourse, result);
		System.out.println(Question1.count);
	}
}

方法二：
import java.util.ArrayList;  
import java.util.Iterator;  
import java.util.LinkedHashSet;  
import java.util.List;  
import java.util.Scanner;  
import java.util.Set;  
  
public class Demo03 {  
    // 去掉重复元素,放入lis   
    public static void removeDuplicate(String s,Set<Character> lis){  
        for(char x:s.toCharArray()){  
            lis.add(x);  
        }  
    }  
    // 为方便操作 将 sets 转 lis    
    public static void convert(List<Character> lis,Set<Character> sets){  
        Iterator<Character> iter = sets.iterator();  
        while(iter.hasNext()){  
            lis.add(iter.next());  
        }  
    }  
    // 检测符合条件的元素组合   
    public static void check(Set<Character> sets){  
        List<Character> lis = new ArrayList<Character>();  
        convert(lis,sets);  // 为方便操作 将 sets 转 lis    
        StringBuffer sb = new StringBuffer();  
        for(int i=0;i<lis.size()-2;i++){  
            for(int j=i+1;j+1<lis.size();j++){   // 向后添加两位,所以 j+1<lis.size()   
                for(int k=j+1;k<lis.size();k++){  
                    sb.append(lis.get(i));  
                    sb.append(lis.get(j));  
                    sb.append(lis.get(k));  
                    System.out.println(sb); // 输出组合   
                    sb.setLength(0);    // 清空   
                }  
            }  
        }  
          
    }  
    public static void main(String[] args){  
        Scanner scan = new Scanner(System.in);  
        System.out.println("输入串（不大于30个字符）。");  
        String s = scan.nextLine();  
        Set<Character> sets = new LinkedHashSet<Character>();  
        removeDuplicate(s,sets);    // 去掉重复元素,放入lis   
        check(sets);    // 检测符合条件的元素组合   
    }  
}  

运行结果:

输入串（不大于30个字符）。  

abcd  

abc  

abd  

acd  

bcd  

2.串的简单处理

串的处理

在实际的开发工作中，对字符串的处理是最常见的编程任务。

本题目即是要求程序对用户输入的串进行处理。具体规则如下：

1. 把每个单词的首字母变为大写。

2. 把数字与字母之间用下划线字符（_）分开，使得更清晰

3. 把单词中间有多个空格的调整为1个空格。

例如：

用户输入：

you and     me what  cpp2005program

则程序输出：

You And Me What Cpp_2005_program

用户输入：

this is     a      99cat

则程序输出：

This Is A 99_cat

我们假设：用户输入的串中只有小写字母，空格和数字，不含其它的字母或符号。

每个单词间由1个或多个空格分隔。

假设用户输入的串长度不超过200个字符。

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*
 * 本题目即是要求程序对用户输入的串进行处理。具体规则如下：
 *1.	把每个单词的首字母变为大写。
 *2.	把数字与字母之间用下划线字符（_）分开，使得更清晰
 *3.	把单词中间有多个空格的调整为1个空格。
 *我们假设：用户输入的串中只有小写字母，空格和数字，不含其它的字母或符号。每个单词间由1个或多个空格分隔。
 *假设用户输入的串长度不超过200个字符。
 */
public class SimpleString {
	public static void main(String args[]){
		String str="";
		str=(new Scanner(System.in)).nextLine();
		String []str1=str.split("[ ]+");
		for(int i=0;i<str1.length;i++)str1[i]=String.valueOf((char)(str1[i].charAt(0)+('A'-'a')))+str1[i].substring(1);
		String s="";
		for(int i=0;i<str1.length-1;i++)//System.out.print(str1[i]+" ");
		{
			s+=str1[i]+" ";
		}
		s+=str1[str1.length-1];
			Pattern p=Pattern.compile("([0-9]+)");
			Matcher m=p.matcher(s);
			String fin="";
			int st=0;
			while(m.find()){
				int start=m.start();
				int end=m.end();
				fin+=s.substring(st,start);
				if(s.charAt(start-1)!=' ')fin+="_";
				fin+=m.group(1);
				if(s.charAt(end)!=' ')fin+="_";
				st=end;
			}
			if(st<s.length())fin+=s.substring(st);
			System.out.println(fin);
	}
}

方法三：
import java.util.Scanner;  
import java.util.regex.Matcher;  
import java.util.regex.Pattern;  
  
public class Demo02 {  
    public static void print(String[] s){  
        for(int i=0;i<s.length-1;i++){  
            System.out.print(s[i]+" ");  
        }  
        System.out.println(s[s.length-1]);  
    }  
    public static void main(String[] args) {  
        Scanner scan = new Scanner(System.in);  
        String s = scan.nextLine();  
        String[] ss = s.split("[\\s]+");  
        for(int i=0;i<ss.length;i++){  
            String up = (""+ss[i].charAt(0)).toUpperCase(); // 大写   
            StringBuffer sb = new StringBuffer(ss[i]);  
            ss[i] = sb.replace(0, 1, up).toString();  
            Matcher m = Pattern.compile("\\d+").matcher(ss[i]);  
            while(m.find()){  
                String num = new String(m.group());  
                String num2 = num;  
                num2 = "_"+num+"_";     // 数字前添加"_"   
                ss[i] = ss[i].replace(num, num2);  
                if(ss[i].startsWith("_")){  // 去头"_"   
                    ss[i] = ss[i].substring(1);  
                }  
                if(ss[i].endsWith("_")){    // 去尾"_"   
                    ss[i] = ss[i].substring(0,ss[i].length()-1);  
                }  
            }  
        }  
        print(ss);  
    }  
}