使用自定义哈希函数对数组中的字符串进行分类

给定字符串数组ARR []由N字符串，任务是根据通过将ASCII值％26字符串中的字符的获得的散列值进行分类的字符串。

例子：

Input: arr[][] = {“geeks”, “for”, “geeks”}
Output:
geeks geeks
for
Explanation:
The hash value of string “for” is (102 + 111 + 114) % 26 = 14
The hash value of string “geeks” is (103 + 101 + 101 + 107 + 115) % 26 = 7
Therefore, two “geeks” are grouped together and “for” is kept in another group.

Input: arr[][] = {“adf”, “aahe”, “bce”, “bgdb”}
Output: 
aahe bgdb
bce
adf 
Explanation: 
The hash value of string “adf” is (97 + 100 + 102)%26 = 13
The hash value of string “aahe” is (97 + 97 + 104 + 101)%26 = 9
The hash value of string “bce” is (98 + 99 + 101)%26 = 12
The hash value of string “bgdb” is (98 + 103 + 100 + 98)%26 = 9
Therefore,  strings “aahe” and “bgdb” have same hashed value, so they are grouped together.

方法：想法是使用 Map Data Structure 将具有相同哈希值的字符串组合在一起。请按照以下步骤解决问题：

• 初始化一个 Map，例如mp ，以将哈希值与向量中的各个字符串进行映射。
• 遍历给定的字符串数组并执行以下步骤：
  • 计算哈希值 根据给定函数的当前字符串。
  • 推字符串与字符串作为在地图MP密钥的计算的散列值的向量。
• 最后，遍历map mp并打印各个key 的所有字符串。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find the hash
// value of the string s
int stringPower(string s)
{
    // Stores hash value of string
    int power = 0;
    int n = s.length();
 
    // Iterate over characters of the string
    for (int i = 0; i < n; i++) {
 
        // Calculate hash value
        power = (power + (s[i])) % 26;
    }
 
    // Return the hash value
    return power;
}
 
// Function to classify the strings
// according to the given condition
void categorisation_Of_strings(
    vector s, int N)
{
    // Maps strings with their strings
    // respective hash values
    map > mp;
 
    // Traverse the array of strings
    for (int i = 0; i < N; i++) {
 
        // Find the hash value of the
        // of the current string
        int temp = stringPower(s[i]);
 
        // Push the current string in
        // value vector of temp key
        mp[temp].push_back(s[i]);
    }
 
    // Traverse over the map mp
    for (auto power : mp) {
 
        // Print the result
        for (auto str : power.second) {
            cout << str << " ";
        }
        cout << endl;
    }
}
 
// Driver Code
int main()
{
    vector arr{ "adf", "aahe",
                        "bce", "bgdb" };
    int N = arr.size();
 
    categorisation_Of_strings(arr, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;
 
class GFG{
     
// Function to find the hash
// value of the string s
static int stringPower(String s)
{
     
    // Stores hash value of string
    int power = 0;
    int n = s.length();
    char C[] = s.toCharArray();
 
    // Iterate over characters of the string
    for(int i = 0; i < n; i++)
    {
         
        // Calculate hash value
        power = (power + (C[i])) % 26;
    }
 
    // Return the hash value
    return power;
}
 
// Function to classify the strings
// according to the given condition
static void categorisation_Of_strings(Vector s,
                                      int N)
{
     
    // Maps strings with their strings
    // respective hash values
    Map > mp = new HashMap<>();
     
    // Traverse the array of strings
    for(int i = 0; i < N; i++)
    {
         
        // Find the hash value of the
        // of the current string
        int temp = stringPower(s.get(i));
 
        // Push the current string in
        // value vector of temp key
        if (mp.containsKey(temp))
        {
            mp.get(temp).add(s.get(i));
        }
        else
        {
            mp.put(temp, new Vector());
            mp.get(temp).add(s.get(i));
        }
    }
 
    // Traverse over the map mp
    for(Map.Entry> entry : mp.entrySet())
    {
         
        // Print the result
        for(String str : entry.getValue())
        {
            System.out.print(str + " ");
        }
        System.out.println();
    }
}
 
// Driver code
public static void main(String[] args)
{
    String[] Sarr = { "adf", "aahe", "bce", "bgdb" };
    Vector arr = new Vector(
        Arrays.asList(Sarr));
    int N = arr.size();
 
    categorisation_Of_strings(arr, N);
}
}
 
// This code is contributed by abhinavjain194

Python3

# Python3 program for the above approach
 
# Function to find the hash
# value of the string s
def stringPower(s):
   
    # Stores hash value of string
    power = 0
    n = len(s)
 
    # Iterate over characters of the string
    for i in range(n):
       
        # Calculate hash value
        power = (power + ord(s[i])) % 26
 
    # Return the hash value
    return power
 
# Function to classify the strings
# according to the given condition
def categorisation_Of_strings(s, N):
   
    # Maps strings with their strings
    # respective hash values
    mp = {}
 
    # Traverse the array of strings
    for i in range(N):
       
        # Find the hash value of the
        # of the current string
        temp = stringPower(s[i])
 
        # Push the current string in
        # value vector of temp key
        if temp in mp:
            mp[temp].append(s[i])
        else:
            mp[temp] = []
            mp[temp].append(s[i])
             
    # Traverse over the map mp
    for i in sorted (mp) :
       
        # Print the result
        for str in mp[i]:
            print(str,end = " ")
        print("\n",end = "")
 
# Driver Code
if __name__ == '__main__':
    arr =  ["adf", "aahe", "bce", "bgdb"]
    N = len(arr)
    categorisation_Of_strings(arr, N)
 
    # This code is contributed by ipg2016107.

Javascript

 
// Javascript program for the above approach
 
// Function to find the hash
// value of the string s
function stringPower(s)
{
     
    // Stores hash value of string
    var power = 0;
    var n = s.length;
 
    // Iterate over characters of the string
    for(var i = 0; i < n; i++)
    {
         
        // Calculate hash value
        power = (power + (s[i].charCodeAt(0))) % 26;
    }
 
    // Return the hash value
    return power;
}
 
// Function to classify the strings
// according to the given condition
function categorisation_Of_strings(s, N)
{
     
    // Maps strings with their strings
    // respective hash values
    var mp = new Map();
 
    // Traverse the array of strings
    for(var i = 0; i < N; i++)
    {
         
        // Find the hash value of the
        // of the current string
        var temp = stringPower(s[i]);
 
        // Push the current string in
        // value vector of temp key
        if (!mp.has(temp))
        {
            mp.set(temp, new Array());
        }
        var tmp = mp.get(temp);
        tmp.push(s[i]);
        mp.set(temp, tmp);
    }
 
    var tmp = Array();
 
    // Traverse over the map mp
    mp.forEach((value, key) => {
        tmp.push(key);
    });
 
    tmp.sort((a, b) => a - b);
 
     // Traverse over the map mp
    tmp.forEach((value) => {
         
        // Print the result
        mp.get(value).forEach(element => {
            document.write(element + " ");
        });
        document.write("<br>");
    });
}
 
// Driver Code
var arr = [ "adf", "aahe", "bce", "bgdb" ];
var N = arr.length;
 
categorisation_Of_strings(arr, N);
 
// This code is contributed by rutvik_56
 

输出：

aahe bgdb 
bce 
adf

时间复杂度： O(N*M)，其中M是最长字符串的长度。
辅助空间： O(N*M)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。