HJ10 字符个数统计 NC68.跳台阶 HJ17.坐标移动 HJ20.密码验证合格程序 HJ23.删除字符串中出现次数最少的字符

HJ10 字符个数统计

描述
编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。
输入描述：
输入一行没有空格的字符串。
输出描述：
输出 输入字符串 中范围在(0~127，包括0和127)字符的种数。
示例1

输入：
abc
输出：
3

思路：利用数组统计， 也可利用HashSet统计

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String target = scanner.nextLine();
        HashSet<Integer> data = new HashSet<>();
        for (int index = 0; index < target.length(); index++) {
            data.add(Integer.valueOf((int)target.charAt(index)));
        }
        System.out.println(data.size());
    }
}

NC68.跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
示例1

输入：
2
返回值：
2
说明：
青蛙要跳上两级台阶有两种跳法，分别是：先跳一级，再跳一级或者直接跳两级。因此答案为2

解析思路：

1 > (1)
2 > (1,1) (2)
3 > (1,2),
(1,1,1), (2,1)
4 > (1,1,2), (2,2)
(1,2,1),(1,1,1,1),(2,1,1)
特殊情况：若为1， 则返回1； 若为2， 则返回2；
若是n为3， 则在2的基础上，在跳1步， 再加上 在 1的基础上再跳2步；合起来就是3的所有跳法，依次类推；

    public static void main3(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int target = scanner.nextInt();
        System.out.println(skip(target));
    }

    /**
     * 1 ==> (1)
     * 2 ==> (1,1) (2)
     * 3 ==> (1,2), (1,1,1), (2,1)
     * 4 ==> (1,1,2), (2,2)
     *       (1,2,1),(1,1,1,1),(2,1,1)
     *
     * @param target
     * @return
     */
    public static Integer skip(Integer target) {
        if (target == 1) {
            return 1;
        }
        if (target == 2) {
            return 2;
        }
        return skip(target - 1) + skip(target - 2);
    }

HJ17.坐标移动

原题太长；
坐标移动

思路：

1. 根据“;”拆分字符串为字符串数组；
2. 判断每个字符串是否合法；
3. 用一个数组保存结果；第一个表示X坐标， 第二个表示Y坐标；
4. 若是W，则Y增加
5. 若是S，则Y减小；
6. 若是A，则X减小；
7. 若是D，则X增加；
   代码

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String target = scanner.nextLine();
        String[] targetArray = target.split(";");
        int[] result = {0, 0};
        for (int index = 0; index < targetArray.length; index++) {
            String val = targetArray[index];
            if (val == null) {
                continue;
            }

            if (val.length() > 3  || val.length() <= 1) {
                continue;
            }
            
            char forward = val.charAt(0);
            if (forward != 'A' && forward != 'W' && forward != 'S' && forward != 'D') {
                continue;
            }

            String num = val.substring(1);
            boolean numFlag = true;
            for (int numIndex  = 0; numIndex < num.length(); numIndex++) {
                char charAt = num.charAt(numIndex);
                if (charAt < '0' || charAt > '9') {
                    numFlag = false;
                }
            }
            if (!numFlag) {
                continue;
            }

            Integer numVal = Integer.valueOf(num);
            if (forward == 'A') {
                result[0] = result[0] - numVal;
            } else if (forward == 'W') {
                result[1] = result[1] + numVal;
            } else if (forward == 'S') {
                result[1] = result[1] - numVal;
            } else  if (forward == 'D') {
                result[0] = result[0]  + numVal;
            }

        }
        System.out.println(result[0] + "," + result[1]);
    }
}

HJ20.密码验证合格程序

描述
密码要求:

1.长度超过8位

2.包括大小写字母.数字.其它符号,以上四种至少三种

3.不能有长度大于2的包含公共元素的子串重复 （注：其他符号不含空格或换行）

输入描述：
一组字符串。

输出描述：
如果符合要求输出：OK，否则输出NG

示例：

输入：
021Abc9000
021Abc9Abc1
021ABC9000
021$bc9000
输出：
OK
NG
NG
OK

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        ArrayList<String> valList = new ArrayList<>();
        while (scanner.hasNextLine()) {
            String nextLine = scanner.nextLine();
            if (nextLine.length() == 0) {
                break;
            }
            valList.add(nextLine);
        }
        for (String val : valList) {
            if (!isLongerEight(val)) {
                System.out.println("NG");
                continue;
            }
            if (!isThreeType(val)) {
                System.out.println("NG");
                continue;
            }
            if (!isDuplicate(val)) {
                System.out.println("NG");
                continue;
            }
            System.out.println("OK");

        }

    }
    public static boolean isLongerEight(String val) {
        if (val != null && val.length() < 8) {
            return false;
        }
        return true;
    }
    public static boolean isThreeType(String val) {
        Boolean digital = isDigital(val);
        Boolean smallChar = isSmallChar(val);
        Boolean bigChar = isBigChar(val);
        Boolean specialChar = isSpecialChar(val);
        int count = 0;
        if (digital) {
            count++;
        }
        if (smallChar) {
            count++;
        }

        if (bigChar) {
            count++;
        }
        if (smallChar) {
            count++;
        }
        return count >= 3;
    }

    private static Boolean isSpecialChar(String val) {
        for (int index = 0; index < val.length(); index++) {
            char c = val.charAt(index);
            if (c >= 'A' && c <= 'Z') {
                continue;
            }
            if (c >= 'a' && c <= 'z') {
                continue;
            }
            if (c >= '0' && c <= '9') {
                continue;
            }
            return true;
        }
        return false;
    }

    private static Boolean isBigChar(String val) {
        for (int index = 0; index < val.length(); index++) {
            char c = val.charAt(index);
            if (c >= 'A' && c <= 'Z') {
                return  true;
            }
        }
        return false;
    }

    private static Boolean isSmallChar(String val) {
        for (int index = 0; index < val.length(); index++) {
            char c = val.charAt(index);
            if (c >= 'a' && c <= 'z') {
                return true;
            }
        }
        return false;
    }

    private static Boolean isDigital(String val) {
        for (int index = 0; index < val.length(); index++) {
            char content = val.charAt(index);
            if (content >= '0' && content <= '9') {
                return true;
            }
        }
        return false;
    }

    public static boolean isDuplicate(String val) {
        for (int index = 0; index < val.length() - 3 ; index++) {
            String indexVal = val.substring(index, index + 3);
            for (int k = index + 3; k < val.length() - 2 ; k++) {
                String kVal = val.substring(k, k + 3);
                if (indexVal.equals(kVal)) {
                    return false;
                }
            }
        }
        return true;
    }
}

HJ23.删除字符串中出现次数最少的字符

描述
实现删除字符串中出现次数最少的字符，若出现次数最少的字符有多个，则把出现次数最少的字符都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。

数据范围：输入的字符串长度满足 1≤n≤20 ，保证输入的字符串中仅出现小写字母
输入描述：
字符串只包含小写英文字母, 不考虑非法输入，输入的字符串长度小于等于20个字节。

输出描述：
删除字符串中出现次数最少的字符后的字符串。

示例1

输入：
aabcddd
输出：
aaddd

解题思路：

1. 使用Map统计每个字符出现的次数；
2. 遍历Map, 找到次数最小的数值；
3. 遍历Map, 找到与次数最小的数组相等的 字符， 放入集合；
4. 调用String#replace方法，将字符替换掉；

代码

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String line = scanner.nextLine();
        HashMap<Character, Integer> map = new HashMap<>();
        for (int index = 0; index < line.length() - 1; index++) {
            char charAt = line.charAt(index);
            Integer count = map.get(charAt);
            map.put(charAt, count == null ? 1 : count + 1);
        }

        Integer smallCount = null;
        ArrayList<Character> removeCharList = new ArrayList<>();
        for (Character character : map.keySet()) {
            Integer count = map.get(character);
            if (smallCount == null) {
                smallCount = count;
            }else if (count <= smallCount) {
                smallCount = count;
            }
        }

        for (Character character : map.keySet()) {
            if (map.get(character) == smallCount) {
                removeCharList.add(character);
            }
        }
        StringBuilder builder = new StringBuilder(line);

        for (Character character : removeCharList) {
            line = line.replace(character.toString(), "");
        }
        System.out.println(line);
    }
}