Comprobar si la suma de dos palabras es igual a la palabra objetivo

Dadas tres strings A , B y C de tamaño L, M y N respectivamente y que consisten solo en alfabetos ingleses en minúsculas menores que ‘K’. La tarea es verificar si la suma de las strings A y B es igual a la string C después de decodificar las strings en números enteros asignando alfabetos con su valor de índice en la lista de alfabetos y concatenándolos.

Ejemplos:

Entrada: A = “acb”, B = “cba”, C = “cdb”
Salida: Sí
Explicación:

1. La string A se modifica al número entero 021 después de reemplazar los caracteres ‘a’, ‘b’ y ‘c’ con sus valores de índice en la lista de alfabetos, es decir, 0, 1 y 2.
2. La string B se modifica al número entero 210 después de reemplazar los caracteres ‘a’, ‘b’ y ‘c’ con sus valores de índice en la lista de alfabetos, es decir, 0, 1 y 2.
3. La string C se modifica al número entero 231 después de reemplazar los caracteres ‘b’, ‘c’ y ‘d’ con sus valores de índice en la lista de alfabetos, es decir, 1, 2 y 3.

La suma de las strings A y B, es decir (21+210 = 231) es igual a 231, que es el valor de la string C. Por lo tanto, imprime «Sí».

Entrada: A = “aaa”, B = “bcb”, C = “bca”
Salida: No

Enfoque: el problema se puede resolver utilizando un enfoque similar al utilizado para encontrar la suma de dos números grandes representados como strings . Siga los pasos a continuación para resolver el problema:

• Invierta las strings A , B y C .
• Inicialice dos variables, digamos curr y rem como 0 para almacenar el valor en la i ^-ésima posición y el resto de la suma de las strings A y B.
• Iterar sobre el rango [0, max(L, max(M, N))] usando la variable i y realizando los siguientes pasos:
  • Almacene la suma de caracteres en el i ^-ésimo índice de las strings A y B en la variable curr .
  • Actualice curr como curr = curr+rem y luego actualice rem como rem = curr/10.
  • Ahora verifique si i es menor que N y curr%10 no es igual al valor C[i]-‘a’ ie en el i ^-ésimo carácter de la string C , luego imprima “ No ” y regrese .
• Finalmente, después de completar los pasos anteriores, si rem es mayor que 0 , imprima » No «. De lo contrario, escriba “ Sí ”.

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 whether summation
// of two words equal to target word
string isSumEqual(string A, string B, string C)
{
 
    // Store the length of each string
    int L = A.length();
    int M = B.length();
    int N = A.length();
 
    // Reverse the strings A, B and C
    reverse(A.begin(), A.end());
    reverse(B.begin(), B.end());
    reverse(C.begin(), C.end());
 
    // Stores the remainder
    int rem = 0;
 
    // Iterate in the range
    // [0, max(L, max(M, N))]
    for (int i = 0; i < max(L, max(M, N)); i++) {
 
        // Stores the integer at ith
        // position from the right in
        // the sum of A and B
        int curr = rem;
 
        // If i is less than L
        if (i < L)
            curr += A[i] - 'a';
 
        // If i is less than M
        if (i < M)
            curr += B[i] - 'a';
 
        // Update rem and curr
        rem = curr / 10;
        curr %= 10;
 
        // If i is less than N
        // and curr is not equal
        // to C[i]-'a', return "No"
        if (i < N && curr != C[i] - 'a') {
            return "No";
        }
    }
 
    // If rem is greater
    // than 0, return "No"
    if (rem)
        return "No";
 
    // Otherwise, return "Yes"
    else
        return "Yes";
}
 
// Driver Code
int main()
{
 
    // Given Input
    string A = "acb", B = "cba", C = "cdb";
 
    // Function Call
    cout << isSumEqual(A, B, C);
 
    return 0;
}

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to check whether summation
// of two words equal to target word
static String isSumEqual(String A, String B, String C)
{
 
    // Store the length of each String
    int L = A.length();
    int M = B.length();
    int N = A.length();
 
    // Reverse the Strings A, B and C
    A = reverse(A);
    B = reverse(B);
    C = reverse(C);
 
    // Stores the remainder
    int rem = 0;
 
    // Iterate in the range
    // [0, Math.max(L, Math.max(M, N))]
    for (int i = 0; i < Math.max(L, Math.max(M, N)); i++) {
 
        // Stores the integer at ith
        // position from the right in
        // the sum of A and B
        int curr = rem;
 
        // If i is less than L
        if (i < L)
            curr += A.charAt(i) - 'a';
 
        // If i is less than M
        if (i < M)
            curr += B.charAt(i) - 'a';
 
        // Update rem and curr
        rem = curr / 10;
        curr %= 10;
 
        // If i is less than N
        // and curr is not equal
        // to C[i]-'a', return "No"
        if (i < N && curr != C.charAt(i) - 'a') {
            return "No";
        }
    }
 
    // If rem is greater
    // than 0, return "No"
    if (rem>0)
        return "No";
 
    // Otherwise, return "Yes"
    else
        return "Yes";
}
static String reverse(String input) {
    char[] a = input.toCharArray();
    int l, r = a.length - 1;
    for (l = 0; l < r; l++, r--) {
        char temp = a[l];
        a[l] = a[r];
        a[r] = temp;
    }
    return String.valueOf(a);
}
   
// Driver Code
public static void main(String[] args)
{
 
    // Given Input
    String A = "acb", B = "cba", C = "cdb";
 
    // Function Call
    System.out.print(isSumEqual(A, B, C));
}
}
 
// This code is contributed by 29AjayKumar

# Python3 program for the above approach
 
# Function to check whether summation
# of two words equal to target word
def isSumEqual(A, B, C):
 
    # Store the length of each string
    L = len(A)
    M = len(B)
    N = len(A)
 
    # Reverse the strings A, B and C
    A = A[::-1]
    B = B[::-1]
    C = C[::-1]
 
    # Stores the remainder
    rem = 0
 
    # Iterate in the range
    # [0, max(L, max(M, N))]
    for i in range(max(L, max(M, N))):
 
        # Stores the integer at ith
        # position from the right in
        # the sum of A and B
        curr = rem
 
        # If i is less than L
        if (i < L):
            curr += ord(A[i]) - ord('a')
 
        # If i is less than M
        if (i < M):
            curr += ord(B[i]) - ord('a')
 
        # Update rem and curr
        rem = curr // 10
        curr %= 10
 
        # If i is less than N
        # and curr is not equal
        # to C[i]-'a', return "No"
        if (i < N and curr != ord(C[i]) - ord('a')):
            return "No"
 
    # If rem is greater
    # than 0, return "No"
    if (rem):
        return "No"
       
    # Otherwise, return "Yes"
    else:
        return "Yes"
 
# Driver Code
if __name__ == '__main__':
   
    # Given Input
    A = "acb"
    B = "cba"
    C = "cdb"
 
    # Function Call
    print (isSumEqual(A, B, C))
 
    # This code is contributed by mohit kumar 29.

// C# program for the above approach
using System;
 
public class GFG{
 
// Function to check whether summation
// of two words equal to target word
static String isSumEqual(String A, String B, String C)
{
 
    // Store the length of each String
    int L = A.Length;
    int M = B.Length;
    int N = A.Length;
 
    // Reverse the Strings A, B and C
    A = reverse(A);
    B = reverse(B);
    C = reverse(C);
 
    // Stores the remainder
    int rem = 0;
 
    // Iterate in the range
    // [0, Math.Max(L, Math.Max(M, N))]
    for (int i = 0; i < Math.Max(L, Math.Max(M, N)); i++) {
 
        // Stores the integer at ith
        // position from the right in
        // the sum of A and B
        int curr = rem;
 
        // If i is less than L
        if (i < L)
            curr += A[i] - 'a';
 
        // If i is less than M
        if (i < M)
            curr += B[i] - 'a';
 
        // Update rem and curr
        rem = curr / 10;
        curr %= 10;
 
        // If i is less than N
        // and curr is not equal
        // to C[i]-'a', return "No"
        if (i < N && curr != C[i] - 'a') {
            return "No";
        }
    }
 
    // If rem is greater
    // than 0, return "No"
    if (rem>0)
        return "No";
 
    // Otherwise, return "Yes"
    else
        return "Yes";
}
static String reverse(String input) {
    char[] a = input.ToCharArray();
    int l, r = a.Length - 1;
    for (l = 0; l < r; l++, r--) {
        char temp = a[l];
        a[l] = a[r];
        a[r] = temp;
    }
    return String.Join("",a);
}
   
// Driver Code
public static void Main(String[] args)
{
 
    // Given Input
    String A = "acb", B = "cba", C = "cdb";
 
    // Function Call
    Console.Write(isSumEqual(A, B, C));
}
}
 
// This code is contributed by 29AjayKumar

<script>
 
// JavaScript program for the above approach
 
 
// Function to check whether summation
// of two words equal to target word
function isSumEqual(A, B, C) {
 
    // Store the length of each string
    let L = A.length;
    let M = B.length;
    let N = A.length;
 
    // Reverse the strings A, B and C
    A.split("").reverse().join("");
    B.split("").reverse().join("");
    C.split("").reverse().join("");
 
    // Stores the remainder
    let rem = 0;
 
    // Iterate in the range
    // [0, max(L, max(M, N))]
    for (let i = 0; i < Math.max(L, Math.max(M, N)); i++) {
 
        // Stores the integer at ith
        // position from the right in
        // the sum of A and B
        let curr = rem;
 
        // If i is less than L
        if (i < L)
            curr += A[i].charCodeAt(0) - 'a'.charCodeAt(0);
 
        // If i is less than M
        if (i < M)
            curr += B[i].charCodeAt(0) - 'a'.charCodeAt(0);
 
        // Update rem and curr
        rem = Math.floor(curr / 10);
        curr %= 10;
 
        // If i is less than N
        // and curr is not equal
        // to C[i]-'a', return "No"
        if (i < N && curr != C[i].charCodeAt(0) -
        'a'.charCodeAt(0)) {
            return "No";
        }
    }
 
    // If rem is greater
    // than 0, return "No"
    if (rem)
        return "No";
 
    // Otherwise, return "Yes"
    else
        return "Yes";
}
 
// Driver Code
 
// Given Input
let A = "acb", B = "cba", C = "cdb";
 
// Function Call
document.write(isSumEqual(A, B, C));
 
</script>

Yes

Complejidad temporal: O(L+M+N)
Espacio auxiliar: O(1)