{"id":4995,"date":"2021-10-08T00:01:00","date_gmt":"2021-10-08T07:01:00","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=4995"},"modified":"2021-10-02T09:37:16","modified_gmt":"2021-10-02T16:37:16","slug":"alphabedecimal-revisited-solution","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=4995","title":{"rendered":"Alphabedecimal Revisited – Solution"},"content":{"rendered":"

The challenge for this month’s Exercise<\/a> is to count in “alphabedecimal,” generating output from AAAA through ZZZZ, without using nested loops or a complex if<\/em> structure. Your solution must use a recursive function that handles flipping the digits, er, characters.
\n
\nThis new approach to the old alphabedecimal puzzle stemmed from a project where I try to brute-force guess passwords. It’s an interesting puzzle, one that appears in an upcoming book. The attempt made me aware of a cleaner, better way to handle flipping digits in alphabetic output.<\/p>\n

For my solution, I created the recursive function, flip()<\/em>:<\/p>\n

int flip(char *c,int pos);<\/code><\/p>\n

The function requires two arguments: a string to manipulate (char *c<\/code>) and a character position to flip(int pos<\/code>). The position argument is the key to eliminating the cascading if<\/em> statements from the earlier solution.<\/p>\n

The flip<\/em> function calls itself when a character at the given position flips from Z to A. The position indicator is incremented and the next character in the string is incremented by calling the flip()<\/em> function again.<\/p>\n

The flip()<\/em> function returns values 1 (TRUE) or 0 (FALSE) depending on whether the final character has flipped. When the final character is finally flipped, the function returns 0 (FALSE). This value falls through all the recursive calls to end the process.<\/p>\n

Here is the full code for my solution:<\/p>\n

2021_10-Exercise.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n\r\nint flip(char *c,int pos)\r\n{\r\n    (*(c+pos))++;                   \/* increment the letter *\/<\/span>\r\n    if( *(c+pos) > 'Z' )            \/* check for overflow *\/<\/span>\r\n    {\r\n        *(c+pos) = 'A';             \/* reset back to a *\/<\/span>\r\n        if( pos!=0 )                \/* watch for overflow *\/<\/span>\r\n        {\r\n            if( !flip(c,pos-1) )    \/* flip the next column's digit *\/<\/span>\r\n                return(0);          \/* echo down the FALSE return *\/<\/span>\r\n        }\r\n        else\r\n            return(0);              \/* last column, FALSE return *\/<\/span>\r\n    }\r\n    return(1);                      \/* keep looping *\/<\/span>\r\n}\r\n\r\nint main()\r\n{\r\n    const unsigned length = 4;\r\n    char digits[length] = \"AAAA\";\r\n\r\n    do\r\n    {\r\n        puts(digits);\r\n    }\r\n    while( flip(digits,length-1) );\r\n\r\n    return(0);\r\n}<\/pre>\n
At Line 5, The flip()<\/em> function increments the character at position pos<\/code>. If this character is greater than 'Z'<\/code>, it’s reset back to 'A'<\/code>. The pos<\/code> variable is compared with zero, which indicates the last character in the string. If pos<\/code> isn’t zero, the flip()<\/em> function is recursively called, incrementing the next digit in the string.<\/p>\n
Because the flip()<\/em> function does all the work, the main()<\/em> function requires only a do-while<\/em> loop to process the string. A puts()<\/em> statement outputs the characters in digits[]<\/code> as they turn from AAAA through ZZZZ.<\/p>\n
I hope you devised a similar solution, using a recursive function to process characters in a string in a sequential manner. A recursive function eliminates not only nested for<\/em> loops but a complex, cascading if<\/em> decision tree.<\/p>\n
By the way, I compared the timing for this solution with my original Exercise solution<\/a>. Both run at about the same speed. I saw no advantage to making the function recursive versus the cascading if<\/em> structure thing. Yet, I still prefer this solution to the problem.<\/p>\n","protected":false},"excerpt":{"rendered":"
The challenge for this month’s Exercise is to count in “alphabedecimal,” generating output from AAAA through ZZZZ, without using nested loops or a complex if structure. Your solution must use a recursive function that handles flipping the digits, er, characters.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[5],"tags":[],"class_list":["post-4995","post","type-post","status-publish","format-standard","hentry","category-solution"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4995","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=4995"}],"version-history":[{"count":7,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4995\/revisions"}],"predecessor-version":[{"id":5010,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4995\/revisions\/5010"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=4995"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=4995"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=4995"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}