Can anyone explain me how to overcome TLE error in Java. I'm getting Time Limit Exceeded in 3 inputs which are taking 100000 test cases as input

Can anyone explain me how to overcome TLE error in Java.

So, I implemented a seating arrangement code in which first line of input take test cases and second line of input takes seat number. In output I've to display the facing seat number of my input and seat type WS, AS or MS.

For example:

2 // test cases
18 // seat number
40 // seat number
19 WS // Output
45 AS // Output

Here is my code which I implemented :

import java.io.*;

class Solution9
{
    public static void main(String arg[])throws Exception
    {
    	int tc;
    	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    tc=Integer.parseInt(br.readLine());
    int sno,q,r;
    String type,s="";
    for(int i=0;i<tc;i++)
    {
        sno=Integer.parseInt(br.readLine());
        sno--;
        q=sno/12;
        r=sno%12;
        int csno;
        csno=11-r;
        csno+=q*12;
        r%=6;
        if(r==0 || r==5)
            type="WS";
        else if(r==1 || r==4)
        	type="MS";
        else
	        type="AS";
        s=s+ (csno+1) + " " + type + "\n" ;
	}
    	System.out.println(s);    
    }
}

If you run your program under control of a profiler tool, you'll most probably notice a huge amount of time spent in StringBuilder activities around your line

s=s+ (csno+1) + " " + type + "\n" ;

Repeatedly adding something to a String is inefficient, as every time it does the following:

• Copy the existing string s into a StringBuilder (takes time proportional to the ever-increasing length of the string),
• append the other components to the StringBuilder,
• create a new String from the StringBuilder contents (again takes time proportional to the ever-increasing length of the contents).

As you aren't really interested in the intermediate Strings, but only in the final result, replace

String s="";

with

StringBuilder s=new StringBuilder();

and

s=s+ (csno+1) + " " + type + "\n" ;

with

s.append(csno+1).append(" ").append(type).append("\n");

This should give a substantial performance boost.

As Strings in Java are immutable, "changing" anything about a String means to somehow create a new String (and probably forget about the old one). So it's better to use a StringBuilder until you're ready for the final result, because StringBuilders allow changing their contents without repeatedly creating new ones.

I doubt your problem is the performance of your code. It could be improved but not by an order of magnitude or anything. I suspect the problem is that your input file is improperly formed, where it is saying that it has more lines than it actually has. Since your first line says how many lines to expect and you are streaming from System.in rather than using File io, it will wait until it sees the lines it expects. System.in will not produce an EOF exception the way a FileReader would, it'll just wait.

Edit: Oh! Wait! I take it back. You're collecting the entire output into a single string and not outputting any of it until your entire input is processed. Think how huge that string is getting! You're probably running out of memory.

Also, Ralf Kleberhoff is completely correct that you're making a new string (copying the whole string in order to add to it) for every row. Consider how much is being copied as you're doing the last couple hundred of your 100,000 rows.

You really have to be outputting as you go along. This makes it awkward to test manually from standard in, but you should get over that. Test from test files.