Draw figures on the console.

cl11_06.c

/*
 * (C)2011 ne_Sachurou [email protected]
 * cf. https://gist.github.com/1037166
 */


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

#define ASTERISC '*'
#define SPACE ' '

int get_figuretype(void);
int get_is_empty(void);
int get_figuresize(void);
void draw_figure(int, int, int);

static void draw_segment(int, char);
static void draw_nl(void);
void draw_row(int, int, char);
void draw_framed_row(int, int, char);

void draw_rectangle(int, int);
void draw_triangle_bottomleft(int, int);
void draw_triangle_topleft(int, int);
void draw_triangle_middleright(int, int);
void draw_diamond(int, int);
void draw_octagle(int, int);
void draw_asterisc(int);

static int coordvalue(int, int, int);
void draw_canvas(char (*)[]);
void fill_canvas(char (*)[], int, char);
void rotate_canvas(char (*)[], int, int);

void draw_spiral(int);


int main(int argc, char *argv[])
{
    int figuretype, is_empty = 0, figuresize;

    if (argc >= 4)
    {
        figuretype = atoi(argv[1]);
        is_empty = atoi(argv[2]);
        figuresize = atoi(argv[3]);
        if (figuretype < 1 || 8 < figuretype ||
            figuresize < 2 || 9 < figuresize) {
            return 1;
        }
        draw_figure(figuretype, figuresize, is_empty);
        return 0;
    }

    while (1)
    {
        figuretype = get_figuretype();
        if (figuretype == 0)
        {
            break;
        }
        is_empty = (figuretype == 7 || figuretype == 8) ? 0 : get_is_empty();
        figuresize = get_figuresize();
        draw_figure(figuretype, figuresize, is_empty);
        printf("\nOK.\n");
        rewind(stdin);
        getchar();
    }
    return 0;
}


int get_figuretype(void)
{
    int figuretype = -1;

    while (figuretype < 0 || 8 < figuretype)
    {
        printf("Select figure type. (0 - 8)\n"
               "  0: Exit this program.\n"
               "  1: Rectangle\n"
               "  2: Triangle (Bottom-Left is the right angle.)\n"
               "  3: Triangle (Top-Left is the right angle.)\n"
               "  4: Triangle (Right-Middle is the right angle.)\n"
               "  5: Diamond\n"
               "  6: Octagon\n"
               "  7: Asterisc\n"
               "  8: Spiral\n");
        rewind(stdin);
        scanf("%d", &figuretype);
    }
    return figuretype;
}


int get_is_empty(void)
{
    char is_empty;

    printf("Is the figure empty or not? (Y/N) : ");
    rewind(stdin);
    scanf("%c", &is_empty);
    return (is_empty == 'Y' || is_empty == 'y') ? 1 : 0;
}


int get_figuresize(void)
{
    int figuresize;

    while (1)
    {
        printf("数字（2～9）を入力してください：");
        rewind(stdin);
        scanf("%d", &figuresize);
        if (figuresize < 2 || 9 < figuresize)
        {
            printf("The int figuresize is irregular number (Please input 2 - 9).\n");
        }
        else
        {
            break;
        }
    }
    return figuresize;
}


void draw_figure(int figuretype, int figuresize, int is_empty)
{
    switch (figuretype)
    {
    case 1:
        draw_rectangle(figuresize, is_empty);
        break;
    case 2:
        draw_triangle_bottomleft(figuresize, is_empty);
        break;
    case 3:
        draw_triangle_topleft(figuresize, is_empty);
        break;
    case 4:
        draw_triangle_middleright(figuresize, is_empty);
        break;
    case 5:
        draw_diamond(figuresize, is_empty);
        break;
    case 6:
        draw_octagle(figuresize, is_empty);
        break;
    case 7:
        draw_asterisc(figuresize);
        break;
    case 8:
        draw_spiral(figuresize);
        break;
    }
}


static void draw_segment(int n, char c) {
    for (; n > 0; --n)
    {
        putchar(c);
    }
}


static void draw_nl(void)
{
    putchar('\n');
}


/*
 * ex.
 *   draw_row(5, 4, '*');
 *   ->    *****\n
 *
 *   draw_row(3, 6, '*');
 *   ->      ***\n
 */
void draw_row(int n, int spaces, char c)
{
    draw_segment(spaces, SPACE);
    draw_segment(n, c);
    draw_nl();
}


/*
 * ex.
 *   draw_framed_row(5, 4, '*');
 *   ->    *   *\n
 *
 *   draw_framed_row(3, 6, '*');
 *   ->      * *\n
 */
void draw_framed_row(int n, int spaces, char c)
{
    draw_segment(spaces, SPACE);
    putchar(c);
    draw_segment(n - 2, SPACE);
    putchar(c);
    draw_nl();
}


void draw_rectangle(int figuresize, int is_empty)
{
    int i;

    if (!is_empty)
    {
        for (i = 0; i < figuresize; ++i)
        {
            draw_row(figuresize, 0, ASTERISC);
        }
    }
    else
    {
        draw_row(figuresize, 0, ASTERISC);
        for (i = 0; i < figuresize - 2; ++i)
        {
            draw_framed_row(figuresize, 0, ASTERISC);
        }
        draw_row(figuresize, 0, ASTERISC);
    }
}


void draw_triangle_bottomleft(int figuresize, int is_empty)
{
    int i;

    if (!is_empty)
    {
        for (i = 1; i <= figuresize; ++i)
        {
            draw_row(i, 0, ASTERISC);
        }
    }
    else
    {
        draw_row(1, 0, ASTERISC);
        for (i = 2; i <= figuresize - 1; ++i)
        {
            draw_framed_row(i, 0, ASTERISC);
        }
        draw_row(figuresize, 0, ASTERISC);
    }
}


void draw_triangle_topleft(int figuresize, int is_empty)
{
    if (!is_empty)
    {
        for (; figuresize > 0; --figuresize)
        {
            draw_row(figuresize, 0, ASTERISC);
        }
    }
    else
    {
        draw_row(figuresize, 0, ASTERISC);
        for (--figuresize; figuresize > 1; --figuresize)
        {
            draw_framed_row(figuresize, 0, ASTERISC);
        }
        draw_row(1, 0, ASTERISC);
    }
}


void draw_triangle_middleright(int figuresize, int is_empty)
{
    int i;

    if (!is_empty)
    {
        for (i = 1; i <= figuresize; ++i)
        {
            draw_row(i, 0, ASTERISC);
        }
        for (i = figuresize - 1; i > 0; --i)
        {
            draw_row(i, 0, ASTERISC);
        }
    }
    else
    {
        draw_row(1, 0, ASTERISC);
        for (i = 2; i <= figuresize; ++i)
        {
            draw_framed_row(i, 0, ASTERISC);
        }
        for (i = figuresize - 1; i > 1; --i)
        {
            draw_framed_row(i, 0, ASTERISC);
        }
        draw_row(1, 0, ASTERISC);
    }
}


void draw_diamond(int figuresize, int is_empty)
{
    int i;

    if (!is_empty)
    {
        for (i = 1; i <= figuresize; ++i)
        {
            draw_row(i * 2 - 1, figuresize - i, ASTERISC);
        }
        for (i = figuresize - 1; i > 0; --i)
        {
            draw_row(i * 2 - 1, figuresize - i, ASTERISC);
        }
    }
    else
    {
        draw_row(1, figuresize - 1, ASTERISC);
        for (i = 2; i <= figuresize; ++i)
        {
            draw_framed_row(i * 2 - 1 , figuresize - i, ASTERISC);
        }
        for (i = figuresize - 1; i > 1; --i)
        {
            draw_framed_row(i * 2 - 1 , figuresize - i, ASTERISC);
        }
        draw_row(1, figuresize - 1, ASTERISC);
    }
}


void draw_octagle(int figuresize, int is_empty)
{
    int i;

    if (!is_empty)
    {
        for (i = 1; i < figuresize; ++i)
        {
            draw_row(figuresize + (i - 1) * 2, figuresize - i, ASTERISC);
        }
        for (i = 0; i < figuresize; ++i)
        {
            draw_row(figuresize * 3 - 2, 0, ASTERISC);
        }
        for (i = figuresize - 1; i > 0; --i)
        {
            draw_row(figuresize + (i - 1) * 2, figuresize - i, ASTERISC);
        }
    }
    else
    {
        draw_row(figuresize, figuresize - 1, ASTERISC);
         for (i = 2; i < figuresize; ++i)
        {
            draw_framed_row(figuresize + (i - 1) * 2, figuresize - i, ASTERISC);
        }
        for (i = 0; i < figuresize; ++i)
        {
            draw_framed_row(figuresize * 3 - 2, 0, ASTERISC);
        }
        for (i = figuresize - 1; i > 1; --i)
        {
            draw_framed_row(figuresize + (i - 1) * 2, figuresize - i, ASTERISC);
        }
        draw_row(figuresize, figuresize - 1, ASTERISC);
    }
}


void draw_asterisc(int figuresize)
{
    int i;

    for (i = 0; i < figuresize / 2; ++i)
    {
        draw_segment(i, SPACE);
        draw_segment(1, ASTERISC);
        draw_segment(figuresize / 2 - (i + 1), SPACE);
        draw_segment(1, ASTERISC);
        draw_segment(figuresize / 2 - (i + 1), SPACE);
        draw_segment(1, ASTERISC);
        draw_nl();
    }
    draw_row(figuresize, 0, ASTERISC);
    for (i = figuresize / 2 - 1; i >= 0; --i)
    {
        draw_segment(i, SPACE);
        draw_segment(1, ASTERISC);
        draw_segment(figuresize / 2 - (i + 1), SPACE);
        draw_segment(1, ASTERISC);
        draw_segment(figuresize / 2 - (i + 1), SPACE);
        draw_segment(1, ASTERISC);
        draw_nl();
    }
}


static int coordvalue(int x, int y, int canvassize)
{
    return (canvassize + 1) * x + y;
}


void draw_canvas(char (*canvas)[])
{
    printf("%s", *canvas);
}


void fill_canvas(char (*canvas)[], int canvassize, char c)
{
    int i, j;

    for (i = 0; i < canvassize; ++i)
    {
        for (j = 0; j < canvassize; ++j)
        {
            (*canvas)[coordvalue(i, j, canvassize)] = c;
        }
    }
    for (i = 0; i < canvassize; ++i)
    {
        (*canvas)[coordvalue(i, canvassize, canvassize)] = '\n';
    }
    (*canvas)[coordvalue(canvassize - 1, canvassize, canvassize) + 1] = '\0';
}


/*
 * @param int direction: Right = 1, Left = -1
 */
void rotate_canvas(char (*canvas)[], int canvassize, int direction)
{
    int i, j;
    char subcanvas[coordvalue(canvassize - 1, canvassize, canvassize) + 2];

    strcpy(subcanvas, *canvas);
    for (i = 0; i < canvassize; ++i)
    {
        for (j = 0; j < canvassize; ++j)
        {
            (*canvas)[coordvalue(i, j, canvassize)] =
                direction == 1 ?
                subcanvas[coordvalue(canvassize - j - 1, i, canvassize)] :
                subcanvas[coordvalue(j, canvassize - i - 1, canvassize)];
        }
    }
}


void draw_spiral(int figuresize)
{
    int point[] = {0, 0},
        is_continue = 0,
        rotate_time = 0,
        tmp;
    char canvas[figuresize * (figuresize + 1) + 1];

    fill_canvas(&canvas, figuresize, SPACE);
    while (1)
    {
        while ((point[1] + 1 <= figuresize) &&
               (canvas[coordvalue(point[0], point[1] + 1, figuresize)] != ASTERISC))
        {
            is_continue = 1;
            canvas[coordvalue(point[0], point[1], figuresize)] = ASTERISC;
            ++point[1];
        }
        rotate_canvas(&canvas, figuresize, -1);
        ++rotate_time;
        tmp = point[0];
        point[0] = figuresize - point[1];
        point[1] = tmp;
        if (is_continue)
        {
            is_continue = 0;
        }
        else
        {
            break;
        }
    }
    for (rotate_time %= 4; rotate_time > 0; --rotate_time)
    {
        rotate_canvas(&canvas, figuresize, 1);
    }
    draw_canvas(&canvas);
}

draw_asterisc.c

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

static int rowlength(int, int, int);
void fillrow(char (*)[], int, char);
void draw_asterisc(int, int, char);


int main(int argc, char *argv[])
{
    int cols, rows;

    if (argc >= 3)
    {
        cols = atoi(argv[1]);
        rows = atoi(argv[2]);
    }
    else
    {
        cols = 7;
        rows = 7;
    }

    draw_asterisc(cols, rows, '*');
    return 0;
}


static int rowlength(int cols, int rows, int stepnum)
{
    return 1 + (cols - 1) * stepnum / (rows - 1);
}


void fillrow(char (*row)[], int length, char c)
{
    length -= 2;
    for (; length >= 0; --length) {
        (*row)[length] = c;
    }
}


void draw_asterisc(int n, int m, char c)
{
    char row[n + 1];
    int i, j;

    row[n] = '\0';
    for (i = 0; i < m; ++i)
    {
        fillrow(&row, n + 1, ' ');
        row[rowlength(n, m, i) - 1] = c;
        row[n / 2] = c;
        row[n - rowlength(n, m, i)] = c;
        if (i == m / 2)
        {
            fillrow(&row, n + 1, c);
        }
        printf("%s\n", row);
    }
}

draw_shape.c

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

static int rowlength(int, int, int);
void draw_row(int, int);
void draw_rectangle(int, int);
void draw_triangle_topleft(int, int);
void draw_triangle_topright(int, int);
void draw_triangle_bottomleft(int, int);
void draw_triangle_bottomright(int, int);
void draw_triangle(int, int, char []);


int main(int argc, char *argv[]) {
    draw_rectangle(3, 3);
    draw_triangle(3, 3, "tr");
    draw_triangle(3, 3, "tl");
    draw_triangle(3, 3, "br");
    draw_triangle(3, 3, "tr");
    return 0;
}


static int rowlength(int cols, int rows, int stepnum) {
    return 1 + (cols - 1) * stepnum / (rows - 1);
}


void draw_row(int n, int spaces) {
    char row[n + spaces + 1];
    int i;

    for (i = 0; i < spaces; ++i)
    {
        row[i] = ' ';
    }
    n += spaces;
    for (; i < n; ++i)
    {
        row[i] = '*';
    }
    row[i] = '\0';
    printf("%s\n", row);
}


void draw_rectangle(int n, int m) {
    for (; m > 0; --m)
    {
        draw_row(n, 0);
    }
}


void draw_triangle_topleft(int n, int m) {
    int i;

    for (i = m - 1; i >= 0; --i)
    {
        draw_row(rowlength(n, m, i), 0);
    }
}


void draw_triangle_topright(int n, int m) {
    int i, rlen;

    for (i = m - 1; i >= 0; --i)
    {
        rlen = rowlength(n, m, i);
        draw_row(rlen, m - rlen);
    }
}


void draw_triangle_bottomleft(int n, int m) {
    int i;

    for (i = 0; i < m; ++i)
    {
        draw_row(rowlength(n, m, i), 0);
    }
}


void draw_triangle_bottomright(int n, int m) {
    int i, rlen;

    for (i = 0; i < n; ++i)
    {
        rlen = rowlength(n, m, i);
        draw_row(rlen, n - rlen);
    }
}


void draw_triangle(int n, int m, char shape[]) {
    if (shape == "tr")
    {
        draw_triangle_topright(n, m);
    }
    else if(shape == "tl")
    {
        draw_triangle_topleft(n, m);
    }
    else if(shape == "br")
    {
        draw_triangle_bottomright(n, m);
    }
    else if(shape == "bl")
    {
        draw_triangle_bottomleft(n, m);
    }
}

cf.
06.c https://gist.github.com/394f655d1e2a8423b4f9

next. Draw Magic Square on the Console. https://gist.github.com/1180700