华为字符串面试题

给定一个非空字符串S，其被N个‘-’分隔成N+1的子串，给定正整数K，要求除第一个子串外，其余的子串每K个字符组成新的子串，并用‘-’分隔。对于新组成的每一个子串，如果它含有的小写字母比大写字母多，则将这个子串的所有大写字母转换为小写字母；反之，如果它含有的大写字母比小写字母多，则将这个子串的所有小写字母转换为大写字母；大小写字母的数量相等时，不做转换。
输入描述:
输入为两行，第一行为参数K，第二行为字符串S。
输出描述:
输出转换后的字符串。
示例1
输入
3
12abc-abCABc-4aB@
输出
12abc-abc-ABC-4aB-@
说明
子串为12abc、abCABc、4aB@，第一个子串保留，后面的子串每3个字符一组为abC、ABc、4aB、@，abC中小写字母较多，转换为abc，ABc中大写字母较多，转换为ABC，4aB中大小写字母都为1个，不做转换，@中没有字母，连起来即12abc-abc-ABC-4aB-@
示例2
输入
12
12abc-abCABc-4aB@
输出
12abc-abCABc4aB@
说明
子串为12abc、abCABc、4aB@，第一个子串保留，后面的子串每12个字符一组为abCABc4aB@，这个子串中大小写字母都为4个，不做转换，连起来即12abc-abCABc4aB@

前置处理：

根据原始字符串，转化成纯大、小写的字符串

/**
     * 字符串大小写转化
     */
    public static String strToUpperCase(String str ,Boolean flag) {
        char[] chars = str.toCharArray();

        if (flag) {
            for (int i = 0; i < chars.length; i++) {
                if (chars[i] >= 'a' && chars[i] <= 'z') {
                    chars[i] = (char) (chars[i] - 32);
                }
            }
        } else {
            for (int i = 0; i < chars.length; i++) {
                if (chars[i] >= 'A' && chars[i] <= 'Z') {
                    chars[i] = (char) (chars[i] + 32);
                }
            }
        }
        return new String(chars);
    }

根据字符串中的大小写个数，判断字符串需要转化的类型

/**
     * 根据子串中的字符大小写个数大小，生成新的字串
     */
    public static String followMoreChara(String originalStr) {

        String localStr = "";

        String[] split = originalStr.split("-");
        for (int i = 0; i < split.length; i++) {
            String s = split[i];
            //判断字串符串中的大小写个数是否相等
            int lowerCaseNum = 0;
            int upperCaseNum = 0;
            for (int j = 0; j < s.length(); j++) {
                char[] chars = s.toCharArray();
                if (chars[j] <= 'z' && chars[j] >= 'a'){
                    lowerCaseNum ++;
                }
                if (chars[j] <= 'Z' && chars[j] >= 'A'){
                    upperCaseNum ++;
                }
            }

            if(lowerCaseNum > upperCaseNum){
                s = strToUpperCase(s,false);
            }
            if(lowerCaseNum < upperCaseNum){
                s = strToUpperCase(s,true);
            }

            if(i == split.length -1){
                localStr += s;
                break;
            }
            localStr += s + "-";
        }
        return localStr;
    }

主方法：处理输入输出，以及字符串的截取

    public static void main(String[] args) {
        System.out.println("请输入K值，以及需要处理的字符串并且以' 'or enter键进行换行");
        Scanner sc = new Scanner(System.in);
        int key = sc.nextInt();
        String str = sc.next();

        //将字符串的首个字串取出并且不做处理
        String newStr = str.substring(0, str.indexOf('-')) + "-";

        String lastStr = str.substring(str.indexOf('-') + 1);

        String newLastStr = lastStr.replace("-", "");

        String componentStr = "";

        for (int i = 1; i < (newLastStr.length() / key) + 2; i++) {
            if(i == (newLastStr.length() / key) + 1){
                componentStr += newLastStr.substring( (i-1) * key ,newLastStr.length());
                break;
            }
            componentStr += newLastStr.substring( (i-1) * key ,key * i) + "-";
        }

        //处理子串中其他的字符串
        componentStr = followMoreChara(componentStr);

        //拼接首个字符串和字串
        componentStr = newStr + componentStr;
        System.out.println("输出：" + "\n" + componentStr);
    }

整体代码如下所示：

技术要点小结：

字符串的大小写转化，使用Character数组，判断并且转化字符大小写，(使用强制类型转化)

将字符数组转化为字符串类型 new String(char[])

升级版，使用StringBuffer，以及字符串大小写转化方法

 public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int k = sc.nextInt();
        String[] strings = sc.nextLine().split("-");

        String s = "";
        for (int i = 1; i < strings.length; i++) {
            s = s + strings[i];
        }
        int index = 0;

        StringBuffer buffer = new StringBuffer();
        buffer.append(strings[0]);
        while (s.length() - index > k) {
            buffer.append("-" + caseConversion(s.substring(index, index + k)));
            index += k;
        }
        if (s.length() - index > 0) {
            buffer.append("-" + caseConversion(s.substring(index)));
        }
        System.out.println(buffer);
    }

    private static String caseConversion(String s) {
        int upperCaseLength = s.length() - s.replaceAll("[A-Z]", "").length();
        int lowerCaseLength = s.length() - s.replaceAll("[a-z]", "").length();
        if (upperCaseLength > lowerCaseLength) {
            return s.toUpperCase(Locale.ROOT);
        }
        if (lowerCaseLength > upperCaseLength) {
            return s.toLowerCase(Locale.ROOT);
        }
        return s;
    }

设计思路：使用spilt方法将字符串进行分割，并将首个子串存储到StringBuffer中， 将删除"-"的字串存入一个临时变量中。使用while循环判断子串中的长度是否大于key值，如果长度大于key值进行截取，并且拼接“-”，当不足key值时，字串已经遍历到尾部。此时，截取的最后一部分字符串。

字符串大小写转化：

        String str = "dadadedADdweAS";
        //获取大写字符串的数量
        int length = str.replaceAll("[A-Z]","").length();
        str = str.toLowerCase(Locale.ROOT);

将字符串大小写字母转化为小写字符串(巧用)