ex8-1.c
/* code: ex8-1.c (v1.16.00) */
#include<stdio.h>
#include<stdlib.h>
#define MAX 128
#define PUSH_SUCCESS 1
#define PUSH_FAILURE -1
#define POP_SUCCESS 2
#define POP_FAILURE -2
/* ------------------------------------------- */
void stack_init (int *top)
{
*top = 0;
}
/* ------------------------------------------- */
void display (int stack[], int top)
{
int i;
printf ("STACK(%d): ", top);
for (i = 0; i < top; i++) {
printf ("%d ", stack[i]);
}
printf ("\n");
}
/* ------------------------------------------- */
int push (int stack[], int *top, int data)
{
if (*top >= MAX) {
/* stack overflow */
return PUSH_FAILURE;
}
else {
stack[*top] = data;
(*top)++;
return PUSH_SUCCESS;
}
}
/* ------------------------------------------- */
int pop (int stack[], int *top, int *data)
{
if ((*top) > 0) {
*data = stack[(*top) - 1];
(*top)--;
return POP_SUCCESS;
}
else {
/* stack empty */
return POP_FAILURE;
}
}
/* ------------------------------------------- */
int main ()
{
int stack[MAX];
int top, data;
stack_init (&top);
data = 300;
printf ("push: %d\n", data);
push (stack, &top, data);
data = 400;
printf ("push: %d\n", data);
push (stack, &top, data);
data = 500;
printf ("push: %d\n", data);
push (stack, &top, data);
display (stack, top);
pop (stack, &top, &data);
printf ("pop: %d\n", data);
pop (stack, &top, &data);
printf ("pop: %d\n", data);
pop (stack, &top, &data);
printf ("pop: %d\n", data);
return 0;
}
ex8-2.c
/* code: ex8-2.c (v1.16.00) */
#include<stdio.h>
#include<stdlib.h>
#define MAX 128
#define ENQUEUE_SUCCESS 1
#define ENQUEUE_FAILURE -1
#define DEQUEUE_SUCCESS 2
#define DEQUEUE_FAILURE -2
/* ------------------------------------------- */
void queue_init (int *front, int *rear)
{
*front = -1;
*rear = -1;
}
/* ------------------------------------------- */
int enqueue (int q[], int *rear, int data)
{
if (*rear < MAX - 1) {
*rear = *rear + 1;
q[*rear] = data;
return ENQUEUE_SUCCESS;
}
else {
return ENQUEUE_FAILURE;
}
}
/* ------------------------------------------- */
int dequeue (int q[], int *front, int rear, int *data)
{
if (*front == rear) {
return DEQUEUE_FAILURE;
}
*front = *front + 1;
*data = q[*front];
return DEQUEUE_SUCCESS;
}
/* ------------------------------------------- */
int main ()
{
int queue[MAX];
int front, rear, data;
int stat;
queue_init (&front, &rear);
enqueue (queue, &rear, 100);
enqueue (queue, &rear, 200);
enqueue (queue, &rear, 300);
enqueue (queue, &rear, 400);
enqueue (queue, &rear, 500);
while (rear - front) {
stat = dequeue (queue, &front, rear, &data);
if (stat == DEQUEUE_SUCCESS) {
printf ("%d\n", data);
}
else {
printf ("QUEUE is empty\n");
}
}
return 0;
}
ex8-3.c
/* code: ex8-3.c (v1.16.00) */
#include <stdio.h>
#include <stdlib.h>
#define WIDTH 40
#define HEIGHT 20
/* ------------------------------------------- */
void cell_evolve (int array[HEIGHT][WIDTH])
{
int array_new[HEIGHT][WIDTH];
int x, y, n, x_width, y_height;
for (y = 0; y < HEIGHT; y++) {
for (x = 0; x < WIDTH; x++) {
n = 0;
for (y_height = y - 1; y_height <= y + 1; y_height++) {
for (x_width = x - 1; x_width <= x + 1; x_width++) {
if (array[(y_height + HEIGHT) % HEIGHT][(x_width + WIDTH) % WIDTH]) {
n++;
}
}
}
if (array[y][x]) {
n--;
}
array_new[y][x] = (n == 3 || (n == 2 && array[y][x]));
}
}
for (y = 0; y < HEIGHT; y++) {
for (x = 0; x < WIDTH; x++) {
array[y][x] = array_new[y][x];
}
}
}
/* ------------------------------------------- */
void cell_first_generation (int array[HEIGHT][WIDTH])
{
int x, y, r;
for (x = 0; x < WIDTH; x++) {
for (y = 0; y < HEIGHT; y++) {
r = RAND_MAX / 8;
if (rand () < r) {
array[y][x] = 1;
}
else {
array[y][x] = 0;
}
}
}
}
/* ------------------------------------------- */
void cell_print (int array[HEIGHT][WIDTH], int generation)
{
int x, y;
printf ("[Generation: %05d]\n", generation);
for (y = 0; y < HEIGHT; y++) {
for (x = 0; x < WIDTH; x++) {
if (array[y][x] == 1) {
printf ("*");
}
else {
printf (".");
}
}
printf ("\n");
}
printf ("\n");
fflush (stdout);
}
/* ------------------------------------------- */
int main ()
{
int i;
int array[HEIGHT][WIDTH];
cell_first_generation (array);
i = 0;
while (i < 100) {
cell_print (array, i);
cell_evolve (array);
i++;
}
return 0;
}
q8-1.c
/* code: q8-1.c (v1.16.00) */
#include<stdio.h>
#include<stdlib.h>
#define MAX 128 /* ring buffer max size */
#define ENQUEUE_SUCCESS 1
#define ENQUEUE_FAILURE -1
#define DEQUEUE_SUCCESS 2
#define DEQUEUE_FAILURE -2
/* ------------------------------------------- */
void rb_queue_init (int *front, int *rear)
{
*front = 0;
*rear = 0;
}
/* ------------------------------------------- */
int rb_enqueue (int q[], int *front, int *rear, int data)
{
int index_f, index_r, index_q;
index_f = *front % MAX;
index_r = (*rear + 1) % MAX;
if (index_f != index_r) {
index_q = (*rear)++ % MAX;
q[index_q] = data;
return ENQUEUE_SUCCESS;
}
else {
return ENQUEUE_FAILURE;
}
}
/* ------------------------------------------- */
int rb_dequeue (int q[], int *front, int *rear, int *data)
{
int index;
if (*front != *rear) {
index = (*front)++ % MAX;
*data = q[index];
return DEQUEUE_SUCCESS;
}
else {
return DEQUEUE_FAILURE;
}
}
/* ------------------------------------------- */
int main ()
{
int queue[MAX];
int front, rear, data;
int stat;
rb_queue_init (&front, &rear);
rb_enqueue (queue, &front, &rear, 100);
rb_enqueue (queue, &front, &rear, 200);
rb_enqueue (queue, &front, &rear, 300);
rb_enqueue (queue, &front, &rear, 400);
rb_enqueue (queue, &front, &rear, 500);
while (rear - front) {
stat = rb_dequeue (queue, &front, &rear, &data);
if (stat == DEQUEUE_SUCCESS) {
printf ("%d\n", data);
}
else {
printf ("QUEUE is empty\n");
}
}
return 0;
}
q8-2.c
/* code: q8-2.c (v1.16.00) */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define WIDTH 40
#define HEIGHT 20
/* ------------------------------------------- */
void cell_evolve (int array[HEIGHT][WIDTH])
{
int array_new[HEIGHT][WIDTH];
int x, y, n, x_width, y_height;
for (y = 0; y < HEIGHT; y++) {
for (x = 0; x < WIDTH; x++) {
n = 0;
for (y_height = y - 1; y_height <= y + 1; y_height++) {
for (x_width = x - 1; x_width <= x + 1; x_width++) {
if (array[(y_height + HEIGHT) % HEIGHT][(x_width + WIDTH) % WIDTH]) {
n++;
}
}
}
if (array[y][x]) {
n--;
}
array_new[y][x] = (n == 3 || (n == 2 && array[y][x]));
}
}
for (y = 0; y < HEIGHT; y++) {
for (x = 0; x < WIDTH; x++) {
array[y][x] = array_new[y][x];
}
}
}
/* ------------------------------------------- */
void cell_first_generation (int array[HEIGHT][WIDTH])
{
int x, y, r;
for (x = 0; x < WIDTH; x++) {
for (y = 0; y < HEIGHT; y++) {
r = RAND_MAX / 8;
if (rand () < r) {
array[y][x] = 1;
}
else {
array[y][x] = 0;
}
}
}
}
/* ------------------------------------------- */
void cell_print (int array[HEIGHT][WIDTH], int generation)
{
int x, y;
printf ("[Generation: %05d]\n", generation);
for (y = 0; y < HEIGHT; y++) {
for (x = 0; x < WIDTH; x++) {
if (array[y][x] == 1) {
printf ("*");
}
else {
printf (".");
}
}
printf ("\n");
}
printf ("\n");
fflush (stdout);
}
/* ------------------------------------------- */
void cell_print_esc (int array[HEIGHT][WIDTH], int generation)
{
int x, y;
printf ("\e[H");
for (y = 0; y < HEIGHT; y++) {
for (x = 0; x < WIDTH; x++) {
if (array[y][x] == 1) {
printf ("\e[07m \e[m");
}
else {
printf (" ");
}
}
printf ("\e[E");
}
fflush (stdout);
}
/* ------------------------------------------- */
int main ()
{
int i;
int array[HEIGHT][WIDTH];
cell_first_generation (array);
i = 0;
while (i < 100) {
cell_print_esc (array, i);
cell_evolve (array);
i++;
sleep (1);
}
return 0;
}
EOF