【Semanal】 No.185

C_01 cadena reformateada

Dada una cadena alfanumérica s. (La cadena alfanumérica es una cadena que consta de letras y dígitos en minúscula en inglés).

Debe encontrar una permutación de la cadena donde ninguna letra es seguida por otra letra y ningún dígito es seguido por otro dígito. Es decir, no hay dos caracteres adyacentes que tengan el mismo tipo.

Devuelva la cadena reformateada o devuelva una cadena vacía si es imposible formatear la cadena.

Input: s = "ab123"
Output: "1a2b3"

Método 1: simplifica el problema

De hecho, no hace falta decir que es tan complicado. Una forma de pensar más complicada es:

• Cuente los caracteres y subíndices de caracteres primero.
• Luego, al comparar el número de números y letras, y finalmente escribir un montón de otras cosas para controlar quién ejecuta primero.

Simplifica el problema:

• El número de excavación predeterminado es el más. Si lo desea, la excavación es más a través del intercambio.
• Luego, agregando caracteres con una mayor cantidad de tipos de anexos primero, luego agregando caracteres con una menor cantidad de tipos de anexos.
  • Sin embargo, se debe cumplir una condición: abs(dig.size() - alp.size() > 1es decir, la diferencia entre el número de los dos tipos de caracteres no es mayor que 1

public String reformat(String s) {
    StringBuilder sb = new StringBuilder();
    ArrayList<Character> dig = new ArrayList<>(), alp = new ArrayList<>();
    char[] S = s.toCharArray();
    for (int i = 0; i < S.length; i++) {
        if (Character.isDigit(S[i])) dig.add(S[i]);
        else alp.add(S[i]);
    }
    if ( Math.abs(dig.size() - alp.size()) > 1)
        return "";

    if (dig.size() < alp.size()) {
        ArrayList<Character> t = dig;
        dig = alp;
        alp = t;
    }
    for (int i = 0; i < dig.size(); i++) {
        sb.append(dig.get(i));
        if (i < alp.size()) {
            sb.append(alp.get(i));
        }
    }
    return sb.toString();
}

Análisis de complejidad.

• Complejidad del tiempo: $O (n)$，
• Complejidad espacial: $O (n)$，

---

B_02 Ninguno

Método 1: ninguno

---

B_03 Contando ranas

Te da una cuerda croakOfFrogs, que representa una combinación de sonidos de ranas (cuerdas "croak") de diferentes ranas. Como puede haber múltiples ranas croando al mismo tiempo, se mezclan múltiples "croaks" en croakOfFrogs. Devuelva el número mínimo de ranas diferentes requerido para todas las ranas en la cadena simulada.

Nota: Para hacer sonar el croar "croak", la rana debe mostrar las cinco letras 'c', 'r', 'o', 'a', 'k' en secuencia. Si no se emiten las cinco letras, no sonará.

Si la cadena croakOfFrogs no es una mezcla de caracteres válidos "croak", devuelva -1.

输入：croakOfFrogs = "crcoakroak"
输出：2 
解释：最少需要两只青蛙，“呱呱” 声用黑体标注
第一只青蛙 "crcoakroak"
第二只青蛙 "crcoakroak"

Método 1: cuenta

• Porque en una cadena legal, el número de ocurrencias de cada carácter debe ser igual.
• Si hay un orden de caracteres diferente y el número es mayor que los caracteres en el orden relativo anterior, entonces esta cadena es ilegal.
• Cuando el número de caracteres es legal, el número de ranas requerido depende solo de la diferencia entre el número de caracteres c y k.
  • Por ejemplo: cuando una rana vuelve a llamar, mientras otra rana también llama, la cantidad de ranas necesarias en este momento será 2.

public int minNumberOfFrogs(String croakOfFrogs) {
    int[] c = new int[5];
    char[] s = croakOfFrogs.toCharArray();
    int max = 0;
    for (char ch : s) {
        if (ch == 'c') c[0]++;
        if (ch == 'r') c[1]++;
        if (ch == 'o') c[2]++;
        if (ch == 'a') c[3]++;
        if (ch == 'k') c[4]++;
        for (int i = c.length-1; i >= 1; i--) {
            if (c[i] > c[i-1])
                return -1;
        }
        max = Math.max(max, c[0]-c[4]);
    }
    return c[0] == c[4] ? max : -1;
}

Análisis de complejidad.

• Complejidad del tiempo: $O (n)$，
• Complejidad espacial: $O (1)$，