蓝桥杯--算法提高 字符串的操作（java）

资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
　　给出一个字符串S，然后给出q条指令，分别有4种：

1. Append str
　　表示在S的最后追加一个字符串str。
　　例：
　　原字符串：ABCDE
　　执行 Append FGHIJ 后
　　字符串变为：ABCDEFGHIJ

2. Insert x str
　　表示在位置x处插入一个字符串str。（输入保证0<x<=当前字符串长度）
　　例：
　　原字符串：ABCGHIJ
　　执行 Insert 4 DEF 后
　　字符串变为：ABCDEFGHIJ

3. Swap a b c d
　　表示交换从第a位到第b位的字符串与从第c位到第d位的字符串。（输入保证0<a<b<c<d<=当前字符串长度）
　　例：
　　原字符串：ABGHIFCDEJ
　　执行 Swap 3 5 7 9后
　　字符串变为：ABCDEFGHIJ

4. Reverse a b
　　表示将从第a位到第b位的字符串反转。（输入保证0<a<b<=当前字符串长度）
　　例：
　　原字符串：ABGFEDCHIJ
　　执行 Reverse 3 7 后
　　字符串变为：ABCDEFGHIJ

最后输出按顺序执行完指令后的字符串。
输入格式
　　输入第一行包含字符串S，第二行包含一个整数q，接下来q行分别为q个指令。
输出格式
　　输出为1行，为按顺序执行完输入指令后的字符串。
样例输入
My
5
Append Hello
Insert 3 dlroW
Reverse 3 7
Swap 3 7 8 12
Swap 1 2 3 7
样例输出
HelloMyWorld
样例说明
　　原字符串：My
　　执行 Append Hello 后：MyHello
　　执行 Insert 3 dlroW 后：MydlroWHello
　　执行 Reverse 3 7 后：MyWorldHello
　　执行 Swap 3 7 8 12 后：MyHelloWorld
　　执行 Swap 1 2 3 7 后：HelloMyWorld
数据规模和约定
　　对于30%的数据，q=1；

对于70%的数据，如有Swap指令，Swap指令中b-a=d-c；

对于100%的数据，最终字符串长度不大于40000，1<=q<=150
————————————————————————————————————————————————
注意：
1.题目中四种操作的索引是从1开始的，所以代码中别忘了-1。
2.swap 可能会交换两个不等长的字符串，我采取的方法是，这两个字符串将原始字符串分为了5个部分，

所以将原始字符串切分为5个子串，然后用StringBuilder 按照 1 4 3 2 5 的顺序进行 append。

import java.util.Scanner;

public class Main {
	static char[] str = new char[40010]; 
	static int T;
	static int index;//一直指向str最后一个字符的后面一个
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s = sc.next();
		for(int i = 0;i < s.length();i++) {
			str[i] = s.charAt(i);
			index++;
		}
		T = sc.nextInt();
		sc.nextLine();//过滤回车符
		while(T-- > 0) {
			String[] order = sc.nextLine().split(" ");
			String s1 = order[0];
			if(s1.equals("Append")) {
				String s2 = order[1];
				for(int i = index;i < index + s2.length();i++) {
					str[i] = s2.charAt(i - index);
				}
				index += s2.length();
			}else if(s1.equals("Insert")) {
				int x = Integer.parseInt(order[1]);
				String s2 = order[2];
				int len2 = s2.length();
				for(int i = index - 1 ;i >= x - 1;i--) {//先往后挪，留出空位置
					str[i + len2] = str[i]; 
				}
				for(int i = x - 1, j = 0;i < x - 1 + len2;i++, j++) {//下标从0开始，需要x-1
					str[i] = s2.charAt(j);//将字符串插入空位置
				}
				index += len2;
			}else if(s1.equals("Swap")) {
				int a = Integer.parseInt(order[1]);
				int b = Integer.parseInt(order[2]);
				int c = Integer.parseInt(order[3]);
				int d = Integer.parseInt(order[4]);
				StringBuilder sb1 = new StringBuilder();
				String sss = String.valueOf(str);
				String ss1 = sss.substring(0, a - 1);
				String ss2 = sss.substring(a - 1, b);
				String ss3 = sss.substring(b, c - 1);
				String ss4 = sss.substring(c - 1, d);
				String ss5 = sss.substring(d, index);
				String res = sb1.append(ss1).append(ss4).append(ss3).append(ss2).append(ss5).toString();
				for(int i = 0;i < res.length();i++){
					str[i] = res.charAt(i);
				}
			}else if(s1.equals("Reverse")) {
				int a = Integer.parseInt(order[1]);
				int b = Integer.parseInt(order[2]);
				StringBuilder tmp = new StringBuilder(); 
				for(int i = a - 1;i <= b - 1;i++) {
					tmp.append(str[i]);
				}
				String ss = tmp.reverse().toString();
				for(int i = 0;i < ss.length();i++) {//反转之后覆盖原区间
					str[a - 1] = ss.charAt(i);
					a++;
				}
			}
		}
		sc.close();
		
		System.out.println(String.valueOf(str));
	}
}