A can't understand what's the problem and why I don't pass it. Help me, please.

What's the meaning of the question ? I tried to get it but in vain, even the test unclear for me

thanks
I want to know what's the task of this problem.

There is an interesting way to code it.

For each piece we can have a function like this:
pair<string, int> get_king(int n, int x0, int y0)
{
  int cnt = 0;
  for (int dx = -1; dx <= 1; dx++)
    for (int dy = -1; dy <= 1; dy++)
      if (dx != 0 || dy != 0)
      {
        int x = x0 + dx;
        int y = y0 + dy;
        cnt += (x >= 1 && x <= n && y >= 1 && y <= n);
      }

  return { "King", cnt };
}

In the main code we just do the following loop:
for (auto get : { get_king, get_knight, get_bishop, get_rook, get_queen })
{
  auto res = get(n, x, y);
  cout << res.first << ": " << res.second << endl;
}

After that the function for queen look very easy:
pair<string, int> get_queen(int n, int x0, int y0)
{
  int cnt = get_rook(n, x0, y0).second + get_bishop(n, x0, y0).second;
  return { "Queen", cnt };
}

If you have any ideas on how to code it better, please write them here :)

My tests (N, Array, Answer):
[8, '6 7 9 13 18 24 31 50', 0],
[5, '5 5 4 3 3', 0],
[5, '3 3 4 5 5', 0],
[1, '1', 1],
[1, '2', 2],
[6, '1 4 5 6 7 9', 0],
[5, '5 8 13 27 14', 3],
[5, '5 4 3 3 3', 0],
[5, '11 10 8 7 6', 0],
[6, '1 4 5 6 7 9', 0],
[6, '9 7 6 5 4 1', 0],
[7, '1 2 3 4 5 6 6', 1],
[3, '1 1 5', 3],
[6, '1 2 3 4 100 100', 0],
[5, '5 8 13 14 15', 1],
[5, '4 6 6 7 9', 0],
[7, '36 25 12 10 8 7 1', 1],
[6, '101 51 51 3 2 2', 0],
[6, '1 4 5 6 7 9', 0],
[4, '1 3 9 27', 14],
[6, '6 6 5 4 3 2', 0],
[20, '1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20', 0]

All tests = True.
What I do wrong?

Edited by author 17.11.2016 19:27

Edited by author 17.11.2016 20:03

What does it mean? For example if K = 10, N = 3, M = 112 correct numbers are
101
102
103
104
105
106
107
108
109
110
111
Is it right?
Thanks.

Edited by author 17.11.2016 18:22

WA8 - all options are off and <10fps
WA12 - "Perfect" when >=60fps, NOT >60fps

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

namespace ConsoleApplication8
{
    class Program
    {
        static void Main(string[] args)
        {
            int N = Convert.ToInt32(Console.ReadLine());
            int A = Convert.ToInt32(Console.ReadLine());
            int B = Convert.ToInt32(Console.ReadLine());
            if (N >= 1 && 100 >= N)
                if (A >= 1 && 100 >= A)
                    if (B >= 1 && 100 >= B)
                    {
                Console.WriteLine(N * A * B * 2);
            }
        }
    }
}

if consider the position of player there are about 7.5*10^8(upper_bound),state, we can come up some idea
to compact the states,and use a huge array instead of hash_table to prevent the duplication of states this may far speed up your program

Edited by author 15.11.2016 13:02

Edited by author 15.11.2016 13:02

I have been stuck on this test 2 for a while now. I gave up then came back, but still don't know what I need to change. Here is my solution, I used 'sieve of eratosthenes' to get out the primes. Please help me out.  Should I change my input range for array.

#include <iostream>
#include <math.h>

using namespace std;



int main() {

    __int64 n;
    cin >> n;
    __int64 *input_list = new __int64[n];
    //__int64 *primes = new __int64[15000];

    long int primes[20000] = { 0 };


// input the numbers
    for (int i = 0; i < n; i++) {
        cin >> input_list[i];
    }

//   Let A be an array of Boolean values, indexed by integers 2 to n,
//initially all set to true.

//for i = 2, 3, 4, ..., not exceeding √n:
  //if A[i] is true:
    //for j = i2, i2+i, i2+2i, i2+3i, ..., not exceeding n :
      //A[j] := false

//Output: all i such that A[i] is true.



    long int a[20000] = { 0 };


    for (long int i = 2; i <= 20000; i++) {

        if (a[i] == 0) {
            for (long int j = i * i, c=1; j < 20000; j +=i, c++) {
                a[j] = 1;
            }
        }
        //cout << a[i] << ends;
    }

    for (long int i = 2, p=0; i <= 20000; i++) {
        if (a[i] == 0) {
            //cout << i << ends;
            primes[p] = i;
            p++;
        }
        else {
            continue;
        }
    }

    for (int i = 0; i < n; i++)
        cout << primes[input_list[i] - 1] << endl;

    return 0;
}



Edited by author 15.11.2016 09:33

I was bit confused to obtain accepted. I applied my solution to test straightforward approach and obtain TLE  but i'm not. With next example i would defenitely obtain TLE:

50 50
00000000000000000000000001111111111111111111111111
00000000000000000000000011111111111111111111111111
00000000000000000000000111111111111111111111111111
00000000000000000000001111111111111111111111111111
00000000000000000000011111111111111111111111111111
00000000000000000000111111111111111111111111111111
00000000000000000001111111111111111111111111111111
00000000000000000011111111111111111111111111111111
00000000000000000111111111111111111111111111111111
00000000000000001111111111111111111111111111111111
00000000000000011111111111111111111111111111111111
00000000000000111111111111111111111111111111111111
00000000000001111111111111111111111111111111111111
00000000000011111111111111111111111111111111111111
00000000000111111111111111111111111111111111111111
00000000001111111111111111111111111111111111111111
00000000011111111111111111111111111111111111111111
00000000111111111111111111111111111111111111111111
00000001111111111111111111111111111111111111111111
00000011111111111111111111111111111111111111111111
00000111111111111111111111111111111111111111111111
00001111111111111111111111111111111111111111111111
00011111111111111111111111111111111111111111111111
00111111111111111111111111111111111111111111111111
01111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111110
11111111111111111111111111111111111111111111111100
11111111111111111111111111111111111111111111111000
11111111111111111111111111111111111111111111110000
11111111111111111111111111111111111111111111100000
11111111111111111111111111111111111111111111000000
11111111111111111111111111111111111111111110000000
11111111111111111111111111111111111111111100000000
11111111111111111111111111111111111111111000000000
11111111111111111111111111111111111111110000000000
11111111111111111111111111111111111111100000000000
11111111111111111111111111111111111111000000000000
11111111111111111111111111111111111110000000000000
11111111111111111111111111111111111100000000000000
11111111111111111111111111111111111000000000000000
11111111111111111111111111111111110000000000000000
11111111111111111111111111111111100000000000000000
11111111111111111111111111111111000000000000000000
11111111111111111111111111111110000000000000000000
11111111111111111111111111111100000000000000000000
11111111111111111111111111111000000000000000000000
11111111111111111111111111110000000000000000000000
11111111111111111111111111100000000000000000000000

#include<iostream>
#include<iomanip>
#include<cmath>
using namespace std;
int main() {
long long n,i=0,c=0;
double a[100001];
 while(cin>>n){
  a[i]=sqrt(n);
   i++;
   c++;
}
for(int i=c-1; i>=0; i--)
 cout<<fixed<<setprecision(4)<<a[i]<<endl;
 system("pause");
  return 0;
}

Could somebody who solved this problem send some examples of tests and solutions?

I thought that I wrote a correct algorithm, that summarise number of stones of each type, then sort it and then check how many permutations of the last one that makes it equal to K, there is and calculate a number of possibilities. But I get error on Test 3.
Or may be I did not understood the task,

Anybody can help me with TEST #10. Just give me an example Thank you very much.

#include <iostream>
long int a,b,c,d,e,f,n,z,x,a1,a2;
using namespace std;
void main() {
    cin >>a;
    n=a%10;
    f=a%100;
    f=f/10;
    e=a%1000;
    e=e/100;
    d=a%10000;
    d=d/1000;
    c=a%100000;
    c=c/10000;
    b=a%1000000;
    b=b/100000;
    if ((n==9)||(f==9)||(e==9)) {
        z=(e+f+n)+1%10;
    } else {
        z=e+f+n;
    } if ((d==9)||(c==9)) {
        x=(b+c+d)+1%10;
    } else {
        x=b+c+d;
    }
    a1=z-x;
    a2=x-z;
    if ((a1==1)||(a2==1)) {
        cout <<"Yes";
    } else {
        cout <<"No";
    }
}

4
0 0
1 0
0 1
-1 1

0.7071


3
0 0
1 0
0 1

0.6436


3
-1 0
1 0
0 1

0.9102

Test#1
3 3
1 2 3
ans:27

Test#2
2 6
1 3
ans:36

Test#3
3 6
3 4 5
ans: 180

Test#4
1 5
3
ans:5

Test#5
1 2
1
ans:1

Test#6
3 2
1 2 2
ans:4

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Timus2002 {

    public static void main(String[] args) {

        Map<String, String> map = new HashMap<>();
        Scanner sc = new Scanner(System.in);
        String[] s = new String[105];
        ArrayList<String> logged = new ArrayList<>();
        int n = Integer.parseInt(sc.nextLine());
        for (int i = 0; i < n; i++) {
            s[i] = sc.nextLine();
        }

        for (int i = 0; i < n; i++) {
            String[] mas = s[i].split(" ");
            if(mas[0].equals("register")){
                if(map.containsKey(mas[1])){
                    System.out.println("fail: user already exists");
                    continue;
                }
                map.put(mas[1], mas[2]);
                System.out.println("success: new user added");
            }

            String login = mas[1];
            if(mas[0].equals("login")){
                String pass = mas[2];
                if(!map.containsKey(login)) {
                    System.out.println("fail: no such user");
                    continue;
                }
                String value = map.get(login);
                if(!value.equals(pass))
                    System.out.println("fail: incorrect password");

                if(value.equals(pass)) {
                    if (!logged.contains(login)) {
                        logged.add(login);
                        System.out.println("success: user logged in");
                    }
                    else
                        System.out.println("fail: already logged in");

                }
            }

            if(mas[0].equals("logout")) {
                if (!map.containsKey(login))
                    System.out.println("fail: no such user");
                if (!logged.contains(login))
                    System.out.println("fail: already logged out");
                else {
                    System.out.println("success: user logged out");
                    logged.remove(login);
                }
            }
        }
    }
}