Coding a Look-and-Say sequence should be fun, just like any C programming project where you’re not under pressure from a deadline. From last week’s Lesson<\/a>, I was able to create a nested loop that takes a number and outputs its Look-and-Say values. It’s time to update this code to output a sequence. This code went through several iterations before I recognized that the sequence quickly overflows the integer data type container. The range of an integer on most modern computers is between -2,147,483,684 and 2,147,483,647 signed, or zero to 4,294,967,295 unsigned. While I wanted to see 20 values of the sequence output, I was barely able to get six!<\/p>\n To ensure that the looksay()<\/em> function could handle larger values, I used an unsigned long long<\/em> value, which has a range from 0 to 18,446,744,073,709,551,615. Here is the code:<\/p>\n The main()<\/em> function uses unsigned long long<\/em> variable The looksay()<\/em> function is base on code presented in last week’s Lesson, though with the unsigned long long<\/em> used instead of int<\/em>. The snprintf()<\/em> function is updated with the The biggest change is building a string, The first statement converts a Look-and-Say value for a series of digits into a string, stored in variable Once the nested loops build the next value in the sequence (as a string), the strtoll()<\/em> function converts the string into a long long<\/em> value stored in variable The code worked at first, but the final values output were always 9223372036854775807, which seemed odd to me. I debugged the code by outputting the string After a few frustrating moments, it occurred to me that the strtoll()<\/em> function was overflowing. This is the reason why I added the test for overflow at the end of the function:<\/p>\n The The looksay()<\/em> function actually finds the next value in the sequence, 13211311123113112211. If you add a puts()<\/em> function to output string The code almost generates the results I wanted from the Look-and-Say sequence, shy one. A possible solution is to use the GMP Library, which I wrote about in a previous Lesson<\/a>. I may attempt to do so in the future, but I’m happy with the code now, and relieved that the issue with my attempt at a Look-and-Say sequence is overflow and not any booboo that I may have made.<\/p>\n","protected":false},"excerpt":{"rendered":" A few changes are required for my Look-and-Say sequence algorithm to output the sequence. Continue reading
\n
\nI tried to keep the entire sequence in the main()<\/em> function, though after a while it became obvious that a function is required. This function, which I name looksay()<\/em>, requires an integer value as its argument and returns an integer value, the next number in the sequence.<\/p>\n2024_09_21-Lesson.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n#include <limits.h>\r\n\r\nunsigned long long looksay(unsigned long long v)\r\n{\r\n const int size = 128;\r\n char number[size],temp[size],*n,c;\r\n static char value[128];\r\n int count;\r\n unsigned long long r;\r\n\r\n \/* convert and process the string *\/<\/span>\r\n snprintf(number,size,\"%lld\",v);\r\n value[0] = '\\0'; \/* cap the buffer for strcat() *\/<\/span>\r\n n = number; \/* initialize the pointer *\/<\/span>\r\n while(*n) \/* loop through the string *\/<\/span>\r\n {\r\n count = 0; \/* digit count *\/<\/span>\r\n c = *n; \/* save the current digit *\/<\/span>\r\n while( *n==c ) \/* loop while the digits match *\/<\/span>\r\n {\r\n count++;\r\n n++;\r\n }\r\n \/* convert the result into a string *\/<\/span>\r\n snprintf(temp,size,\"%d%c\",count,c);\r\n \/* build the new value string *\/<\/span>\r\n strcat(value,temp);\r\n }\r\n\r\n \/* convert the string back into a long *\/<\/span>\r\n r = strtoll(value,NULL,10);\r\n\r\n \/* check for overflow *\/<\/span>\r\n if( r==LONG_MAX )\r\n {\r\n puts(\"OVERFLOW\");\r\n exit(1);\r\n }\r\n\r\n return(r);\r\n}\r\n\r\nint main()\r\n{\r\n unsigned long long start;\r\n int x;\r\n\r\n printf(\"Starting value: \");\r\n scanf(\"%llu\",&start);\r\n\r\n \/* loop through 10 iterations *\/<\/span>\r\n printf(\"%llu\\n\",start);\r\n for( x=0; x<10; x++ )\r\n {\r\n start = looksay(start);\r\n printf(\"%llu\\n\",start);\r\n }\r\n\r\n return 0;\r\n}<\/pre>\nstart<\/code>, obtained from the user. The scanf()<\/em> function requires the %llu<\/code> placeholder to represent an unsigned long long<\/em> value. A for<\/em> loop repeats ten times, obtaining the Look-and-Say values in the sequence and outputting each one.<\/p>\n%llu<\/code> placeholder.<\/p>\nvalue<\/code>, which contains the Look-and-Say number. Two statements are used:<\/p>\nsnprintf(temp,size,\"%d%c\",count,c);
\nstrcat(value,temp);<\/code><\/p>\ntemp<\/code>. This string is then appended (concatenated) to the string value<\/code>.<\/p>\nr<\/code>.<\/p>\nvalue<\/code> created, which didn’t match the result returned from the strtoll()<\/em> function.<\/p>\nif( r==LONG_MAX )
\n{
\n puts(\"OVERFLOW\");
\n exit(1);
\n}<\/code><\/p>\nOVERFLOW<\/code> constant is defined in the limits.h<\/code> header file. This test is trigged in the looksay()<\/em> function, which removes the bogus value from the output, but proves that the function has its limits. Here is a sample run:<\/p>\nStarting value: 1
\n1
\n11
\n21
\n1211
\n111221
\n312211
\n13112221
\n1113213211
\n31131211131221
\nOVERFLOW<\/code><\/p>\nvalue<\/code> before the strtoll()<\/em> function, you see this value properly generated. But it’s value is beyond the range of an unsigned long long<\/em> integer — if you can fathom that.<\/p>\n