+*/+8*8*+8+8/-8
+++++++---++

git@github.com:soroush/8-8-puzzle.git

...
8888+*888++8/-*        (8*((8*(8+8))-((8+(8+8))/8)))
8888+*88+8+8/-*        (8*((8*(8+8))-(((8+8)+8)/8)))
8888+*88+8/-*8-        ((8*((8*(8+8))-((8+8)/8)))-8)
8888+*88/-*88+-        ((8*((8*(8+8))-(8/8)))-(8+8))
8888+*88/-*8-8-        (((8*((8*(8+8))-(8/8)))-8)-8)
888+88+8/88*-*-        (8-((8+8)*(((8+8)/8)-(8*8))))
...

class EightPuzzleSolver
{
public:
    EightPuzzleSolver(WINDOW *_window, const std::string& outFile);
    ~EightPuzzleSolver();
    bool initialize(const size_t &start, const size_t &end);
    void start();
    void setThreadCount(const size_t&);
    std::vector<std::string> getResults();
private:
    bool check(const std::string &inputs);
    void permutation(std::string &input, size_t index);
    double total;
    int current;
    double precentage;
    uint printLine;
    std::pair<size_t,size_t> range;
    WINDOW* window;
    std::stack<int> evaluation;
    std::string symbols;
    std::vector<std::string> results;
    std::ofstream outFile;
    size_t splitDepth;
    std::mutex guard;
    // Timing
    std::chrono::steady_clock::time_point startTime;
};

void EightPuzzleSolver::permutation(string &input, size_t index)
{
    if(index==input.size()) {
        this->guard.lock();
        steady_clock::time_point now = steady_clock::now();
        auto ticks = now-this->startTime;
        auto s = duration_cast<chrono::seconds>(ticks).count()%60;
        auto m = duration_cast<chrono::minutes>(ticks).count()%60;
        auto h = duration_cast<chrono::hours>(ticks).count();
        auto ms = duration_cast<chrono::milliseconds>(ticks).count();
        wmove(window, 2, 0);
        ++current;
        precentage = 100.0*static_cast<double>(current)/total;
        std::chrono::milliseconds predict(static_cast<int>(100*ms/precentage));
        wprintw(window, "Elapsed Time: %dh:%dm:%ds," 
                   " Remaining Time: %04dh:%02dm:%02ds," 
                   " Progress: %d of %.0lf (%.4f%%) sample: %s",
                h,m,s,
                duration_cast<std::chrono::hours>(predict).count(),
                duration_cast<std::chrono::minutes>(predict).count()%60,
                duration_cast<std::chrono::seconds>(predict).count()%60,
                current,total,precentage,input.c_str());
        wrefresh(window);
        if(check(input)) {
            wmove(window, printLine, 0);
            wprintw(window, "%d: %s",results.size()+1,input.c_str());
            results.push_back(input);
            outFile << input << std::endl;
            wrefresh(window);
            ++printLine;
        }
        this->guard.unlock();
        return;
    }
    else if (index == this->splitDepth) {
        vector<thread> threads;
        for (char symbol : this->symbols) {
            input[index] = symbol;
            threads.emplace_back([=] {
                string cpy(input);
                permutation(cpy, index+1);
            });
        }
        for (thread& t: threads) {
            t.join();
        }
    }
    else {
        for (char symbol : this->symbols) {
            input[index] = symbol;
            permutation(input, index+1);
        }
    }
}

bool EightPuzzleSolver::check(const string &inputs)
{
    while(!evaluation.empty()) {
        evaluation.pop();
    }
    for(const auto& n: inputs) {
        int n1, n2;
        switch (n) {
        case '+': {
                if(evaluation.empty()) {
                    return false;
                }
                else {
                    n1 = evaluation.top();
                    evaluation.pop();
                }
                if(evaluation.empty()) {
                    return false;
                }
                else {
                    n2 = evaluation.top();
                    evaluation.pop();
                }
                evaluation.push(n2+n1);
            }
            break;
        case '-': {
                if(evaluation.empty()) {
                    return false;
                }
                else {
                    n1 = evaluation.top();
                    evaluation.pop();
                }
                if(evaluation.empty()) {
                    return false;
                }
                else {
                    n2 = evaluation.top();
                    evaluation.pop();
                }
                evaluation.push(n2-n1);
            }
            break;
        case '*': {
                if(evaluation.empty()) {
                    return false;
                }
                else {
                    n1 = evaluation.top();
                    evaluation.pop();
                }
                if(evaluation.empty()) {
                    return false;
                }
                else {
                    n2 = evaluation.top();
                    evaluation.pop();
                }
                evaluation.push(n2*n1);
            }
            break;
        case '/': {
                if(evaluation.empty()) {
                    return false;
                }
                else {
                    n1 = evaluation.top();
                    evaluation.pop();
                }
                if(evaluation.empty()) {
                    return false;
                }
                else {
                    n2 = evaluation.top();
                    evaluation.pop();
                }
                if(n1==0) {
                    return false;
                }
                else {
                    evaluation.push(n2/n1);
                }
            }
            break;
        case '8':
            evaluation.push(8);
            break;
        default:
            return false;
            break;
        }
    }
    return (evaluation.size()==1 && evaluation.top()==1000);
}

void EightPuzzleSolver::start()
{
    for (size_t length = this->range.second; length> this->range.first; --length) {
        wmove(window, 0, 0);
        total = pow(5.0,length);
        current = 0;
        precentage = 0.0;
        wprintw(window, "Checking strings of length: %d",length);
        wmove(window, 1, 0);
        wprintw(window, "Total: %.0lf",pow(5.0,length));
        string input(length,'8');
        this->startTime = steady_clock::now();
        permutation(input,0);
    }
}