Printing Length of Input and the Limited Input

Hello all! First post here! I look forward to receiving your generous help so eventually I will be decent enough to help others. Anyways..straight to the point...

So I am learning to program in C using the K&R book. I am struggling with a problem, in the book. For those with the book, chapter 1.9, exercise 1-16.
For those without the book; The book has given me a piece of code that has the main function and two other functions. The original code simply took in an input of lines, and printed out the longest line as allowed by the MAXLINE number. The exercise now wants me to modify only the MAIN code so that it prints out the actual length of the longest line, and as much as possible of the line as limited by MAXLINE.

The way I attempted to do it does not even pass the most simple test, in which I only give it one line. It skips the first character and prints out the rest that is possible according to the limit, but it also returns back a length of 0, which is not valid. Can somebody help me please?

This is the original code from the book...

Code:

---

#include <stdio.h>
#define MAXLINE 1000

int getLine(char line[], int maxline);
void copy(char to[], char from[]);

//prints longest input line
main(){
        int len; //current line length
        int max; //maximum length seen so far
        char line[MAXLINE]; //current input line
        char longest[MAXLINE]; //longest line saved here

                max = 0;

        while ((len = getline(line, MAXLINE)) > 0)
                if (len > max){
                        max = len;
                        copy(longest, line);
                }
                if (max > 0){ //there was a line
                        putchar('\n');
                        printf("%s", longest);
                }
                return 0;
}

//read a line into s, return length
int getline(char s[], int lim){
        int c, i;

        for(i = 0; i < lim-1 && (c = getchar()) != EOF && c != '\n'; ++i)
                s[i] = c;
        if(c == '\n'){
                s[i] = c;
                ++i;
        }
        s[i] = '\0';
        return i;
}

//copy from into to: assume to is big enough
void copy(char to[], char from[]){
        int i;

        i = 0;
        while ((to[i] = from[i]) != '\0')
                ++i;
}

---

Here is my modified version...

Code:

---

#include <stdio.h>
#define MAXLINE 10

int getline(char line[], int maxline);
void copy(char to[], char from[]);

//prints longest input line
main(){
        int c; //the char
        int len; //current line length
        int max; //maximum length seen so far
        int maxlen; //longest line
        int possiblemax; //possibly max line
        char line[MAXLINE]; //current input line
        char longest[MAXLINE]; //longest line saved here
       
        //sets default values
        max = maxlen = possiblemax = 0;

        //while loop for checking end of input
        while ((c = getchar()) != EOF){
               
                //if case for when the char is equal to a new line
                if (c == '\n'){

                        //when char is equal to a new line
                        //and possiblemax is greater than maxlen
                        //change maxlen to equal to possible max
                        //reset possible max to 0
                        if (possiblemax > maxlen){
                                maxlen = possiblemax;
                                possiblemax = 0;
                        }

                        //else just set possiblemax back to 0
                        else possiblemax = 0;
                }

                //if not a new line, add 1 to possiblemax
                else ++possiblemax;

        while ((len = getline(line, MAXLINE)) > 0)
                if (len > max){
                        max = len;
                        copy(longest, line);
                }
                if (max > 0){ //there was a line
                        //prints maxlen value
                        printf("length:%d", maxlen);
                        putchar('\n');
                        printf("%s", longest);
                }
                return 0;
        }
}

//read a line into s, return length
int getline(char s[], int lim){
        int c, i;

        for(i = 0; i < lim-1 && (c = getchar()) != EOF && c != '\n'; ++i)
                s[i] = c;
        if(c == '\n'){
                s[i] = c;
                ++i;
        }
        s[i] = '\0';
        return i;
}

//copy from into to: assume to is big enough
void copy(char to[], char from[]){
        int i;

        i = 0;
        while ((to[i] = from[i]) != '\0')
                ++i;
}

---

Thank you for your future help!

[I have not run your code]
You have two while loops and of which are both get character from stdin. the outer loop eats the first character the user inputted each time.

You put the return statement within the outer loop, I think it's the reason your program stops after giving it only one line.

Code:

---

#include <stdio.h>
#define MAXLINE 10

int getline(char line[], int maxline);
void copy(char to[], char from[]);

//prints longest input line
main(){
        int c; //the char
        int len; //current line length
        int max; //maximum length seen so far
        int maxlen; //longest line
        int possiblemax; //possibly max line
        char line[MAXLINE]; //current input line
        char longest[MAXLINE]; //longest line saved here
       
        //sets default values
        max = maxlen = possiblemax = 0;

        //while loop for checking end of input
        while ((c = getchar()) != EOF){
               
                //if case for when the char is equal to a new line
                if (c == '\n'){

                        //when char is equal to a new line
                        //and possiblemax is greater than maxlen
                        //change maxlen to equal to possible max
                        //reset possible max to 0
                        if (possiblemax > maxlen){
                                maxlen = possiblemax;
                                possiblemax = 0;
                        }

                        //else just set possiblemax back to 0
                        else possiblemax = 0;
                }

                //if not a new line, add 1 to possiblemax
                else ++possiblemax;

        while ((len = getline(line, MAXLINE)) > 0)
                if (len > max){
                        max = len;
                        copy(longest, line);
                }
                if (max > 0){ //there was a line
                        //prints maxlen value
                        printf("length:%d", maxlen);
                        putchar('\n');
                        printf("%s", longest);
                }
        }

                return 0;
}

//read a line into s, return length
int getline(char s[], int lim){
        int c, i;

        for(i = 0; i < lim-1 && (c = getchar()) != EOF && c != '\n'; ++i)
                s[i] = c;
        if(c == '\n'){
                s[i] = c;
                ++i;
        }
        s[i] = '\0';
        return i;
}

//copy from into to: assume to is big enough
void copy(char to[], char from[]){
        int i;

        i = 0;
        while ((to[i] = from[i]) != '\0')
                ++i;
}

---

So I modified my code so the return 0 would be outside the while loop now. However, what can I do to prevent my first letter from being "eaten"? I am stumped on that part..Also my length likes to return a length of 0, despite it knowing what the longest line is. To me it seems like my length finding function seems correct though. I also noticed it only eats the first letter of the first line, and this can only been seen when the first line is the longest line.

In your getline function, your for loop is missing brackets after it.

Code:

---

int getline(char s[], int lim){
        int c, i;

        for(i = 0; i < lim-1 && (c = getchar()) != EOF && c != '\n'; ++i){
                s[i] = c;
        if(c == '\n'){
                s[i] = c;
                ++i;
        }
        s[i] = '\0';
        }
        return i;
}

---

That is exactly the way the K&R book gave it to me...possible typo? Or maybe the authors have their own reason for doing that?

> In your getline function, your for loop is missing brackets after it.
No it isn't.
The single-line for loop does all the work.

> However, what can I do to prevent my first letter from being "eaten"?
Why do you even need the first while loop?
The
while ((len = getline(line, MAXLINE)) > 0)
does the right thing with EOF anyway.
Your attempt to detect an early EOF is just messing things up.

Hmm..I understand what you mean...but now how would I go about finding the length of the line without being limited by the number passed into the getline function?

In the code which calls getline(), detect whether the returned line contains a \n (or not) to decide whether the line is really long.

Unless you want to make getline a lot more complicated with calls to malloc and realloc, to expand the space as the user keeps typing.

I think I understand what you are saying. However is it possible to change the array so that its able to fit new characters? Would I have to make a new array for the purpose of "overmax" lines or can I change the array size? Also would I add something that is similar to

Code:

---

if (line[MAXLINE] != '\n'){

?expand the array?
}

---

within the main function?

Quote:

---

Originally Posted by dnguyen1022

However is it possible to change the array so that its able to fit new characters? Would I have to make a new array for the purpose of "overmax" lines or can I change the array size?

---

Instead of your current fixed size arrays, you would use dynamic memory allocation, e.g., with malloc(), realloc() and free() from <stdlib.h>.

line[MAXLINE]
this is out of bounds access, the valid indexes are from 0 to MAXLINE - 1

Hmm...alright I'll change it around and see what I get, with the MAXLINE - 1 in mind. Also
silverlight, I apologize if this sounds rude, but I am trying to follow the book and using the information that they have given me so far to solve this problem. I believe I should solve this problem with the basics before getting into more complicated stuff or by using shortcuts. I appreciate your help and still want your help to solve this problem but in a less advanced way...for now. :)

So..I tried it again...this time my code does not seem to be doing anything. I think I have the concept down. However my code is wrong....I think the

Code:

---

(c = getchar())

---

must be intefering with my getline function...can somebody help me please?

Code:

---

#include <stdio.h>
#define MAXLINE 10

int getLine(char line[], int maxline);
void copy(char to[], char from[]);

//prints longest input line
main(){
        int len; //current line length
        int max; //maximum length seen so far
        int possiblemax; //possible maximum length
        int realmax; //the real maximum length
        int c; //the char
    char line[MAXLINE]; //current input line
        char longest[MAXLINE]; //longest line saved here
       
    max = possiblemax = realmax = 0;

        while ((len = getline(line, MAXLINE)) > 0)
                //checks to see if array ends with a new line
                if (line[len - 1] != '\n'){

                        //while c is not end of file
                        while ((c = getchar()) != EOF){
                                //if c is not equal to a new line
                                if (c != '\n'){
                                        //while c is not a new line add one to possible max
                                        while(c != '\n'){
                                                    ++possiblemax;
                                                        }
                                }

                                //else if is equal to a new line
                                else if (c == '\n'){
                                        //if possiblemax is greater than real max
                                        //set realmax to possiblemax
                                        //reset possible max
                                        if (possiblemax > realmax){
                                realmax = possiblemax;
                                possiblemax = 0;
                }

                                //otherwise reset possiblemax
                                        else possiblemax = 0;
                }
            }
        }
                                           
                if (len > max){
                        max = len;
                        copy(longest, line);
                }

                if (max > 0){ //there was a line
                        printf("length:&#37;d", realmax);
                        putchar('\n');
                        printf("%s", longest);
                }
                return 0;
}

//read a line into s, return length
int getline(char s[], int lim){
        int c, i;

        for(i = 0; i < lim-1 && (c = getchar()) != EOF && c != '\n'; ++i)
                s[i] = c;
        if(c == '\n'){
                s[i] = c;
                ++i;
        }
        s[i] = '\0';
        return i;
}

//copy from into to: assume to is big enough
void copy(char to[], char from[]){
        int i;

        i = 0;
        while ((to[i] = from[i]) != '\0')
                ++i;
}

---

Code:

---

while(c != '\n'){
        ++possiblemax;
}

---

Good luck getting that loop to stop. That's assuming you decide on the name of the function getL/line, since your program doesn't compile as is. And is the point of this c thing in main to throw away the rest of the line?

Wouldn't it stop when it gets to a new line or when it reaches EOF due to the while loop that it is in? Also it is suppose to get the length of the REST of the line..since the getline stops whenever it reaches its MAXLINE limit. The main purpose of the program is to print out the length of the longest line, and print out as much as possible of the line as limited by MAXLINE.

Quote:

---

Originally Posted by dnguyen1022

Wouldn't it stop when it gets to a new line or when it reaches EOF due to the while loop that it is in? Also it is suppose to get the length of the REST of the line..since the getline stops whenever it reaches its MAXLINE limit. The main purpose of the program is to print out the length of the longest line, and print out as much as possible of the line as limited by MAXLINE.

---

Once you get into the inner while loop, it has to finish before the outer while loop can continue. If you want it to happen once per character, then make it happen once, not an infinite number of times per character.

So instead of a while statement, would it be better to use If?
Or would it be more efficient to change the while loop? Thanks!

Code:

---

if (c != '\n'){
        ++possiblemax;
}

---

Code:

---

while((c=getchar()) != '\n'){
        ++possiblemax;
}

---

Quote:

---

Originally Posted by dnguyen1022

So instead of a while statement, would it be better to use If?
Or would it be more efficient to change the while loop? Thanks!

Code:

---

if (c != '\n'){
        ++possiblemax;
}

---

Code:

---

while((c=getchar()) != '\n'){
        ++possiblemax;
}

---

---

You might want to change your loop -- currently it stops at EOF, instead of \n.

So I changed my code a little bit...I don't think it ever reaches the part where c is equal to a new line within the while loop though. How would I fix this?

Code:

---

#include <stdio.h>
#define MAXLINE 10

int getLine(char line[], int maxline);
void copy(char to[], char from[]);

//prints longest input line
main(){
        int len; //current line length
        int max; //maximum length seen so far
        int possiblemax; //possible maximum length
        int realmax; //the real maximum length
        int c; //the char
    char line[MAXLINE]; //current input line
        char longest[MAXLINE]; //longest line saved here
       
    max = possiblemax = realmax = 0;

        while ((len = getline(line, MAXLINE)) > 0)
                //checks to see if array ends with a new line
                if (line[len - 1] != '\n'){

                        //while c is not end of file
                        while ((c = getchar()) != '\n'){
                                //if c is not equal to a new line
                                if (c != '\n'){
                                        //if c is not a new line add one to possible max
                                        ++possiblemax;               
                                }

                                //else if is equal to a new line
                                else if (c == '\n'){
                                        //if possiblemax is greater than real max
                                        //set realmax to possiblemax
                                        //reset possible max
                                        if (possiblemax > realmax){
                                realmax = possiblemax;
                                possiblemax = 0;
                }

                                //otherwise reset possiblemax
                                        else possiblemax = 0;
                }
            }
        }
                                           
                if (len > max){
                        max = len;
                        copy(longest, line);
                }

                if (max > 0){ //there was a line
                        printf("length:%d", realmax);
                        putchar('\n');
                        printf("%s", longest);
                }
                return 0;
}

//read a line into s, return length
int getline(char s[], int lim){
        int c, i;

        for(i = 0; i < lim-1 && (c = getchar()) != EOF && c != '\n'; ++i)
                s[i] = c;
        if(c == '\n'){
                s[i] = c;
                ++i;
        }
        s[i] = '\0';
        return i;
}

//copy from into to: assume to is big enough
void copy(char to[], char from[]){
        int i;

        i = 0;
        while ((to[i] = from[i]) != '\0')
                ++i;
}

---

So now I thought about it again and tried a different approach. My program now doesn't freeze anymore. However it doesn't return anything back...just tells me to press any key to continue.

Code:

---

#include <stdio.h>
#define MAXLINE 10

int getLine(char line[], int maxline);
void copy(char to[], char from[]);

//prints longest input line
main(){
        int len; //current line length
        int max; //maximum length seen so far
        int possiblemax; //possible maximum length
        int realmax; //the real maximum length
        int c; //the char
    char line[MAXLINE]; //current input line
        char longest[MAXLINE]; //longest line saved here
       
    max = possiblemax = realmax = 0;

        while ((len = getline(line, MAXLINE)) > 0)
                //checks to see if array ends with a new line
                if (line[len - 1] != '\n'){

                                //if c is not equal to a new line
                                if ((c = getchar()) != '\n'){
                                        //if c is not a new line add one to possible max
                                        ++possiblemax;               
                                }

                                //else if is equal to a new line
                                else if ((c = getchar()) == '\n'){
                                        //if possiblemax is greater than real max
                                        //set realmax to possiblemax
                                        //reset possible max
                                        if (possiblemax > realmax){
                                realmax = possiblemax;
                                possiblemax = 0;
                }

                                //otherwise reset possiblemax
                                        else possiblemax = 0;
                }
            }
                                           
                if (len > max){
                        max = len;
                        copy(longest, line);
                }

                if (max > 0){ //there was a line
                        printf("length:%d", realmax + MAXLINE);
                        putchar('\n');
                        printf("%s", longest);
                }
                return 0;
}

//read a line into s, return length
int getline(char s[], int lim){
        int c, i;

        for(i = 0; i < lim-1 && (c = getchar()) != EOF && c != '\n'; ++i)
                s[i] = c;
        if(c == '\n'){
                s[i] = c;
                ++i;
        }
        s[i] = '\0';
        return i;
}

//copy from into to: assume to is big enough
void copy(char to[], char from[]){
        int i;

        i = 0;
        while ((to[i] = from[i]) != '\0')
                ++i;
}

---

bump..I still need help...

You do realize the code you've posted doesn't compile? (There is no definition of the symbol "getline" when the function is called, because your prototype is for getLine.)

Okay..I fixed it..it didn't seem to be having any problems compiling in Microsoft Visual C++ though. I think I know why it did not compile in c++ bloodshed though.

Code:

---

#include <stdio.h>
#define MAXLINE 10

int getline(char line[], int maxline);
void copy(char to[], char from[]);

//prints longest input line
main(){
        int len; //current line length
        int max; //maximum length seen so far
        int possiblemax; //possible maximum length
        int realmax; //the real maximum length
        int c; //the char
    char line[MAXLINE]; //current input line
        char longest[MAXLINE]; //longest line saved here
       
    max = possiblemax = realmax = 0;

        while ((len = getline(line, MAXLINE)) > 0)
               
                if (len > max){
                        max = len;
                        copy(longest, line);
                }
               
                //checks to see if array ends with a new line
                if (line[len - 1] != '\n'){

                                //if c is not equal to a new line
                                if ((c = getchar()) != '\n'){
                                        //if c is not a new line add one to possible max
                                        ++possiblemax;               
                                }

                                //else if is equal to a new line
                                else if ((c = getchar()) == '\n'){
                                        //if possiblemax is greater than real max
                                        //set realmax to possiblemax
                                        //reset possible max
                                        if (possiblemax > realmax){
                                realmax = possiblemax;
                                possiblemax = 0;
                }

                                //otherwise reset possiblemax
                                        else possiblemax = 0;
                }
            }
                                           
               
                realmax = realmax + max;

                if (max > 0){ //there was a line
                        printf("length:&#37;d", realmax);
                        putchar('\n');
                        printf("%s", longest);
                }
                return 0;
}

//read a line into s, return length
int getline(char s[], int lim){
        int c, i;

        for(i = 0; i < lim-1 && (c = getchar()) != EOF && c != '\n'; ++i)
                s[i] = c;
        if(c == '\n'){
                s[i] = c;
                ++i;
        }
        s[i] = '\0';
        return i;
}

//copy from into to: assume to is big enough
void copy(char to[], char from[]){
        int i;

        i = 0;
        while ((to[i] = from[i]) != '\0')
                ++i;
}

---

Here is the correct code without the spelling mistake. However it still does the same thing..gives me a length only up to 9.

Code:

---

else if ((c = getchar()) == '\n'){
                                        //if possiblemax is greater than real max
                                        //set realmax to possiblemax
                                        //reset possible max
                                        if (possiblemax > realmax){
                                realmax = possiblemax;
                                possiblemax = 0;
                }

                                //otherwise reset possiblemax
                                        else possiblemax = 0;
                }

---

You realize this will only happen when there are two enter-keys in a row?

I am not sure what you mean by two enter keys in a row...can you explain it please? As in press enter twice? I realized I had to do that, but I do not see why my coding would produce such a result.

Well, what do you think getchar does if not take characters from input? For this piece of code to execute, the if statement (with a getchar in it) would have to be false, meaning that enter key has been eaten -- but this else if has another getchar in it, which means we need to have another enter-key.

Edit: Oh: and if you want to go through the whole line, shouldn't you have a while loop (loop until c == \n, rather than just check the very next letter)?

Quote:

---

Originally Posted by tabstop

Code:

---

while(c != '\n'){
        ++possiblemax;
}

---

Good luck getting that loop to stop. That's assuming you decide on the name of the function getL/line, since your program doesn't compile as is. And is the point of this c thing in main to throw away the rest of the line?

---

Didn't you tell me that loop would never stop? Also I removed that getchar() from my else if, but it seems like I still have to press enter twice.

Code:

---

#include <stdio.h>
#define MAXLINE 10

int getline(char line[], int maxline);
void copy(char to[], char from[]);

//prints longest input line
main(){
        int len; //current line length
        int max; //maximum length seen so far
        int possiblemax; //possible maximum length
        int realmax; //the real maximum length
        int c; //the char
    char line[MAXLINE]; //current input line
        char longest[MAXLINE]; //longest line saved here
       
    max = possiblemax = realmax = 0;

        while ((len = getline(line, MAXLINE)) > 0)
               
                if (len > max){
                        max = len;
                        copy(longest, line);
                }
               
                //checks to see if array ends with a new line
                if (line[len - 1] != '\n'){
                               
                                (c = getchar());

                                //while c is not equal to a new line
                                while (c != '\n'){
                                        //while c is not a new line add one to possiblemax
                                        ++possiblemax;
                                }

                                //if is equal to a new line
                                if (c  == '\n'){
                                        //if possiblemax is greater than real max
                                        //set realmax to possiblemax
                                        //reset possible max
                                        if (possiblemax > realmax){
                                realmax = possiblemax;
                                possiblemax = 0;
                }

                                //otherwise reset possiblemax
                                        else possiblemax = 0;
                }
            }
                                           
               
                realmax = realmax + max;

                if (max > 0){ //there was a line
                        printf("length:%d", realmax);
                        putchar('\n');
                        printf("%s", longest);
                }
                return 0;
}

//read a line into s, return length
int getline(char s[], int lim){
        int c, i;

        for(i = 0; i < lim-1 && (c = getchar()) != EOF && c != '\n'; ++i)
                s[i] = c;
        if(c == '\n'){
                s[i] = c;
                ++i;
        }
        s[i] = '\0';
        return i;
}

//copy from into to: assume to is big enough
void copy(char to[], char from[]){
        int i;

        i = 0;
        while ((to[i] = from[i]) != '\0')
                ++i;
}

---

It sure does look like it is infinitely going on with this code though. I also moved the (c = getchar()); to the outside of the if and else statements.

The while and the getchar need to be together, as the only thing that can make your while loop stop is the getchar! You need to change c inside the loop, not ten lines away.

Oh I get what you are saying..However now my program does nothing at all, no matter how many "enter-keys" I put in. Assuming my while loop works, I think it may have to do with when my code actually reaches a new line.

Code:

---

#include <stdio.h>
#define MAXLINE 10

int getline(char line[], int maxline);
void copy(char to[], char from[]);

//prints longest input line
main(){
        int len; //current line length
        int max; //maximum length seen so far
        int possiblemax; //possible maximum length
        int realmax; //the real maximum length
        int c; //the char
    char line[MAXLINE]; //current input line
        char longest[MAXLINE]; //longest line saved here
       
    max = possiblemax = realmax = 0;

        while ((len = getline(line, MAXLINE)) > 0)
               
                if (len > max){
                        max = len;
                        copy(longest, line);
                }
               
                //checks to see if array ends with a new line
                if (line[len - 1] != '\n'){

                                //while c is not equal to a new line
                                while ((c = getchar()) != '\n'){
                                        //while c is not a new line add one to possible max
                                        ++possiblemax;
                                }

                                //if is equal to a new line
                                if (c  == '\n'){
                                        //if possiblemax is greater than real max
                                        //set realmax to possiblemax
                                        //reset possible max
                                        if (possiblemax > realmax){
                                realmax = possiblemax;
                                possiblemax = 0;
                }

                                //otherwise reset possiblemax
                                        else possiblemax = 0;
                }
            }
                                           
               
                realmax = realmax + max;

                if (max > 0){ //there was a line
                        printf("length:&#37;d", realmax);
                        putchar('\n');
                        printf("%s", longest);
                }
                return 0;
}

//read a line into s, return length
int getline(char s[], int lim){
        int c, i;

        for(i = 0; i < lim-1 && (c = getchar()) != EOF && c != '\n'; ++i)
                s[i] = c;
        if(c == '\n'){
                s[i] = c;
                ++i;
        }
        s[i] = '\0';
        return i;
}

//copy from into to: assume to is big enough
void copy(char to[], char from[]){
        int i;

        i = 0;
        while ((to[i] = from[i]) != '\0')
                ++i;
}

---

Also I must say thank you for your patience with me! =]

Your indentation is lying to you, perhaps. Do you want to be able to type in more than one line?

Code:

---

while ((len = getline(line, MAXLINE)) > 0)
                {
                if (len > max){
                        max = len;
                        copy(longest, line);
                }
               
                //checks to see if array ends with a new line
                if (line[len - 1] != '\n'){

                                //while c is not equal to a new line
                                while ((c = getchar()) != '\n'){
                                        //while c is not a new line add one to possible max
                                        ++possiblemax;
                                }

                                //if is equal to a new line
                                if (c  == '\n'){
                                        //if possiblemax is greater than real max
                                        //set realmax to possiblemax
                                        //reset possible max
                                        if (possiblemax > realmax){
                                realmax = possiblemax;
                                possiblemax = 0;
                }

                                //otherwise reset possiblemax
                                        else possiblemax = 0;
                }
            }
                              }            
               
                realmax = realmax + max;

                if (max > 0){ //there was a line
                        printf("length:%d", realmax);
                        putchar('\n');
                        printf("%s", longest);
                }
                return 0;
}

---

Maybe add the pair of braces, so that the while loop sees more than just the reading-in part.

wow..thanks...so now I am able to get the correct length of the longest line, but it does not copy the correct longest line. it simply gives me back the first longest line that passes MAXLINE. However It does give me back the correct one when all the given lines have a length less than MAXLINE. I think something may be wrong with the way im copying it.

Edit: So I fixed it..however I don't see why the copy inside the while loop does not interfere with the one outside of it. I would see why it wouldnt if all the lines were within MAXLINE because it would never reach the point where it adds to possiblemax. However when there are a mixture of lines, the code seems to run fine. I would think the copy outside the while loop would interfere with the one inside. Can someone explain this to me please?

Code:

---

#include <stdio.h>
#define MAXLINE 10

int getline(char line[], int maxline);
void copy(char to[], char from[]);

//prints longest input line
main(){
        int len; //current line length
        int max; //maximum length seen so far
        int possiblemax; //possible maximum length
        int realmax; //the real maximum length
        int c; //the char
    char line[MAXLINE]; //current input line
        char longest[MAXLINE]; //longest line saved here
       
    max = possiblemax = realmax = 0;

        while ((len = getline(line, MAXLINE)) > 0){

                //checks to see if array ends with a new line
                if (line[len - 1] != '\n'){

                                //while c is not equal to a new line
                                while ((c = getchar()) != '\n'){
                                        //while c is not a new line add one to possible max
                                        ++possiblemax;
                                }

                                //if is equal to a new line
                                if (c  == '\n'){

                                        //if possiblemax is greater than real max
                                        //set realmax to possiblemax
                                        //reset possible max
                                        if (possiblemax > realmax){
                                                                copy(longest, line);
                                realmax = possiblemax;
                                possiblemax = 0;
                }

                                //otherwise reset possiblemax
                                        else possiblemax = 0;
                }
            }

                if (len > max){
                        max = len;
                        copy(longest, line);
                }
        }
                                           
               
                realmax = realmax + max;

                if (max > 0){ //there was a line
                        printf("length:&#37;d", realmax);
                        putchar('\n');
                        printf("%s", longest);
                }
                return 0;
}

//read a line into s, return length
int getline(char s[], int lim){
        int c, i;

        for(i = 0; i < lim-1 && (c = getchar()) != EOF && c != '\n'; ++i)
                s[i] = c;
        if(c == '\n'){
                s[i] = c;
                ++i;
        }
        s[i] = '\0';
        return i;
}

//copy from into to: assume to is big enough
void copy(char to[], char from[]){
        int i;

        i = 0;
        while ((to[i] = from[i]) != '\0')
                ++i;
}

---

What do you mean by interfere with? You have a big if-else at the top -- if the line is long, you go into the "if" part, if it's short it goes into the "else" part. If the line you have is longer than the previous longest line, you copy it. It overwrites what was previously there.

What I meant was if say the program does reach a line that is longer than MAXLINE, the inside copy inside the FIRST IF copies the line into the array. What would the second copy within the SECOND IF do?

Quote:

---

Originally Posted by dnguyen1022

Code:

---

                                //FIRST IF
                //checks to see if array ends with a new line
                if (line[len - 1] != '\n'){

                                //while c is not equal to a new line
                                while ((c = getchar()) != '\n'){
                                        //while c is not a new line add one to possible max
                                        ++possiblemax;
                                }

                                //if is equal to a new line
                                if (c  == '\n'){

                                        //if possiblemax is greater than real max
                                        //set realmax to possiblemax
                                        //reset possible max
                                        if (possiblemax > realmax){
                                                                                                                       
                                  copy(longest, line);
                                realmax = possiblemax;
                                possiblemax = 0;
                }

                                //otherwise reset possiblemax
                                        else possiblemax = 0;
                }
            }
                                //SECOND IF
                if (len > max){
                        max = len;
                        copy(longest, line);
                }
        }

---

---

Also there actually is no else if. I noticed if I changed the SECOND IF to an else if, the code will not work if it reaches a line that is over the MAXLINE limit.

Then in your current code, your second copy statement is what saves your bacon -- notice that max is not set to the proper value in the first copy, so it will immediately get copied again in the second copy (since max is still at its prior, smaller, value)