Быстрый поиск супернатуральных чисел

long count=0;
long num[8];
double res=0;
for(i=2;i<10;i++)
{ 
 num[i-2]=0;
 while((n>1)&&(n%i==0))
  {
   n/=i;
   num[i-2]++;
   count++;
  }
  (num[i-2]>1)?res+=fact(num[i-2]);
}
if (n==1) 
 {
   res=fact(count)-res;
 }
else res=0;

#include <cstdlib>
#include <iostream>
 
using namespace std;
typedef unsigned long DWORD;
 
double *facttable=NULL;
double *facttable2=NULL;
DWORD nums[8];
DWORD countn=0;
double rescomb=0;
 
void initfact(DWORD n)
{
     facttable=new double[n+1];
     facttable2=new double[n+1];
     facttable[0]=1;
     facttable[1]=1;
     facttable2[0]=0;
     facttable2[1]=0;
     for (DWORD i=2;i<=n;i++)
     {
         facttable[i]=facttable[i-1]*i;
         facttable2[i]=facttable[i];
     }
}
 
bool getnums(DWORD n)
{
    rescomb=0;
    countn=0;     
    if (n<2) return 0;
    cout <<"num\tcount"<<endl;;
    for(char i=2,j=0;i<10;i++,j++)
    {
       nums[j]=0;      
       while ((n>1)&&(!(n%i))) 
       {
          n/=i;
          nums[j]++;
          countn++;
       }
       cout<<(char)(48+i)<<"\t"<<nums[j]<<endl;
    }
    cout<<"ostatok = "<<n<<endl;
    if (n!=1) return 0;
    initfact(countn);
    double res=0;
    for (char i=0;i<8;i++) res+=facttable2[nums[i]];
    rescomb=res;
    return 1;
 }
 
void changenums(char inum, long delta)
{
       rescomb-=facttable2[nums[inum]];
       countn+=delta;
       nums[inum]+=delta;
       rescomb+=facttable2[nums[inum]];
}
 
double all4()
{
       double res=0;
       if (nums[0]<2) return res;
       DWORD max4=nums[0]/2;
       for (DWORD i=0;i<max4;i++)
       {
           changenums(0,-2);
           changenums(2,1);
           res+=(facttable[countn]-rescomb);
       }
       changenums(2,(-1)*max4);
       changenums(0,2*max4);
       return res;     
 } 
 
double all8and4()
{
       double res=all4();
       cout<<"4 returned "<<res<<endl;
       if (nums[0]<3) return res;
       DWORD max8=nums[0]/3;
       for (DWORD i=0;i<max8;i++)
       {
           changenums(0,-3);
           changenums(6,1);
           res+=(facttable[countn]-rescomb);
       }
       changenums(6,(-1)*max8);
       changenums(0,3*max8);
       return res;     
 } 
 
double all9and8and4()
{
       double res=all8and4();
       cout<<"84 returned "<<res<<endl;
       if (nums[1]<3) return res;
       DWORD max9=nums[1]/3;
       for (DWORD i=0;i<max9;i++)
       {
           changenums(1,-3);
           changenums(7,1);
           res+=(facttable[countn]-rescomb);
       }
       changenums(7,(-1)*max9);
       changenums(1,3*max9);
       return res;     
 } 
 
double all6and9and8and4()
{
       double res=all9and8and4();
       cout<<"984 returned "<<res<<endl;
       if ((nums[0]<1)||(nums[1]<1)) return res;
       DWORD max6=(nums[0]<nums[1])?nums[0]:nums[1];
       for (DWORD i=0;i<max6;i++)
       {
           changenums(0,-1);
           changenums(1,-1);
           changenums(4,1);
           res+=(facttable[countn]-rescomb);
       }
       changenums(4,(-1)*max6);
       changenums(1,max6);
       changenums(0,max6);
       cout<<"6984 returned "<<res<<endl;
       return res;     
 } 
 
 
 
 
int main(int argc, char *argv[])
{
    DWORD n=0;
    cout<<"n=";
    cin>>n;
    if(getnums(n)) 
    {
         double result=facttable[countn]-rescomb;
         if (result<1) result=1;
         cout<<"rescomb="<<result<<endl;
         result+=all6and9and8and4();
         cout<<n<<" imeet "<<result<<" supernaturalnih chisel"<<endl;;
    }
    else
    {
        cout<<n<<" ne imeet supernaturalnih chisel"<<endl;
    }
    system("PAUSE");
    if (facttable)
    {
       delete[] facttable;
       delete[] facttable2;
    }
    return EXIT_SUCCESS;
}

#include <cstdio>
#include <map>
using namespace std;
 
typedef char byte;
typedef map< int, byte > mymap;
typedef pair< int, byte > mypair;
 
mymap m;
 
byte calc( int n )
{
    if ( n == 1 ) return 1;
    if ( m.find( n ) != m.end() ) return m[ n ];
 
    int res = 0;
 
    for ( int i = 2, x; i <= 9; ++i )
    {
        x = n / i;
        if ( x * i == n )
        {
            if ( m.find( x ) != m.end() ) res += m[ x ];
            else res += calc( x );
        }
    }
    m.insert( mypair( n, res % 101 ) );
    return m[ n ];
}
 
int main()
{
    int n;
 
    scanf( "%d", &n );
    if ( n == 1 ) printf( "%d\n", 0 );
    else printf( "%d\n", calc( n ) );
 
    return 0;
}

#include <cstdlib>
#include <iostream>
 
using namespace std;
typedef unsigned long DWORD;
 
double *facttable=NULL;
DWORD nums[8];
DWORD countn=0;
double rescomb=0;
 
void initfact(DWORD n)
{
     facttable=new double[n+1];
     facttable[0]=1;
     facttable[1]=1;
     for (DWORD i=2;i<=n;i++) facttable[i]=facttable[i-1]*i;
}
 
bool getnums(DWORD n)
{
    rescomb=0;
    countn=0;     
    if (n<2) return 0;
    cout <<"num\tcount"<<endl;;
    for(char i=2,j=0;i<10;i++,j++)
    {
       nums[j]=0;      
       while ((n>1)&&(!(n%i))) 
       {
          n/=i;
          nums[j]++;
          countn++;
       }
       cout<<(char)(48+i)<<"\t"<<nums[j]<<endl;
    }
    cout<<"ostatok = "<<n<<endl;
    if (n!=1) return 0;
    initfact(countn);
    double res=1;
    for (char i=0;i<8;i++) res*=facttable[nums[i]];
    rescomb=res;
    return 1;
 }
 
void changenums(char inum, long delta)
{
       rescomb/=facttable[nums[inum]];
       countn+=delta;
       nums[inum]+=delta;
       rescomb*=facttable[nums[inum]];
}
 
double all4()
{
       double res=0;
       if (nums[0]<2) return res;
       DWORD max4=nums[0]/2;
       for (DWORD i=0;i<max4;i++)
       {
           changenums(0,-2);
           changenums(2,1);
           if(rescomb)res+=(facttable[countn]/rescomb);
       }
       changenums(2,(-1)*max4);
       changenums(0,2*max4);
       return res;     
 } 
 
double all8and4()
{
       double res=all4();
       cout<<"4 returned "<<res<<endl;
       if (nums[0]<3) return res;
       DWORD max8=nums[0]/3;
       for (DWORD i=0;i<max8;i++)
       {
           changenums(0,-3);
           changenums(6,1);
           if(rescomb)res+=(facttable[countn]/rescomb);
           res+=all4();
       }
       changenums(6,(-1)*max8);
       changenums(0,3*max8);
       return res;     
 } 
 
double all9and8and4()
{
       double res=all8and4();
       cout<<"84 returned "<<res<<endl;
       if (nums[1]<3) return res;
       DWORD max9=nums[1]/3;
       for (DWORD i=0;i<max9;i++)
       {
           changenums(1,-3);
           changenums(7,1);
           if(rescomb)res+=(facttable[countn]/rescomb);
           res+=all8and4();
       }
       changenums(7,(-1)*max9);
       changenums(1,3*max9);
       return res;     
 } 
 
double all6and9and8and4()
{
       double res=all9and8and4();
       cout<<"984 returned "<<res<<endl;
       if ((nums[0]<1)||(nums[1]<1)) return res;
       DWORD max6=(nums[0]<nums[1])?nums[0]:nums[1];
       for (DWORD i=0;i<max6;i++)
       {
           changenums(0,-1);
           changenums(1,-1);
           changenums(4,1);
           if(rescomb)res+=(facttable[countn]/rescomb);
           res+=all9and8and4();
       }
       changenums(4,(-1)*max6);
       changenums(1,max6);
       changenums(0,max6);
       cout<<"6984 returned "<<res<<endl;
       return res;     
 } 
 
 
 
 
int main(int argc, char *argv[])
{
    DWORD n=0;
    cout<<"n=";
    cin>>n;
    if(getnums(n)) 
    {
         double result=facttable[countn];          
         cout<<"rescomb="<<rescomb<<endl;
         if(rescomb)result/=rescomb;
         if (result<1) result=1;
         cout<<"result="<<result<<endl;
         result+=all6and9and8and4();
         cout<<n<<" imeet "<<result<<" supernaturalnih chisel"<<endl;;
    }
    else
    {
        cout<<n<<" ne imeet supernaturalnih chisel"<<endl;
    }
    system("PAUSE");
    if (facttable)
    {
       delete[] facttable;
    }
    return EXIT_SUCCESS;
}

#include <iostream>
using namespace std;
 
struct NaborElem
{
    int value;
    NaborElem *Next;
};
class NaborList
{
private:
    int childNabSize;   
public:
    NaborElem *FirElem;
    NaborList **childNabors; //array
    int countElems;
    NaborList()
    {
        FirElem=NULL;
        childNabors=NULL;
        countElems=0;
        childNabSize=0;
    }
    void addChildNabor(NaborList *nabor)
    {
        if(!childNabors)
        {
            childNabSize=1;
            childNabors=new NaborList*[1];
            childNabors[0]=nabor;
        }
        else
        {
            childNabSize++;
            NaborList **chnabor2=new NaborList*[childNabSize];
            for(int i=0;i<childNabSize-1;i++) chnabor2[i]=childNabors[i];
            chnabor2[childNabSize-1]=nabor;
            delete []childNabors;
            childNabors=chnabor2;
        }
    }
    int* NaborToArray()
    {       
        if(!FirElem) return NULL;
        int *nbArray=new int[countElems];
        int i=0;
        NaborElem *T=FirElem;
        while(T && i<countElems)
        {
            nbArray[i]=T->value;
            i++;
            T=T->Next;
        }
        return nbArray;
    }
    void loadFromArray(int *arr, int arrCount)
    {
        FirElem=new NaborElem;
        FirElem->value=arr[0];
        FirElem->Next=NULL;
        NaborElem *T=FirElem;
        countElems=1;
        for(int i=1;i<arrCount;i++)
        {
            if(arr[i]==0) continue;
            T->Next=new NaborElem;
            T=T->Next;
            T->value=arr[i];
            T->Next=NULL;
            countElems++;
        }
    }
    int getChildNaborCount()//только прямые потомки
    {
        return childNabSize; 
    }
    
}*nabors;
int allNaborsCount;
NaborList *tmpNabor;
void getAllChildNabors(NaborList *teknabor)//обойти дерево и записать всех как детей первого уровня в tmpNabor
{
    tmpNabor->addChildNabor(teknabor);
    int chCount=teknabor->getChildNaborCount();
    for(int i=0;i<chCount;i++) getAllChildNabors(teknabor->childNabors[i]); 
}
bool arrayCmp(int *arr1, int *arr2, int countelem) //если совпадают вернет true
{   
    for(int i=0;i<countelem;i++)
    {
        if(arr1[i]!=arr2[i]) return false;
    }
    return true;
}
NaborList *findSimpleNabor(int n)
{
    int devs[]={2,3,5,7};
    NaborList *simpleNabor=new NaborList;
    simpleNabor->childNabors=NULL;
    simpleNabor->countElems=0;
    simpleNabor->FirElem=NULL;
    NaborElem *T;
    for(int i=0;i<=3;i++)
    {
        while(n%devs[i]==0)
        {
            if(simpleNabor->FirElem)
            {
                T->Next=new NaborElem;
                T=T->Next;
            }
            else
            {
                simpleNabor->FirElem=new NaborElem;
                T=simpleNabor->FirElem;
            }
            T->Next=NULL;
            T->value=devs[i];
            (simpleNabor->countElems)++;
            n/=devs[i];
        }   
    }
    if(n>1) return NULL; //неверное значение n
    return simpleNabor; 
}
NaborElem* sortNabor(NaborElem *Nabor)
{
    NaborElem *nab2, *T2, *T=Nabor;
    nab2=Nabor;
    T=T->Next;
    nab2->Next=NULL;
    while(T)
    {
        T2=nab2;
        if(T->value<=T2->value)
        {
            NaborElem *T3=T->Next;
            T->Next=T2;
            nab2=T;
            T=T3;
            continue;
        }
        while(T2->Next && T->value>T2->Next->value) T2=T2->Next;
        NaborElem *T3=T2->Next;
        T2->Next=T;
        T=T->Next;
        T2->Next->Next=T3;
    }
    return nab2;
}
void addNaborElem(NaborElem **Nabor, NaborElem *addElem)
{
    if(!(*Nabor)) (*Nabor)=addElem;
    else
    {
        NaborElem *T=(*Nabor);
        while(T->Next) T=T->Next;
        T->Next=addElem;
    }
}
void addNaborElem(NaborElem **Nabor, int elem)
{
    if(!(*Nabor)) 
    {
        (*Nabor)=new NaborElem;
        (*Nabor)->value=elem;
        (*Nabor)->Next=NULL;
    }
    else
    {
        NaborElem *T=(*Nabor);
        while(T->Next) T=T->Next;
        T->Next=new NaborElem;
        T->Next->value=elem;
        T->Next->Next=NULL;
    }
}
 void insertNabor(NaborElem *PrevElem, NaborElem *insNabor)//нельзя вставить в начало
 {
     NaborElem *Next=PrevElem->Next;
     PrevElem->Next=insNabor;
     NaborElem *T=insNabor;
     while(T->Next) T=T->Next;
     T->Next=Next;
 }
 NaborList *cloneNabor(NaborList *source)
 {
     NaborList *dest=new NaborList;
     //dest->FirElem=new NaborElem;
     NaborElem *T=source->FirElem;
     while(T)
     {
         addNaborElem(&(dest->FirElem),T->value);
         T=T->Next;
     }
     return dest;
 }
 void insertNaborPrevFirst(NaborElem *First, NaborElem *insNabor)
 {
     NaborElem *T=insNabor;
     while(T->Next) T=T->Next;
     T->Next=First;
 }
void findNabors(NaborList *teknabor)
{
    allNaborsCount++;
    if(teknabor->countElems>1)
    {
        int *ar=teknabor->NaborToArray();
        for(int i=0;i<(teknabor->countElems-1);i++)
            for(int j=i+1;j<(teknabor->countElems);j++)
            {
                if(ar[i]*ar[j]<=9)
                {
                    ar[i]*=ar[j];
                    ar[j]=0; //будет пропущен при преобразовании
                    NaborList *newNabor=new NaborList;
                    newNabor->loadFromArray(ar, teknabor->countElems); // вот здесь пропускаем j
                    newNabor->FirElem=sortNabor(newNabor->FirElem);
                    teknabor->addChildNabor(newNabor);
                    findNabors(newNabor);  //строим дерево
                    delete []ar;
                    ar=teknabor->NaborToArray(); //обновить массив для последующего поиска
                }
            }       
    }
}
//количество перестановок для набора
long long factorial(int i)
{
    if(i==0 || i==1) return 1;
    long long res=1;
    for(int k=2;k<=i;k++) res*=k;
    return res;
}
long long PCount(int *nabArray, int len)
{
    int *repeatcount=new int[10]; //0,1 -not use
    for(int i=0;i<=9;i++) repeatcount[i]=0;
    for(int i=0;i<len;i++)
    {
        repeatcount[nabArray[i]]++;
    }
    long long res=factorial(len);
    for(int i=0;i<=9;i++) res/=factorial(repeatcount[i]);
    delete []repeatcount;
    return res;
}
void main()
{
    cout<<"input super natural proizv sign: ";
    int n;  
    for(;;)
    {
        cin>>n;
        allNaborsCount=0;
        nabors=findSimpleNabor(n); //здесь ищем набор, состоящий только из простых чисел
        if(!nabors)
        {
            cout<<"no correct value, input super natural proizv sign again: ";          
        }
        else break;
    }
    findNabors(nabors); //строим дерево
    tmpNabor=new NaborList;
    getAllChildNabors(nabors); //преобразуем дерево в массив
    //преобразуем массив
    int nbCount=tmpNabor->getChildNaborCount();
    int **allNabors=new int*[nbCount];
    int *allNaborsLens=new int[nbCount];
    for(int i=0;i<nbCount;i++)
    {
        allNabors[i]=tmpNabor->childNabors[i]->NaborToArray();
        allNaborsLens[i]=tmpNabor->childNabors[i]->countElems;
    }
    
 
    //найдем и удалим дубликаты
    int realCount=nbCount;
    for(int i=0;i<realCount;i++)
    {
        for(int j=i+1;j<realCount;j++)
        {
            if(allNaborsLens[i]==allNaborsLens[j] && arrayCmp(allNabors[i],allNabors[j],allNaborsLens[i]))
            {
                delete [](allNabors[j]);
                for(int k=j;k<realCount-1;k++)
                {
                    allNabors[k]=allNabors[k+1];
                    allNaborsLens[k]=allNaborsLens[k+1];
                }
                allNabors[realCount-1]=NULL;
                realCount--;
                j--; //c учетом удаленой строки
            }
        }
    }
    //подсчитаем колиечство повторений в наборах
    long long pcnt=0;
    for(int i=0;i<realCount;i++) pcnt+=PCount(allNabors[i], allNaborsLens[i]);
    cout<<"super natural count: "<<pcnt<<" \nDo you want to see nabor? (y/n): ";
    char a=getchar();
    cin>>a; 
    //n=getchar();
    if(a=='y' || a=='Y')
    {
        for(int i=0;i<realCount;i++)
        {
            for(int j=0;j<allNaborsLens[i];j++)
            {
                cout<<allNabors[i][j]<<" ";
            }
            cout<<'\n';
        }
    }
    cin>>n; //задержка чтоб окно не закрывалось
}

#include <iostream>
using namespace std;
 
struct NaborElem
{
    int value;
    NaborElem *Next;
};
class NaborList
{
private:
    int childNabSize;   
public:
    NaborElem *FirElem;
    NaborList **childNabors; //array
    int countElems;
    NaborList()
    {
        FirElem=NULL;
        childNabors=NULL;
        countElems=0;
        childNabSize=0;
    }
    void addChildNabor(NaborList *nabor)
    {
        if(!childNabors)
        {
            childNabSize=1;
            childNabors=new NaborList*[1];
            childNabors[0]=nabor;
        }
        else
        {
            childNabSize++;
            NaborList **chnabor2=new NaborList*[childNabSize];
            for(int i=0;i<childNabSize-1;i++) chnabor2[i]=childNabors[i];
            chnabor2[childNabSize-1]=nabor;
            delete []childNabors;
            childNabors=chnabor2;
        }
    }
    int* NaborToArray()
    {       
        if(!FirElem) return NULL;
        int *nbArray=new int[countElems];
        int i=0;
        NaborElem *T=FirElem;
        while(T && i<countElems)
        {
            nbArray[i]=T->value;
            i++;
            T=T->Next;
        }
        return nbArray;
    }
    void loadFromArray(int *arr, int arrCount)
    {
        FirElem=new NaborElem;
        FirElem->value=arr[0];
        FirElem->Next=NULL;
        NaborElem *T=FirElem;
        countElems=1;
        for(int i=1;i<arrCount;i++)
        {
            if(arr[i]==0) continue;
            T->Next=new NaborElem;
            T=T->Next;
            T->value=arr[i];
            T->Next=NULL;
            countElems++;
        }
    }
    int getChildNaborCount()//только прямые потомки
    {
        return childNabSize; 
    }
    
}*nabors;
int allNaborsCount;
NaborList *tmpNabor;
void getAllChildNabors(NaborList *teknabor)//обойти дерево и записать всех как детей первого уровня в tmpNabor
{
    tmpNabor->addChildNabor(teknabor);
    int chCount=teknabor->getChildNaborCount();
    for(int i=0;i<chCount;i++) getAllChildNabors(teknabor->childNabors[i]); 
}
bool arrayCmp(int *arr1, int *arr2, int countelem) //если совпадают вернет true
{   
    for(int i=0;i<countelem;i++)
    {
        if(arr1[i]!=arr2[i]) return false;
    }
    return true;
}
NaborList *findSimpleNabor(int n)
{
    int devs[]={2,3,5,7};
    NaborList *simpleNabor=new NaborList;
    simpleNabor->childNabors=NULL;
    simpleNabor->countElems=0;
    simpleNabor->FirElem=NULL;
    NaborElem *T;
    for(int i=0;i<=3;i++)
    {
        while(n%devs[i]==0)
        {
            if(simpleNabor->FirElem)
            {
                T->Next=new NaborElem;
                T=T->Next;
            }
            else
            {
                simpleNabor->FirElem=new NaborElem;
                T=simpleNabor->FirElem;
            }
            T->Next=NULL;
            T->value=devs[i];
            (simpleNabor->countElems)++;
            n/=devs[i];
        }   
    }
    if(n>1) return NULL; //неверное значение n
    return simpleNabor; 
}
NaborElem* sortNabor(NaborElem *Nabor)
{
    NaborElem *nab2, *T2, *T=Nabor;
    nab2=Nabor;
    T=T->Next;
    nab2->Next=NULL;
    while(T)
    {
        T2=nab2;
        if(T->value<=T2->value)
        {
            NaborElem *T3=T->Next;
            T->Next=T2;
            nab2=T;
            T=T3;
            continue;
        }
        while(T2->Next && T->value>T2->Next->value) T2=T2->Next;
        NaborElem *T3=T2->Next;
        T2->Next=T;
        T=T->Next;
        T2->Next->Next=T3;
    }
    return nab2;
}
void addNaborElem(NaborElem **Nabor, NaborElem *addElem)
{
    if(!(*Nabor)) (*Nabor)=addElem;
    else
    {
        NaborElem *T=(*Nabor);
        while(T->Next) T=T->Next;
        T->Next=addElem;
    }
}
void addNaborElem(NaborElem **Nabor, int elem)
{
    if(!(*Nabor)) 
    {
        (*Nabor)=new NaborElem;
        (*Nabor)->value=elem;
        (*Nabor)->Next=NULL;
    }
    else
    {
        NaborElem *T=(*Nabor);
        while(T->Next) T=T->Next;
        T->Next=new NaborElem;
        T->Next->value=elem;
        T->Next->Next=NULL;
    }
}
 void insertNabor(NaborElem *PrevElem, NaborElem *insNabor)//нельзя вставить в начало
 {
     NaborElem *Next=PrevElem->Next;
     PrevElem->Next=insNabor;
     NaborElem *T=insNabor;
     while(T->Next) T=T->Next;
     T->Next=Next;
 }
 NaborList *cloneNabor(NaborList *source)
 {
     NaborList *dest=new NaborList;
     //dest->FirElem=new NaborElem;
     NaborElem *T=source->FirElem;
     while(T)
     {
         addNaborElem(&(dest->FirElem),T->value);
         T=T->Next;
     }
     return dest;
 }
 void insertNaborPrevFirst(NaborElem *First, NaborElem *insNabor)
 {
     NaborElem *T=insNabor;
     while(T->Next) T=T->Next;
     T->Next=First;
 }
void findNabors(NaborList *teknabor)
{
    allNaborsCount++;
    if(teknabor->countElems>1)
    {
        int *ar=teknabor->NaborToArray();
        for(int i=0;i<(teknabor->countElems-1);i++)
            for(int j=i+1;j<(teknabor->countElems);j++)
            {
                if(ar[i]*ar[j]<=9)
                {
                    ar[i]*=ar[j];
                    ar[j]=0; //будет пропущен при преобразовании
                    NaborList *newNabor=new NaborList;
                    newNabor->loadFromArray(ar, teknabor->countElems); // вот здесь пропускаем j
                    newNabor->FirElem=sortNabor(newNabor->FirElem);
                    teknabor->addChildNabor(newNabor);
                    findNabors(newNabor);  //строим дерево
                    delete []ar;
                    ar=teknabor->NaborToArray(); //обновить массив для последующего поиска
                }
            }       
    }
}
//количество перестановок для набора
long long factorial(int i)
{
    if(i==0 || i==1) return 1;
    long long res=1;
    for(int k=2;k<=i;k++) res*=k;
    return res;
}
long long PCount(int *nabArray, int len)
{
    int *repeatcount=new int[10]; //0,1 -not use
    for(int i=0;i<=9;i++) repeatcount[i]=0;
    for(int i=0;i<len;i++)
    {
        repeatcount[nabArray[i]]++;
    }
    long long res=factorial(len);
    for(int i=0;i<=9;i++) res/=factorial(repeatcount[i]);
    delete []repeatcount;
    return res;
}
void main()
{
    cout<<"input super natural proizv sign: ";
    int n;  
    for(;;)
    {
        cin>>n;
        allNaborsCount=0;
        nabors=findSimpleNabor(n); //здесь ищем набор, состоящий только из простых чисел
        if(!nabors)
        {
            cout<<"no correct value, input super natural proizv sign again: ";          
        }
        else break;
    }
    findNabors(nabors); //строим дерево
    tmpNabor=new NaborList;
    getAllChildNabors(nabors); //преобразуем дерево в массив
    //преобразуем массив
    int nbCount=tmpNabor->getChildNaborCount();
    int **allNabors=new int*[nbCount];
    int *allNaborsLens=new int[nbCount];
    for(int i=0;i<nbCount;i++)
    {
        allNabors[i]=tmpNabor->childNabors[i]->NaborToArray();
        allNaborsLens[i]=tmpNabor->childNabors[i]->countElems;
    }
    
 
    //найдем и удалим дубликаты
    int realCount=nbCount;
    for(int i=0;i<realCount;i++)
    {
        for(int j=i+1;j<realCount;j++)
        {
            if(allNaborsLens[i]==allNaborsLens[j] && arrayCmp(allNabors[i],allNabors[j],allNaborsLens[i]))
            {
                delete [](allNabors[j]);
                for(int k=j;k<realCount-1;k++)
                {
                    allNabors[k]=allNabors[k+1];
                    allNaborsLens[k]=allNaborsLens[k+1];
                }
                allNabors[realCount-1]=NULL;
                realCount--;
                j--; //c учетом удаленой строки
            }
        }
    }
    //подсчитаем колиечство повторений в наборах
    long long pcnt=0;
    for(int i=0;i<realCount;i++) pcnt+=PCount(allNabors[i], allNaborsLens[i]);
    cout<<"super natural count: "<<pcnt<<" \nDo you want to see nabor? (y/n): ";
    char a=getchar();    
    if(a=='y' || a=='Y')
    {
        for(int i=0;i<realCount;i++)
        {
            for(int j=0;j<allNaborsLens[i];j++)
            {
                cout<<allNabors[i][j]<<" ";
            }
            cout<<'\n';
        }
    }
    cin>>n; //задержка чтоб окно не закрывалось
}

char a;
cin>>a;

#include <iostream>
using namespace std;
 
struct NaborElem
{
    int value;
    NaborElem *Next;
};
class NaborList
{
private:
    int childNabSize;   
public:
    NaborElem *FirElem;
    NaborList **childNabors; //array
    int countElems;
    NaborList()
    {
        FirElem=NULL;
        childNabors=NULL;
        countElems=0;
        childNabSize=0;
    }
    void addChildNabor(NaborList *nabor)
    {
        if(!childNabors)
        {
            childNabSize=1;
            childNabors=new NaborList*[1];
            childNabors[0]=nabor;
        }
        else
        {
            childNabSize++;
            NaborList **chnabor2=new NaborList*[childNabSize];
            for(int i=0;i<childNabSize-1;i++) chnabor2[i]=childNabors[i];
            chnabor2[childNabSize-1]=nabor;
            delete []childNabors;
            childNabors=chnabor2;
        }
    }
    int* NaborToArray()
    {       
        if(!FirElem) return NULL;
        int *nbArray=new int[countElems];
        int i=0;
        NaborElem *T=FirElem;
        while(T && i<countElems)
        {
            nbArray[i]=T->value;
            i++;
            T=T->Next;
        }
        return nbArray;
    }
    void loadFromArray(int *arr, int arrCount)
    {
        FirElem=new NaborElem;
        FirElem->value=arr[0];
        FirElem->Next=NULL;
        NaborElem *T=FirElem;
        countElems=1;
        for(int i=1;i<arrCount;i++)
        {
            if(arr[i]==0) continue;
            T->Next=new NaborElem;
            T=T->Next;
            T->value=arr[i];
            T->Next=NULL;
            countElems++;
        }
    }
    int getChildNaborCount()//только прямые потомки
    {
        return childNabSize; 
    }
    
}*nabors;
int allNaborsCount;
NaborList *tmpNabor;
void getAllChildNabors(NaborList *teknabor)//обойти дерево и записать всех как детей первого уровня в tmpNabor
{
    tmpNabor->addChildNabor(teknabor);
    int chCount=teknabor->getChildNaborCount();
    for(int i=0;i<chCount;i++) getAllChildNabors(teknabor->childNabors[i]); 
}
bool arrayCmp(int *arr1, int *arr2, int countelem) //если совпадают вернет true
{   
    for(int i=0;i<countelem;i++)
    {
        if(arr1[i]!=arr2[i]) return false;
    }
    return true;
}
NaborList *findSimpleNabor(int n)
{
    int devs[]={2,3,5,7};
    NaborList *simpleNabor=new NaborList;
    simpleNabor->childNabors=NULL;
    simpleNabor->countElems=0;
    simpleNabor->FirElem=NULL;
    NaborElem *T;
    for(int i=0;i<=3;i++)
    {
        while(n%devs[i]==0)
        {
            if(simpleNabor->FirElem)
            {
                T->Next=new NaborElem;
                T=T->Next;
            }
            else
            {
                simpleNabor->FirElem=new NaborElem;
                T=simpleNabor->FirElem;
            }
            T->Next=NULL;
            T->value=devs[i];
            (simpleNabor->countElems)++;
            n/=devs[i];
        }   
    }
    if(n>1) return NULL; //неверное значение n
    return simpleNabor; 
}
NaborElem* sortNabor(NaborElem *Nabor)
{
    NaborElem *nab2, *T2, *T=Nabor;
    nab2=Nabor;
    T=T->Next;
    nab2->Next=NULL;
    while(T)
    {
        T2=nab2;
        if(T->value<=T2->value)
        {
            NaborElem *T3=T->Next;
            T->Next=T2;
            nab2=T;
            T=T3;
            continue;
        }
        while(T2->Next && T->value>T2->Next->value) T2=T2->Next;
        NaborElem *T3=T2->Next;
        T2->Next=T;
        T=T->Next;
        T2->Next->Next=T3;
    }
    return nab2;
}
void addNaborElem(NaborElem **Nabor, NaborElem *addElem)
{
    if(!(*Nabor)) (*Nabor)=addElem;
    else
    {
        NaborElem *T=(*Nabor);
        while(T->Next) T=T->Next;
        T->Next=addElem;
    }
}
void addNaborElem(NaborElem **Nabor, int elem)
{
    if(!(*Nabor)) 
    {
        (*Nabor)=new NaborElem;
        (*Nabor)->value=elem;
        (*Nabor)->Next=NULL;
    }
    else
    {
        NaborElem *T=(*Nabor);
        while(T->Next) T=T->Next;
        T->Next=new NaborElem;
        T->Next->value=elem;
        T->Next->Next=NULL;
    }
}
 void insertNabor(NaborElem *PrevElem, NaborElem *insNabor)//нельзя вставить в начало
 {
     NaborElem *Next=PrevElem->Next;
     PrevElem->Next=insNabor;
     NaborElem *T=insNabor;
     while(T->Next) T=T->Next;
     T->Next=Next;
 }
 NaborList *cloneNabor(NaborList *source)
 {
     NaborList *dest=new NaborList;
     //dest->FirElem=new NaborElem;
     NaborElem *T=source->FirElem;
     while(T)
     {
         addNaborElem(&(dest->FirElem),T->value);
         T=T->Next;
     }
     return dest;
 }
 void insertNaborPrevFirst(NaborElem *First, NaborElem *insNabor)
 {
     NaborElem *T=insNabor;
     while(T->Next) T=T->Next;
     T->Next=First;
 }
void findNabors(NaborList *teknabor)
{
    allNaborsCount++;
    if(teknabor->countElems>1)
    {
        int *ar=teknabor->NaborToArray();
        for(int i=0;i<(teknabor->countElems-1);i++)
            for(int j=i+1;j<(teknabor->countElems);j++)
            {
                if(ar[i]*ar[j]<=9)
                {
                    ar[i]*=ar[j];
                    ar[j]=0; //будет пропущен при преобразовании
                    NaborList *newNabor=new NaborList;
                    newNabor->loadFromArray(ar, teknabor->countElems); // вот здесь пропускаем j
                    newNabor->FirElem=sortNabor(newNabor->FirElem);
                    teknabor->addChildNabor(newNabor);
                    findNabors(newNabor);  //строим дерево
                    delete []ar;
                    ar=teknabor->NaborToArray(); //обновить массив для последующего поиска
                }
            }       
    }
}
//количество перестановок для набора
long long factorial(int i)
{
    if(i==0 || i==1) return 1;
    long long res=1;
    for(int k=2;k<=i;k++) res*=k;
    return res;
}
long long PCount(int *nabArray, int len)
{
    int *repeatcount=new int[10]; //0,1 -not use
    for(int i=0;i<=9;i++) repeatcount[i]=0;
    for(int i=0;i<len;i++)
    {
        repeatcount[nabArray[i]]++;
    }
    long long res=factorial(len);
    for(int i=0;i<=9;i++) res/=factorial(repeatcount[i]);
    delete []repeatcount;
    return res;
}
void main()
{
    cout<<"input super natural proizv sign: ";
    int n;  
    for(;;)
    {
        cin>>n;
        allNaborsCount=0;
        nabors=findSimpleNabor(n); //здесь ищем набор, состоящий только из простых чисел
        if(!nabors)
        {
            cout<<"no correct value, input super natural proizv sign again: ";          
        }
        else break;
    }
    findNabors(nabors); //строим дерево
    tmpNabor=new NaborList;
    getAllChildNabors(nabors); //преобразуем дерево в массив
    //преобразуем массив
    int nbCount=tmpNabor->getChildNaborCount();
    int **allNabors=new int*[nbCount];
    int *allNaborsLens=new int[nbCount];
    for(int i=0;i<nbCount;i++)
    {
        allNabors[i]=tmpNabor->childNabors[i]->NaborToArray();
        allNaborsLens[i]=tmpNabor->childNabors[i]->countElems;
    }
    
 
    //найдем и удалим дубликаты
    int realCount=nbCount;
    for(int i=0;i<realCount;i++)
    {
        for(int j=i+1;j<realCount;j++)
        {
            if(allNaborsLens[i]==allNaborsLens[j] && arrayCmp(allNabors[i],allNabors[j],allNaborsLens[i]))
            {
                delete [](allNabors[j]);
                for(int k=j;k<realCount-1;k++)
                {
                    allNabors[k]=allNabors[k+1];
                    allNaborsLens[k]=allNaborsLens[k+1];
                }
                allNabors[realCount-1]=NULL;
                realCount--;
                j--; //c учетом удаленой строки
            }
        }
    }
    //подсчитаем колиечство повторений в наборах
    long long pcnt=0;
    for(int i=0;i<realCount;i++) pcnt+=PCount(allNabors[i], allNaborsLens[i]);
    cout<<"super natural count: "<<(pcnt%101)<<" \nDo you want to see nabor? (y/n): ";
    char a;    
    cin>>a;
    if(a=='y' || a=='Y')
    {
        for(int i=0;i<realCount;i++)
        {
            for(int j=0;j<allNaborsLens[i];j++)
            {
                cout<<allNabors[i][j]<<" ";
            }
            cout<<'\n';
        }
    }
    cin>>n; //задержка чтоб окно не закрывалось
}

double all9and8and4()
{
       double res=all8and4();
       if (nums[1]<2) return res;
       DWORD max9=nums[1]/2;
       for (DWORD i=0;i<max9;i++)
       {
           changenums(1,-2);
           changenums(7,1);
           if(rescomb)res+=(facttable[countn]/rescomb);
           res+=all8and4();
       }
       changenums(7,(-1)*max9);
       changenums(1,2*max9);
       cout<<"984 returned "<<res<<endl;
       return res;     
 }