蓝桥杯（java）Day1

1. 字符排序

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

import java.util.Scanner;
import java.util.Vector;

public class csort {
    public static long count = 0L;

    private void quanpai(Vector<Character> source, Vector<Character> result) {
        int i;
        if (source.size() == 0) {
            for(i = 0; i < result.size(); ++i) {
                System.out.print(result.elementAt(i));
            }

            System.out.println();
            ++count;
        } else {
            for(i = 0; i < source.size(); ++i) {
                Vector<Character> tsource = new Vector(source);
                Vector<Character> tresult = new Vector(result);
                tresult.add((Character)source.elementAt(i));
                tsource.remove(i);
                (new csort()).quanpai(tsource, tresult);
            }

        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        Vector<Character> source = new Vector();
        Vector<Character> result = new Vector();

        for(int i = 0; i < n; ++i) {
            source.add((char)('A' + i));
        }

        (new csort()).quanpai(source, result);
        System.out.println(count);
    }
}

2. 串的简单处理

串的处理

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

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

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

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

把单词中间有多个空格的调整为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.Vector;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String string = scanner.nextLine();
        Vector<Character> vector = new Vector();

        int index;
        for(index = 0; index < string.length(); index++) {
            vector.add(string.charAt(index));
        }

        try {
            for(index = 0; index < vector.size(); index++) {
                if (index == 0 && (Character)vector.elementAt(index) >= 'a' && (Character)vector.elementAt(index) <= 'z') {
                    vector.set(index, (char)((Character)vector.elementAt(index) - 32));
                } else if ((Character)vector.elementAt(index - 1) == ' ' && (Character)vector.elementAt(index) == ' ') {
                    vector.remove(index);
                    --index;
                } else if ((Character)vector.elementAt(index - 1) == ' ' && (Character)vector.elementAt(index) >= 'a' && (Character)vector.elementAt(index) <= 'z') {
                    vector.set(index, (char)((Character)vector.elementAt(index) - 32));
                } else if ((Character)vector.elementAt(index - 1) >= 'a' && (Character)vector.elementAt(index - 1) <= 'z' && (Character)vector.elementAt(index) >= '0' && (Character)vector.elementAt(index) <= '9') {
                    vector.add(index, '_');
                    ++index;
                } else if ((Character)vector.elementAt(index - 1) >= '0' && (Character)vector.elementAt(index - 1) <= '9' && (Character)vector.elementAt(index) >= 'a' && (Character)vector.elementAt(index) <= 'z') {
                    vector.add(index, '_');
                    ++index;
                }
            }
            for(int i = 0; i < vector.size(); ++i) {
                System.out.print(vector.elementAt(i));
            }
            System.out.println();
        } catch (ArrayIndexOutOfBoundsException var6) {
        }

    }
}

3. 猜算式

看下面的算式：

□□ x □□ = □□ x □□□

它表示：两个两位数相乘等于一个两位数乘以一个三位数。

如果没有限定条件，这样的例子很多。

但目前的限定是：这9个方块，表示1~9的9个数字，不包含0。

该算式中1至9的每个数字出现且只出现一次！

比如：

46 x 79 = 23 x 158

54 x 69 = 27 x 138

54 x 93 = 27 x 186

…

请编程，输出所有可能的情况！

注意：

左边的两个乘数交换算同一方案，不要重复输出！

不同方案的输出顺序不重要

import java.util.ArrayList;
import java.util.Vector;
import java.util.List;

public class Main {
    public static List<Vector<Character>> filteredNonRedundantResults;
    private static boolean isfilter(Vector<Character> result) {
        int a=(result.elementAt(0)-'0')*10+(result.elementAt(1)-'0');
        int b=(result.elementAt(2)-'0')*10+(result.elementAt(3)-'0');
        int c=(result.elementAt(4)-'0')*10+(result.elementAt(5)-'0');
        int d=(result.elementAt(6)-'0')*100+(result.elementAt(7)-'0')*10+(result.elementAt(8)-'0');
        if(a*b==c*d){
            return true;
        }
        return false;
    }
    public static void print(Vector<Character>vector) {
        System.out.printf("%c%c × %c%c = %c%c × %c%c%c",vector.elementAt(0),vector.elementAt(1),vector.elementAt(2),vector.elementAt(3),vector.elementAt(4),vector.elementAt(5),vector.elementAt(6),vector.elementAt(7),vector.elementAt(8));
    }
    private static void fullPermutation(Vector<Character>sourse, Vector<Character> result) {
        if(sourse.size()==0&&isfilter(result)){
            boolean exit=false;
            for (int i = 0; i < filteredNonRedundantResults.size(); i++) {
                int ra=(result.elementAt(0)-'0')*10+(result.elementAt(1)-'0');
                int rb=(result.elementAt(2)-'0')*10+(result.elementAt(3)-'0');
                int fa=(filteredNonRedundantResults.get(i).elementAt(0)-'0')*10+(filteredNonRedundantResults.get(i).elementAt(1)-'0');
                int fb=(filteredNonRedundantResults.get(i).elementAt(2)-'0')*10+(filteredNonRedundantResults.get(i).elementAt(3)-'0');
                if(ra==fb&&rb==fa){
                    exit=true;
                    break;
                }
            }
            if(exit==false){
                filteredNonRedundantResults.add(new Vector<Character>(result));
            }
            return;
        }
        for (int i = 0; i < sourse.size(); i++) {
            result.add(sourse.elementAt(i));
            sourse.remove(i);
            fullPermutation(sourse, result);
            sourse.add(i, result.elementAt(result.size()-1));
            result.remove(result.size()-1);
        }
    }
    public static void main(String[] args) {
        int n=9;
        Vector<Character> sourse=new Vector<Character>();
        Vector<Character> result=new Vector<Character>();
        for (int i = 1; i <= n; i++) {
            sourse.add((char)('0'+i));
        }
        Main.filteredNonRedundantResults=new ArrayList<Vector<Character>>();
        Main.fullPermutation(sourse, result);
        for (int i = 0; i < Main.filteredNonRedundantResults.size(); i++) {
            Main.print(Main.filteredNonRedundantResults.get(i));
            System.out.println();
        }
    }
}