idea...!

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _2035
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] arrS = Console.ReadLine().Split(' ');
            long a = long.Parse(arrS[0]);
            long b = long.Parse(arrS[1]);
            long c = long.Parse(arrS[2]);
//10^9 =1 000 000 000

            if (((c - b) > a && (c-b)>0))
                Console.WriteLine("Impossible");
            else if (((c - a) > b && (c-a)>0))
                Console.WriteLine("Impossible");
            else if ((c - b) > 0 )
                Console.WriteLine("{0} {1}", (c - b), b);
            else
                Console.WriteLine("{0} {1}", (c - a), a);

        }
    }
}

Edited by author 06.03.2015 12:54

Notice that k maybe be bigger than n.

Could anyone provide any information about the 11-th test?

This is my programm below:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;

namespace _1248
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            double s = 0;
            for (int i = 0; i < n; i++)
            {
                string strS = Console.ReadLine();
                double ch =0;
                if (strS.Contains("e"))
                {
                    string[] arr = strS.Split('e');
                    double ss = double.Parse (arr[1]);
                    ch = double.Parse(arr[0], CultureInfo.InvariantCulture) *  Math.Pow(10, ss);
                }
                else
                    ch = double.Parse  (strS );

                s +=ch;
            }

            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("{0:0.000000000000000000e0}", s);
            string sss = sb.ToString();
            sss = sss.Replace(',', '.');
            //sss = sss.Replace("e0", "");
            Console.WriteLine(sss);
        }
    }
}

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Scanner;

public class Election {
    static long count;

    public static void main(String agrs[]) {
        Scanner scan = new Scanner(System.in);
        long N = scan.nextInt();
        long N1 = scan.nextInt();
        DecimalFormat form = new DecimalFormat("0.00");
        ArrayList<Integer> array = new ArrayList<Integer>();
        for (int i = 0; i < N1; i++) {
            array.add(scan.nextInt());
        }

        for (int i = 1; i <= N; i++) {

            for (int j = 0; j < N1; j++) {
                if (array.get(j) == i) {

                    count++;

                }

            }

            System.out.println(form.format((count * 100) / N1) + "%");
            count = 0;
        }
    }

}
===================
Cant find any error. :(

Right or wrong my answer to the next test?
10
1 1 2 2 3
10 1 11 2 1
5 5 6 7 2
3 4 8 7 3
1 3 9 9 3
12 11 15 12 1
3 3 6 6 2
4 6 8 10 3
3 7 4 12 3
2 5 4 7 2
4 50

rez:
107.071068
35.355339  35.355339


and this one:

10
1 1 2 2 8
10 1 11 2 1
5 5 6 7 2
3 4 8 7 3
1 3 9 9 3
12 11 15 12 6
3 3 6 6 5
4 6 8 10 3
3 7 4 12 3
2 5 4 7 2
4 50

rez:
153.263903
19.695965 45.957252

Edited by author 21.11.2007 14:15

Edited by author 15.03.2008 10:46

Edited by author 15.03.2008 10:49

Let your recursion function is "void dfs1(int k, int curr)", k is digit, curr is current S, then use it code:

    int start = 0;
    start = max(start, curr - 9 * (k - 1));

    int end = min(9, curr);
    if(k == 10) {
        end = min(1, end);
    }

    for(int i = start; i <= end; i++) {
        dfs1(k - 1, curr - i);
    }

It turns out, curr does not go beyond zero at k = 0!
I have 937ms with this solution

But with precalc I have 31ms :)
Good luck

Think about how many sides of steaks you need to cook, not in terms of whole steaks.
Except you can't cook both sides at the same time (when k > n).

What about Simpson integration ?

please.

Try these tests on big input data:
1000000000000000000 999999999999999990 999999999999999999
3

1000000000000000000 10 500000000000000000
3

1000000000000000000 500000000000000000 250000000000000000
2

Tips:
1. Remember, that you should not only forget about using big types (for c++ it's long long int or __int64) but not forget to take big input data correctly.
For example, if you will use scanf("%d", &i), it will not get correctly a big input digit.
2. If you use min function in you program to find the minimum of two digits, don't forget to initialize your min value variable with the maximum value your can input.
For example, __int64 minInit = LLONG_MAX.

If you have such problems, you will have incorrect answers on the second and third tests (you'll get 4 and 3 respectively) and you will have WA on the tests 17 (the first tip) and 18 (the second tip).

#include <iostream>
using namespace std;
int main()
{
    int a, b;
    cout << "Enter the first number: ";
    cin >> a;
    cout << "Enter the second number: ";
    cin >> b;
    cout <<"the result: "<< a + b << endl;
    return 0;
}

delete please/

Edited by author 13.11.2014 21:07

problem solved

Edited by author 14.10.2015 11:08

why wrong answer?
#include <iostream>
using namespace std;
int main()
{
    int banki=10, banki_s, bankis_ss;
    cout << "Harry shot cans: ";
    cin >> banki_s;
    cout << "Larry shot cans: ";
    cin >> bankis_ss;
cout << "Harry shot: " << (banki - banki_s) << endl;
cout << "Larry shot: " << (banki - bankis_ss) << endl;

    return 0;
}

Sorry for russian comments, I don't speak English well. Why WA? (system("pause"); is only for checking, of course)
#include <iostream>
using namespace std;

int main()
{
    unsigned long N, P, A;
    cin >> N;
    for (A = 1; A <= N; A++) // чтобы P было максимальным, начинаем с меньшего А
    {    // прокручиваем P с N/A вниз, т.к. вроде бы это минимальное число с которого следует начинать
        for (P = N / A; P*A + P*(P - 1) / 2 > N; P--);
        if (P*A + P*(P - 1) / 2 == N) // если нашли - останавливаемся
            break;
    }
    cout << A << ' ' << P;
    system("pause");
    return 0;
}

Edited by author 24.02.2015 13:16

I don't know what problem.....
Can help me ...?

--------------------------------------------------------------------------
Code:
#include <stdio.h>
#include <math.h>

main(){
    unsigned long long int inn[99999],count=0;
    while(scanf("%llud",&inn[count])!=EOF){
            count++;
    }
    printf("count:%d\n",count);
    for(;count>0;){
        count--;
        printf("%0.4f\n",sqrt(inn[count]));
    }
    return 0;
}
-------------------------------------------------------------------------
Thanks for help.

Edited by author 17.05.2014 23:37

who can prove it