SPOJ | Some selected solutions

What is the complexity of your algorithm of finding the longest increasing subsequence?

This article provides an algorithm with the complexity of O(n log n). Upd: doesn't work. You don't even need to modify the code, because in python comparison works for tuples: assert (1, 2) < (3, 4)

I think the time limit is exceeding because of the slow I/O. This is mainly because of System.out.println's underlying PrintStream. Find more details in this post why-is-system-out-println-so-slow. You can refer to the below Fast I/O template which will help solve this problem.

Reference - Fast I/O in java

The error is caused because your input "n" makes both arguments same in the range function in this line "for j in range(int(n) + 1, 1000000 + 1)". It looks like this range(1000001, 1000001) which return nothing. Use input of "n" smaller than 1000000. It will work.

It return empty list when I use this code.

The most obvious thing to do is to stop copying and reversing the string. Instead, compare the first character to the last character, then the second to the second-to-last, and so on.

Also, why are you using strings at all? Strings are complex and expensive. The operations you are performing can be done entirely on numbers.

Lastly, consider numbers like "473X". None of those can ever be palindromes. You don't have to test all ten of them. If you're going to look at four-digit numbers starting with "47", there's only one that's a palindrome -- so why are you checking all hundred of them?

Before writing code to solve a problem like this, think through the algorithm you're going to use and make sure you don't have any obvious wasted effort.

The problem specification tells you what to do:

Attention: the program should clear the output buffer after printing each line.

It can be done using fflush(stdout) command or by setting the proper type of buffering at the beginning of the execution - setlinebuf(stdout).

The problem title indicates why:

(Interactive)

The judging software is operating the program interactively. After giving the program an input, it waits for output before providing more input. When your program does not flush the buffered output, the judging software keeps waiting until its time limit is exceeded.

Commonly, output streams to terminals are line-buffered, in which case printing a new-line character causes them to be flushed. However, this judging software is likely using a pipe that is fully buffered, so output will not be flushed until the buffer is full or you explicitly request a flush (or, at the start of the program, you change the buffering mode to unbuffered or line-buffered).

When you flush the output, the judging software will see it, and then it will continue and provide more input.

As an alternative to flushing the output after each printf, you can set the stream to line buffering mode by executing setvbuf(stdout, NULL, _IOLBF, 0); at the beginning of the program (before doing any other operation on the stream).

Since this is a SPOJ question, and you're not given the test data, what you should do is to randomize the tests until you get a failure. That way, you may be able to get a sample case that fails. This is called fuzzing, and is a technique that can be used in your question.

The following will work for the cases that cause segmentation faults, and in some cases, to verify if a given output matches the expected output. In other words, instead of trying to figure out the test data, let the computer generate the tests for you.

The way you do this is to look at the constraints that the question gives you, and generate random data that fits the constraints. Since they are all integers, you can do this by using the header, and using a uniform_int_distribution.

Here is a sample of fuzzing the data using the following constraints for N, K, and the data for prices:

In the lines:

If you mean the messagebox module that comes with tkinter, then no. But you can easily make your own message boxes with the Toplevel widget, and those can do anything you want.