Número de strings que satisfacen la condición dada

Dadas N strings de igual longitud. Las strings contienen solo dígitos (1 a 9). La tarea es contar el número de strings que tienen una posición de índice tal que el dígito en esta posición de índice sea mayor que los dígitos en la misma posición de índice de todas las demás strings.
Ejemplos: 
 

Entrada: arr[] = {“223”, “232”, “112”} 
Salida: 2 
El primer dígito de la ^1ra y la ^2da string son las más grandes. 
El segundo dígito de la string 2 ^nd es el más grande. 
El tercer dígito de la string 1 ^es el más grande.
Entrada: arr[] = {“999”, “122”, “111”} 
Salida: 1 
 

Enfoque: para cada posición de índice, encuentre el dígito máximo en esa posición en todas las strings. Y almacene los índices de la string que satisfacen la condición dada en un conjunto para que la misma string no se cuente dos veces para diferentes posiciones de índice. Finalmente, devuelva el tamaño del conjunto.
A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the count of valid strings
int countStrings(int n, int m, string s[])
{
 
    // Set to store indices of valid strings
    unordered_set<int> ind;
    for (int j = 0; j < m; j++) {
        int mx = 0;
 
        // Find the maximum digit for current position
        for (int i = 0; i < n; i++)
            mx = max(mx, (int)s[i][j] - '0');
 
        // Add indices of all the strings in the set
        // that contain maximal digit
        for (int i = 0; i < n; i++)
            if (s[i][j] - '0' == mx)
                ind.insert(i);
    }
 
    // Return number of strings in the set
    return ind.size();
}
 
// Driver code
int main()
{
    string s[] = { "223", "232", "112" };
    int m = s[0].length();
    int n = sizeof(s) / sizeof(s[0]);
    cout << countStrings(n, m, s);
}

// Java implementation of the approach
import java.util.*;
 
class GfG
{
 
// Function to return the count of valid strings
static int countStrings(int n, int m, String s[])
{
 
    // Set to store indices of valid strings
    HashSet<Integer> ind = new HashSet<Integer>();
    for (int j = 0; j < m; j++)
    {
        int mx = 0;
 
        // Find the maximum digit for current position
        for (int i = 0; i < n; i++)
            mx = Math.max(mx, (int)(s[i].charAt(j) - '0'));
 
        // Add indices of all the strings in the set
        // that contain maximal digit
        for (int i = 0; i < n; i++)
            if (s[i].charAt(j) - '0' == mx)
                ind.add(i);
    }
 
    // Return number of strings in the set
    return ind.size();
}
 
// Driver code
public static void main(String[] args)
{
    String s[] = { "223", "232", "112" };
    int m = s[0].length();
    int n = s.length;
    System.out.println(countStrings(n, m, s));
}
}
 
// This code has been contributed by 29AjayKumar

# Python3 implementation of the approach
 
# Function to return the count of
# valid strings
def countStrings(n, m, s):
 
    # Set to store indices of
    # valid strings
    ind = dict()
    for j in range(m):
        mx = 0
 
        str1 = s[j]
 
        # Find the maximum digit for
        # current position
        for i in range(n):
            mx = max(mx, int(str1[i]))
 
        # Add indices of all the strings in
        # the set that contain maximal digit
        for i in range(n):
            if int(str1[i]) == mx:
                ind[i] = 1
     
    # Return number of strings
    # in the set
    return len(ind)
 
# Driver code
s = ["223", "232", "112"]
m = len(s[0])
n = len(s)
print(countStrings(n, m, s))
 
# This code is contributed
# by Mohit Kumar

// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GfG
{
 
// Function to return the count of valid strings
static int countStrings(int n, int m, String[] s)
{
 
    // Set to store indices of valid strings
    HashSet<int> ind = new HashSet<int>();
    for (int j = 0; j < m; j++)
    {
        int mx = 0;
 
        // Find the maximum digit for current position
        for (int i = 0; i < n; i++)
            mx = Math.Max(mx, (int)(s[i][j] - '0'));
 
        // Add indices of all the strings in the set
        // that contain maximal digit
        for (int i = 0; i < n; i++)
            if (s[i][j] - '0' == mx)
                ind.Add(i);
    }
 
    // Return number of strings in the set
    return ind.Count;
}
 
// Driver code
public static void Main()
{
    String []s = { "223", "232", "112" };
    int m = s[0].Length;
    int n = s.Length;
    Console.WriteLine(countStrings(n, m, s));
}
}
 
/* This code contributed by PrinciRaj1992 */

<script>
 
// JavaScript implementation of the approach
 
// Function to return the count of valid strings
function countStrings(n,m,s)
{
    // Set to store indices of valid strings
    let ind = new Set();
    for (let j = 0; j < m; j++)
    {
        let mx = 0;
   
        // Find the maximum digit for current position
        for (let i = 0; i < n; i++)
            mx = Math.max(mx, (s[i][j].charCodeAt(0) -
            '0'.charCodeAt(0)));
   
        // Add indices of all the strings in the set
        // that contain maximal digit
        for (let i = 0; i < n; i++)
            if (s[i][j].charCodeAt(0) - '0'.charCodeAt(0) == mx)
                ind.add(i);
    }
   
    // Return number of strings in the set
    return ind.size;
}
 
// Driver code
let s=[ "223", "232", "112"];
let m = s[0].length;
let n = s.length;
document.write(countStrings(n, m, s));
 
// This code is contributed by patel2127
 
</script>

2

Complejidad de tiempo: O(N * M) donde N es el número de strings y M es la longitud de las strings.