What is Test case #5 for question 1104

I wrote the code in python as below
x = input().split(' ')
a = int(x[0])
b = int(x[1])
sum = a + b
print(sum)

But it shows compilation error and I don't know what causes it and how to fix it.

#include <iostream>
#include <fstream>
#include <cstdio>
#include <cassert>
#include <complex>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <numeric>
#include <sstream>
#include <ctime>
#include <cctype>
#include <set>
#include <map>
#include <queue>
#include <bitset>
#include <deque>
#include <stack>
#include <memory.h>
using namespace std;
typedef long long ll;
#define mp make_pair
const int MAXN =1500;

struct bign
{
    int len, s[MAXN];
    bign ()
    {
        memset(s, 0, sizeof(s));
        len = 1;
    }
    bign (int num) { *this = num; }
    bign (const char *num) { *this = num; }
    bign operator = (const int num)
    {
        char s[MAXN];
        sprintf(s, "%d", num);
        *this = s;
        return *this;
    }
    bign operator = (const char *num)
    {
        for(int i = 0; num[i] == '0'; num++) ;  //ȥǰµ¼0
        len = strlen(num);
        for(int i = 0; i < len; i++) s[i] = num[len-i-1] - '0';
        return *this;
    }
    bign operator + (const bign &b) const //+
    {
        bign c;
        c.len = 0;
        for(int i = 0, g = 0; g || i < max(len, b.len); i++)
        {
            int x = g;
            if(i < len) x += s[i];
            if(i < b.len) x += b.s[i];
            c.s[c.len++] = x % 10;
            g = x / 10;
        }
        return c;
    }
    bign operator += (const bign &b)
    {
        *this = *this + b;
        return *this;
    }
    void clean()
    {
        while(len > 1 && !s[len-1]) len--;
    }
    bign operator * (const bign &b) //*
    {
        bign c;
        c.len = len + b.len;
        for(int i = 0; i < len; i++)
        {
            for(int j = 0; j < b.len; j++)
            {
                c.s[i+j] += s[i] * b.s[j];
            }
        }
        for(int i = 0; i < c.len; i++)
        {
            c.s[i+1] += c.s[i]/10;
            c.s[i] %= 10;
        }
        c.clean();
        return c;
    }
    bign operator *= (const bign &b)
    {
        *this = *this * b;
        return *this;
    }
    bign operator - (const bign &b)
    {
        bign c;
        c.len = 0;
        for(int i = 0, g = 0; i < len; i++)
        {
            int x = s[i] - g;
            if(i < b.len) x -= b.s[i];
            if(x >= 0) g = 0;
            else
            {
                g = 1;
                x += 10;
            }
            c.s[c.len++] = x;
        }
        c.clean();
        return c;
    }
    bign operator -= (const bign &b)
    {
        *this = *this - b;
        return *this;
    }
    bign operator / (const bign &b)
    {
        bign c, f = 0;
        for(int i = len-1; i >= 0; i--)
        {
            f = f*10;
            f.s[0] = s[i];
            while(f >= b)
            {
                f -= b;
                c.s[i]++;
            }
        }
        c.len = len;
        c.clean();
        return c;
    }
    bign operator /= (const bign &b)
    {
        *this  = *this / b;
        return *this;
    }
    bign operator % (const bign &b)
    {
        bign r = *this / b;
        r = *this - r*b;
        return r;
    }
    bign operator %= (const bign &b)
    {
        *this = *this % b;
        return *this;
    }
    bool operator < (const bign &b)
    {
        if(len != b.len) return len < b.len;
        for(int i = len-1; i >= 0; i--)
        {
            if(s[i] != b.s[i]) return s[i] < b.s[i];
        }
        return false;
    }
    bool operator > (const bign &b)
    {
        if(len != b.len) return len > b.len;
        for(int i = len-1; i >= 0; i--)
        {
            if(s[i] != b.s[i]) return s[i] > b.s[i];
        }
        return false;
    }
    bool operator == (const bign &b)
    {
        return !(*this > b) && !(*this < b);
    }
    bool operator != (const bign &b)
    {
        return !(*this == b);
    }
    bool operator <= (const bign &b)
    {
        return *this < b || *this == b;
    }
    bool operator >= (const bign &b)
    {
        return *this > b || *this == b;
    }
    string str() const
    {
        string res = "";
        for(int i = 0; i < len; i++) res = char(s[i]+'0') + res;
        return res;
    }
};

istream& operator >> (istream &in, bign &x)
{
    string s;
    in >> s;
    x = s.c_str();
    return in;
}

ostream& operator << (ostream &out, const bign &x)
{
    out << x.str();
    return out;
}
bign dp[1800][2];
bign k;
int n;
int main()
{
    cin>>n>>k;
    dp[0][0]=k-1;
    dp[0][1]=0;
    for(int i=1;i<n;i++){
        dp[i][0]=(k-1)*(dp[i-1][0]+dp[i-1][1]);
        dp[i][1]=dp[i-1][0];
    }
    cout<<dp[n-1][0]+dp[n-1][1];
    return 0;
}

Please, somebody provide with test case ...

#include <stdio.h>
#include <math.h>

void recur(void);

int main() {

    recur();
    return 0;
}

void recur() {
    long int num;
    scanf("%ld", &num);
    if (num != EOF)
        recur();
    printf("%.5f\n", sqrt(num));
}

Edited by author 09.08.2018 18:20

char[200001] gives perfect time if you will check repeats while string is inputting

i used deque. cout got me TLE.using printf save me.

      if(st.front()!=s[i])
        {
            st.emplace_front(s[i]);
        }
        else
            st.pop_front();


for(it=st.end()-1; it>=st.begin(); it--)
    {
        printf("%c",*it);
    }

/*
* @Author: eleven
* @Date:   2017-05-21 02:50:38
* @Last Modified by:   eleven
* @Last Modified time: 2018-02-09 14:49:14
*/

// Status : AC ( works with stable_sort )
// doesn't works with sort

#include <bits/stdc++.h>

using namespace std;

#define SIZE 150005

struct team{
    int id;
    int solved;
}teams[SIZE];

bool foo(team lhs, team rhs){
return lhs.solved > rhs.solved;
}

void print(int n ){

    for(int i= 0; i<n ; ++i){
        cout<<teams[i].id<<" "<<teams[i].solved<<'\n';
    }
}


int main(){


    //freopen("in","r",stdin);
    //freopen("out","w",stdout);

    int n ;

    cin>>n;

    for(int i = 0; i<n ; ++i){
        cin>>teams[i].id>>teams[i].solved;
    }

    stable_sort(teams,teams+n ,foo);

    print(n);

    return 0;

}

#include<iostream>
#include<string>
#include<map>
#include<set>
using namespace std;

int main(){
    map<char,set<string>> dic;
    string w;
    int n;
    cin>>n;
    while(--n>=0){
        cin>>w;
        dic[w[0]].insert(w);
    }
    char c;
    cin>>c;
    for(auto s:dic[c])
        cout<<s<<endl;
}

If you are using DP, make sure you are using multimap instead of map ( In c++ )

Does anyon know, what is the longest test? I check a couple of numbers,with k= 99998 execution was the longest, but i'm not sure.

UPD: I check (write k=99998 instead a reading  number), and if WA#1 said truth, i reach the answere in 0,71. But this decision is still have TLE#41 :(

Maybe, there is a harder 'k' for this task?

Edited by author 07.08.2018 11:17

Edited by author 07.08.2018 11:17

i am doing (n%k)+(n/k) after putting restriction on k(k<=1000) and n(n>=1). but my answer is  said to be wrong.please help.

Edited by author 30.06.2013 01:11

"Some tram drivers are fans of fast driving, and they damage both rails and their trams. If a tram accelerates to a high speed, say 80 kilometers per hour, and then brakes sharply before a stop, it goes some distance skidding."
Is this "initial D" reference?!

Edited by author 19.08.2018 20:53

Had problem with 25th test because of integer overflow. My program used int64_t which was not enough with my approach. Casting computations to double hepled me.

The statement says

"The number of intermediate levels of employees between an arbitrary employee who has subordinates (an ordinary employee) and the employee who has no superiors (the main superior) is the same for all ordinary employees."

However, in the first paragraph, it says that "ordinary employee" means an employee who has NO subordinates. Therefore, I think the statement should say:

"The number of intermediate levels of employees between an arbitrary employee who has NO subordinates (an ordinary employee) and the employee who has no superiors (the main superior) is the same for all ordinary employees."

I looked at the Russian version of the statement with google translate and that seems to be the case.

Edited by author 06.08.2018 11:30

4*h *  n ( n + 1 )  > H
minimal  n - is answer!

but I doubt, that this is correct.

It's correct or not?

#include<stdio.h>
int main()
{
int n,m,sum;
scanf("%d \t %d", &n ,&m);
if(n<=4000 && m<=4000){
sum=n*(m+1);
printf("%d",sum);
}
return 0;
}

http://s020.radikal.ru/i702/1410/52/a428d102a994.jpg

Why?



Edited by author 11.10.2014 19:51

I Solved it with java BigInteger.
Is there any solutions without long arifmetic?