def weightedUniformStrings(s, queries):
    # Write your code here
    dp = []
    for i in range(len(s)):
        weight = ord(s[i]) - 96
        if i == 0 or (s[i] != s[i-1]):
            dp.append(weight)
        else:
            dp.append(weight + dp[i-1])
    ans = []
    dp = set(dp)
    for x in queries:
        if x in dp:
            ans.append("Yes")
        else:
            ans.append("No")
    return ans

public static List<String> weightedUniformStrings(String s, List<Integer> queries) {
    // Write your code here
    Set<Integer> st=new HashSet<Integer>();
    
    char c=s.charAt(0);
    int wt=((int)c-96);
    st.add(wt);
    
    for(int i=0;i<s.length();i++)
    {
        if(s.charAt(i)!=c)
        {
            c=s.charAt(i);
            wt=((int)c)-96;
            st.add(wt);
        }
        else
        {
            wt+=((int)c-96);
            st.add(wt);
        }
    }
    List<String> str=new ArrayList<String>();
    System.out.println(st);
    for(int x: queries)
    if(st.contains(x))
    str.add("Yes");
    else
    str.add("No");
    
    return str;
    

    }

  function weightedUniformStrings(s, queries) {
    const values = []
    const alphabet = "abcdefghijklmnopqrstuvwxyz"

    let currentChar = ""
    for (let i = 0; i <= s.length; i++) {
        if (s[i] !== s[i - 1] && currentChar) {
            values.push(currentChar)
            currentChar = ""
        }
        if (!currentChar || s[i] === s[i - 1]) {
            currentChar += s[i]
        }
    }

    const charWeights = values.map(item => {
        return [...item].map((item, index) => (alphabet.indexOf(item) + 1) * (index + 1))
    }).flat()

    return queries.map(item => charWeights.includes(item) ? 'Yes' : 'No')
}

func weightedUniformStrings(s string, queries []int32) []string {
    characters := "abcdefghijklmnopqrstuvwxyz"
    m := map[string]int32{}
    for i,val := range characters{
        m[string(val)] = int32(i+1)
    }
    temp := ""
    intMap := map[int32]*string{}
    var sum int32 = 0
    for i:=0;i<len(s);i++{
        char := string(s[i])
        if len(temp) > 0{
            if string(s[i]) == string(temp[0]){
                temp += string(s[i])
                sum += m[string(s[i])]
                intMap[sum] = &temp
            }else{ 
                temp = string(s[i])
                sum = m[string(s[i])]
                intMap[sum] = &char
            }   
        }else{
            temp = string(s[i])
            sum = m[string(s[i])]
            intMap[sum] = &char
        }
    }
    output := []string{}
    for _,val := range queries{
        if _, found:= intMap[int32(val)];found{
            output = append(output, "Yes")
        }else{
            output = append(output, "No")
        }
    }
    return output
}

function weightedUniformStrings(s, queries) {
    let prev = '';
    let weight = 0;
    const possibility = {};
    
    for(let el of s) {
        if(el === prev) weight++;
        else {
            prev = el;
            weight = 1;
        }
        
        const val = (el.charCodeAt() - 96) * weight;
        possibility[val] = el;
    }
    
    let out = [];
    for(let query of queries) out.push(possibility[query] ? "Yes" : "No")
    
    return out;
}