HJ10 Contar el número de caracteres NC68 Saltar pasos HJ17 Coordenadas de movimiento HJ20 Procedimiento de verificación de contraseña HJ23 Borrar el carácter con el menor número de ocurrencias en la cadena

Estadísticas de conteo de caracteres HJ10

Descripción
Escriba una función que cuente el número de caracteres distintos en una cadena. Los caracteres están dentro del rango de códigos ASCII (0~127, incluidos 0 y 127), y la nueva línea representa el carácter final, que no está incluido en los caracteres. Los que no estén dentro del alcance no serán contados. Múltiples caracteres idénticos solo se cuentan una vez
Por ejemplo, para la cadena abaca, hay tres caracteres diferentes a, b y c, por lo que se genera 3.
Descripción de entrada:
ingrese una cadena sin espacios en una línea.
Descripción de la salida:
Muestra el número de caracteres en el rango (0~127, incluidos 0 y 127) en la cadena de entrada.
Ejemplo 1

Entrada:
abc
Salida:
3

Idea: use estadísticas de matriz o estadísticas de 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 Saltar escaleras

Una rana puede saltar hasta 1 peldaño a la vez y también puede saltar hasta 2 peldaños. Encuentre el número total de métodos de salto para que la rana salte un paso de n nivel (diferentes secuencias cuentan como diferentes resultados).
Ejemplo 1

Entrada:
2
Valor de retorno:
2
Explicación:
Hay dos métodos de salto para que una rana salte dos escalones, a saber: primero salta un nivel, luego salta un nivel o directamente salta dos escalones. entonces la respuesta es 2

Ideas de análisis:

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)
caso especial: si es 1, devuelve 1; si es 2, devuelve 2;
si n es 3, luego, sobre la base de 2, salta 1 paso, más salta 2 pasos sobre la base de 1; el total es todos los métodos de salto de 3, y así sucesivamente;

    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 Movimiento de coordenadas

La pregunta original es demasiado larga,
las coordenadas se mueven

Ideas:

1. Divida la cadena en una matriz de cadenas según ";";
2. Determine si cada cadena es legal;
3. Utilice una matriz para guardar los resultados, la primera representa la coordenada X y la segunda representa la coordenada Y;
4. Si W, entonces Y aumenta
5. Si S, entonces Y disminuye;
6. Si A, entonces X disminuye;
7. Si D, entonces X aumenta;
   código

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 Procedimiento de verificación de contraseña

Descripción
Requisitos de la contraseña:

1. La longitud supera los 8 bits

2. Incluyendo letras mayúsculas y minúsculas Números Otros símbolos, al menos tres de los cuatro anteriores

3. No puede haber subcadenas repetidas que contengan elementos comunes con una longitud superior a 2 (Nota: otros símbolos no contienen espacios ni saltos de línea)

Descripción de entrada:
una matriz de cadenas.

Descripción de la salida:
si cumple con los requisitos, salida: OK, de lo contrario, salida NG

Ejemplo:

Entrada:
021Abc9000
021Abc9Abc1
021ABC9000
021$bc9000
Salida:
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 Eliminar el carácter con el menor número de ocurrencias en la cadena

Descripción
Realiza la eliminación del carácter con menor número de ocurrencias en la cadena, si hay más de un carácter con menor número de ocurrencias, borra todos los caracteres con menor número de ocurrencias. Envíe la cadena después de eliminar estas palabras y mantenga otros caracteres en la cadena en el orden original.

Rango de datos: la longitud de la cadena de entrada satisface 1≤n≤20, lo que garantiza que solo aparezcan letras minúsculas en la cadena de entrada Descripción de la entrada
:
la cadena solo contiene letras minúsculas en inglés, independientemente de la entrada ilegal, la longitud de la cadena de entrada es menor mayor o igual a 20 bytes.

Descripción de salida:
la cadena después de eliminar el carácter con el menor número de ocurrencias en la cadena.

Ejemplo 1

Entrada:
aabcddd
Salida:
aaddd

Ideas para resolver problemas:

1. Use Mapa para contar el número de ocurrencias de cada carácter;
2. Atraviese el Mapa para encontrar el valor con el menor número de veces;
3. Recorra el Mapa, encuentre los caracteres iguales a la matriz con el menor número de veces y póngalos en la colección;
4. Llame al método String#replace para reemplazar los caracteres;

el código

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);
    }
}