The Big Programming Thread - Page 643

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

struct DiceConfiguration
{
    int DiceNumber;
    int DiceType;
};

struct DiceThrowsResult
{
    int DiceNumber;
    int Sum;
    int ThrowsResults[];
};

struct DiceConfiguration* GetConfiguration(void);
struct DiceThrowsResult* ThrowDices(struct DiceConfiguration *config);
int ThrowDice(struct DiceConfiguration *config);
void PrintDiceThrowsResult(struct DiceThrowsResult *result);
//void CheckExit(struct DiceConfiguration *config);
int CheckContinue(void);
void ReleaseMemory(struct DiceConfiguration *config, struct DiceThrowsResult *result);

int main(void)
{
    int ThrowAgain;
    struct DiceConfiguration *config;
    struct DiceThrowsResult *result;
   
    do
    {
        srand((unsigned int) time(0)); // random seed
   
        config = GetConfiguration();
       
        //CheckExit(config);
   
        result = ThrowDices(config);
   
        PrintDiceThrowsResult(result);
       
        ThrowAgain = CheckContinue();
    }while(ThrowAgain = 1);
   
    ReleaseMemory(config, result);
   
    return 0;
}

struct DiceConfiguration* GetConfiguration(void)
{
    struct DiceConfiguration *config;
    config = malloc(sizeof(struct DiceConfiguration));
   
    printf("Entering \"0\" (zero) will exit the program.\n");
    printf("Enter the number of dice: ");
    scanf("%d", &config->DiceNumber);
    printf("Enter dice type (sides) : ");
    scanf("%d", &config->DiceType);
   
    return config;
}

struct DiceThrowsResult* ThrowDices(struct DiceConfiguration *config)
{
    struct DiceThrowsResult *result;
    result = malloc(sizeof(struct DiceThrowsResult) + config->DiceNumber * sizeof(int));
    result->DiceNumber = config->DiceNumber;
   
    for (int i = 0; i < config->DiceNumber; i++)
    {
        result->ThrowsResults[i] = ThrowDice(config);
        result->Sum += result->ThrowsResults[i];
    }
   
    return result;
}

int ThrowDice(struct DiceConfiguration *config)
{
    return rand() % config->DiceType + 1;
}

void PrintDiceThrowsResult(struct DiceThrowsResult *result)
{
   
    for (int i = 0; i < result->DiceNumber; i++)
    {
        printf("%d ", result->ThrowsResults[i]);
    }
   
    printf("Sum: %d\n", result->Sum);
}

/*
void CheckExit(struct DiceConfiguration *config)
{
   
    if (config->DiceNumber = 0 || config->DiceType = 0)
    {
        printf("Closing generator...\n");
        break;
    }
}
*/

int CheckContinue(void)
{
    char ContinueDecision;
    int AdjustLoop;
   
    printf("Would you like to throw the dice again? (y/n): ");
    ContinueDecision = getchar();
    while(getchar() != '\n');
   
    if(ContinueDecision = 'y')
    {
        AdjustLoop = 1;
    }
   
    if(ContinueDecision = 'n')
    {
        AdjustLoop = 0;
    }
   
    return AdjustLoop;
}

void ReleaseMemory(struct DiceConfiguration *config, struct DiceThrowsResult *result)
{
    if (config != NULL)
    {
        free(config);
        config = NULL;
    }
   
    if (result != NULL)
    {
        free(result);
        result = NULL;
    }
}

return x > ? fill_range(x, size, range, 1) : fill_range(x, size, range, 0);

/bin
  -- executables go here
/config
  -- makefiles, misc config files
/data
  -- sqlite databases, images etc.
/scripts
  -- Lua and other stuff
/src
  /ext
    -- external libraries (other people's stuff and such)
  /lib
    -- actual c code goes here
  /sys
    -- headers go here

#include <stdio.h>
#define MIN(X, Y) (((X) < (Y)) ? (X) : (Y));
#define MAX(X, Y) (((X) > (Y)) ? (X) : (Y));

// prototypes
int factorial(int n);
int sum(int n);
int check_increment(int x, int reverse)
int* fill_range(int x, int size, int* range, int reverse);
int* irange(int x, int y);

int main()
{
    int fac = factorial(5);
    int* range1 = irange(1, 10);
    int* range2 = irange(10, 1);
    int i = 0;

    printf("Factorial of 5 is: %d\n", fac);
    
    for (i = 0; i < 10; ++i)
    {
        printf("Normal range %d: %d\n", i, range1[i];
    }
    
    for (i = 0; i < 10; ++i)
    {
        printf("Reverse range %d: %d\n", i, range2[i];
    }

    return 0;
}

int factorial(int n)
{
    if (n < 2)
        return 1;
    
    return (n * factorial(n - 1));
}

int sum(int n)
{
    return ((n * (n + 1)) / 2);
}

int check_increment(int x, int reverse)
{
    return reverse ? x -= 1 : x += 1;
}

int* fill_range(int x, int size, int* range, int reverse)
{
    int i = 0;
    
    while (i < size)
    {
        range[i] = x;

        i += 1;
        x = check_increment(x, reverse);
    }
    
    return range;
}


int* irange(int x, int y)
{
    int size = MAX(x, y) - MIN(x, y) + 1;
    int range[size];
        
    return x > ? fill_range(x, size, range, 1) : fill_range(x, size, range, 0);
}

int* fill_range(int x, int size, int* range, int step)
{
    int i = 0;
    
    while (i < size)
    {
        range[i] = x;

        i += 1;
        x += step;
    }
    
    return range;
}

int* irange(int x, int y)
{
    int size = MAX(x, y) - MIN(x, y) + 1;
    int range[size];
        
    return x > y? fill_range(x, size, range, 1) : fill_range(x, size, range, -1);
}

 if (..) throw std::exception(..);

typedef std::vector<SomeType> SomeTypeVector;
typedef SomeTypeVector::iterator SomeTypeVectorIt;

int step = x>y ? 1 : -1;
return fill_range( x, size, range, step );

int debug_printf(char * buffer, int len);
int main()
{
    char* foo = "Hello World"; // "Hello World" is put onto the Stack here
    debug_printf(foo, strlen(foo));
}

int debug_printf(char * buffer, int len)
{
    //"Hello World" is still within the stack frame for 
    buffer[len] = "\n"
    buffer[len+1] = 0;
    printf("%s", buffer);
    return 1;
}