第八天|字符串| 344.反转字符串， 541. 反转字符串II， 卡码网：54.替换数字

目录

344.反转字符串

 541. 反转字符串II

 卡码网：54.替换数字

ACM输入输出结构

方法1_fff:

方法2：

---

今天的收获：学习到ACM输入输出格式。

其余的难度正常。

344.反转字符串

这道题还是很简单的，使用一个双指针思想就可以。

class Solution {
    public void reverseString(char[] s) {
        int left = 0;
        int right = s.length-1;
        while (left<right){
            char temp;
            temp = s[left];
            s[left] = s[right];
            s[right] = temp;
            left++;
            right--;
        }
    }
}

 541. 反转字符串II

541方法1较为复杂，是我按照自己的想法做的。使用了substring()和concat().

方法2使用了StringBuffer().

请参考方法3，简便易懂点。注意：for中并不是i++，而是可以直接写成 i = i + 2 * k ，更加简单。

    class Solution {
        public String reverseStr(String s, int k) {
//            方法1_fff：分3种情况分别判断
            int len = s.length();
            String str = "";
            int i = 0;
            while (true){
                if (len >= 2 * k) {
                    String temp = "";
                    temp = reverse(s.substring(0, k));
                    str = str.concat(temp);
                    temp = s.substring(k, 2 * k);
                    str =str.concat(temp);
                    len = len - 2 * k;
                    s = s.substring(2 * k);
                } else if (len < k) {
                    str =str.concat(reverse(s));
                    break;
                } else {
                    String temp = "";
                    temp = s.substring(0, k);
                    str =str.concat(reverse(temp));
                    str =str.concat(s.substring(k));
                    break;
                }
            }
            return str;
        }

        public String reverse(String s) {
            char[] str = s.toCharArray();
            int i = 0;
            int j = str.length - 1;
            for (; i < j; i++, j--) {
                char temp;
                temp = str[i];
                str[i] = str[j];
                str[j] = temp;
            }
            s = new String(str);
            return s;
        }
    }

    class Solution {
        public String reverseStr(String s, int k) {
//            方法2：
            StringBuffer res = new StringBuffer();
            int length = s.length();
            int start = 0;
            while (start < length) {
                // 找到k处和2k处
                StringBuffer temp = new StringBuffer();
                // 与length进行判断，如果大于length了，那就将其置为length
                int firstK = (start + k > length) ? length : start + k;
                int secondK = (start + (2 * k) > length) ? length : start + (2 * k);
                //无论start所处位置，至少会反转一次
                temp.append(s.substring(start, firstK));
                res.append(temp.reverse());
                // 如果firstK到secondK之间有元素，这些元素直接放入res里即可。
                if (firstK < secondK) {
                    res.append(s.substring(firstK, secondK));
                }
                start += (2 * k);
            }
            return res.toString();
        }
    }

class Solution {
        public String reverseStr(String s, int k) {
//          方法3：
            //题目的意思其实概括为 每隔2k个反转前k个，尾数不够k个时候全部反转
            char[] ch = s.toCharArray();
            for (int i = 0; i < ch.length; i += 2 * k) {
                int start = i;
                //这里是判断尾数够不够k个来取决end指针的位置
                int end = Math.min(ch.length - 1, start + k - 1);
                while (start < end) {
                    char temp = ch[start];
                    ch[start] = ch[end];
                    ch[end] = temp;
                    start++;
                    end--;
                }
            }
            return new String(ch);
        }
    }

 卡码网：54.替换数字

这道题很有意思，不是LeetCode上的，卡玛网的题目要求ACM输入输出格式，并且要自己敲。

ACM输入输出结构

例如继续输入A+B，遇到 A、B 为0 的时候终止，对应的ACM写法：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            if (a == 0 && b == 0) {
                break;
            }
            System.out.println(a + b);
        }
    }
}

方法1_fff:

使用StringBuffer:

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        s = reverseInt(s);
        System.out.println(s);
    }
    
    
    public static String reverseInt(String s) {
        char[] ch = s.toCharArray();
        StringBuffer res = new StringBuffer();
        for (int i = 0; i < ch.length; i++) {
            if (ch[i] >='0' && ch[i]<='9'){
                res.append("number");
            }else {
                res.append(ch[i]);
            }
        }
        return res.toString();
    }
}

方法2：

为了还原题目本意，先把原数组复制到扩展长度后的新数组，然后不再使用原数组、原地对新数组进行操作。

首先扩充数组到每个数字字符替换成 "number" 之后的大小。

然后从后向前替换数字字符，也就是双指针法

从后向前替换数字字符有两个好处：

1. 不用申请新数组。
2. 从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        int len = s.length();
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) >= '0' && s.charAt(i) <= '9'){
                len += 5;
            }
        }
        char[] ret = new char[len];
        for(int i = 0; i < s.length(); i++){
            ret[i] = s.charAt(i);
        }
        for(int i = s.length() - 1, j = len - 1; i >= 0; i--){
            if(ret[i] >= '0' && ret[i] <= '9'){
                ret[j--] = 'r';
                ret[j--] = 'e';
                ret[j--] = 'b';
                ret[j--] = 'm';
                ret[j--] = 'u';
                ret[j--] = 'n';
            } else {
                ret[j--] = ret[i];
            }
        }
        System.out.println(ret);
    }
}

第八天的总算是结束了，直冲Day9！