The Big Programming Thread - Page 727

//main.c
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "arange.h"
#include "irange.h"

int main(void)
{
    int_range_t *int_range = irange(1, 5);
    char_range_t *char_range = arange('a', 'f');

    puts("Int range:\n");

    for (int i = 0; i < int_range->length; i++) {
        printf("%d", int_range->nums[i]);
    }

    puts("Char range:\n");

    for (int i = 0; i < char_range->length; i++) {
        printf("%c", char_range->chars[i]);
    }

    free(int_range);
    free(char_range);

    return 0;
}

//arange.h
#include <stdlib.h>
#include <stdbool.h>

/* Definitions */
typedef struct char_range_s char_range_t;

/* Prototypes */
char_range_t *arange(char start, char end);
bool is_valid_letter(char input);

//arange.c
#include "arange.h"

typedef struct char_range_s {
    int length;
    char chars[];
} char_range_t;

/*
 * Function : arange
 * Arguments: char start - initial char, char end - final char
 *            (if start > end the range will be in descending order,
 *            only letters are supported)
 * Returns  : char_range_t or NULL
 * Notes    : The caller has to free the allocated memory
 */
char_range_t *arange(char start, char end)
{
    if (!is_valid_letter(start) || !is_valid_letter(end)) {
        return NULL;
    }

    char c;
    int istart = start - '0';
    int iend = end - '0';
    bool reverse = (iend < istart);
    int size = (reverse ? istart - iend : iend - istart) + 1;
    size_t mem = sizeof(char_range_t) + size * sizeof(char);
    char_range_t *range = malloc(mem);

    if (range == NULL) {
        return NULL;
    }

    range->length = size;

    for (int i = 0; i < size; i += 1) {
        c = reverse ? istart - i : istart + i;
        range->chars[i] = c;
    }

    return range;
}

bool is_valid_letter(char input)
{
    int val = input - '0';

    if ((val >= 65 && val <= 90) || (val >= 97 && val <= 122)) {
        return true;
    }

    return false;
}

//irange.h
#include <stdlib.h>
#include <stdbool.h>

/* Definitions */
typedef struct int_range_s int_range_t;

/* Prototypes */
int_range_t *irange(int start, int end);

//irange.c
#include "irange.h"

typedef struct int_range_s {
    int length;
    int nums[];
} int_range_t;

/*
 * Function : irange
 * Arguments: int start - initial int, int end - final int
 *            (if start > end the range will be in descending order)
 * Returns  : int_range_t or NULL
 * Notes    : The caller has to free the allocated memory
 */
int_range_t *irange(int start, int end)
{
    bool reverse = (end < start);
    int size = (reverse ? start - end : end - start) + 1;
    size_t mem = sizeof(int_range_t) + size * sizeof(int);
    int_range_t *range = malloc(mem);

    if (range == NULL) {
        return NULL;
    }

    range->length = size;

    for (int i = 0; i < size; i += 1) {
        range->nums[i] = reverse ? start - i : start + i;
    }

    return range;
}