Recuento de strings posibles reemplazando consonantes con la vocal más cercana

Dada una string str que consta de N letras, la tarea es encontrar el número total de strings que se pueden generar reemplazando cada consonante con la vocal más cercana a ella en el alfabeto inglés.

Ejemplos:

Entrada: str = “código”
Salida: 2
Explicación: Str = “ c o d e” tiene dos consonantes c y d. 
La vocal más cercana a d es e y la más cercana a c son a y e .
Las strings posibles son “ aoee ” y “ eoee ”

Entrada: str = «geeks»
Salida: 2

Planteamiento: El problema se puede resolver con base en la siguiente observación:

Hay un total de 21 consonantes en las que ‘c’, ‘g’, ‘l’ y ‘r’ son consonantes que están más cerca de dos vocales. 
Entonces, solo estas consonantes tienen 2 opciones y las restantes tienen una opción cada una.
Por lo tanto, el número total de strings posibles = el producto del número de opciones para cada consonante.

Siga los pasos mencionados a continuación para implementar la observación:

• Inicialice una variable (digamos res = 1 ) para almacenar el número de strings posibles.
• Iterar a través de la string de i = 0 a N :
  • Si el carácter es una de las cuatro consonantes especiales mencionadas anteriormente, entonces tiene dos opciones. Así que multiplica 2 con res .
  • De lo contrario, multiplique 1 con el valor de res .
• El valor final de res es la respuesta requerida.

A continuación se muestra la implementación del enfoque anterior:

// C++ code to implement the approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the total number of
// distinct beautiful strings
int uniqueString(string str)
{
    long long int res = 1;
    for (int i = 0; i < str.length(); i++) {
        if (str[i] == 'c' || str[i] == 'g'
            || str[i] == 'l' || str[i] == 'r') {
            res = res * 2;
        }
    }
 
    // Return res as which is
    // total number of possible strings
    return res;
}
 
// Driver code
int main()
{
    string str = "code";
 
    // Function call
    cout << (uniqueString(str));
    return 0;
}

// java code to implement the approach
 
import java.io.*;
 
class GFG {
    // Function to find the total number of distinct beautiful strings
    public static int beautyString(String str)
    {
        char alpha[]
            = str.toCharArray(); // converting string into
        // array
        int res = 1, count = 0;
        // count for character 'c', 'g', 'l' and 'r'
        for (int i = 0; i < str.length(); i++) {
            if (alpha[i] == 'c' || alpha[i] == 'g'
                || alpha[i] == 'l' || alpha[i] == 'r') {
                count++;
                res = res * 2;
            }
        }
        return res;
    }
    // Driver Code
    public static void main(String[] args)
    {
        String str = "code";
        // Function Call
        System.out.println(beautyString(str));
    }
}

# Python code to implement the approach
 
# Function to find the total number of
# distinct beautiful strings
def uniqueString(s):
    res = 1
    for i in range(len(s)):
        if s[i] == 'c' or s[i] == 'g' or s[i] == 'l' or s[i] == 'r':
            res = res * 2
 
    # Return res as which is
    # total number of possible strings
    return res
 
# Driver code
if __name__ == "__main__":
    s = "code"
     
    # Function call
    print(uniqueString(s))
 
# This code is contributed by Rohit Pradhan

// C# code to implement the above approach
using System;
 
public class GFG {
 
  // Function to find the total number of distinct beautiful strings
  public static int beautyString(string str)
  {
    char []alpha = str.ToCharArray(); // converting string into
    // array
    int res = 1, count = 0;
 
    // count for character 'c', 'g', 'l' and 'r'
    for (int i = 0; i < str.Length; i++) {
      if (alpha[i] == 'c' || alpha[i] == 'g'
          || alpha[i] == 'l' || alpha[i] == 'r') {
        count++;
        res = res * 2;
      }
    }
    return res;
  }
 
  // Driver Code
  public static void Main(string[] args)
  {
    string str = "code";
 
    // Function Call
    Console.WriteLine(beautyString(str));
  }
}
 
// This code is contributed by AnkThon

<script>
// javascript code to implement the above approach
 
// Function to find the total number of
// distinct beautiful strings
function uniqueString(s){
    let res = 1
    for (let i = 0; i < s.length; i++){
        if (s[i] == 'c' | s[i] == 'g' | s[i] == 'l' | s[i] == 'r')
            res = res * 2
}
    // Return res as which is
    // total number of possible strings
    return res
     
}
 
// Driver code
let s = "code"
 
// Function call
document.write(uniqueString(s))
 
// This code is contributed by AnkThon
</script>

2

Complejidad temporal: O(N)
Espacio auxiliar: O(1)