I finally got accepted it on a C#!! Main memory issue here are always any Strings! Awoid using Console.ReadLine() in cycle. For some reason, .net sometimes does not use string interning. I got below accepted using only Console.Read() byte-by-byte:

class Program
    {
        static int N = 0;
        static byte[] Digs1 = null;
        static char m_Zero = '0';

        static void _ReadData()
        {
            string v_Str = Console.ReadLine();
            if (v_Str == null) return false;
            N = Int32.Parse(v_Str);
            Digs1 = new byte[N];
            int v_TmpVal = 0;

            // Fill Digs
            for (int i = 0; i < N; i++)
            {
                v_TmpVal = Console.Read();
                Digs1[i] = (byte)(Convert.ToChar(v_TmpVal) - m_Zero);
                Console.Read();
                v_TmpVal = Console.Read();
                Digs1[i] += (byte)((Convert.ToChar(v_TmpVal) - m_Zero) * 10);
                Console.Read(); //#13
                Console.Read(); //#10
            }
static void SolveProblem()
        {
            bool v_AddOne = false;
            bool v_NextAddOne = false;
            byte v_First = 0;
            byte v_Second = 0;

            for (int i = Digs1.Length - 1; i >= 0; i--)
            {
                v_First = (byte)(Digs1[i] % 10);
                v_Second = (byte)(Digs1[i] / 10);

                v_AddOne = (v_First + v_Second + (v_NextAddOne ? 1 : 0)) > 9;

                Digs1[i] = (byte)((v_First + v_Second + (v_NextAddOne ? 1 : 0)) % 10);
                v_NextAddOne = v_AddOne;
            }
        }
 static void Main(string[] args)
        { _ReadData(); SolveProblem();

            for (int i = 0; i < N; i++)
            {
                Console.Write(Digs1[i]);
            }
}

I think string is: result = str(b) +result
During this operation:
- new string with size  = result.size+1 created;
- b contents copied to new string
I am not sure about memory but it must lead to TLE.

You know your n1, n2, result strings have known size = n.
You should rather use efficient byte arrays of size n to store n1, n2, result contents

Edited by author 28.04.2016 13:22

if You get TLE verdict, U can try to use short instead of int

I think you should be more careful when you read the task.
Test
4
0 0
1 1
1 1
1 1
Answer
0222
And your program gives 222.

Edited by author 06.09.2006 15:38

I have made the same mistake.

3
1 1
9 0
9 1

try this
this test helped me

What is double mantissa size? About 17 decimal digits?
What is required number size? About 1,000,000 digits?

So, how your solution is supposed to work?

5M is too much. It isn't necessary to get whole numbers in memory.

s is one digit by definition

But if a+b>=10 s can be expressed only using two digits

Ohh, wait...

Try print(int(s))

I suppose you print in scientific notation when s is huge

I wrote the same code on C#, but it was TLE on test#4!
So, i send your code.
Thank you.

 -- use fread | fwrite;
 -- do not use << if >> statement or minimize it;
 -- minimize div  and mod  operations ( % , / operators);
 -- instead of % , /  operators may to use  pre-calculated arrays.
 -- and last, need lucky :)

Your program ate 12 Mb memory. So I suppose you are reading the whole numbers and then do addition.

It isn't necessary. It's possible to add numbers digit by digit (yes, from high digits to low) without any arrays usage - 0.3s even using scanf/printf.

And yes, use fread/fwrite.

Edited by author 13.12.2016 22:15

result = str(arr[i]) + result

Run this code 1M iterations locally.

Task:
> The first line contains a single integer N that is the length of the given integers (1 ≤ N ≤ 1 000 000)

Your code:
> int v=Integer.parseInt(b);

How many digits can be placed into int v?

From task description:
> (1 ≤ N ≤ 1 000 000)

Why do you think you are able to put result into 32-bit (10 digits max) int variable?

A test:
5
0 0
0 0
0 0
9 9
9 9

Answer:00198

Could someone help with time optimization?

i think that no such input like yours. ( my ac solution does not handle it properly. )

you should write it in this way (only one digit for one number per line):
1 1
0 2
9 3
1 1
5 0
1 1
1 3
and therefore N = 7