Даны две последовательности. Верно ли, что все члены второй последовательности входят в первую?

bool func(int *a, int *b, int m,int n)
{
 int i,j;
if(n>m)
  return false;
for(i=0;i<n;i++)
 {
  for(j=0;j<m;j++)
  {
     if(a[j]==b[i])
       break;
   }
  if(j==m)
    return false;
}
return true;
}

#include <algorithm>
#include <iostream>
 
using namespace std;
 
int main() 
{
  int A[] = { 1, 2, 3, 4, 5 };
  int B[] = { 4, 5, 6 };
  const size_t NA = sizeof A / sizeof *A;
  const size_t NB = sizeof B / sizeof *B;
 
  sort(A, A + NA);
  sort(B, B + NB);
 
  int C[NB];
  cout << (set_difference(B, B + NB, A, A + NA, C) == C ? "входят" : "не входят") << endl;
}

#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;
 
int main()
{
    int *a,*b,n,m;
    bool Z;
    cout<<"Vvedite n i m:\n";
    cin>>n>>m;
    a=new int[n];
    b=new int[m];
    cout<<"Vvedite N:\n";
    {for(int i=0;i<n;i++)
    cin>>a[i];}
    cout<<"Vvedite M:\n";
for(int i=0;i<m;i++)
    cin>>b[i];
for(int j=0;j<m;j++)
    {
for(int i=0;i<m;i++)
{if(b[j]==a[i])
    Z=1;
}
if(Z==0)
 cout<<"Net ";
 else
    cout<<"Da";
}
 
return 0;
   }

#include <iostream>
#include <functional>
#include <algorithm>
#include <unordered_set>
 
using namespace std;
using namespace std::placeholders;
 
int main() 
{
  int A[] = { 1, 2, 3, 4, 5 };
  int B[] = { 4, 5, 6 };
  const size_t NA = sizeof A / sizeof *A;
  const size_t NB = sizeof B / sizeof *B;
 
  typedef unordered_set<int> Set;
  Set s(B, B + NB);
 
  Set::size_type (Set::*erase)(const Set::key_type&) = &Set::erase;
  for_each(A, A + NA, bind(erase, &s, _1));
 
  cout << (s.empty() ? "входят" : "не входят") << endl;
}

#include <algorithm>
#include <iostream>
#include <set>
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    for(;;)
    {
        std::locale::global(std::locale(""));
        int A[] = { 1, 2, 3, 4, 5 };
        int B[] = { 4, 5, 5 + rand() % 2 };
        const size_t NA = sizeof A / sizeof *A;
        const size_t NB = sizeof B / sizeof *B;
        std::set<int>   s( B, B + NB );
        std::cout   <<  (
                            std::includes
                                (
                                    A,
                                    A + NA,
                                    s.begin     (),
                                    s.end       ()
                                )
                                ?   "входят"
                                :   "не входят"
                        )
                    << std::endl;
        system("pause");
    }//for
}