how?

the answer is 2 , isn't it?

Thank you!

I had WA9 because i thought there would be only one king of the same color, but seems like actually there might be more. Thankfully to take more kings into account i had to delete some of my code rather than add some.

An example test:

0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
-1 0 0 0 0 0 0 0
0 -1 0 0 0 0 0 0
6 0 6 0 0 0 0 0
1
White
<any move> (for example a1-a2 or c1-c2)

The answer is "Incorrect" and then a table, because no matter what white does, there's at least one king remaining under check.

Also had WA7 because of using shortint and a bit too small constant for amount of available moves. After changing from 100 to 300 and from shortint to longint got AC.

An example test, where white have 288 available moves:

5 5 5 5 5 5 5 5
5 0 0 0 0 0 0 5
5 0 0 0 0 0 0 5
5 0 0 0 0 0 0 5
5 0 0 0 0 0 0 5
5 0 0 0 0 0 0 5
5 0 0 0 0 0 0 5
5 5 5 5 5 5 5 5
1
White
a1-b2

Result: "Draw" and table output.

Edited by author 11.01.2016 03:55

why does cin.eof() produces WA 3 ?

You should use while(scanf("%lf", &a))

You should try to increase the size of your array and perhaps use a double array over float.

> A size of the input stream does not exceed 256 KB

Minimum number of chars per number is 2 - "0 ". So you have to receive up to 128 K numbers. Your array is about 8 K numbers.

You shouldn't allocate such big arrays on stack. Use dynamic allocation or std::vector.

And another note.
> unsigned long long n,j,k;
> for(i=0;i<n;i++)
>  cin>>a[i];

How many times will this for iterate? Why?

Edited by author 15.12.2015 21:02

No use, still WA#8

Check if you comparing right prices for 2-rooms apartment when person lives single.

Your algorithm is not wrong, but it cost too much time. Try "sieve of Eratosthenes". You can search it on wiki.

Правильное решение (Accepted):
using System;
namespace _1086_Криптография
{
    class Program
    {

        static void Main(string[] args)
        {
            // считываем количество выводимых чисел
            int n = int.Parse(Console.ReadLine());
            // создаем массив и считуем в него порядочные номера простых чисел
            int[] hip = new int[n];
            for (int i = 0; i < n; i++)
            {
                hip[i] = int.Parse(Console.ReadLine());

            }
            // определим максимальный элемент масива
            // можно исользовать цикл
            int[] hip1 = new int[n];
            Array.Copy(hip, hip1, n);
            Array.Sort(hip1);
            // зададим массив упорядоченых простых чисео с запасом
            int[] val = new int[hip1[hip1.Length - 1]+2];
            // зададим начальный ряд простых чисел
            val[0] = 2;
            val[1] = 3;
            val[2] = 5;
            val[3] = 7;
            // определяем простые числа делением на предыдущие простые числа
            // метод итераций построен на do while
                int k = 4; int i1 = 8;
                do
                {
                    int reid = 0;
                    for (int i = 0; i < k; i++)
                    {
                        if (i1 % val[i] == 0)
                        {reid = 1; break; }
                    }
                    if (reid == 0)
                    { val[k] = i1; k++; }
                    i1++;

                }
                while (k < hip1[hip1.Length - 1]+1);
            // вывод заданых простых чисел
                for (int i = 0; i < hip.Length; i++)
                {
                    Console.WriteLine(val[hip[i]-1]);
                }
        }
    }
}

Edited by author 08.01.2016 17:23

Edited by author 08.01.2016 17:23

You don't need your "div()".

Thank you. And we even can go a step further. Now see, A * k = A * k - A + A = A(k - 1) + A, So what we need to examine is just whether sum( digit[i]) is divisible by ( k - 1).

output1:
sd5=<span class=string>#124</span><span class=string>'ashds'</span><span class=string>#12</span><span class=string>#154</span><span class=string>'sah'</span>;

Test #1 describe into problem statement.

10 3 3
4 5 1

What it means, we have range [0, 10] and start position in 3. And have 3 shifts.
First shift we can go from 3 to [-1, 7] as -1 not in range we have only [7] positions.
Second shift we can go to positions [2, 12] as 12 not in range we have only [2] position.
Third shift we can go to positions [1, 3] as all of them in range we have 2 possible final states 1 and 3, minimal of them 1 and maximal 3. Answer will be 1 3.


Another test:
100 50 4
1 2 4 8

Possible positions on steps:
0) [50]
1) [49, 51]
2) [47, 49, 51, 53]
3) [43, 45, 47, 49, 51, 53, 55, 57]
4) [35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65]
Answer will be 35 65

Hi. Can you remember, what was the problem with test 14?

because of the test cases are to easy....

you can use (next_permutation) easyly...

5
RGRBG

7
RBGBRGB

6
RGBGRB

4
RRBG

Input:
1
1
2
Output:
-2

try
0
0
5
ans -5 not 0