数组中字符串字符的加权和| 2套

给定一个字符串数组str[] ，任务是从数组中找到给定字符串s的分数。的字符串的分数被定义为它的字符的字母值与所述阵列中的字符串的位置的和的乘积。
例子：

Input: str[] = {“sahil”, “shashanak”, “sanjit”, “abhinav”, “mohit”}, s = “abhinav” 
Output: 228 
Sum of alphabetical values of “abhinav” = 1 + 2 + 8 + 9 + 14 + 1 + 22 = 57 
Position of “abhinav” in str is 4, 57 x 4 = 228 
Input: str[] = {“geeksforgeeks”, “algorithms”, “stack”}, s = “algorithms” 
Output: 244 
 

方法：
在 SET 1 中，我们看到了一种方法，每次执行查询时，都必须通过一次遍历str[]来找到字符串的位置。这可以在使用哈希表进行大量查询时进行优化。

• 创建str[]中所有字符串及其在数组中各自位置的哈希映射。
• 然后对于每个查询s ，检查s是否存在于地图中。如果是，则计算s的字母值的总和并将其存储在sum 中。
• 打印sum * pos其中pos是与 map 中的s相关联的值，即它在str[] 中的位置。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function to return the required string score
int strScore(string str[], string s, int n)
{
    // create a hash map of strings in str
    unordered_map m;
 
    // Store every string in the map
    // along with its position in the array
    for (int i = 0; i < n; i++)
        m[str[i]] = i + 1;
 
    // If given string is not present in str[]
    if (m.find(s) == m.end())
        return 0;
 
    int score = 0;
 
    for (int i = 0; i < s.length(); i++)
        score += s[i] - 'a' + 1;
 
    // Multiply sum of alphabets with position
    score = score * m[s];
 
    return score;
}
 
// Driver code
int main()
{
    string str[] = { "geeksforgeeks", "algorithms", "stack" };
    string s = "algorithms";
    int n = sizeof(str) / sizeof(str[0]);
    int score = strScore(str, s, n);
    cout << score;
 
    return 0;
}

Java

// Java implementation of the approach
import java.util.HashMap;
import java.util.Map;
 
class GfG
{
    // Function to return the required string score
    static int strScore(String str[], String s, int n)
    {
        // create a hash map of strings in str
        HashMap m = new HashMap<>();
     
        // Store every string in the map
        // along with its position in the array
        for (int i = 0; i < n; i++)
            m.put(str[i], i + 1);
     
        // If given string is not present in str[]
        if (!m.containsKey(s))
            return 0;
     
        int score = 0;
     
        for (int i = 0; i < s.length(); i++)
            score += s.charAt(i) - 'a' + 1;
     
        // Multiply sum of alphabets with position
        score = score * m.get(s);
     
        return score;
    }
 
    // Driver code
    public static void main(String []args)
    {
        String str[] = { "geeksforgeeks", "algorithms",
                                            "stack" };
        String s = "algorithms";
        int n = str.length;
        System.out.println(strScore(str, s, n));
         
    }
}
 
// This code is contributed by Rituraj Jain

Python3

# Python3 implementation of the approach
 
# Function to return the required
# string score
def strScore(string, s, n) :
 
    # create a hash map of strings in str
    m = {}
 
    # Store every string in the map
    # along with its position in the array
    for i in range(n) :
        m[string[i]] = i + 1
 
    # If given string is not present in str[]
    if s not in m.keys() :
        return 0
 
    score = 0
 
    for i in range(len(s)) :
        score += ord(s[i]) - ord('a') + 1
 
    # Multiply sum of alphabets
    # with position
    score = score * m[s]
 
    return score
 
# Driver code
if __name__ == "__main__" :
 
    string = [ "geeksforgeeks",
               "algorithms", "stack" ]
    s = "algorithms"
    n = len(string)
    score = strScore(string, s, n);
    print(score)
 
# This code is contributed by Ryuga

C#

// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GfG
{
    // Function to return the required string score
    static int strScore(string [] str, string s, int n)
    {
        // create a hash map of strings in str
        Dictionary m = new Dictionary();
         
        // Store every string in the map
        // along with its position in the array
        for (int i = 0; i < n; i++)
            m[str[i]] = i + 1;
     
        // If given string is not present in str[]
        if (!m.ContainsKey(s))
            return 0;
     
        int score = 0;
     
        for (int i = 0; i < s.Length; i++)
            score += s[i] - 'a' + 1;
     
        // Multiply sum of alphabets with position
        score = score * m[s];
     
        return score;
    }
 
    // Driver code
    public static void Main()
    {
        string [] str = { "geeksforgeeks", "algorithms",
                                            "stack" };
        string s = "algorithms";
        int n = str.Length;
        Console.WriteLine(strScore(str, s, n));
         
    }
}
 
// This code is contributed by ihritik

Javascript

 
// JavaScript Program to implement
// the above approach
 
    // Function to return the required string score
    function strScore(str, s, n)
    {
        // create a hash map of strings in str
        let m = new Map();
     
        // Store every string in the map
        // along with its position in the array
        for (let i = 0; i < n; i++)
            m.set(str[i], i + 1);
     
        // If given string is not present in str[]
        if (!m.has(s))
            return 0;
     
        let score = 0;
     
        for (let i = 0; i < s.length; i++)
            score += s[i].charCodeAt() - 'a'.charCodeAt() + 1;
     
        // Multiply sum of alphabets with position
        score = score * m.get(s);
     
        return score;
    }
 
// Driver Code
 
        let str = [ "geeksforgeeks", "algorithms",
                                            "stack" ];
        let s = "algorithms";
        let n = str.length;
        document.write(strScore(str, s, n));
 

输出：

244

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