Count Unique Characters of All Substrings of a Given String solution and explanation

def countUniqueChars(s):
    return len(set(s))


def sumOfUniqueCharsInAllSubstrings(s):
    total_sum = 0
    n = len(s)
    for i in range(n):
        for j in range(i+1, n+1):
            total_sum += countUniqueChars(s[i:j])
    return total_sum


# Example Usage
s = 'ABC'
print(sumOfUniqueCharsInAllSubstrings(s))  # Output: 10

def uniqueLetterString(s):
    index = {c: [-1, -1] for c in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'}
    result = 0

    for i, x in enumerate(s):
        k, j = index[x]
        result += (i - j) * (j - k)
        index[x] = [j, i]

    for c in index:
        k, j = index[c]
        result += (len(s) - j) * (j - k)

    return result


# Example Usage
s = 'ABC'
print(uniqueLetterString(s))  # Output: 10

def main():
    hmap = {}
    hmap[1] = 100
    print("Value for key 1:", hmap[1])  # Outputs 100

main()

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, Integer> map = new HashMap<>();
        map.put(1, 100);
        System.out.println("Value for key 1: " + map.get(1)); // Outputs 100
    }
}

#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<int, int> map;
    map[1] = 100;
    std::cout << "Value for key 1: " << map[1] << std::endl; // Outputs 100
    return 0;
}

let map = new Map();
map.set(1, 100);
console.log('Value for key 1:', map.get(1)); // Outputs 100

#include <stdio.h>
#include <stdlib.h>

// Define a simple hash map node
typedef struct Node {
    int key;
    int value;
    struct Node* next;
} Node;

#define MAP_SIZE 1000

// Hash function
int hash(int key) {
    return key % MAP_SIZE;
}

// Insert into hash map
void insert(Node** map, int key, int value) {
    int h = hash(key);
    Node* newNode = malloc(sizeof(Node));
    newNode->key = key;
    newNode->value = value;
    newNode->next = map[h];
    map[h] = newNode;
}

// Search in hash map
int search(Node** map, int key) {
    int h = hash(key);
    Node* curr = map[h];
    while (curr != NULL) {
        if (curr->key == key) return curr->value;
        curr = curr->next;
    }
    return -1; // Not found
}

int main() {
    Node* map[MAP_SIZE] = { NULL };
    insert(map, 1, 100);
    printf("Value for key 1: %d\n", search(map, 1)); // Outputs 100
    return 0;
}

using System;
using System.Collections.Generic;

public class Program {
    public static void Main(string[] args) {
        Dictionary<int, int> map = new Dictionary<int, int>();
        map[1] = 100;
        Console.WriteLine("Value for key 1: " + map[1]); // Outputs 100
    }
}

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = left + (right - left) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

arr = [1, 3, 5, 7, 9]
target = 5
print("Element found at index:", binary_search(arr, target))  # Outputs 2

public class Main {
    public static int binarySearch(int[] arr, int target) {
        int left = 0, right = arr.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == target)
                return mid;
            else if (arr[mid] < target)
                left = mid + 1;
            else
                right = mid - 1;
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9};
        int target = 5;
        System.out.println("Element found at index: " + binarySearch(arr, target)); // Outputs 2
    }
}

#include <iostream>
#include <vector>
#include <algorithm>

int binarySearch(const std::vector<int>& arr, int target) {
    int left = 0, right = arr.size() - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target)
            return mid;
        else if (arr[mid] < target)
            left = mid + 1;
        else
            right = mid - 1;
    }
    return -1;
}

int main() {
    std::vector<int> arr = {1, 3, 5, 7, 9};
    int target = 5;
    int index = binarySearch(arr, target);
    std::cout << "Element found at index: " << index << std::endl; // Outputs 2
    return 0;
}

function binarySearch(arr, target) {
    let left = 0, right = arr.length - 1;
    while (left <= right) {
        let mid = Math.floor(left + (right - left) / 2);
        if (arr[mid] === target) return mid;
        else if (arr[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

let arr = [1, 3, 5, 7, 9];
let target = 5;
console.log('Element found at index:', binarySearch(arr, target)); // Outputs 2

#include <stdio.h>

int binarySearch(int arr[], int size, int target) {
    int left = 0, right = size - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target)
            return mid;
        else if (arr[mid] < target)
            left = mid + 1;
        else
            right = mid - 1;
    }
    return -1;
}

int main() {
    int arr[] = {1, 3, 5, 7, 9};
    int target = 5;
    int index = binarySearch(arr, 5, target);
    printf("Element found at index: %d\n", index); // Outputs 2
    return 0;
}

using System;

class Program {
    static int BinarySearch(int[] arr, int target) {
        int left = 0, right = arr.Length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == target)
                return mid;
            else if (arr[mid] < target)
                left = mid + 1;
            else
                right = mid - 1;
        }
        return -1;
    }

    static void Main() {
        int[] arr = {1, 3, 5, 7, 9};
        int target = 5;
        Console.WriteLine("Element found at index: " + BinarySearch(arr, target)); // Outputs 2
    }
}

function uniqueLetterString(s: string): number {
    const d: number[][] = Array.from({ length: 26 }, () => [-1]);
    for (let i = 0; i < s.length; ++i) {
        d[s.charCodeAt(i) - 'A'.charCodeAt(0)].push(i);
    }
    let ans = 0;
    for (const v of d) {
        v.push(s.length);

        for (let i = 1; i < v.length - 1; ++i) {
            ans += (v[i] - v[i - 1]) * (v[i + 1] - v[i]);
        }
    }
    return ans;
}

func uniqueLetterString(s string) (ans int) {
	d := make([][]int, 26)
	for i := range d {
		d[i] = []int{-1}
	}
	for i, c := range s {
		d[c-'A'] = append(d[c-'A'], i)
	}
	for _, v := range d {
		v = append(v, len(s))
		for i := 1; i < len(v)-1; i++ {
			ans += (v[i] - v[i-1]) * (v[i+1] - v[i])
		}
	}
	return
}

impl Solution {
    pub fn unique_letter_string(s: String) -> i32 {
        let mut d: Vec<Vec<i32>> = vec![vec![-1; 1]; 26];
        for (i, c) in s.chars().enumerate() {
            d[(c as usize) - ('A' as usize)].push(i as i32);
        }
        let mut ans = 0;
        for v in d.iter_mut() {
            v.push(s.len() as i32);
            for i in 1..v.len() - 1 {
                ans += (v[i] - v[i - 1]) * (v[i + 1] - v[i]);
            }
        }
        ans as i32
    }
}