Open In App

For each lowercase English alphabet find the count of strings having these alphabets

Given an array of strings of lowercase English alphabets. The task is for each letter [a-z] to find the count of strings having these letters.
Examples:

Input: str = { “geeks”, “for”, “code” } 
Output: { 0 0 1 1 2 1 1 0 0 0 0 0 0 0 2 0 0 1 1 0 0 0 0 0 0 0 } 
Explanation: 
For a letter, say ‘e’, it is present in { “geeks”, “code” }, hence its count is 2. 
Similarly for another letter result can be found.

Input: str = { “i”, “will”, “practice”, “everyday” } 
Output: 2 0 1 1 2 0 0 0 3 0 0 0 0 0 0 1 0 2 0 1 0 1 1 0 1 0 
Explanation: 
For a letter, say ‘i’, it is present in { “i”, “will”, “practice” }, hence its count is 3. 
Similarly for another letter result can be found.

Method : Brute Force

  1. Create a global counter array for each letter of size 26, initialize it with 0.
  2. For every lowercase alphabet check whether it exists in a current string
  3. If the alphabet exists in the string then increment the count. 
  4. Repeat this for all strings of input.




#include <iostream>
#include <vector>
#include <string>
 
using namespace std;
 
// Function to find the countStrings
// for each letter [a-z]
void CountStrings(vector<string>& str)
{
    int size = str.size();
 
    // Initialize result as zero
    vector<int> count(26, 0);
 
    // Loop through each Strings
    for (int i = 0; i < size; ++i) {
        // looping all the characters from a to z
        for (int j = 0; j < 26; j++) {
            char c = static_cast<char>(j + 'a');
 
            // checking whether the current string
            // contains the present Character
            if (str[i].find(c) != string::npos) {
                count[j]++;
            }
        }
    }
 
    // Print count for each letter
    for (int i = 0; i < 26; ++i) {
        cout << count[i] << " ";
    }
}
 
// Driver program
int main()
{
    // Given array of Strings
    vector<string> str
        = { "i", "will", "practice", "everyday" };
 
    // Call the CountStrings function
    CountStrings(str);
 
    return 0;
}




/*package whatever //do not write package name here */
 
import java.io.*;
 
// Java program to find count of Strings
// for each letter [a-z] in english alphabet
class GFG {
 
    // Function to find the countStrings
    // for each letter [a-z]
    static void CountStrings(String[] str)
    {
        int size = str.length;
 
        // Initialize result as zero
        int[] count = new int[26];
 
        // Loop through each Strings
        for (int i = 0; i < size; ++i) {
            // looping all the characters from a to z
            for (int j = 0; j < 26; j++) {
                char c = (char)(j + 'a');
 
                // checking whether the current string
                // contains the present Character
                if (str[i].contains("" + c)) {
                    count[j]++;
                }
               
            }
        }
 
        // Print count for each letter
        for (int i = 0; i < 26; ++i) {
            System.out.print(count[i] + " ");
        }
    }
 
    // Driver program
    public static void main(String[] args)
    {
        // Given array of Strings
        String[] str
            = { "i", "will", "practice", "everyday" };
 
        // Call the countStrings function
        CountStrings(str);
    }
}
 
// This code is contributed by aeroabrar_31




# Python program to find count of Strings
# for each letter [a-z] in the English alphabet
 
# Function to find the countStrings
# for each letter [a-z]
 
 
def count_strings(strings):
    size = len(strings)
 
    # Initialize result as zero
    count = [0] * 26
 
    # Loop through each string
    for i in range(size):
        # Loop through all the characters from 'a' to 'z'
        for j in range(26):
            c = chr(j + ord('a'))
 
            # Checking whether the current string
            # contains the present character
            if c in strings[i]:
                count[j] += 1
 
    # Print count for each letter
    for i in range(26):
        print(count[i], end=' ')
 
 
# Driver program
if __name__ == '__main__':
    # Given list of strings
    strings = ["i", "will", "practice", "everyday"]
 
    # Call the count_strings function
    count_strings(strings)




using System;
using System.Collections.Generic;
 
class Program
{
    // Function to find the countStrings
    // for each letter [a-z]
    static void CountStrings(List<string> str)
    {
        int size = str.Count;
 
        // Initialize result as zero
        int[] count = new int[26];
 
        // Loop through each Strings
        for (int i = 0; i < size; ++i)
        {
            // looping all the characters from a to z
            for (int j = 0; j < 26; j++)
            {
                char c = (char)(j + 'a');
 
                // checking whether the current string
                // contains the present Character
                if (str[i].Contains(c))
                {
                    count[j]++;
                }
            }
        }
 
        // Print count for each letter
        for (int i = 0; i < 26; ++i)
        {
            Console.Write(count[i] + " ");
        }
    }
 
    // Driver program
    static void Main()
    {
        // Given array of Strings
        List<string> str = new List<string> { "i", "will", "practice", "everyday" };
 
        // Call the CountStrings function
        CountStrings(str);
    }
}




// Function to find the countStrings
// for each letter [a-z]
function CountStrings(str) {
    const size = str.length;
 
    // Initialize result as zero
    const count = new Array(26).fill(0);
 
    // Loop through each Strings
    for (let i = 0; i < size; ++i) {
        // looping all the characters from a to z
        for (let j = 0; j < 26; j++) {
            const c = String.fromCharCode(j + 'a'.charCodeAt(0));
 
            // checking whether the current string
            // contains the present Character
            if (str[i].includes(c)) {
                count[j]++;
            }
        }
    }
 
    // Print count for each letter
    for (let i = 0; i < 26; ++i) {
        process.stdout.write(count[i] + " ");
    }
}
 
// Driver program
function main() {
    // Given array of Strings
    const str = ["i", "will", "practice", "everyday"];
 
    // Call the CountStrings function
    CountStrings(str);
}
 
main();

Output
2 0 1 1 2 0 0 0 3 0 0 1 0 0 0 1 0 2 0 1 0 1 1 0 1 0 

Time Complexity: O(N*26*(len)) 

where N is length of input array and len is maximum length of strings.

Efficient Approach:

Below is the implementation of the above approach:




// C++ program to find count of strings
// for each letter [a-z] in english alphabet
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the countStrings
// for each letter [a-z]
void CountStrings(vector<string>& str)
{
    int size = str.size();
 
    // Initialize result as zero
    vector<int> count(26, 0);
 
    // Mark all letter as not visited
    vector<bool> visited(26, false);
 
    // Loop through each strings
    for (int i = 0; i < size; ++i)
    {
 
        for (int j = 0; j < str[i].length(); ++j)
        {
 
            // Increment the global counter
            // for current character of string
            if (visited[str[i][j]] == false)
                count[str[i][j] - 'a']++;
 
            visited[str[i][j]] = true;
        }
 
        // Instead of re-initialising boolean
        // vector every time we just reset
        // all visited letter to false
        for (int j = 0; j < str[i].length(); ++j)
        {
            visited[str[i][j]] = false;
        }
    }
 
    // Print count for each letter
    for (int i = 0; i < 26; ++i)
    {
        cout << count[i] << " ";
    }
}
 
// Driver program
int main()
{
    // Given array of strings
    vector<string> str = {"i", "will",
                          "practice", "everyday"};
 
    // Call the countStrings function
    CountStrings(str);
 
    return 0;
}




// Java program to find count of Strings
// for each letter [a-z] in english alphabet
class GFG{
 
// Function to find the countStrings
// for each letter [a-z]
static void CountStrings(String []str)
{
    int size = str.length;
 
    // Initialize result as zero
    int []count = new int[26];
 
    // Mark all letter as not visited
    boolean []visited = new boolean[26];
    // Loop through each Strings
    for (int i = 0; i < size; ++i)
    {
        for (int j = 0; j < str[i].length(); ++j)
        {
            // Increment the global counter
            // for current character of String
            if (visited[str[i].charAt(j) - 'a'] == false)
                count[str[i].charAt(j) - 'a']++;
 
            visited[str[i].charAt(j) - 'a'] = true;
        }
 
        // Instead of re-initialising boolean
        // vector every time we just reset
        // all visited letter to false
        for (int j = 0; j < str[i].length(); ++j)
        {
            visited[str[i].charAt(j) - 'a'] = false;
        }
    }
 
    // Print count for each letter
    for (int i = 0; i < 26; ++i)
    {
        System.out.print(count[i] + " ");
    }
}
 
// Driver program
public static void main(String[] args)
{
    // Given array of Strings
    String []str = {"i", "will",
                    "practice", "everyday"};
 
    // Call the countStrings function
    CountStrings(str);
}
}
 
// This code is contributed by shikhasingrajput




# Python3 program to find count of
# strings for each letter [a-z] in
# english alphabet
 
# Function to find the countStrings
# for each letter [a-z]
def CountStrings(s):
     
    size = len(s)
     
    # Initialize result as zero
    count = [0] * 26
     
    # Mark all letter as not visited
    visited = [False] * 26
     
    # Loop through each strings
    for i in range(size):
        for j in range(len(s[i])):
             
            # Increment the global counter
            # for current character of string
            if visited[ord(s[i][j]) -
                       ord('a')] == False:
                count[ord(s[i][j]) -
                      ord('a')] += 1
                 
            visited[ord(s[i][j]) -
                    ord('a')] = True
             
        # Instead of re-initialising boolean
        # vector every time we just reset
        # all visited letter to false
        for j in range(len(s[i])):
            visited[ord(s[i][j]) -
                    ord('a')] = False
             
    # Print count for each letter
    for i in range(26):
        print(count[i], end = ' ')
 
# Driver code
if __name__=='__main__':
     
    # Given array of strings
    s = [ "i", "will",
          "practice", "everyday" ]
 
    # Call the countStrings function
    CountStrings(s)
 
# This code is contributed by rutvik_56




// C# program to find count of Strings
// for each letter [a-z] in english alphabet
using System;
 
class GFG{
 
// Function to find the countStrings
// for each letter [a-z]
static void CountStrings(String []str)
{
    int size = str.Length;
 
    // Initialize result as zero
    int []count = new int[26];
 
    // Mark all letter as not visited
    bool []visited = new bool[26];
     
    // Loop through each Strings
    for(int i = 0; i < size; ++i)
    {
        for(int j = 0; j < str[i].Length; ++j)
        {
             
            // Increment the global counter
            // for current character of String
            if (visited[str[i][j] - 'a'] == false)
                count[str[i][j] - 'a']++;
 
            visited[str[i][j] - 'a'] = true;
        }
 
        // Instead of re-initialising bool
        // vector every time we just reset
        // all visited letter to false
        for(int j = 0; j < str[i].Length; ++j)
        {
            visited[str[i][j] - 'a'] = false;
        }
    }
 
    // Print count for each letter
    for(int i = 0; i < 26; ++i)
    {
        Console.Write(count[i] + " ");
    }
}
 
// Driver code
public static void Main(String[] args)
{
     
    // Given array of Strings
    String []str = { "i", "will",
                     "practice", "everyday"};
 
    // Call the countStrings function
    CountStrings(str);
}
}
 
// This code is contributed by Amit Katiyar




<script>
// JavaScript program to find count of strings
// for each letter [a-z] in english alphabet
 
// Function to find the countStrings
// for each letter [a-z]
function CountStrings(str)
{
    let size = str.length;
 
    // Initialize result as zero
    let count = new Array(26).fill(0);
 
    // Mark all letter as not visited
    let visited = new Array(26).fill(false);
 
    // Loop through each strings
    for (let i = 0; i < size; ++i)
    {
 
        for (let j = 0; j < str[i].length; ++j)
        {
 
            // Increment the global counter
            // for current character of string
            if(visited[str[i].charCodeAt(j) - 97] == false)
                count[str[i].charCodeAt(j) - 97]++;
 
            visited[str[i].charCodeAt(j) - 97] = true;
        }
 
        // Instead of re-initialising boolean
        // vector every time we just reset
        // all visited letter to false
        for (let j = 0; j < str[i].length; ++j)
        {
            visited[str[i].charCodeAt(j) - 97] = false;
        }
    }
 
    // Print count for each letter
    for (let i = 0; i < 26; ++i)
    {
        document.write(count[i]," ");
    }
}
 
// Driver program
 
// Given array of strings
let str = ["i", "will","practice", "everyday"];
 
// Call the countStrings function
CountStrings(str);
 
// This code is contributed by shinjanpatra
 
</script>

Output
2 0 1 1 2 0 0 0 3 0 0 1 0 0 0 1 0 2 0 1 0 1 1 0 1 0






Time Complexity: O(N), where N is the sum of the length of all strings. 
Auxiliary Space: O(1)


Article Tags :