用Java写程序，给定［" a "," b "," a "," b "," c "," a "," b "," c "," b "］字符串数组，然后使用 Map 的 key 来保存数组中字符串元素， value 保存该字符串元素的出现次数，最后统计出各字符串元素的出现次数。

可以使用Java中的Map来保存字符串元素和它们的出现次数。具体实现步骤如下：
1. 创建一个空的Map对象，用于保存字符串元素和它们的出现次数。
2. 遍历给定的字符串数组，对于数组中的每个字符串元素，判断它是否已经在Map中存在，如果存在，则将该字符串元素的出现次数加1，否则将该字符串元素作为新的key添加到Map中，并将它的出现次数初始化为1。
3. 遍历Map中的所有key，输出每个key和它对应的value，即该字符串元素的出现次数。

下面是Java代码实现：

String[] arr = {"a", "b", "a", "b", "c", "a", "b", "c", "b"};
Map<String, Integer> map = new HashMap<>();
for (String s : arr) {
    if (map.containsKey(s)) {
        map.put(s, map.get(s) + 1);
    } else {
        map.put(s, 1);
    }
}
for (String key : map.keySet()) {
    System.out.println(key + ": " + map.get(key));
}

相关问题

给定字符串a和b,输出a和b中的最长公共子串 python

题目描述：

给定两个字符串a和b，求它们的最长公共子串。

解题思路：

最长公共子串问题是求两个字符串中最长的相同子串，可以使用动态规划来解决。

我们定义一个二维数组dp[i][j]表示以a[i]和b[j]为结尾的最长公共子串的长度。即，如果a[i]和b[j]相等，则dp[i][j] = dp[i-1][j-1] + 1，否则dp[i][j] = 0。

接下来，我们遍历整个数组，并记录下最大的dp[i][j]的值，以及对应的结束位置。

代码实现：

def get_lcs(a, b):
len_a = len(a)
len_b = len(b)

dp = [[0] * (len_b + 1) for _ in range(len_a + 1)]

max_len = 0
end_pos = 0

for i in range(1, len_a+1):
for j in range(1, len_b+1):
if a[i-1] == b[j-1]:
dp[i][j] = dp[i-1][j-1] + 1
if dp[i][j] > max_len:
max_len = dp[i][j]
end_pos = i

return a[end_pos-max_len:end_pos]

测试样例：

a = 'abcdefg'
b = 'cdefghijk'

print(get_lcs(a, b)) # cdefg

参考资料：

https://blog.csdn.net/mrenglish233/article/details/104587952

给定两个升序数组A，B，将这两个数组合并为一个升序数组。c语言

可以使用双指针算法来实现两个升序数组的合并。

具体实现如下：

void merge(int* A, int ASize, int* B, int BSize, int* C) {
    int i = 0, j = 0, k = 0;
    while (i < ASize && j < BSize) {
        if (A[i] <= B[j]) {
            C[k++] = A[i++];
        } else {
            C[k++] = B[j++];
        }
    }
    while (i < ASize) {
        C[k++] = A[i++];
    }
    while (j < BSize) {
        C[k++] = B[j++];
    }
}

其中，A、B为待合并的两个升序数组，ASize、BSize分别为其长度，C为合并后的升序数组，需要提前分配好足够的空间。

双指针算法的思路是，分别维护两个指针i、j，表示当前需要比较的元素在A、B数组中的位置，然后比较A[i]和B[j]的大小，将较小的元素加入到合并后的数组C中，并将对应指针向后移动一位。当其中一个数组的指针到达末尾时，将另一个数组中剩余的元素按顺序加入到C中即可。