Programming

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

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

void parallel_function( int, int * );

int main()
{
    int flag = -1;
    int count = 0;

    #pragma omp parallel default( none ) shared( flag ) reduction( +:count )
    {
        while( flag < 0 )
        {
            parallel_function( count, &flag );
            count++;
        }
    }

    if( !flag )
        printf( "Nothing found!!! %i tries\n", count );

    else
        printf( "Match: %s ! Tries: %i\n",  EndString, count );

    return 0;
}

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( strncmp( TestString, str, sizeof( TestString ) ) == 0 )
    {
        strncpy( EndString, str, strlen( str ) );
        ( *flag ) = count;
    }
}

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

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

void parallel_function( int, int * );

int main()
{
    int flag = -1;
    int count = 0;

    #pragma omp parallel default( none ) shared( flag ) reduction( +:count )
    {
        while( flag < 0 )
        {
            parallel_function( count, &flag );
            count++;
        }
    }

    if( !flag )
        printf( "Nothing found!!! %i tries\n", flag );

    else
        printf( "Match: %s ! Tries: %i\n",  EndString, flag );

    return 0;
}

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( strncmp( TestString, str, sizeof( TestString ) ) == 0 )
    {
        strncpy( EndString, str, strlen( str ) );
        ( *flag ) = count;
    }
}

#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[]  = "4877";
char               EndString[16];

/* Functions */

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

int main()
{
    unsigned Counter     = 0;
    int      CheckStatus = -1;

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

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

            for( int i = 0; i < NLiterals; ++i )
            {
                FirstEntry[0] = i;
                LastEntry[0]  = i + 1;

                if( CheckStatus < 0 )
                    BruteForcer( FirstEntry, LastEntry, WordLength, &Counter, &CheckStatus );
            }
        }
    }

    if( CheckStatus < 0 )
        fprintf( stdout, "\nNothing found: '%s'! %u tries.\n", "Empty", Counter / 8 ); // Divided through the number of cores/threads <- in my case eight (Intel Core i7-920) ;-)

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

    exit( EXIT_SUCCESS );
}

static void BruteForcer( const int *FstEntry, const int *LstEntry, int WdLength, unsigned *CounterPtr, int *CheckStatusPtr )
{
    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 )
    {
        ++*CounterPtr;

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

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

        /* string compare */
        if( strncmp( TestString, Word, sizeof( TestString ) ) == 0 )
        {
            strncpy( EndString, Word, strlen( Word ) );
            *CheckStatusPtr = *CounterPtr;
            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;
    }
}