Completing C code with D style

[forkit]

On Monday, 8 November 2021 at 12:04:26 UTC, forkit wrote:
> On Tuesday, 2 November 2021 at 23:45:39 UTC, pascal111 wrote:
>> Next code originally was a classic C code I've written, it's 
>> pure vertical thinking, now, I converted it successfully to D 
>> code, but I think I made no much changes to make it has more 
>> horizontal thinking style that it seems D programmers care in 
>> horizontal thinking style. Is there any additions I can make 
>> in the code to make it suitable with D style or it's fine?
>>
>
> Oh man! some of those answers... whoooooohah....
>
> Here's mine, with a little of that horizontal thinking ;-)
>
> ....

And just had a little fun transposing my D code back into C.

They both produce exactly the same output.

But I tell ya.. the cognitive load .. well.. it increased 
dramatically ;-)

increased cognitive load bad!

// ==========================================

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>

void displayResults(const char answer1, const char answer2);

int main(void)
{
     char answer1, answer2;

     while (true)
     {
         printf("Would you like in list (n=negatives, p=positives, 
b=both)? ");
         scanf_s(" %c", &answer1, 1);
         if (answer1 == 'n' || answer1 == 'p' || answer1 == 'b')
         {
             break;
         }
         printf("%c is not a valid answer. Try again.\n", answer1);
     }

     while (true)
     {
         printf("Would you like in list (e=evens, o=odds, b=both)? 
");
         scanf_s(" %c", &answer2, 1);
         if (answer2 == 'e' || answer2 == 'o' || answer2 == 'b')
         {
             break;
         }
         printf("%c is not a valid answer. Try again.\n", answer2);
     }

     displayResults(answer1, answer2);

     putchar('\n');
     return EXIT_SUCCESS;
}

void displayResults(const char answer1, const char answer2)
{
     // NOTE: 0 is neither positive or negative, but is considered 
to be even

     int numbers[11] = {-3, 14, 47, -49, -30, 15, 4, -82, 99, 26, 
0};

     // an array to store results from answer1
     int result1[sizeof(numbers) / sizeof(numbers[0])];

     // the final array that consolidates the results from answer1 
and answer2
     // must be at least this size in case it stores all elements 
from numbers.
     int finalResult[sizeof(numbers) / sizeof(numbers[0])];

     int result1Count = 0; // to keep count of number of elements 
aquired in answer1
     int result2Count = 0; // to keep count of number of elements 
aquired in answer2

     // my version of a string builder ;-)
     const int msgSize = 50; // should be large enough to hold the 
entire message.
     char *const resultMsg = (char *)malloc(msgSize);
     if (resultMsg == NULL)
     {
         exit(EXIT_FAILURE); // not enough memory!! really??!!
     }
     strcpy_s(resultMsg, 15, "\nHere are all ");

     switch (answer1)
     {
         case 'n':
             for (size_t i = 0; i < sizeof(numbers) / sizeof(int); 
i++)
             {
                 if (numbers[i] < 0)
                     result1[result1Count++] = numbers[i];
             }
             memcpy((char *)resultMsg + 14, "[negative] \0", 12);
             break;
         case 'p':
             for (size_t i = 0; i < sizeof(numbers) / sizeof(int); 
i++)
             {
                 if (numbers[i] > 0)
                     result1[result1Count++] = numbers[i];
             }
             memcpy((char *)resultMsg + 14, "[positive] \0", 12);
             break;
         case 'b':
             for (size_t i = 0; i < sizeof(numbers) / sizeof(int); 
i++)
             {
                 result1[result1Count++] = numbers[i];
             }
             break;
         default:
             // how could it ever get here??
             printf("Bad input!!\n%c is not a valid answer.", 
answer1);
             assert(0); // don't waste my time!
     }

     // debug
     /*
     {
         printf("\n[ result1Count after processing answer1 is: %d 
]\n ", result1Count);
         for (int i = 0; i < result1Count; i++)
         {
             printf("%d ", result1[i]);
         }
         putchar('\n');
     }
     */

     switch (answer2)
     {
         case 'e':
             for (int i = 0; i < result1Count; i++)
             {
                 if ((result1[i] % 2) == 0)
                     finalResult[result2Count++] = result1[i];
             }

             if (answer1 == 'b')
             {
                 memcpy((char *)resultMsg + 14, "[even]\0", 7);
             }
             else
             {
                 memcpy((char *)resultMsg + 25, "[even]\0", 7);
             }

             break;
         case 'o':
             for (int i = 0; i < result1Count; i++)
             {
                 if ((result1[i] % 2) != 0)
                     finalResult[result2Count++] = result1[i];
             }

             if (answer1 == 'b')
             {
                 memcpy((char *)resultMsg + 14, "[odd]\0", 6);
             }
             else
             {
                 memcpy((char *)resultMsg + 25, "[odd]\0", 6);
             }

             break;
         case 'b':
             for (int i = 0; i < result1Count; i++)
             {
                 finalResult[result2Count++] = result1[i];
             }
             break;
         default:
             // how could it ever get here??
             printf("Bad input!!\n%c is not a valid answer.", 
answer2);
             assert(0); // don't waste my time!
     }

     // debug
     /*
     {
         printf("\n[ result2Count after processing answer2 is: %d 
]\n ", result2Count);
         for (int i = 0; i < result2Count; i++)
         {
             printf("%d ", finalResult[i]);
         }
         putchar('\n');
     }
     */

     // sort the part of the array that we're interested in, in 
ascending order.
     int t;
     for (int i = 0; i < result2Count; i++)
     {
         for (int j = i + 1; j < result2Count; j++)
         {
             if (finalResult[i] > finalResult[j])
             {
                 t = finalResult[i];
                 finalResult[i] = finalResult[j];
                 finalResult[j] = t;
             }
         }
     }

     printf("%s numbers:\n", resultMsg);

     // print all the elements of the array
     for (int i = 0; i < result2Count; i++)
     {
         printf("%d ", finalResult[i]);
     }

     free(resultMsg);
}


// =====================================================