Drawing a Vertical Graph of # based on stdin in C - c

Question

I've written a program that reads integer values from stdin, separated by one or more spaces or newlines, until reaching EOF. The input will contain no more than 80 values.
On standard output, I want to create a simple vertical column graph based the input values, in order left to right, using hash # characters. The number of hashes printed in each column is be equal to the corresponding input value.
The area above a completed column is filled with space characters.
I have this so far and it works correctly for inputs that are 4 numbers or greater, but when I input 2 or 3 numbers I get a seg fault. Can anyone see why?
#include <stdio.h>
#include <stdlib.h>
int main(int argc, const char*argv) {
int arr[80];
int count=0;
int i,j;
while(1) {
if((scanf("%d", &arr[count++]))==EOF) {
break;
}
}
int max=arr[0];
for(i=0; i<count; i++) {
if(max<arr[i]) {
max=arr[i];
}
}
char **matrix;
matrix=(char**)malloc(max*sizeof(char*));
for(i=0;i<count;i++) {
matrix[i]=(char*)malloc(sizeof(char)*max);
}
for(i=0;i<count-1;i++) {
for(j=max-1;j>=0;j--) {
if(max-j<=arr[i]) {
matrix[j][i]='#';
}
else {
matrix[j][i]=' ';
}
}
}
for(i=0;i<max;i++) {
for(j=0;j<count;j++) {
printf("%c", matrix[i][j]);
}
printf("\n");
}
return 0;
}

Answer 1

The problem is that OP is allocating enough memory to store max * max characters (where max is the maximum value entered), while what they need is max * count (where count is number of values entered) if only positive numbers are allowed.
Moreover, the program leaks memory, as the proper free calls are missing.
An easier way to deal with memory managment (if OP can compile with a C99 compliant compiler) is using a Variable Length Array:
char matrix[rows][cols]; // where rows and cols aren't known at compile time
If VLA aren't an option, the memory can still be allocated contiguously:
#include <stdlib.h>
char **matrix = malloc(rows * sizeof(*matrix));
if ( !matrix )
exit(EXIT_FAILURE);
matrix[0] = malloc(rows * cols * sizeof(**matrix));
if ( !matrix[0] ) {
free(matrix);
exit(EXIT_FAILURE);
}
for ( int i = 1; i < rows; ++i )
matrix[i] = matrix[i - 1] + cols;
// do something with 'matrix'...
free(matrix[0]);
free(matrix);
Another potential issue is that the loop responsible for the input doesn't limit the number of values entered to the size of the buffer (80) nor checks if those values are really numbers.
The following is a complete working implementation (with some helper functions):
#include "stdio.h"
#include "limits.h"
#define MAX_ARR_SIZE 80
int min (int a, int b) {
return a < b ? a : b;
}
int max (int a, int b) {
return a > b ? a : b;
}
void draw_bar_chart (FILE *out_stream, char fill_char,
int *arr, int size,
int bottom, int top);
int read_ints (FILE *in_stream,
int *arr, int size,
int *min, int *max);
int main(void) {
int min_value, max_value;
int values[MAX_ARR_SIZE];
int n_values = read_ints(stdin, values, MAX_ARR_SIZE,
&min_value, &max_value);
// Avoid clipping the chart
int top_view = max(max_value, 0);
int bottom_view = min(min_value, 0);
draw_bar_chart(stdout, '#', values, n_values, bottom_view, top_view);
}
int read_ints (FILE *in_stream,
int *arr, int size,
int *min, int *max) {
int count = 0;
*min = INT_MAX;
*max = INT_MIN;
// Reads up to 'size' values to avoid buffer overflow.
while ( count < size && fscanf(in_stream, "%d", &arr[count]) == 1 )
{ // note that it stops when the read fails (EOF or not an int) ^^^^
if ( arr[count] > *max )
*max = arr[count];
if ( arr[count] < *min )
*min = arr[count];
++count;
}
return count;
}
void tidy_up (int a, int b, int *min, int *max) {
if ( a > b ) {
*min = b;
*max = a;
} else {
*min = a;
*max = b;
}
}
void draw_bar_chart (FILE *out_stream, char fill_char,
int *arr, int size,
int bottom, int top) {
int draw_height = top - bottom;
int i, j, start, end;
// VLA, requires a C99 compliant compiler
char canvas[draw_height][size + 1];
// null-terminates every row to make output easier
for ( i = 0; i < draw_height; ++i )
canvas[i][size] = '\0';
// The "drawing" can be done in many ways...
for ( j = 0; j < size; ++j ) {
tidy_up(top, top - arr[j], &start, &end);
for ( i = 0; i < start; ++i )
canvas[i][j] = ' ';
for ( ; i < end; ++i )
canvas[i][j] = fill_char;
for ( ; i < draw_height; ++i )
canvas[i][j] = ' ';
}
for ( i = 0; i < draw_height; ++i ) {
fprintf(out_stream, "%s\n", canvas[i]);
}
}
Which, given for example those inputs
1 5 6 9 8 7 3 2 0 -3 -8 -5 -4 1 1 2 0 1 q
Outputs:
#
##
###
####
#####
#####
######
####### #
######## ### #
####
####
####
###
##
#
#
#
It's worth noting that for this particular task, we don't need to use a temporary 2D array at all. The function responsible for printing the chart can be implemented like this:
void draw_bar_chart (FILE *out_stream, char fill_char,
int *arr, int size,
int bottom, int top) {
int start, end;
// "draws" the chart by determining if the current position is inside a bar
for ( int i = top - 1; i >= bottom; --i ) {
for ( int j = 0; j < size; ++j ) {
tidy_up(0, arr[j], &start, &end);
putc((i >= start && i < end ? fill_char : ' '), out_stream);
}
puts("");
}
}