Bear and Prime 100

Description

This is an interactive problem. In the output section below you will see the information about flushing the output.

Bear Limak thinks of some hidden number — an integer from interval [2, 100]. Your task is to say if the hidden number is prime or composite.

Integer x > 1 is called prime if it has exactly two distinct divisors, 1 and x. If integer x > 1 is not prime, it’s called composite.

You can ask up to 20 queries about divisors of the hidden number. In each query you should print an integer from interval [2, 100]. The system will answer “yes” if your integer is a divisor of the hidden number. Otherwise, the answer will be “no”.

For example, if the hidden number is 14 then the system will answer “yes” only if you print 2, 7 or 14.

When you are done asking queries, print “prime” or “composite” and terminate your program.

You will get the Wrong Answer verdict if you ask more than 20 queries, or if you print an integer not from the range [2, 100]. Also, you will get the Wrong Answer verdict if the printed answer isn’t correct.

You will get the Idleness Limit Exceeded verdict if you don’t print anything (but you should) or if you forget about flushing the output (more info below).

Input

After each query you should read one string from the input. It will be “yes” if the printed integer is a divisor of the hidden number, and “no” otherwise.

Output

Up to 20 times you can ask a query — print an integer from interval [2, 100] in one line. You have to both print the end-of-line character and flush the output. After flushing you should read a response from the input.

In any moment you can print the answer “prime” or “composite” (without the quotes). After that, flush the output and terminate your program.

To flush you can use (just after printing an integer and end-of-line):

fflush(stdout) in C++;
System.out.flush() in Java;
stdout.flush() in Python;
flush(output) in Pascal;
See the documentation for other languages.
Hacking. To hack someone, as the input you should print the hidden number — one integer from the interval [2, 100]. Of course, his/her solution won’t be able to read the hidden number from the input.

Sample Input

Input

yes
no
yes

Output

2
80
5
composite

Input

no
yes
no
no
no

Output

58
59
78
78
2
prime

题意：

第一次遇到这种题型，虽然看懂了题意。。但是没想到怎么做。
题目就是说有一个隐藏的数，范围在2到100之间，需要你去猜这个数是素数还是合数，你可以做出最多20次询问，每次询问你可以输出一个数，然后后台会返回一个字符串，yes或no给你，如果你输出的数是隐藏数的约数的话，后台就会返回一个yes，否则就是一个no，根据这样的多次交互，你需要猜测隐藏数是素数还是合数。

思路：

我们假设隐藏数是一个合数，那么它就是多个素数相乘，因为在2到100间最小的素数是2，又因为隐藏数是小于等于100的，所以构成隐藏数的最大的素数为47，可以通过素数打表找出2到47之间的所有素数：
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47。
对于一个隐藏数，我们想要知道它是素数还是合数，只需知道上述素数中有几个是它的约数，若有大于1个的则是合数，当然这样考虑会忽略平方数，次方数的情况（比如说4，只有2一个素数约数，但是却是合数），所以在考虑2，3，5，7的情况的时候，我们还要考虑它们的平方数4，9，25，49（11*11>100）是不是隐藏数的约数，由于最多可以询问20次，而我们考虑的情况只有15（2到47的素数个数）+4（2，3，5，7的平方数）=19种，也就是最多只需要询问19次，所以全都询问一遍确定约数的个数即可。需要注意的是在输出一个数后你需要在后面写上fflush(stdout)，代码如下：

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
#include<stack>
using namespace std;
#define clr_all(a,b) memset(a,b,sizeof(a))
#define clr(a,b,n) memset(a,b,sizeof(a[0])*n)
template<typename T> T Max(T a, T b){ return a > b ? a : b; }
const int MAXN = 100 + 10;

int main(){
	int d = 0;
	int num[] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47 };
	for (int i = 0; i < 15; i++){
		printf("%d\n", num[i]); 
		fflush(stdout);
		char str[5];
		scanf("%s", str);
		if (str[0] == 'y'){
			d++;
			if (num[i] <= 7){
				printf("%d\n", num[i] * num[i]);
				fflush(stdout);
				scanf("%s", str);
				if (str[0] == 'y')
					d++;
			}
		}
	}
	if (d >= 2){
		printf("composite\n");
		fflush(stdout);
	}
	else{
		printf("prime\n");
		fflush(stdout);
	}
	return 0;
}