Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 2 years ago.
Improve this question
I wrote a simple program to find greatest among three numbers. But it seems that I wrote it in a way that makes it slightly confusing - hard to understand. What would be the way to improve this program to make it better at expressing its purpose and operation, and to remove the obvious repetition?
main()
{
int a,b,c;
printf("Enter three numbers: ");
scanf("%d %d %d",&a,&b,&c);
if (a==b && b==c)
printf("all are equal....:)");
else if(a>b)
{
if(a>c)
printf("%d is greatest among all",a);
else
printf("%d is greatest among all",c);
}
else
{
if(b>c)
printf("%d is the greatest among all",b);
else
printf("%d is the greatest among all",c);
}
getch();
}
#include <stdio.h>
int max(int a, int b)
{
return (a > b) ? a : b;
}
int main(void)
{
int a, b, c;
printf("Enter three number: ");
scanf("%d %d %d", &a, &b, &c);
if ((a == b) && (b == c))
{
printf("all are equal.");
}
else
{
printf("%d is the greatest among all", max(a, max(b, c)));
}
return 0;
}
I'd like to offer an example of the development process that could lead to figuring it out. I've linked relevant documentation to fill in the likely gaps in knowledge, and attempted to explain what led me to that documentation. Variants of such thought process are common among developers, yet the process is regrettably often not explained in educational settings, and must be acquired by "sweat and tears". I figure: let's shed some light on it!
A decent reference to the C language and standard library is https://en.cppreference.com/w/c (yes, it's cppreference, but it's not just for C++!).
The clarity of this program matters, and it certainly could be improved.
But people also interpret efficiency to mean speed. But: The speed of this particular program is irrelevant. The slowest element is the human, by more than 6 orders of magnitude vs. the machine. If you wished for this code to be faster when e.g. working on a large array of triples of numbers, then you could edit the question and instead provide an example that works through a big array of triples. As it stands, the program could be written in a shell script file and you wouldn't be able to tell the difference. It's a good idea to optimize what matters - and maintainability often matters more than raw performance :)
Output Skeleton
You only need to print the largest number - so let's start with a way to print it, and assume that the selection of the largest number, and the detection whether they are all equal, has been taken care of:
#include <stdio.h>
int main() {
char all_equal;
int max;
// to be done
if (all_equal) printf("All numbers are equal.\n");
else printf("%d is the greatest among the numbers entered.\n", max);
}
Thus, we have a skeleton for the output of the program. That's our goal. It helps to start with the goal expressed in the language of the problem domain - here in C - for it can focus and guide the implementation. We know exactly where we're going now: we have to get the input, and then process it to obtain the max value, and the all_equal predicate (a boolean: zero means falseness, anything else means truth).
We could actually turn this goal into a functional program by providing some "fake" data. Such data could be called test data, or mock data, depending on who you ask :)
#include <stdio.h>
int main() {
char all_equal = 0;
int max = 10;
if (all_equal) printf("All numbers are equal to %d.\n", max);
else printf("%d is the greatest among the numbers entered.\n", max);
}
We can run this, then change all_equal to 1 and see how the output is changed. So - we have some idea about what results should be fed into the output section of the program.
Processing
Getting the input from the user is on the opposite end of the goal, so let's work on something that builds up directly on the goal: let's compute those all_equal and max values! The processing code should replace the mock char all_equal = 0; int max = 10; section.
First, we need some numbers - we'll use mock data again, and from them we need to select the largest number:
int numbers[3] = {-50, 1, 30}; // mock data
char all_equal = 0; // mock data
int max = numbers[0];
for (int i = 1; i < 3; i++) {
if (numbers[i] > max) max = numbers[i];
}
Modern compilers will usually unroll this loop, and the resulting code will be very compact. The i loop variable won't even appear in the output, I'd expect.
We can foresee a potential for mistakes: if we ever decide to change the quantity of numbers, we can easily miss a place where such quantity is hardcoded (here as the literal 3). It'd be good to factor it out:
#define N 3
int numbers[N] = {-50, 1, 30}; // mock data
char all_equal = 0; // mock data
int max = numbers[0];
for (int i = 1; i < N; i++) {
if (numbers[i] > max) max = numbers[i];
}
You'll run into such #define-heavy code. It has its place back when C compilers were poor at optimizing code. Those times are now thankfully well over, but people continue doing this - without quite understanding why it is that they do it.
For numeric constants, it's usually unnecessary and counterproductive: the preprocessor does string substitution, so it has no idea what the code it modifies actually means. Preprocessor definitions "pollute" the global context - they leak out from wherever we define them, unless we explicitly #undef-ine them (How many people do that? You'll find that not many do.)
Instead, let's express it as a constant. We try:
const int N = 3;
int numbers[N];
But: this doesn't compile on some compilers. Huh? We read up on array declarations, and it seems that iff variable-length arrays (VLAs) are not supported by our compiler, then the number of elements must be a [constant expression][constexpr]. C doesn't consider a const int to be a constant expression (how silly, I know!). We have to kludge a bit, and use an enumeration constant to get the constant expression we need:
enum { N = 3 };
int numbers[N] = {-50, 1, 30}; // mock data
char all_equal = 0; // mock data
int max = numbers[0];
for (int i = 1; i < n; i++) {
if (numbers[i] > max) max = numbers[i];
}
We start by assigning the value of the first number in the list (index 0!) to max. Then we loop over subsequent numbers (starting with index 1!), compare each to the maximum, and update the maximum if a number happens to be greater than the maximum.
That's half of the goal: we got max, but we also need all_equal! The check for quality can be done in the same loop as the selection of the maximum (greatest number), thus:
enum { N = 3 };
int numbers[N] = {-50, 1, 30}; // mock data
char all_equal = 1;
int max = numbers[0];
for (int i = 1; i < N; i++) {
all_equal = all_equal && numbers[i] == max;
if (numbers[i] > max) max = numbers[i];
}
// here we have valid all_equal and max
We start with the assumption that the numbers are all equal (all_equal = 1). Then, for each subsequent number (indices 1 onwards), we check if the number is equal to the maximum, and we use a logical conjunction (logical and - &&) to update the all_equal proposition. Proposition is what we call a boolean: simply a statement that can be either true (here: non-zero) of false (zero). The conjunction applied repeatedly to all_equal has the effect of a one-way valve: once all_equal goes false, it will stay false.
Logicians would state it as ∀ p ∈ ℙ : (false ∧ p) = false. Read: for all ℙropositions p, false and p is false.
We merge this into our skeleton, and get a slightly more useful program. It still uses mock data, but it performs all the "interesting" parts of the problem.
#include <stdio.h>
int main() {
enum { N = 3 };
int numbers[N] = {-50, 1, 30}; // mock data
char all_equal = 1;
int max = numbers[0];
for (int i = 1; i < N; i++) {
all_equal = all_equal && numbers[i] == max;
if (numbers[i] > max) max = numbers[i];
}
if (all_equal) printf("All numbers are equal.\n");
else printf("%d is the greatest among the numbers entered.\n", max);
}
We can run this code, tweak the mock data, and verify that it appears to do what we want it to! Yay!
Input
Finally, we should get those numbers from the user, to get rid of the final bit of mock data:
#include <stdio.h>
int main() {
enum { N = 3 };
int numbers[N];
printf("Enter %d numbers:\n", N);
for (int i = 0; i < N; i++) scanf("%d", &numbers[i]);
char all_equal = 1;
int max = numbers[0];
for (int i = 1; i < N; i++) {
all_equal = all_equal && numbers[i] == max;
if (numbers[i] > max) max = numbers[i];
}
if (all_equal) printf("All numbers are equal.\n");
else printf("%d is the greatest among the numbers entered.\n", max);
}
We run it, and hey! It seems to work! This program is equivalent to the one you wrote. But. There's always a "but".
Handling Invalid Input
Software testing now begins in earnest. We "play" some more with the program (we "exercise" it), and notice that the program doesn't react any differently when a non-number is entered. It sometimes seems to ignore the invalid number and still provide sensible result based on other, correct, numbers, but sometimes it just spits out a random value. Random value - hmm. Could perhaps one of the numbers be uninitialized?
We read the documentation of scanf() and notice that it won't modify its output argument if it fails! Thus the program has undefined behavior: here it results in "random" output.
Reading on, we find that the return value of scanf() can be used to check if it was successful. We'd like to handle invalid input and provide some feedback:
int main() {
enum { N = 3 };
int numbers[N];
printf("Enter %d numbers.\n", N);
for (int i = 0; i < N; /*empty!*/) {
printf("#%d: ", i+1);
if (scanf("%d", &numbers[i]) != 1)
printf("Sorry, invalid input. Try again.\n");
else
i++;
}
...
}
We [try again][run4], and the program goes into an infinite loop as soon as invalid input is provided. Hmm. Something weird is going on. We read up on the issue of parsing user input in C, and realize that scanf() alone won't work correctly if any input errors are present, since the input remains in the input buffer - it will keep "tripping" subsequent scanf's. We must remove that input before retrying.
To find a function that may do that, we read up on the C input/output library and find the getchar() function. We use it:
int main() {
enum { N = 3 };
int numbers[N];
printf("Enter %d numbers.\n", N);
for (int i = 0; i < N; /*empty*/) {
printf("#%d: ", i+1);
if (scanf("%d", &numbers[i]) != 1) {
printf("Sorry, invalid input. Try again.\n");
char c;
while ((c = getchar()) != '\n'); // remove input until end of line
} else
i++;
}
...
}
We try it again, and things seem to work. But! We can do something else: let's try closing the input stream (^Z,Enter on Windows, ^D on Unix). The program goes into an infinite loop - again.
Aha! End of input - EOF! We must explicitly handle the EOF (end of file/read error) condition, and the best we can do then is to stop the program. How? We read up about C program utilities, and find a perfect function that would abort the program: abort(). Program utilities are utilities that used to manage "other" tasks that a program might do - tasks that don't fall under other categories (are not I/O, math, etc.).
#include <stdlib.h> // added for abort()
int main() {
enum { N = 3 };
int numbers[N];
printf("Enter %d numbers.\n", N);
for (int i = 0; i < N; /*empty*/) {
int c;
printf("#%d: ", i);
c = scanf("%d", &numbers[i]);
if (c == EOF) abort();
if (c != 1) {
printf("Sorry, invalid input. Try again.\n");
while ((c = getchar()) != EOF && c != '\n');
if (c == EOF) abort();
} else
i++;
}
...
}
We try yet again, and this time things really seem to work fine. No matter what we throw at the program, it behaves reasonably: if the input is still available, it asks the user to enter the number again. If the input won't be available anymore (EOF indicates that), we abort().
In even more deviousness, we try to surround the numbers with spaces and tabs in our input - after all, it's just whitespace, and to a human it'd look like valid input in spite of the spaces. We try it, and no problem: scanf() seems to do the "right thing". Hah. But why? We read into the scanf() documentation, and discover that [emphasis mine]:
All conversion specifiers other than [, c, and n consume and discard
all leading whitespace characters (determined as if by calling
isspace) before attempting to parse the input. These consumed
characters do not count towards the specified maximum field width.
Complete Program
We now got all the pieces. Put them together, and the complete program is:
#include <stdio.h>
#include <stdlib.h>
int main() {
enum { N = 3 };
int numbers[N];
printf("Enter %d numbers.\n", N);
for (int i = 0; i < N; /*empty*/) {
printf("#%d: ", i+1);
int c = scanf("%d", &numbers[i]);
if (c == EOF) abort();
if (c != 1) {
printf("Sorry, invalid input. Try again.\n");
while ((c = getchar()) != EOF && c != '\n');
if (c == EOF) abort();
} else
i++;
}
char all_equal = 1;
int max = numbers[0];
for (int i = 1; i < N; i++) {
all_equal = all_equal && numbers[i] == max;
if (numbers[i] > max) max = numbers[i];
}
if (all_equal) printf("All numbers are equal.\n");
else printf("%d is the greatest among the numbers entered.\n", max);
}
Try it out!.
Useful Refactoring
This works fine, but the input processing dominates over main, and seems to obscure the data processing and output. Let's factor out the input, to clearly expose the part of the program that does "real work".
We decide to factor out the following function:
void read_numbers(int *dst, int count);
This function would read a given count of numbers into the dst array. We think a bit about the function and decide that a zero or negative count doesn't make sense: why would someone call read_numbers if they didn't want to get any input?
We read up on error handling in C, and discover that assert() seems a good candidate to make sure that the function was not called with incorrect parameters, due to a programming bug. Note that assert() must not be used to detect invalid program input!!. It is only meant to aid in finding program bugs, i.e. the mistakes of the developer of the program, not mistakes of the user. If user input had to be checked, it has to be done explicitly using e.g. the conditional statement (if), or a custom function that checks the input - but never assert!
Note how assert is used:
It tells you, the human reader of the program, that at the given point in the program, count must be greater than zero. It helps reasoning about the subsequent code.
The compiler generates the code that checks the asserted condition, and aborts if it doesn't hold (is false). The checks usually are only performed in the debug build of the program, and are not performed in the release version.
To keep the program flow clear, we forward-declare read_numbers(), use it in main(), and define (implement) the function last, so that it doesn't obscure things:
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
void read_numbers(int *dst, int count);
int main() {
enum { N = 3 };
int numbers[N];
read_numbers(numbers, N);
char all_equal = 1;
int max = numbers[0];
for (int i = 1; i < N; i++) {
all_equal = all_equal && numbers[i] == max;
if (numbers[i] > max) max = numbers[i];
}
if (all_equal) printf("All numbers are equal.\n");
else printf("%d is the greatest among the numbers entered.\n", max);
}
void read_numbers(int *dst, int count) {
assert(count > 0);
printf("Enter %d numbers.\n", count);
for (int i = 0; i < count; /*empty*/) {
printf("#%d: ", i+1);
int c = scanf("%d", &dst[i]);
if (c == EOF) abort();
if (c != 1) {
printf("Sorry, invalid input. Try again.\n");
while ((c = getchar()) != EOF && c != '\n');
if (c == EOF) abort();
} else
i++;
}
}
You can try this program out in onlinegdb.com - just click this link!
In my opinion, main() looks very clear now. The input function stands on its own and can be analyzed in isolation: note how it's a pure function, and has no global state. Its output only acts on the arguments passed in. There are no global variables! There shouldn't ever be, really.
That's where I'd stop. We have a clear program that handles both valid and invalid input.
Moar Refactoring !!111!!
But you could say: how about we factor out data processing and final output as well? We can do that, sure. Yet, in a simple program like ours, it perhaps will slightly obscure what's going on. But at least let's see how it could look then, play with it and decide for ourselves :)
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct {
char all_equal; // true if all numbers were equal
int max; // the greatest number
} Result;
void read_numbers(int *dst, int count);
Result find_greatest(int *numbers, int count);
void output_result(const Result *r);
int main() {
enum { N = 3 };
int numbers[N];
read_numbers(numbers, N);
const Result r = find_greatest(numbers, N);
output_result(&r);
}
void read_numbers(int *dst, int count) {
assert(count > 0);
printf("Enter %d numbers.\n", count);
for (int i = 0; i < count; /*empty*/) {
printf("#%d: ", i+1);
int c = scanf("%d", &dst[i]);
if (c == EOF) abort();
if (c != 1) {
printf("Sorry, invalid input. Try again.\n");
while ((c = getchar()) != EOF && c != '\n');
if (c == EOF) abort();
} else
i++;
}
}
Result find_greatest(int *numbers, int count) {
assert(count > 0);
Result r = {.all_equal = 1, .max = numbers[0]};
for (int i = 1; i < count; i++) {
r.all_equal = r.all_equal && numbers[i] == r.max;
if (numbers[i] > r.max) r.max = numbers[i];
}
return r;
}
void output_result(const Result *r) {
if (r->all_equal) printf("All numbers are equal.\n");
else printf("%d is the greatest among the numbers entered.\n", r->max);
}
Note how the Result local variable is initialized using struct initialization with designated initializers:
Result r = {.all_equal = 1, .max = numbers[0]};
If you needed to perform the initialization independently of the declaration of the variable, you would wish to use compound literals - a lesser known, but very important notational shortcut in modern C:
Result r;
// some intervening code
r = (Result){.all_equal = 1, .max = numbers[0]};
or perhaps:
void function(Result r);
void example(void) {
function((Result){.all_equal = 1, .max = numbers[0]});
}
Your code is fine; in fact, Bentley, McIlroy, Engineering a sort function, 1993, realised by, among others, BSD qsort, employs the same sort of mechanism in the inner loop for finding the median of three values. Except,
If all values are the same, it doesn't, "find the greatest among three numbers," but rather short-circuits and finds how many times the maximal value occurs, (three.) This is a separate problem.
It generally pays to separate one's logic from the output.
I've taken your code and put it in a function, stripped the output, and stripped of the equality.
#include <assert.h>
static int hi3(const int a, const int b, const int c) {
/* Same as `return a > b ? a > c ? a : c : b > c ? b : c;`. */
if(a > b) {
if(a > c) {
return a;
} else {
return c;
}
} else {
if(b > c) {
return b;
} else {
return c;
}
}
}
int main(void) {
/* Permutations of 3 distinct values. */
assert(hi3(1, 2, 3) == 3
&& hi3(1, 3, 2) == 3
&& hi3(2, 1, 3) == 3
&& hi3(2, 3, 1) == 3
&& hi3(3, 1, 2) == 3
&& hi3(3, 2, 1) == 3);
/* Permutation of 2 distinct values. */
assert(hi3(1, 2, 2) == 2
&& hi3(2, 1, 2) == 2
&& hi3(2, 2, 1) == 2);
assert(hi3(1, 1, 2) == 2
&& hi3(1, 2, 1) == 2
&& hi3(2, 1, 1) == 2);
/* All the same value. */
assert(hi3(1, 1, 1) == 1);
return 0;
}
Your code tests all the combinations of relative magnitudes successfully.
#include <stdio.h>
int main() {
int n;
printf("Enter width: ");
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j || (i + j + 1) == n) {
printf("X");
} else {
printf(" ");
}
}
printf("\n");
}
return 0;
}
How can I convert this code into a recursive function? I am having trouble with the "base case" I am trying to work with this line
void recursiveProblem(int num, int max) {
if (num <= (max / 2 + 1))
...
}
so if I reach halfway I can print the middle line and return it, but it's not working. This function will print a large X made from x's?
To solve tasks using recursion, you can use this pattern:
to solve the task:
check if you've reached a trivial case. If so:
do the trivial thing
otherwise:
split the task into smaller parts that look similar to the whole task
solve each of the smaller tasks by calling the function recursively
In your case the task is print_diagonals(width_of_the_square, current_line_number).
Defining this task by giving it a proper name and by finding out the parameters and their names is the most important part of solving this kind of problems. It's much easier to think about print_diagonals than about recursiveProblem since the names I've given carry lots of meaning and exactly describe their purpose.
The "trivial case" in this task can be either "print the line in the middle of the square" or "print the bottom line of the square". Both will work, and the programs will look similar. Try them both and then compare the resulting programs. The part these programs have in common is typical for recursive programs.
Using this information, you should be able to do your homework by yourself.
I don't understand why anyone would want to make this recursive. But this works.
#include <stdio.h>
void recurse(int i, int j, int n){
printf(i==j || i+j+1==n ? "X" : " ");
if (++j == n) {
printf("\n");
if (++i == n)
return;
j=0;
}
recurse(i, j, n);
}
int main(){
int n;
printf("Enter width: ");
scanf("%d",&n);
recurse(0, 0, n);
return 0;
}
If you'll notice, I move one if block right inside the printf statement using the ? : operator.
Also, notice that every single printf is called from it's own recurse function call, which is on top of every other function call on the stack. So if your stack is limited and n is large, you could run out of stack and crash. This is one reason recursive functions should only be used with caution.
Alternately, you could put the loop that increments j in the recursive function and only recurse to increment i. That would use a lot less stack.
I am trying to find the closest pair of numbers entered by the user. My C code isn't working right and I can't figure out what's wrong. I think it might have something to do with storing the values but I don't know where to go from here.
#include <stdio.h>
#include <math.h>
int main()
{
int i, j,arr[50], first,second;
//loop input
for(i=0;i<50;i++) //loop 50 times
{
scanf("%d", &i); //scan
//break if i=-1
if (i==-1)
break;
//if not print
}
//2nd num - 1st num < 3rd num-1st num, closest = 1st and 2nd num
//i[0]=num1, j[0+i]=2nd num, i= 4 , 5, 7, ans=arr,
//if j[0+i]-i[0]= ans < j[0+i]-i[i]=ans
//arr[i]=8,2,17,4,25
for(i=0;i<50;i++)
{
for(j=i+1;j<50;j++)
{
if(arr[j]-arr[i]<arr[j+1]-arr[i])
{
first = arr[i];//3
second = arr[j+1];//5
}
}
}
printf("%d %d\n", first, second);
return 0;
}
Don't post it as answer, prefer editing your code instead. Anyway, the problem is here :
for (j = i + 1; j < len; j++)//j<i <-why is it wrong?
How isn't it wrong? You've initialised j with the value i+1. How's it supposed to be ever less than i? And due to that, it's picking up values from outside the array and providing you with unexpected results.
The correct form is :
for (j = 0; j < i; j++)
The problem is with this chunk of code. You're scanning in the counter variable i instead of array. And then you're manipulating stuff using array arr. Why should that work in any scenario?
for(i=0;i<50;i++) //loop 50 times
{
scanf("%d", &i); //scan
//break if i=-1
if (i==-1)
break;
//if not print
}
And i can never be -1 unless it's a miracle.
I was solving the HackerRank problem given here : -- https://www.hackerrank.com/challenges/bigger-is-greater
Program statement is as follow :
Given a word, rearrange the letters to construct another word in such a way that is lexicographically greater than original one. In case of multiple possible answers, find the lexicographically smallest one among them.
If you don't understand then just go to the link; they have explained with examples.
I made the program as given below. In this program I have made two dimensional array. And variable t decides number of row and number is fix.
Code is running as it should be when t = 1.
But when t is greater than 1 or some large number it gives error segmentation error
Code is as below :
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main() {
/* Enter your code here. Read input from STDIN. Print output to STDOUT */
int i,j,n,rot;
int t;
scanf("%d",&t);
char c[t][100];
char temp;
for(int i=0;i<t;i++)
{
scanf(" %s",c[i]);
}
rot=t;
for(int t=0;t<rot;t++)
{
n = strlen(c[t]);
//printf("%d\n",n);
for(i=n-1;i>=0;i--)
{
for(j=i-1;j>=0;j--)
{
//printf("comparint %c and %c\n",c[t][i],c[t][j]); //FOR DEBUG
if(c[t][i]>c[t][j]) goto gotit;
}
}
printf("no answer\n");
continue;
gotit:
temp = c[t][i];
c[t][i]=c[t][j];
c[t][j]=temp;
n = (n-1)-j;
//printf("%s\n",c[t]); //FOR DEBUG
//printf("%d %d %d\n",i,j,n); //FOR DEBUG
for(i=0;i<n-1;i++)
{
for(int k=0;k<n-1;k++)
{
// printf("comparint %c and %c\n",c[t][j+k+1],c[t][j+k+2]);
if(c[t][j+k+1]>c[t][j+k+2] )
{
temp = c[t][j+k+1];
c[t][j+k+1]=c[t][j+k+2];
c[t][j+k+2]=temp;
}
}
}
printf("%s\n",c[t]);
}
return 0;
}
t can be 10^5 or 100,000. Your c array is c[t][100], so the size of that is 100000 * 100, which is 10,000,000. You're probably getting a stack overflow.
As WhozCraig pointed out, the processing of each case is independent. Thus, c can be a one dimensional array: char c[100]. Change all c[t][...] into c[...].
Adjust things so that you have one outer loop:
int
main()
{
int t;
char c[100];
scanf("%d", &t);
for (int i = 0; i < t; i++) {
scanf(" %s", c);
// do all processing for this line ...
n = strlen(c);
}
return 0;
}