qinshan.top

Appearance

字符串 ​

笔记 split 🚀 ​

split方法参数为正则，可通过\\s+匹配多个空格。如果直接用" "，结果中会有空字符串，这点一定要注意。

java
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.util.Arrays;

@Slf4j
public class MyTest {
    @Test
    public void test() {
        String str = "   pasture    land water ";
        String[] strs1 = str.trim().split("\\s+");
        String[] strs2 = str.trim().split(" ");
        log.info(Arrays.toString(strs1));
        log.info(Arrays.toString(strs2));
    }
}

输出

21:18:30.465 [main] INFO MyTest -- [pasture, land, water]
21:18:30.472 [main] INFO MyTest -- [pasture, , , , land, water]

笔记 join 🚀 ​

java
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

@Slf4j
public class MyTest {
    @Test
    public void test() {
        String[] strs = {"1", "2", "3"};
        String str = String.join("@", strs);
        log.info(str);
    }
}

输出

21:28:18.259 [main] INFO MyTest -- 1@2@3

笔记 replaceAll & reverse 🚀 ​

java
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

@Slf4j
public class MyTest {
    @Test
    public void test() {
        // 去除非字母数字字符并用小写表示
        String s1 = "3 F 是 F *23aB";
        s1 = s1.toLowerCase().replaceAll("[^a-z0-9]", "");
        log.info(s1);
        // 字符串逆序
        String s2 = new StringBuilder(s1).reverse().toString();
        log.info(s2);
    }
}

输出

22:13:20.142 [main] INFO MyTest -- 3ff23ab
22:13:20.146 [main] INFO MyTest -- ba32ff3

笔记 indexOf & lastIndexOf 🚀 ​

第二个参数为起始下标，不带默认为0

java
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

@Slf4j
public class MyTest {
    @Test
    public void test() {
        String s = "abcdefabcdef";
        log.info("{}", s.indexOf('a'));
        log.info("{}", s.indexOf('a', 3));
        log.info("{}", s.lastIndexOf('a'));
        log.info("{}", s.lastIndexOf('a', 3));
    }
}

输出

15:00:47.516 [main] INFO MyTest -- 0
15:00:47.516 [main] INFO MyTest -- 6
15:00:47.516 [main] INFO MyTest -- 6
15:00:47.516 [main] INFO MyTest -- 0

NB158 简单 牛牛的名字游戏 🚀 ​

简单 时间限制：5秒 空间限制：256M

描述 ​

牛牛和朋友在玩耍时发现了一款关于单词长度的智力游戏。在这个游戏中，他们首先会输入一串由若干单词组成的字符串 s，单词之间用一些空格字符隔开。他们的任务是计算字符串中最后一个单词的长度。例如，他们可以模仿说："牛X牛 Y 牛Z"，最后一个单词是"牛Z"，长度为2。请编写一个函数，计算给定字符串 s 中最后一个单词的长度。

示例1 ​

输入：

"I am a Cow"

返回值：

3

说明：

最后一个单词是"Cow"，长度为 3。

示例2 ​

输入：

"Hello World from Grassland"

返回值：

9

说明：

最后一个单词是"Grassland"，长度为 9。

备注 ​

1 <= s.length <= 10^4
s 仅由英文字母和空格 ' ' 组成。

s 中至少存在一个单词。
返回结果不包含空格。

我的方案 ​

java
import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param s string字符串
     * @return int整型
     */
    public int lengthOfLastWord (String s) {
        s = s.trim();
        return s.length() - s.lastIndexOf(" ") - 1;
    }
}

NB159 简单 牛群消息传递 🚀 ​

简单 时间限制：5秒 空间限制：256M

描述 ​

​ 牛群活动之后，每个牛都用一个字符串表示他们与附近其他牛的关系，但是由于传递过程中出现了一些混乱，导致这些单词出现了顺序错乱。现在草原上的牛们把这个任务交给你，请你帮忙恢复他们之间关系的正确顺序。

​ 给你一个字符串 s 。要求你将字符串中的单词倒序排列，单词之间需要用一个空格隔开，同时保证开头或结尾没有空格，以及单词间的空格不会多于一个。请创建一个函数，返回恢复顺序后的字符串。

示例1 ​

输入：

"cattle find shelter"

返回值：

"shelter find cattle"

备注 ​

1 <= s.length <= 104。s 可由英文字母（大写或小写）、数字、空格组成，且至少包含一个非空格字符。

我的方案 ​

java
import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param s string字符串
     * @return string字符串
     */
    public String reverseWords (String s) {
        String[] strs = s.trim().split("\\s+");
        StringBuilder sb = new StringBuilder();
        for (int i = strs.length - 1; i > -1; i--) {
            sb.append(strs[i]);
            sb.append(" ");
        }
        return sb.toString().trim();
    }
}

NB160 简单 牛群的信息传递 🚀 ​

简单 时间限制：5秒 空间限制：256M

描述 ​

在草原上，牛群为了进行信息传递-同步安全信息，他们需要在一串信息中查找到对方关键词的起始位置。他们请你实现一个函数，给定一串信息 message 和一个关键词 keyword，找到关键词 keyword 第一次出现在信息 message 中的起始位置下标。如果关键词并未出现在信息中，返回 -1。

示例1 ​

输入：

"The_shy_cow_never_gets_the_grass","cow"

返回值：

8

示例2 ​

输入：

"Jumping_over_the_fences_makes_me_hungry","tiger"

返回值：

-1

备注 ​

1 <= message.length, keyword.length <= 10^4，message 和 keyword 仅由大小写英文字母、数字和符号组成。

我的方案 ​

java
import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param message string字符串
     * @param keyword string字符串
     * @return int整型
     */
    public int findKeyword (String message, String keyword) {
        return message.indexOf(keyword);
    }
}

NB161 简单 回文昵称 🚀 ​

简单 时间限制：5秒 空间限制：256M

描述 ​

草原上的牛群每个成员都有一个昵称，作为身份的标志。这些昵称在去除非字母数字字符和忽略大小写后，如果正着读和反着读都一样（空串我们认为是回文），则这个昵称被认为是回文昵称。

现在需要你编写一个程序，判断给定的昵称是否为回文昵称.

示例1 ​

输入：

"Little BoCalf: 77, fLAcoB elTtil!"

返回值：

true

说明：

在去除非字母数字字符，并忽略大小写后，昵称为 "littlebocalf77flacobelttil"，它是一个回文昵称。

示例2 ​

输入：

"Cows jump high!"

返回值：

false

说明：

在去除非字母数字字符，并忽略大小写后，昵称为 "cowsjumphigh"，它不是一个回文昵称。

备注 ​

s（1 <= s.length <= 2 * 10^5），表示牛群中一个成员的昵称，仅包含可打印的 ASCII 字符。

我的方案 ​

java
import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param s string字符串
     * @return bool布尔型
     */
    public boolean isPalindromeNickname (String s) {
        s = s.toLowerCase().replaceAll("[^a-z0-9]", "");
        String s2 = new StringBuilder(s).reverse().toString();
        return s.equals(s2);
    }
}

NB168 简单 名字串生成I 🚀 ​

简单 时间限制：5秒 空间限制：256M

描述 ​

农场主有一群牛，每头牛都有一个独特的名字，名字由英文字母组成。农场主注意到，有一些牛的名字具有特殊的规律，这些名字可以由一个子串重复若干次得到。现在，农场主想要找出一个最长的子串，这个子串既可以生成牛A的名字str1，也可以生成牛B的名字str2。你需要帮助农场主找出这个子串。

示例1 ​

输入：

"ABCABC","ABC"

返回值：

"ABC"

示例2 ​

输入：

"ABABAB","ABAB"

返回值：

"AB"

备注 ​

m == str1.length，n == str2.length，1 <= m, n <= 1000，s 和 t 由大写英文字母组成

我的方案 ​

注意：匹配到后要break或者直接返回，不然就是最短的子串了。

java
import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param str1 string字符串
     * @param str2 string字符串
     * @return string字符串
     */
    public String gcdOfStrings (String str1, String str2) {
        String longStr = str1;
        String shortStr = str2;
        if (str1.length() < str2.length()) {
            longStr = str2;
            shortStr = str1;
        }
        String result = "";
        for (int i = shortStr.length(); i > 0 ; i--) {
            String subStr = shortStr.substring(0, i);
            if (shortStr.replace(subStr, "").length() == 0 &&
                    longStr.replace(subStr, "").length() == 0) {
                result = subStr;
                break;
            }
        }
        return result;
    }
}

NB169 简单 名字串生成II 🚀 ​

简单 时间限制：5秒 空间限制：256M

描述 ​

农场主有一群牛，每头牛都有一个独特的名字，名字由英文字母组成。农场主注意到，有一些牛的名字具有特殊的规律，这些名字可以由一个子串重复若干次得到。现在，农场主想要找出一个最短的子串，这个子串既可以由牛A的名字str1生成，也可以由牛B的名字str2生成。你需要帮助农场主找出这个子串。

示例1 ​

输入：

"ABC","ABCABC"

返回值：

"ABCABC"

示例2 ​

输入：

"ABABABAB","ABAB"

返回值：

"ABABABAB"

备注 ​

m == str1.length，n == str2.length，1 <= m, n <= 1000，s 和 t 由大写英文字母组成

我的方案

java
import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param str1 string字符串
     * @param str2 string字符串
     * @return string字符串
     */
    public String lcmOfStrings (String str1, String str2) {
        String longStr = str1;
        String shortStr = str2;
        if (str1.length() < str2.length()) {
            longStr = str2;
            shortStr = str1;
        }
        String result = "";
        int times = 0;
        while (times < 100) {
            StringBuilder sb = new StringBuilder(shortStr);
            for (int i = 0; i < times; i++) {
                sb.append(shortStr);
            }
            if (sb.toString().replace(longStr, "").length() == 0) {
                result = sb.toString();
                break;
            }
            times++;
        }
        return result;
    }
}

NB163 中等 特工的密码 🚀 ​

中等 时间限制：5秒 空间限制：256M

描述 ​

特工牛牛需要根据密码来找到他们组织内部的相关信息。一条密码如果是另一条信息的子序列，那么这条密码就可以用来找到那条信息。

给定两个字符串 s 和 t，判断 s 是否为 t 的子序列。如果 s 是 t 的子序列，返回 true；否则返回 false。

示例1 ​

输入：

"moo","hmookrpiodc"

返回值：

true

示例2 ​

输入：

"boo","hmookrpiodc"

返回值：

false

备注 ​

s（0 <= s.length <= 100）和 t（0 <= t.length <= 10^4），只包含小写字母。
子序列即原始字符串删除一些或者不删除字符而不改变剩余字符相对位置形成的新字符串，即可以不用相邻。

我的方案 ​

java
import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param s string字符串
     * @param t string字符串
     * @return bool布尔型
     */
    public boolean isSubsequence (String s, String t) {
        int index = -1;
        boolean result = true;
        for (char c : s.toCharArray()) {
            int i = t.indexOf(c, index + 1);
            if (i == -1 || i <= index) {
                result = false;
                break;
            }
            index = i;
        }
        return result;
    }
}

NB170 中等 牛群的编码 🚀 ​

中等 时间限制：5秒 空间限制：256M

描述 ​

在一个农场中，农夫使用二进制字符串来编码他的牛群。每一头牛都有一个二进制编码，农夫将两头牛的编码相加，以此来创建一个新的二进制编码。现在，农夫给出了两头牛的编码 a 和 b，你需要帮他计算出它们的编码和。

示例1 ​

输入：

"1101","101"

返回值：

"10010"

示例2 ​

输入：

"1111","1111"

返回值：

"11110"

备注 ​

1 <= a.length, b.length <= 10^4，编码只由字符 '0' 或 '1' 组成，编码如果不是 "0" ，就不含前导零。

我的方案 ​

java
import java.util.*;
import java.math.BigInteger;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param a string字符串
     * @param b string字符串
     * @return string字符串
     */
    public String addBinary (String a, String b) {
        BigInteger aValue = new BigInteger(a, 2);
        BigInteger bValue = new BigInteger(b, 2);
        return aValue.add(bValue).toString(2);
    }
}

NB166 中等 牛族寻找祖先 🚀 ​

中等 时间限制：5秒 空间限制：256M

描述 ​

草原上的牛们都有各种各样的名字，它们认为名字中包含共同的前缀表示有共同的祖先。现在草原上的牛们请求你帮忙找出他们中间有哪些牛有共同的祖先，请编写一个函数，求解这些名字中的最长公共前缀。如果不存在共同的祖先（没有公共前缀），请返回空字符串""。请编写一个函数，返回字符串数组中的最长公共前缀。

示例1 ​

输入：

["touthill", "touttail", "toutrain"]

返回值：

"tout"

备注 ​

1 <= names.length <= 200
0 <= names[i].length <= 200
names[i] 仅由小写英文字母组成

我的方案 ​

java
import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param names string字符串一维数组
     * @return string字符串
     */
    public String findAncestor (String[] names) {
        String shortestName = names[0];
        for (String name : names) {
            if (name.length() < shortestName.length()) {
                shortestName = name;
            }
        }
        String result = "";
        StringBuilder sb = new StringBuilder();
        outer:
        for (char ch : shortestName.toCharArray()) {
            sb.append(ch);
            for (String name : names) {
                if (!name.startsWith(sb.toString())) {
                    break outer;
                }
            }
            result = sb.toString();
        }
        return result;
    }
}

NB180 中等 压缩牛群编号 🚀 ​

中等 时间限制：5秒 空间限制：256M

描述 ​

农场里有一群牛，农夫为了方便管理，给每头牛都编了号，用字符来表示。现在农夫想要统计农场里每种牛的数量，但是由于数量过多，农夫想要将连续的相同的牛的数量进行压缩表示。请你帮助农夫完成这个任务。

给你一个字符数组 cows ，请使用下述算法压缩：

从一个空字符串 s 开始。对于 cows 中的每组 连续重复字符 ：

如果这一组长度为 1 ，则将字符追加到 s 中，不作其他改变 否则，需要向 s 追加字符，后跟这一组的长度。 压缩后得到的字符串 s 不应该直接返回 ，需要转储到字符数组 cows 中。需要注意的是，如果组长度为 10 或 10 以上，则数字在 cows 数组中会被拆分为多个字符。

请在 修改完输入数组后 ，返回该数组的新长度。

你必须设计并实现一个只使用常量额外空间的算法来解决此问题。

示例1 ​

输入：

[x,x,y,y,z,z,z]

返回值：

[x,2,y,2,z,3]

说明：

"xx" 被 "x2" 替代。"yy" 被 "y2" 替代。"zzz" 被 "z3" 替代。

示例2 ​

输入：

[a,b,b,b,b,b,b,b,b,b,b,b,b]

返回值：

[a,b,1,2]

说明：

由于字符 "a" 不重复，所以不会被压缩。"bbbbbbbbbbbb" 被 “b12” 替代。

备注 ​

1 <= cows.length <= 10000
cows[i] 可以是小写英文字母、大写英文字母、数字或符号

我的方案 ​

java
import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param chars char字符型一维数组
     * @return char字符型一维数组
     */
    public char[] compress (char[] chars) {
        StringBuilder sb = new StringBuilder(Character.toString(chars[0]));
        int nums = 1;
        for (int i = 1; i < chars.length; i++) {
            char ch = chars[i];
            if ( sb.charAt(sb.length() - 1) ==  ch) {
                nums++;
            } else {
                if (nums > 1) {
                    sb.append(nums);
                }
                sb.append(ch);
                nums = 1;
            }
        }
        if (nums > 1) {
            sb.append(nums);
        }
        return sb.toString().toCharArray();
    }
}