Espada se refiere a la "Cadena de rotación izquierda" de la serie Oferta.

Hay una instrucción de cambio en lenguaje ensamblador llamada 循环左移(ROL). Ahora hay una tarea simple, que es simular el resultado de la operación de esta instrucción con una cadena. Para una secuencia de caracteres dada S, gírela hacia la izquierda K bits y envíe la secuencia. Por ejemplo, la secuencia de caracteres S = "abcXYZdef", es necesaria para generar el resultado del desplazamiento circular a la izquierda en 3 bits, es decir, "XYZdefabc". ¿No es sencillo? OK, ¡hazlo!

Método 1 : utilizarString

public class Solution {
    
    
    public String LeftRotateString(String str, int n) {
    
    
        int len = str.length();
        String res = "";
        if(len == 0 || str == null) return res;
        int n_true = n % len;
        for(int i = n_true; i < len; i++){
    
    
            res += str.charAt(i);
        }
        for(int i = 0; i < n_true; i++){
    
    
            res += str.charAt(i);
        }
        return res;
    }
}

De hecho, puede ser así:

public class Solution {
    
    
    public String LeftRotateString(String str, int n) {
    
    
        String res = "";
        for(int i = n; i < n + str.length(); i++){
    
    
          	res += str.charAt(i % str.length());
        }
        return res;
    }
}

Complejidad temporal: O (N)
Complejidad espacial: O (N)

Método dos : usarStringBuilder

StringEl empalme producirá muchos "fragmentos", utiliceStringBuilder

public class Solution {
    
    
    public String LeftRotateString(String str, int n) {
    
    
        int len = str.length();
        String res = "";
        if(len == 0 || str == null) return res;
        int n_true = n % len;
        StringBuilder stringBuilder = new StringBuilder();
        for(int i = n; i < n + str.length(); i++){
    
    
          	stringBuilder.append(str.charAt(i % str.length()));
        }
        res = stringBuilder.toString();
        return res;
    }
}

Complejidad temporal: O (N)
Complejidad espacial: O (N)

Método 3 : corte de cuerdas

public class Solution {
    
    
    public String LeftRotateString(String str,int n) {
    
    
        if(str.length() == 0 || str == null) return str;
        return str.substring(n, str.length()) + str.substring(0, n);
    }
}

Complejidad temporal: O (N)
Complejidad espacial: O (N)

Método 4 : usa la función de voltear

Primero 0 - (n-1)voltea, luego n-(length-1)voltea y finalmente 0-(length-1)voltea

Por ejemplo: cadena "abc123",n = 3

1. Primero 0 - 2convierta la tapa en "cba123";

2. Luego 3-5voltea "cba321";

3. Finalmente, el 0-5giro se convierte en "123abc";

import java.util.Arrays;

public class Solution {
    
    
    public static String LeftRotateString(String str, int n) {
    
    
        if(str.length() == 0 || str == null) return str;
        str = reverse(str, 0 , n-1);
        str = reverse(str, n , str.length()-1);
        str =reverse(str, 0 , str.length()-1);
        return str;
    }

    private static String reverse(String str, int startIndex, int endIndex){
    
    
        char[] chars = str.toCharArray();
        while(startIndex < endIndex){
    
    
            char temp = chars[startIndex];
            chars[startIndex] = chars[endIndex];
            chars[endIndex] = temp;
            startIndex++;
            endIndex--;
        }
        str = new String(chars);
        return str;
    }
}

Complejidad temporal: O (N)
Complejidad espacial: O (N)