Reducing the time for rolling hash

This code does not implement a rolling hash. For every iteration of the main loop, the hash is reset and then entirely re-calculated from nothing with an inner loop. A rolling hash would remove a character from the hash and then add a new character, doing only a constant amount of work per sub-string.

There are some edge-cases for you to work out, but main element of the technique is this:

hash = hash - s1[kal - len2] + s1[kal] 

No inner loop. Also no - 96 because it is cancelled out.

So far, your code has some general problems that are much more urgent than performance:

1. You are using namespace std;. This is an extremely bad habit and will ruin your life ("this is a contest and I write everything in main" is not an acceptable excuse). See Why is using namespace std; considered bad practice?.

2. The main function is very long and a reader cannot tell at a glance what it does. If you need so many comments, you should consider refactoring your code. (Also, why do your comments end with //?)

3. You are not making enough use of the standard library.

4. There is too little space. And the indentation is inconsistent.

5. The variable names are not helpful. What is sum1? s3?

6. j++ is being used instead of the correct ++j. See Difference between pre-increment and post-increment in a loop?.

Also, please avoid std::endl when not necessary. Use '\n' instead. See C++: std::endl vs \n.

And str.erase() is much less intuitive than str.clear(). (In fact, I didn't know until today that erase can be invoked this way.)

Here's I would write the same code, at the very least: (30 seconds code, not tested comprehensively)

#include <iostream> #include <numeric> #include <string> int hash_code(const std::string& pattern) { // note: c - 'a' + 1 is not portable return std::accumulate(pattern.begin(), pattern.end(), 0, [](int x, char c){ return x + (c - 'a' + 1); }); } void search(const std::string& string, const std::string& pattern) { const int pattern_hash = hash_code(pattern); for (std::size_t i = 0; i + pattern.size() <= string.size(); ++i) { auto str = string.substr(i, pattern.size()); if (hash_code(str) == pattern_hash) std::cout << str << " " << i << "\n"; } } int main() { int n; std::cin >> n; for (int i = 0; i < n; ++i) { std::string string, pattern; std::cin >> string >> pattern; search(string, pattern); } } 

(Also, the input style is quite strange, I have to admit, but that seems to be beyond your control.)

Incidentally, I don't think you properly implemented the sentence "If no match is found, print -1."

Two more things about something like
sum=sum+(int)pattern[j]-96;:
- 96 is a magic number: The reader is left to figure out what it means here. ('a' - 1) is portable and suggestive.
- C has assignment operators to avoid repeating an "operand that gets assigned the result":
 sum += pattern[j] - 'a' + 1;

You don't need to collect the characters from the input string contributing to the checksum: They stay right there.

I don't see comparing patterns more than once.
For patterns of same length, checksums for parts of the input string get recomputed - if so inclined, try to exploit that.
For patterns P1 of length l1 and P2, |P2| = l2 = l1 + 1, the checksum to compare with checksum S2 of P2 is just "one computation step from S1" - but don't try to exploit this:
That way lies madness. (What if there was a P3: l3 = l1 + l2? P4:  l4 = l3 - 1?)