Programming

#pragma omp parallel default... reduction ( +: Counter )

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <omp.h>

/* Global variables */

const char         Literals[]    = "0123456789";
const unsigned int NLiterals     = sizeof( Literals ) - 1;
const char         TestString[]  = "4788";
char               EndString[16];

int CheckStatus = 0;

/* Functions */

static void BruteForcer( const int *, const int *, int, unsigned * );

int main()
{
    unsigned Counter = 0;

    #pragma omp parallel default( none ) shared( CheckStatus ) reduction( +:Counter )
    {
        for( int WordLength = 0; WordLength < 5; ++WordLength )
        {
            int FirstEntry[WordLength], LastEntry[WordLength], MyCheckStatus;

            for( int j = 0; j < WordLength; ++j )
                FirstEntry[j] = LastEntry[j] = 0;

            #pragma omp for schedule( dynamic )
            for( int i = 0; i < NLiterals; ++i )
            {
                FirstEntry[0] = i;
                LastEntry[0]  = i + 1;
                #pragma omp atomic read
                MyCheckStatus = CheckStatus;
                if( !MyCheckStatus )
                    BruteForcer( FirstEntry, LastEntry, WordLength, &Counter );
            }
        }
    }

    if( CheckStatus )
        fprintf( stdout, "\nWord found: '%s'! %u tries.\n", EndString, Counter );

    else
        fprintf( stdout, "\nNothing found: '%s'! %u tries.\n", "Empty", Counter );

    exit( EXIT_SUCCESS );
}

static void BruteForcer( const int *FstEntry, const int *LstEntry, int WdLength, unsigned *CounterPtr )
{
    char Word[WdLength];
    int  Entry[WdLength + 1];
    int  i, j;

    memset( Entry, '\0', WdLength );

    /* copy FstEntry to Entry */
    for( i = 0; i < WdLength; ++i )
        Entry[i] = FstEntry[i];

    i = 0;

    while( i < WdLength )
    {
        /* generate word */
        for( i = 0; i < WdLength; ++i )
            Word[i] = Literals[Entry[i]];

        /* null-byte at end of string */
        Word[WdLength] = '\0';

        ++*CounterPtr;

        /* string compare */
        if( strncmp( TestString, Word, sizeof( TestString ) ) == 0 )
        {
            strncpy( EndString, Word, strlen( Word ) );
            #pragma omp atomic write
            CheckStatus = 1;
            return;
        }

        /* increment Entry */
        for( i = 0; i < WdLength && ++Entry[WdLength-i-1] == NLiterals; i++ )
            Entry[WdLength-i-1] = 0;

        /* when Entry != LstEntry then leave loop */
        for( j = 0; j < WdLength; ++j )
            if( Entry[j] != LstEntry[j] )
                break;

        /* when Entry == LstEntry leave function */
        if( j == WdLength )
            return;
    }
}

Word found: '4788' ! 5899 tries!

Word found: '4788' ! 10899 tries! (Each time the number is another!)

int flag=-1;

while(flag < 0) {
        function(count, &flag);
        count++;
}

void parallel_function(int count, int *flag) {
        char str[10];
        int c=count;

        if( (*flag) >= 0) return;

        memset(str, 0, sizeof(str));

        // Compute the string from the value of 'c'.  Each different
        // count will give a unique solution.
        int length=(c%5)+1;
        c /= 5;

        for(int n=0; n<length; n++)
        {
                str[n]=Literals[c%Nliterals];
                c /= Nliterals;
        }

        // If and only if we have the correct solution, store the value.
        if(string_matches)
                (*flag)=count;
}