个含有字符串的数组，例如:["a","b"."a” ，b”，d”.a”1,1].需要得到一个新数组 ["a1""b1""a2""c","b2""d""a3""11""12"]

我认为输入的数组中有一些错误，应该是这样的：["a","b","a","b","d","a","1","1"]，而不是["a","b"."a” ，b”，d”.a”1,1]。在这个假设下，以下是一个可以得到新数组的实现：

def get_new_array(arr):
    d = {}
    new_arr = []
    for s in arr:
        if s in d:
            d[s] += 1
            new_arr.append(s + str(d[s]))
        else:
            d[s] = 1
            new_arr.append(s + str(d[s]))
    return new_arr

arr = ["a","b","a","b","d","a","1","1"]
new_arr = get_new_array(arr)
print(new_arr) # ["a1","b1","a2","b2","d1","a3","11","12"]

这个实现中，我们用一个字典 `d` 来记录每个字符串出现的次数，然后遍历输入数组，对于每个字符串，如果它已经出现过，就在它后面加上它出现的次数，否则就把它加入字典，并在后面加上 1。最后返回新数组。

相关问题

js 一个含有字符串的数组，例如:["a","b"."a” ，b”，d”.a”1,1].需要得到一个新数组 ["a1""b1""a2""c","b2""d""a3""11""12"]

这个题目有点不清晰，我假设题目意思是将每个字符串中的数字累加，并且将相同的字符串合并为一个，最后返回一个新的数组。

可以使用一个对象来记录每个字符串出现的次数和累加的数字，然后再将对象转换成数组。

以下是实现代码：

function transformArray(arr) {
  const obj = {};
  for (let i = 0; i < arr.length; i++) {
    const str = arr[i];
    const match = str.match(/\d+/g);
    const num = match ? match.reduce((acc, val) => acc + parseInt(val), 0) : 0;
    const key = str.replace(/\d+/g, '');
    if (!obj[key]) {
      obj[key] = {
        str: key,
        count: 1,
        num: num,
      };
    } else {
      obj[key].count++;
      obj[key].num += num;
    }
  }
  return Object.values(obj).map(({ str, count, num }) => `${str}${count}${num}`);
}

const arr = ["a","b","a","b","d","a1","1","1"];
const result = transformArray(arr);
console.log(result); // ["a3","b2","d1","a11","12"]

这个实现的时间复杂度是 O(n)，其中 n 是数组的长度。

c#中 一个含有字符串的数组，例如:["a","b","a","c","b","d","a"],需要得到一个新数组 ["a1","b1","a2","c","b2","d","a3"] 只出现一次的字符串不变

可以使用字典来记录每个字符串出现的次数，然后根据次数来构建新的数组。具体步骤如下：

1. 创建一个空字典`count_dict`来记录每个字符串出现的次数。
2. 遍历原始数组，对于每个字符串：
- 如果该字符串已经在`count_dict`中存在，将其对应的次数加1。
- 如果该字符串不在`count_dict`中，将其添加到`count_dict`中，并将其对应的次数初始化为1。
3. 创建一个新的数组`new_array`，用于存储结果。
4. 遍历原始数组，对于每个字符串：
- 如果该字符串在`count_dict`中的次数大于1，将其在`new_array`中的值修改为原字符串加上对应的次数。
- 如果该字符串在`count_dict`中的次数等于1，将其在`new_array`中的值保持不变。
5. 返回`new_array`作为结果。

下面是使用C#实现上述算法的代码示例：

using System;
using System.Collections.Generic;

public class Program
{
    public static string[] GetNewArray(string[] array)
    {
        Dictionary<string, int> countDict = new Dictionary<string, int>();
        foreach (string str in array)
        {
            if (countDict.ContainsKey(str))
            {
                countDict[str]++;
            }
            else
            {
                countDict[str] = 1;
            }
        }

        string[] newArray = new string[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            if (countDict[array[i]] > 1)
            {
                newArray[i] = array[i] + countDict[array[i]];
            }
            else
            {
                newArray[i] = array[i];
            }
        }

        return newArray;
    }

    public static void Main(string[] args)
    {
        string[] array = { "a", "b", "a", "c", "b", "d", "a" };
        string[] newArray = GetNewArray(array);
        foreach (string str in newArray)
        {
            Console.WriteLine(str);
        }
    }
}

运行以上代码，将会输出新的数组`["a1","b1","a2","c","b2","d","a3"]`。