Comprobar si todos los caracteres de una string se pueden igualar mediante incrementos o decrementos

Dada una string S que consta de N alfabetos en minúsculas, la tarea es verificar si es posible hacer que todos los caracteres de la string S sean iguales aumentando y disminuyendo dos caracteres cualesquiera de la string dada en 1 . Si es posible hacer que todos los caracteres sean iguales, imprima «Sí» . De lo contrario, escriba “No” .

Incrementar o disminuir cualquier carácter significa que cambia los caracteres a su siguiente o anterior carácter en el alfabeto inglés, respectivamente. Si los caracteres son ‘a’ y ‘z’ , no se pueden cambiar más.

Ejemplos:

Entrada: S = “beb”
Salida: Sí
Explicación:
Los caracteres de la string dada S pueden igualarse realizando las siguientes operaciones:

• Para la string «beb», incremente ‘b’ en 1 y disminuya ‘e’ en 1, luego la string se convierte en «cdb».
• Para la string «cdb», disminuya ‘d’ en 1 e incremente ‘b’ en 1, luego la string se convierte en «ccc».

Entrada: S = «geeks»
Salida: No

Enfoque: El problema dado se puede resolver en base a las siguientes observaciones:

• Mientras aumenta y disminuye cualquier carácter en 1 al mismo tiempo, la suma de los valores ASCII de la string permanece igual antes y después de la operación.
• Supongamos que el valor ASCII de cualquier carácter es X . Si todos los caracteres son iguales, la suma del valor ASCII de la string es N*X . Por lo tanto , se puede decir que la suma es divisible por N. Por lo tanto, la suma inicial del valor ASCII debe ser divisible por N para que todos los caracteres sean iguales.

Siga los pasos a continuación para resolver este problema:

• Inicializa una suma variable , que almacena la suma del valor ASCII de la string dada .
• Recorra la string dada S y para cada carácter S[i] agregue el valor de (S[i] – ‘a’ + 1) a la suma .
• Después de completar los pasos anteriores, si el valor de sum es divisible por N , todos los caracteres de la string dada pueden igualarse. Por lo tanto, imprima “Sí” . De lo contrario, escriba “No” .

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

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if it is
// possible to make all characters
// of string S same or not
void canMakeEqual(string S)
{
    // Length of string
    int N = S.size();
 
    // Stores the sum of ASCII value
    int weightOfString = 0;
 
    // Traverse the string S
    for (int i = 0; i < N; i++) {
 
        // Update the weightOfString
        weightOfString += S[i] - 'a' + 1;
    }
 
    // If the sum is divisible by N
    // then print "Yes"
    if (weightOfString % N == 0)
        cout << "Yes";
 
    // Otherwise print "No"
    else
        cout << "No";
}
 
// Driver Code
int main()
{
    string S = "beb";
    canMakeEqual(S);
 
    return 0;
}

// Java program for the above approach
import java.io.*;
 
class GFG {
  
// Function to check if it is
// possible to make all characters
// of string S same or not
static void canMakeEqual(String S){
   // Length of string
    int N = S.length();
 
    // Stores the sum of ASCII value
    int weightOfString = 0;
 
    // Traverse the string S
    for (int i = 0; i < N; i++) {
 
        // Update the weightOfString
        weightOfString += S.charAt(i) - 'a' + 1;
    }
 
    // If the sum is divisible by N
    // then print "Yes"
    if (weightOfString % N == 0)
        System.out.println("Yes");
 
    // Otherwise print "No"
    else
        System.out.println("No");
}
   
  // Driver Code
    public static void main (String[] args) {
            String S = "beb";
               canMakeEqual(S);
    }
}
 
// This code is contributed by aadityaburujwale

# Python3 program for the above approach
 
# Function to check if it is
# possible to make all characters
# of string S same or not
def canMakeEqual(S):
     
    # Length of string
    N = len(S)
  
    # Stores the sum of ASCII value
    weightOfString = 0
  
    # Traverse the string S
    for i in range(N):
  
        # Update the weightOfString
        weightOfString += ord(S[i]) - ord('a') + 1
     
    # If the sum is divisible by N
    # then print "Yes"
    if (weightOfString % N == 0):
        print("Yes")
  
    # Otherwise print "No"
    else:
        print("No")
 
# Driver Code
S = "beb"
canMakeEqual(S)
 
# This code is contributed by susmitakundugoaldanga

// C# program for the above approach
using System;
 
class GFG{
  
// Function to check if it is
// possible to make all characters
// of string S same or not
static void canMakeEqual(String S)
{
     
    // Length of string
    int N = S.Length;
 
    // Stores the sum of ASCII value
    int weightOfString = 0;
 
    // Traverse the string S
    for(int i = 0; i < N; i++)
    {
         
        // Update the weightOfString
        weightOfString += S[i] - 'a' + 1;
    }
 
    // If the sum is divisible by N
    // then print "Yes"
    if (weightOfString % N == 0)
        Console.WriteLine("Yes");
 
    // Otherwise print "No"
    else
        Console.WriteLine("No");
}
   
// Driver Code
public static void Main(String[] args)
{
    String S = "beb";
    canMakeEqual(S);
}
}
 
// This code is contributed by shikhasingrajput

<script>
 
// Javascript program for the above approach
 
// Function to check if it is
// possible to make all characters
// of string S same or not
function canMakeEqual(S){
   // Length of string
    var N = S.length;
 
    // Stores the sum of ASCII value
    var weightOfString = 0;
 
    // Traverse the string S
    for (var i = 0; i < N; i++) {
 
        // Update the weightOfString
        weightOfString += S.charAt(i).charCodeAt(0) -
        'a'.charCodeAt(0) + 1;
    }
 
    // If the sum is divisible by N
    // then print "Yes"
    if (weightOfString % N == 0)
        document.write("Yes");
 
    // Otherwise print "No"
    else
        document.write("No");
}
   
// Driver Code
var S = "beb";
canMakeEqual(S);
 
// This code contributed by Princi Singh
 
</script>

Yes

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