recursive call and placing strings in link list notes

[GokuK97]

You need to write a permute class that will take first and second strings to rearrange letters in first, followed by second. For example, if the first is “CAT” string and second is “MAN” string, then the program would print the strings TACMAN, ATCMAN, CTAMAN, TCAMAN, ACTMAN, and CATMAN. The first and second strings can be any length of string or a null.

The permute class uses a Note class as link list note to link all letters arrangement. The permute class has Note pointers, firstNote and lastNote, to point to the beginning and ending Notes of the link list as private data members. There are three other private data members (total, firstString and secondString) to store the total possible number of arrangements and strings pass into the class.

Write a driver to test the permute class to pass in any two strings of any sizes.

Other than mention in the following, you can add more classes, functions, and private data members to this program.

Note class

The Note class needs to have two private data members and a constructor. The two private data members are data and p pointer. The data’s data type is string and p pointer is Note. The Note class constructor has two parameters, one is string and the other is Note pointer.

Permute class

The Permute class has five private data members (*firstNote, *lastNote, total, firstString and secondString). The firstNote and lastNote pointers are point to Note. The total has integer data type. The firstString and secondString have string data type.

There should have at least three public member functions, Permute, permutation and print. The Permute function is the constructor which takes strings to initialize the private data members. The permutation function does the recursive call to arrange the strings and setup the link list. The print function will print out the private data member information.

Driver file

The driver file should declare a Permute eight elements pointer array. Instantiate eight Permute object with the following eight set of data and assign the object to the pointer array. Use a repetition to call the object’s print function to print out the private data member information. If the total of the permute private data member is less than 100 then print out the permutated letters four in a row, otherwise print out 9 in a row.

first = "", second="",

first = "", second ="CATMAN",

first = "C", second ="ATMAN",

first = "CA", second ="TMAN",

first = "CAT", second ="MAN",

first = "CATM", second ="AN",

first = "CATMA", second ="N",

first 1 = "CATMAN", second ="";

and here is the output of the should look like:
String 1 for this object is:
String 2 for this object is:
There is no permutation.



String 1 for this object is:
String 2 for this object is: CATMAN
The total possible permutation is 1
That is:
CATMAN

String 1 for this object is: C
String 2 for this object is: ATMAN
The total possible permutation is 1
That is:
CATMAN

String 1 for this object is: CA
String 2 for this object is: TMAN
The total possible permutation is 2
They are:
ACTMAN CATMAN

String 1 for this object is: CAT
String 2 for this object is: MAN
The total possible permutation is 6
They are:
TACMAN ATCMAN CTAMAN TCAMAN
ACTMAN CATMAN

String 1 for this object is: CATM
String 2 for this object is: AN
The total possible permutation is 24
They are:
MTACAN TMACAN AMTCAN MATCAN
TAMCAN ATMCAN CMTAAN MCTAAN
TCMAAN CTMAAN MTCAAN TMCAAN
ACMTAN CAMTAN MACTAN AMCTAN
CMATAN MCATAN TACMAN ATCMAN
CTAMAN TCAMAN ACTMAN CATMAN


String 1 for this object is: CATMA
String 2 for this object is: N
The total possible permutation is 120
They are:
AMTACN MATACN TAMACN ATMACN MTAACN TMAACN AAMTCN AAMTCN MAATCN
AMATCN AMATCN MAATCN TAAMCN ATAMCN ATAMCN TAAMCN AATMCN AATMCN
MTAACN TMAACN AMTACN MATACN TAMACN ATMACN CAMTAN ACMTAN MCATAN
CMATAN AMCTAN MACTAN TCAMAN CTAMAN ATCMAN TACMAN CATMAN ACTMAN
MTCAAN TMCAAN CMTAAN MCTAAN TCMAAN CTMAAN AMTCAN MATCAN TAMCAN
ATMCAN MTACAN TMACAN ACAMTN CAAMTN AACMTN AACMTN CAAMTN ACAMTN
MACATN AMCATN CMAATN MCAATN ACMATN CAMATN AMACTN MAACTN AAMCTN
AAMCTN MAACTN AMACTN CAMATN ACMATN MCAATN CMAATN AMCATN MACATN
TACAMN ATCAMN CTAAMN TCAAMN ACTAMN CATAMN ATACMN TAACMN AATCMN
AATCMN TAACMN ATACMN CATAMN ACTAMN TCAAMN CTAAMN ATCAMN TACAMN
ACATMN CAATMN AACTMN AACTMN CAATMN ACATMN MTACAN TMACAN AMTCAN
MATCAN TAMCAN ATMCAN CMTAAN MCTAAN TCMAAN CTMAAN MTCAAN TMCAAN
ACMTAN CAMTAN MACTAN AMCTAN CMATAN MCATAN TACMAN ATCMAN CTAMAN
TCAMAN ACTMAN CATMAN

String 1 for this object is: CATMAN
String 2 for this object is:
The total possible permutation is 720
They are:
NAMTAC ANMTAC MNATAC NMATAC AMNTAC MANTAC TNAMAC NTAMAC ATNMAC
TANMAC NATMAC ANTMAC MTNAAC TMNAAC NMTAAC MNTAAC TNMAAC NTMAAC
AMTNAC MATNAC TAMNAC ATMNAC MTANAC TMANAC ANAMTC NAAMTC AANMTC
AANMTC NAAMTC ANAMTC MANATC AMNATC NMAATC MNAATC ANMATC NAMATC
AMANTC MAANTC AAMNTC AAMNTC MAANTC AMANTC NAMATC ANMATC MNAATC
NMAATC AMNATC MANATC TANAMC ATNAMC NTAAMC TNAAMC ANTAMC NATAMC
ATANMC TAANMC AATNMC AATNMC TAANMC ATANMC NATAMC ANTAMC TNAAMC
NTAAMC ATNAMC TANAMC ANATMC NAATMC AANTMC AANTMC NAATMC ANATMC
MTANAC TMANAC AMTNAC MATNAC TAMNAC ATMNAC NMTAAC MNTAAC TNMAAC
NTMAAC MTNAAC TMNAAC ANMTAC NAMTAC MANTAC AMNTAC NMATAC MNATAC
TANMAC ATNMAC NTAMAC TNAMAC ANTMAC NATMAC AMTANC MATANC TAMANC
ATMANC MTAANC TMAANC AAMTNC AAMTNC MAATNC AMATNC AMATNC MAATNC
TAAMNC ATAMNC ATAMNC TAAMNC AATMNC AATMNC MTAANC TMAANC AMTANC
MATANC TAMANC ATMANC CNAMTA NCAMTA ACNMTA CANMTA NACMTA ANCMTA
MCNATA CMNATA NMCATA MNCATA CNMATA NCMATA AMCNTA MACNTA CAMNTA
ACMNTA MCANTA CMANTA NAMCTA ANMCTA MNACTA NMACTA AMNCTA MANCTA
TCNAMA CTNAMA NTCAMA TNCAMA CNTAMA NCTAMA ATCNMA TACNMA CATNMA
ACTNMA TCANMA CTANMA NATCMA ANTCMA TNACMA NTACMA ATNCMA TANCMA
CNATMA NCATMA ACNTMA CANTMA NACTMA ANCTMA MTCNAA TMCNAA CMTNAA
MCTNAA TCMNAA CTMNAA NMTCAA MNTCAA TNMCAA NTMCAA MTNCAA TMNCAA
CNMTAA NCMTAA MCNTAA CMNTAA NMCTAA MNCTAA TCNMAA CTNMAA NTCMAA
TNCMAA CNTMAA NCTMAA AMTCNA MATCNA TAMCNA ATMCNA MTACNA TMACNA
CAMTNA ACMTNA MCATNA CMATNA AMCTNA MACTNA TCAMNA CTAMNA ATCMNA
TACMNA CATMNA ACTMNA MTCANA TMCANA CMTANA MCTANA TCMANA CTMANA
NAMTCA ANMTCA MNATCA NMATCA AMNTCA MANTCA TNAMCA NTAMCA ATNMCA
TANMCA NATMCA ANTMCA MTNACA TMNACA NMTACA MNTACA TNMACA NTMACA
AMTNCA MATNCA TAMNCA ATMNCA MTANCA TMANCA ACNAMT CANAMT NACAMT
ANCAMT CNAAMT NCAAMT AACNMT AACNMT CAANMT ACANMT ACANMT CAANMT
NAACMT ANACMT ANACMT NAACMT AANCMT AANCMT CNAAMT NCAAMT ACNAMT
CANAMT NACAMT ANCAMT MACNAT AMCNAT CMANAT MCANAT ACMNAT CAMNAT
NMACAT MNACAT ANMCAT NAMCAT MANCAT AMNCAT CNMAAT NCMAAT MCNAAT
CMNAAT NMCAAT MNCAAT ACNMAT CANMAT NACMAT ANCMAT CNAMAT NCAMAT
AMACNT MAACNT AAMCNT AAMCNT MAACNT AMACNT CAMANT ACMANT MCAANT
CMAANT AMCANT MACANT ACAMNT CAAMNT AACMNT AACMNT CAAMNT ACAMNT
MACANT AMCANT CMAANT MCAANT ACMANT CAMANT NAMACT ANMACT MNAACT
NMAACT AMNACT MANACT ANAMCT NAAMCT AANMCT AANMCT NAAMCT ANAMCT
MANACT AMNACT NMAACT MNAACT ANMACT NAMACT AMANCT MAANCT AAMNCT
AAMNCT MAANCT AMANCT CNAMAT NCAMAT ACNMAT CANMAT NACMAT ANCMAT
MCNAAT CMNAAT NMCAAT MNCAAT CNMAAT NCMAAT AMCNAT MACNAT CAMNAT
ACMNAT MCANAT CMANAT NAMCAT ANMCAT MNACAT NMACAT AMNCAT MANCAT
TACNAM ATCNAM CTANAM TCANAM ACTNAM CATNAM NTACAM TNACAM ANTCAM
NATCAM TANCAM ATNCAM CNTAAM NCTAAM TCNAAM CTNAAM NTCAAM TNCAAM
ACNTAM CANTAM NACTAM ANCTAM CNATAM NCATAM ATACNM TAACNM AATCNM
AATCNM TAACNM ATACNM CATANM ACTANM TCAANM CTAANM ATCANM TACANM
ACATNM CAATNM AACTNM AACTNM CAATNM ACATNM TACANM ATCANM CTAANM
TCAANM ACTANM CATANM NATACM ANTACM TNAACM NTAACM ATNACM TANACM
ANATCM NAATCM AANTCM AANTCM NAATCM ANATCM TANACM ATNACM NTAACM
TNAACM ANTACM NATACM ATANCM TAANCM AATNCM AATNCM TAANCM ATANCM
CNATAM NCATAM ACNTAM CANTAM NACTAM ANCTAM TCNAAM CTNAAM NTCAAM
TNCAAM CNTAAM NCTAAM ATCNAM TACNAM CATNAM ACTNAM TCANAM CTANAM
NATCAM ANTCAM TNACAM NTACAM ATNCAM TANCAM ACNATM CANATM NACATM
ANCATM CNAATM NCAATM AACNTM AACNTM CAANTM ACANTM ACANTM CAANTM
NAACTM ANACTM ANACTM NAACTM AANCTM AANCTM CNAATM NCAATM ACNATM
CANATM NACATM ANCATM MTACNA TMACNA AMTCNA MATCNA TAMCNA ATMCNA
CMTANA MCTANA TCMANA CTMANA MTCANA TMCANA ACMTNA CAMTNA MACTNA
AMCTNA CMATNA MCATNA TACMNA ATCMNA CTAMNA TCAMNA ACTMNA CATMNA
NTMCAA MTNCAA TMNCAA ACNMTA CANMTA NACMTA ANCMTA CNAMTA NCAMTA