Я пытаюсь найти шесть значений на основе 4 уравнений

Если я понял проблему, вы должны выбрать между всеми возможными комбинациями различных значений цвета, которые решают ваши четыре уравнения.

Вложенные циклы в коде OP предоставят (почти, некоторые циклы начинаются с 1) все возможные комбинации, но способ, который исключает дублирующиеся значения, совершенно неверен.

Уравнения также могут быть проверены в одном условии.

Следующий код должен дать ожидаемый результат:

#include <iostream>

int main(void)
{
long int n = 0, solutions = 0;

for (int green = 0; green < 10; ++green)
{
for (int yellow = 0; yellow < 10; ++yellow)
{
if ( yellow == green )    // skip the duplicate values
continue;

for (int purple = 0; purple < 10; ++purple)
{
if ( purple == green  ||  purple == yellow )
continue;

for (int orange = 0; orange < 10; ++orange)
{
if ( orange == green  ||  orange == yellow  ||  orange == purple )
continue;

for (int red = 0; red < 10; ++red)
{
if ( red == green   ||  red == yellow  ||
red == purple  ||  red == orange)
continue;

for (int blue = 0; blue < 10; ++blue)
{
if ( blue == green   ||  blue == yellow  ||
blue == purple  ||  blue == orange  ||  blue == red )
continue;

// Now check if the values solve all the equations
// Assuming that you don't want integer divisions
if (   purple * 10 + green  == green * yellow
&& purple * 10 + orange == red * red
&& yellow * 10 + orange == red * blue
&&    red * 10 + green  == green * blue)
{
std::cout << "Green:  " << green
<< "\nYellow: " << yellow
<< "\nPurple: " << purple
<< "\nOrange: " << orange
<< "\nRed:    " << red
<< "\nBlue:   " << blue << '\n';
++solutions;
}
++n;
}
}
}
}
}
}
// The number of different combinations should be 10 * 9 * 8 * 7 * 6 * 5 = 151200
std::cout << "\nCombinations tested: " << n
<< " (out of " << 10*10*10*10*10*10 << ")\n"<< "Solutions: " << solutions << '\n';
}

После выполнения выдает:

Зеленый: 5
Желтый: 3
Фиолетовый: 1
Оранжевый: 6
Красный: 4
Синий: 9

Проверенные комбинации: 151200 (из 1000000)
Решения: 1

РЕДАКТИРОВАТЬ

Подстрекаемый Jarod42«s ответ, Я хотел бы показать более эффективное решение, которое использует преимущества стандартной функции библиотеки std::next_permutation (а также std::prev_permutation тоже) и вместо того, чтобы пропускать нежелательные перестановки, напрямую генерирует только нужные.

#include <iostream>
#include <vector>
#include <array>
#include <algorithm>
#include <numeric>

// Applies f() to all the permutations of n values taken k at a time
// where k is the size of the range [first, last)
// n!/(n − k)! iterations are performed
template<class Iterator, class Func>
void for_each_n_permute_k(int n, Iterator first, Iterator last, Func f);

int main()
{
std::array<int, 6> chosen;
int solutions = 0;

for_each_n_permute_k(10, chosen.begin(), chosen.end(), [&chosen, &solutions] () {
auto & [green, yellow, purple, orange, red, blue] = chosen;

if (   purple * 10 + green  == green * yellow
&& purple * 10 + orange == red * red
&& yellow * 10 + orange == red * blue
&&    red * 10 + green  == green * blue)
{
std::cout << "Solution found (" << ++solutions << ")\n"<< "Green:  " << green
<< "\nYellow: " << yellow
<< "\nPurple: " << purple
<< "\nOrange: " << orange
<< "\nRed:    " << red
<< "\nBlue:   " << blue << '\n';
}
});
}

// copy the elements from [it1, last) to dest if the predicate applied to
// the corresponding element of [it2, it2 + distance(it1, last)) returns true
template<class Input1It, class Input2It, class OutputIt, class Predicate>
constexpr OutputIt select_if(Input1It it1, Input1It last,
Input2It it2, OutputIt dest, Predicate pred)
{
for( ; it1 != last; ++it1, ++it2)
{
if (pred(*it2))
{
*dest++ = *it1;
}
}
return dest;
}

template<class Iterator, class Func>
void for_each_n_permute_k(int n, Iterator first, Iterator last, Func f)
{
// e.g. for n == 10 -> {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::vector<int> numbers(n);
std::iota(numbers.begin(), numbers.end(), 0);

// e.g. for n == 10 and k == 6 -> {1, 1, 1, 1, 1, 1, 0, 0, 0, 0};
std::vector<int> flags(n);
std::fill(flags.begin(), flags.begin() + std::distance(first, last), 1);

long long int tested = 0;

do
{
// choose the k elements, e.g. for n == 10 and k == 6 -> {0, 1, 2, 3, 4, 5};
select_if(numbers.begin(), numbers.end(), flags.begin(), first,
[] (int x) { return x == 1; });
do
{
++tested;
f();
} while (std::next_permutation(first, last));

// 'flags' starts sorted in descending order, so I need the previous permutation
} while (std::prev_permutation(flags.begin(), flags.end()));

std::cout << "\nPermutations tested: " << tested << '\n';
}

Он находит то же решение, пересекая все и только различные (10! / (10 — 6)!) = 151 200 перестановок.