# HackerRank Weighted Uniform Strings problem solution

In this HackerRank Weighted Uniform Strings, problem Given a string, s, let U be the set of weights for all possible uniform contiguous substrings of string s. There will be n queries to answer where each query consists of a single integer. Create a return array where for each query, the value is Yes if query[i] related to U. Otherwise, append No.

## Problem solution in Python programming.

```#!/bin/python3

import sys
from collections import Counter

def weight_of_letter(l):
return ord(l) - 96

def get_uniform_subsets(s):
cnt = Counter()
curr = 0
last = ""
for ch in s:
if ch == last:
curr += 1
else:
last = ch
curr = 1
if curr > cnt[ch]: cnt[ch] = curr

weights = set()
for i in cnt:
for j in range(cnt[i]):
return weights

s = input().strip()
weights = get_uniform_subsets(s)
n = int(input().strip())
for a0 in range(n):
x = int(input().strip())
if x in weights:
print("Yes")
else:
print("No")```

## Problem solution in Java Programming.

```import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s = in.next();
int n = in.nextInt();
HashSet<Integer> map = new HashSet<Integer>();
int i, j, curr;
i = 0;

while (i < s.length()) {
j = i;
curr = 0;
while (j < s.length() && s.charAt(j) == s.charAt(i)) {
curr += s.charAt(j++) - 'a' + 1;
}
i = j;
}
for(int a0 = 0; a0 < n; a0++){
int x = in.nextInt();
if (map.contains(x))
System.out.println("Yes");
else
System.out.println("No");
}
}
}```

### Problem solution in C++ programming.

```#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <queue>
#include <stack>
#include <string>
#include <bitset>
#include <cstdio>
#include <limits>
#include <vector>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <numeric>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <unordered_map>

using namespace std;

int maxlen[26] = {};

int main(){
string s;
cin >> s;
int len = s.size();
int i = 0;
while (i < len) {
int j = i;
while (j < len && s[i] == s[j]) j++;
maxlen[s[i] - 'a'] = max(maxlen[s[i] - 'a'], j - i);
i = j;
}

int n;
cin >> n;
for(int a0 = 0; a0 < n; a0++){
int x;
cin >> x;
bool poss = false;
for (i = 0; i < 26; i++) {
if (x % (i + 1) == 0) {
int y = x / (i + 1);
poss |= (y <= maxlen[i]);
}
}
cout << (poss ? "Yes" : "No") << endl;
}
return 0;
}```

### Problem solution in C programming.

```#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>

int main(){
char* s = (char *)malloc(512000 * sizeof(char));
scanf("%s",s);
int n;
scanf("%d",&n);
int i;
int *c = (int *)malloc(10000000 * sizeof(int));
int sum;
i = -1;
while (s[++i] != '\0')
{
if (i > 0 && s[i - 1] == s[i])
sum = (s[i] - 96) + sum;
else
sum = s[i] - 96;
c[sum - 1] = sum;
}
free(s);
for(int a0 = 0; a0 < n; a0++){
int x;
scanf("%d",&x);
if (c[x - 1] == x)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}```

### Problem solution in JavaScript programming.

```process.stdin.resume();
process.stdin.setEncoding('ascii');

var input_stdin = "";
var input_stdin_array = "";
var input_currentline = 0;

process.stdin.on('data', function (data) {
input_stdin += data;
});

process.stdin.on('end', function () {
input_stdin_array = input_stdin.split("\n");
main();
});

return input_stdin_array[input_currentline++];
}

/////////////// ignore above this line ////////////////////

function main() {
let alphabet = "abcdefghijklmnopqrstuvwxyz";
let weights = {};
alphabet.split("").forEach((letter, index) => {
weights[letter] = index+1;
});
let blocks = {};
let currentSum = 0;
let currentLetter = s[0];
for(let i = 0;i<s.length;i++){
currentSum += weights[currentLetter];
blocks[currentSum] = true;
if(i+1 < s.length && s[i+1] !== currentLetter){
currentSum = 0;
currentLetter = s[i+1];
}
}

for(var a0 = 0; a0 < n; a0++){