Compruebe si la segunda string se puede formar a partir de los caracteres de la primera string utilizados cualquier número de veces

Dadas dos strings str1 de tamaño N y str2 de tamaño M. La tarea es encontrar si es posible componer str2 usando solo los caracteres de str1 de modo que cada carácter de str1 se pueda usar cualquier cantidad de veces. 
Nota: Las minúsculas y las mayúsculas deben considerarse diferentes. 
 

Ejemplos: 
 

Entrada: str1 = «El rápido zorro marrón salta», str2 = «el zorro fue más rápido que el perro» 
Salida: No 
Explicación: 
En str2 , hay un carácter d , que no está presente en str1 . Entonces, es imposible hacer la string str2 de str1 
 

Entrada: str1 = «a todos nos encantan los geeksforgeeks», str2 = «a todos nos encantan los geeks» 
Salida: Sí 
 

Enfoque ingenuo: el enfoque más simple es buscar cada carácter de str2 en str1 . Si se encuentran todos los caracteres, imprima «Sí». De lo contrario, escriba «No». 
 

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

Enfoque eficiente: la idea es marcar la presencia de todos los caracteres de str1 en una array count[] . Luego, recorra str2 y verifique si los caracteres de str2 están presentes en str1 o no. 
 

1. Haga una array count[] de tamaño 256 (número total de caracteres ASCII ) y configúrela en cero.
2. Luego itere sobre str1 y haga count[str[i]] = 1 para marcar la aparición de cada carácter.
3. Itere sobre str2 y verifique si ese carácter está presente en str1 o no usa la array count [] .

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

// C++ implementation of
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if
// str2 can be made by characters
// of str1 or not
void isPossible(string str1, string str2)
{
    // To store the
    // occurrence of every
    // character
    int arr[256] = { 0 };
 
    // Length of the two
    // strings
    int l1 = str1.size();
    int l2 = str2.size();
 
    int i, j;
 
    // Assume that it is
    // possible to compose the
    // string str2 from str1
    bool possible = true;
 
    // Iterate over str1
    for (i = 0; i < l1; i++) {
        // Store the presence of every
        // character
        arr[str1[i]] = 1;
    }
 
    // Iterate over str2
    for (i = 0; i < l2; i++) {
 
        // Ignore the spaces
        if (str2[i] != ' ') {
 
            // Check for the presence
            // of character in str1
            if (arr[str2[i]] == 1)
                continue;
 
            else {
                possible = false;
                break;
            }
        }
    }
 
    // If it is possible to make
    // str2 from str1
    if (possible) {
        cout << "Yes" << endl;
    }
    else {
        cout << "No" << endl;
    }
}
 
// Driver Code
int main()
{
    // Given strings
    string str1 = "we all love geeksforgeeks";
    string str2 = "we all love geeks";
 
    // Function Call
    isPossible(str1, str2);
    return 0;
}

// Java implementation of
// the above approach
 
import java.util.Arrays;
 
class GFG {
 
    // Function to check if
    // str2 can be made by characters
    // of str1 or not
    public static void isPossible(String str1, String str2) {
        // To store the
        // occurrence of every
        // character
        int arr[] = new int[256];
 
        Arrays.fill(arr, 0);
        // Length of the two
        // strings
        int l1 = str1.length();
        int l2 = str2.length();
 
        int i, j;
 
        // Assume that it is
        // possible to compose the
        // string str2 from str1
        boolean possible = true;
 
        // Iterate over str1
        for (i = 0; i < l1; i++) {
            // Store the presence of every
            // character
            arr[str1.charAt(i)] = 1;
        }
 
        // Iterate over str2
        for (i = 0; i < l2; i++) {
 
            // Ignore the spaces
            if (str2.charAt(i) != ' ') {
 
                // Check for the presence
                // of character in str1
                if (arr[str2.charAt(i)] == 1)
                    continue;
 
                else {
                    possible = false;
                    break;
                }
            }
        }
 
        // If it is possible to make
        // str2 from str1
        if (possible) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }
    }
 
    // Driver Code
    public static void main(String args[])
    {
        // Given strings
        String str1 = "we all love geeksforgeeks";
        String str2 = "we all love geeks";
 
        // Function Call
        isPossible(str1, str2);
 
    }
 
}
 
// This code is contributed by saurabh_jaiswal.

// C# implementation of
// the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to check if
// str2 can be made by characters
// of str1 or not
static void isPossible(string str1, string str2)
{
   
    // To store the
    // occurrence of every
    // character
    int []arr = new int[256];
    Array.Clear(arr,0,256);
 
    // Length of the two
    // strings
    int l1 = str1.Length;
    int l2 = str2.Length;
 
    int i;
 
    // Assume that it is
    // possible to compose the
    // string str2 from str1
    bool possible = true;
 
    // Iterate over str1
    for (i = 0; i < l1; i++) {
        // Store the presence of every
        // character
        arr[str1[i]] = 1;
    }
 
    // Iterate over str2
    for (i = 0; i < l2; i++) {
 
        // Ignore the spaces
        if (str2[i] != ' ') {
 
            // Check for the presence
            // of character in str1
            if (arr[str2[i]] == 1)
                continue;
 
            else {
                possible = false;
                break;
            }
        }
    }
 
    // If it is possible to make
    // str2 from str1
    if (possible) {
        Console.Write("Yes");
    }
    else {
        Console.Write("No");
    }
}
 
// Driver Code
public static void Main()
{
    // Given strings
    string str1 = "we all love geeksforgeeks";
    string str2 = "we all love geeks";
 
    // Function Call
    isPossible(str1, str2);
}
}
 
// This code is contributed by ipg2016107.

# Python3 implementation of
# the above approach
 
# Function to check if
# str2 can be made by characters
# of str1 or not
def isPossible(str1, str2):
   
      # To store the
    # occurrence of every
    # character
    arr = {}
     
    # Length of the two
    # strings
    l1 = len(str1)
    l2 = len(str2)
     
        # Assume that it is
    # possible to compose the
    # string str2 from str1
    possible = True
     
        # Iterate over str1
    for i in range(l1):
       
      # Store the presence or every element
        arr[str1[i]] = 1
         
        # Iterate over str2
    for i in range(l2):
       
      # Ignore the spaces
        if str2[i] != ' ':
           
              # Check for the presence
           # of character in str1
            if arr[str2[i]] == 1:
                continue
            else:
                possible = False
                break
                 
     # If it is possible to make
    # str2 from str1          
    if possible:
        print("Yes")
    else:
        print("No")
 
 
# Driver code
str1 = "we all love geeksforgeeks"
str2 = "we all love geeks"
 
# Function call.
isPossible(str1, str2)
 
# This code is contributed by Parth Manchanda

<script>
 
// JavaScript implementation of
// the above approach
 
// Function to check if
// str2 can be made by characters
// of str1 or not
function isPossible(str1, str2) {
  // To store the
  // occurrence of every
  // character
  let arr = new Array(256).fill(0);
 
  // Length of the two
  // strings
  let l1 = str1.length;
  let l2 = str2.length;
 
  let i, j;
 
  // Assume that it is
  // possible to compose the
  // string str2 from str1
  let possible = true;
 
  // Iterate over str1
  for (i = 0; i < l1; i++) {
    // Store the presence of every
    // character
    arr[str1[i]] = 1;
  }
 
  // Iterate over str2
  for (i = 0; i < l2; i++) {
    // Ignore the spaces
    if (str2[i] != " ") {
      // Check for the presence
      // of character in str1
      if (arr[str2[i]] == 1) continue;
      else {
        possible = false;
        break;
      }
    }
  }
 
  // If it is possible to make
  // str2 from str1
  if (possible) {
    document.write("Yes<br>");
  } else {
    document.write("No<br>");
  }
}
 
// Driver Code
 
// Given strings
let str1 = "we all love geeksforgeeks";
let str2 = "we all love geeks";
 
// Function Call
isPossible(str1, str2);
 
</script>

Yes

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