How many palindromes can you create from array - c++

Question

I'm trying to build a basic code that is taking an int array and outputing all of its optional palindromes.
Example: {1, 2, 2, 2, 3}
Output: {2 2}, {2 1 2}, {2 3 2}, {2 2 2}
I was thinking of reorganizing the array in every way possible and checking if it's an array by each time. But, I think I'm heading to it wrongly.
The code I made for now is:
#include <iostream>
using namespace std;
int main()
{
int arr[] = { 1, 2, 3, 2, 1 };// 7 int //56
bool check = true;
for(int i=0; i< sizeof(arr)/sizeof(int)/2;i++)
{
if(arr[i] != arr[sizeof(arr)/sizeof(int)-1-i])
check = false;
}
if(check)
{
for(int i=0; i< sizeof(arr)/sizeof(int);i++)
{
cout<<arr[i]<< " ";
}
cout<<endl;
}
return 0;
}
I will appreciate help if possible. Thank you all and have an amazing day!

Answer 1

We have to implement 2 major mathematical concepts here
Create a power set
Get all permutations from powerset.
Then, of course check for the palindrome property.
Let's start with the power set.
We will first make a simplification for an easier understanding of the task. We will use lower case letters in this example. Then we will take 4 elements {A,B,C,D} for demo purposes.
What we need to generate is a power set from this. There are 2 main standard approaches.
Counting with checking of set bits via it mask
Setting more and more bits in a field and do permutations.
Let us look at solution 1. Counting. Based on "abcd" we will get
Count Binary Selection (sub set)
DCBA Cardinality
0 0000 {----} 0 Empty set
1 0001 {---A} 1
2 0010 {--B-} 1
3 0011 {--BA} 2
4 0100 {-C--} 1
5 0101 {-C-A} 2
6 0110 {-CB-} 2
7 0111 {-CBA} 3
8 1000 {D---} 4
9 1001 {D--A} 2
10 1010 {D-B-} 2
11 1011 {D-BA} 3
12 1100 {DC--} 3
13 1101 {DC-A} 3
14 1110 {DCB-} 3
15 1111 {DCBA} 4
As a result we will get the powerset:
{{A},{B},{AB},{C},{AC},{BC},{ABC},{D},{AD},{BD},{ABD},{CD},{ACD},{BCD},{ABCD}}
If you look at the output, we see that the elements are not sorted according to their cardinality. Therefore we will choose a different approach. We will set more and more bits in a field an do permutations on them. Also with a selector. Then, we will get something like this:
Binary Selection
0000 {----} Empty set. Ignored
0001 {---A} Set bit 0
0010 {--B-} Permutation
0101 {-C--} Permutation
1000 {D---} Permutation
0011 {--BA} Set next bit number 1
0101 {-C-A} Permutation
1001 {D--A} Permutation
0110 {-CB-} Permutation
1010 {D-B-} Permutation
1100 {D--A} Permutation
0111 {-CBA} Set next bit number 2
1011 {D-BA} Permutation
1101 {DC-A} Permutation
1110 {DCB-} Permutation
1111 {DCBA} Set next bit number 3
As a result we will get the "more reasonable/expected" powerset:
{{A},{B},{C},{D},{AB},{AC},{AD},{BC},{BD},{AD},{ABC},{ABD},{ACD},{BCD},{ABCD}}
By the way. The overall number of sub sets is of course 2^n and the size of the cardinality group is equal to the corresponding binomial coeeficient.
Cardinality
0 4 choose 0 --> 1
1 4 choose 1 --> 4
2 4 choose 1 --> 6
3 4 choose 1 --> 4
4 4 choose 1 --> 1
Sum: 16
The corresponding algorithm is easy to implement, which can also be seen later in the code example.
Next, after having calculated one subset, we will create all permutations of data in this subset with the existing C++ function std::next_permutation.
After a successful check for a Palindrome, we will add this subset to a resulting std::set . We will use the std::set to avoid duplicates.
At the end, we can show the result.
The below example is brute force and hence very very slow for big input arrays.
Anyway, please see the example code below:
#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
int main() {
std::vector testData{ 1,2,2,2,3 };
// Here we will store the result
std::set<std::vector<int>> result{};
// Selectors for creating the subsets of the power set
std::vector<bool> selector(testData.size());
// For all number of elements in the original test data
for (size_t k{0}; k < testData.size(); ++k) {
// Set selector bits. In each loop one more bit. So, 1 then 11, then 111 and so on
selector[k] = true;
// Do all permutations of the above set selector bits
do {
// Build the subset
std::vector<int> subset{};
for (std::size_t n{}; n < testData.size(); ++n)
if (selector[n]) subset.push_back(testData[n]);
do {
// Check, if palindrome
if (subset == std::vector<int>(subset.rbegin(), subset.rend()))
result.insert(subset);
} while (std::next_permutation(subset.begin(), subset.end()));
} while (std::prev_permutation(selector.begin(), selector.end()));
}
// Show all resulting palindromes
std::cout << "\n\nNumber of palindromes: " << result.size() << "\n\n";
int counter{ 1 };
for (const std::vector<int>& v : result) {
std::cout << "Palindrome " << counter++ << ":\t";
for (const int i : v) std::cout << ' ' << i;
std::cout << '\n';
}
}