I hope this month’s Exercise didn’t terrify you. I remember seeing * The Seventh Voyage of Sinbad * when I was a kid. The cyclops bothered me so much I asked my mom questions about him for a month.

A cyclops number is neither 10 meters tall nor impervious to javelins. It is, however, easy to catch when you do as I did and use the *sprintf()* function to convert the value into a string. Afterwards, you scan the string for the presence of a zero digit and then determine whether that single zero dwells in the center of the odd-character string.

For my solution, I crafted the *zero_count()* function. It consumes a string and returns the number of zeros. This function helped reduce my solution’s main loop to a handful of *if* tests that pluck out a cyclopean value.

### 2022_09-Exercise.c

#include <stdio.h> #include <string.h> /* count the zero '0' characters in the string */ int zero_count(char *v) { int a = 0; /* - crawl through the string - okay to modify v here */ while( *v ) { if( *v == '0' ) a++; /* count '0' character */ v++; /* increment pointer */ } return(a); } int main() { const char digits = 6; /* storage for up to 5 digits */ const int total = 100; /* total numbers to find */ const int columns = 9; /* number of columns for output table */ int cyclops,count,len,mid,x,y; char buffer[digits]; int results[total]; /* store the results for fancy output */ printf("The first %d cyclops numbers\n",total); cyclops = count = 0; while( count<total ) { sprintf(buffer,"%d",cyclops); len = strlen(buffer); /* process strings greater than two characters and only odd-length strings */ if( len>2 && len%2 ) { /* must have only one zero */ if( zero_count(buffer)==1 ) { mid = len/2; /* middle character offset */ if(buffer[mid]=='0' ) /* is zero? */ { /* save the value and update the count */ results[count] = cyclops; count++; } } } /* next potential cyclops value */ cyclops++; } /* output the results in a fancy table */ x = 0; while( count ) { for( y=0; y<columns; y++ ) { printf("%5d",results[(x*columns)+y]); count--; /* decrement the count */ if( !count ) /* if count is zero, stop */ break; if( y<columns-1) putchar('\t'); } x++; putchar('\n'); } return(0); }

The *zero_count()* function plows through string `v`

looking for zero digit characters. It counts the total and returns this value.

In the *main()* function, a *while* loop uses variable `count`

to tally the first 100 cyclops values. Three *if* tests cull the results as variable `cyclops`

increments from zero.

The first *if* test ensures that the string length (`len`

) value has at least three digits and an odd length: `if( len>2 && len%2 )`

The second *if* test confirms that the value has only one zero:

`if( zero_count(buffer)==1 )`

The final *if* test uses variable `mid`

to seek out the string’s center digit: `mid = len/2;`

As these variables are integers, the result is rounded. Then the final *if* test checks the center digit: `if(buffer[mid]=='0' )`

Upon success, the value is stored in the `results[]`

array, and variable `count`

is incremented.

The final *while* loop generates a multi-column table displaying the results. You can read details on how this loop works in a future Lesson.

I hope your solution met with success. From the earlier post on counting digits, obviously logarithms and division can also be used to determine the number of digits in a value. If you used one of these approaches in your solution, all the better!

Just interested in your thoughts on the differences between (a) going through all the numbers and testing for Cyclops numbers, and (b) generating the Cyclops numbers in order. Your solution has the advantage of being easier to code, but as the numbers become longer and longer the proportion of Cyclops numbers will slowly but surely drop, meaning more and more time testing numbers which aren’t Cyclops. My solution generates all Cyclops numbers which (I hope!) means it is more efficient in the long run.

#include <stdio.h>#include <stdlib.h>intincrement(int*digits,intnDigits){// increment an nDigits-

longnumber, ensuring there are no zeros// digits are stored in an

intarrayint*currDigit = digits + nDigits – 1; // find last digitintdone = 0;while(!done){(*currDigit)++;

if(*currDigit == 10){// time to tick over the next digit to the left

*currDigit = 1;

*currDigit–;

done = (currDigit < digits); // have we gone past the front?

}elsereturn1; // increment was successful}return0; // No valid increment, all done}intmain (void){int*digitBuffer = NULL, *pre, *post, digits = 1, count = 0;constintcountLimit = 100;while(count < countLimit){if(!digitBuffer){// first time entering loop with this number of digits

digitBuffer = malloc(2 * digits *

sizeof(int));if(!digitBuffer){printf("No memory for malloc()\n");

return1;}pre = digitBuffer;

post = digitBuffer + digits;

for(intd = 0; d < digits; d++)*(pre + d) = *(post + d) = 1;

*(post + digits – 1) = 0; // set *post ready to be incremented

}if(increment(post, digits)){// success! Print the Cyclops number and keep count

for(intd = 0; d < digits; d++)putchar(‘0’ + *(pre + d));

putchar(‘0’);

for(intd = 0; d < digits; d++)putchar(‘0’ + *(post + d));

putchar(‘\n’);

count++;

}else{// failed to increment, so … try to increment pre

if(increment(pre, digits)){// success! reset post to be ready to be incremented next loop

for(intd = 0; d < digits – 1; d++)*(post + d) = 1;

*(post + digits – 1) = 0;

}else{// OK, run out of digits. Reset and start again with one more digit

free(digitBuffer);

digitBuffer = NULL;

digits++;

}}}free(digitBuffer);

return0;}Now that’s darn clever! I didn’t think of that approach, which is purely constructive as opposed to mine which is more of a hunt. I congratulate you on such a clever solution!