PAT 1010

1015. Reversible Primes (20)

A reversible prime in any number system is a prime whose "reverse" in that number system is also a prime. For example in the decimal system 73 is a reversible prime because its reverse 37 is also a prime.

Now given any two positive integers N (< 10⁵) and D (1 < D <= 10), you are supposed to tell if N is a reversible prime with radix D.

Input Specification:

The input file consists of several test cases. Each case occupies a line which contains two integers N and D. The input is finished by a negative N.

Output Specification:

For each test case, print in one line "Yes" if N is a reversible prime with radix D, or "No" if not.

Sample Input:

73 10
23 2
23 10
-2

Sample Output:

Yes
Yes
No

 

代码：

//============================================================================
// Name        : PAT.cpp
// Author      : wenlong
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include <vector>
#include <cstdio>
#include <cstring>
using namespace std;

bool debug = true;
long long least = 0, most = 0;

int getV(char v) {
    if (v >= '0' && v <= '9') {
        return v - '0';
    } else if (v >= 'a' && v <= 'z') {
        return v - 'a' + 10;
    }

    return 0;
}

long long findLowRadix(char *p) {
    int len = strlen(p);
    long long low = 0;
    long long num;
    for (int i = 0; i < len; i++) {
        num = getV(p[i]);
        if (num + 1 > low) {
            low = num + 1;
        }
    }
    return low;
}

long long getVV(char *d, long long a) {
    int i = 0;
    long long res = 0;
    while (d[i] != '\0') {
        res = res * a + getV(d[i]);
        i++;
    }

    return res;
}

int compare(char* p, long long radix, long long target) {
    long long len = strlen(p);
    long long num = 1;
    long long sum = 0;
    for (int i = 0; i < len; i++) {
        num = getV(p[i]);
        sum = sum * radix + num;
        if (sum > target) {  //avoid  overflow
            return 1;
        }
    }
    if (sum > target) {
        return 1;
    } else if (sum < target) {
        return -1;
    } else {
        return 0;
    }
}

long long binarySearch(char *p, long long low, long long high, long long top) {
    long long mid = low;
    long long tmp;
    while (low <= high) {
        tmp = compare(p, mid, top);
        if (tmp > 0) {
            high = mid - 1;
        } else if (tmp < 0) {
            low = mid + 1;
        } else {
            return mid;
        }
        mid = (low + high) / 2;
    }
    return -1;
}

int main() {

    debug = false;

    int tag;
    long long value, radix;

    char n1[11], n2[11];

    cin >> n1 >> n2 >> tag >> radix;

    int i = 0;
    value = 0;
    char *datas = NULL;
    if (tag == 1) {
        value = getVV(n1, radix);
        datas = n2;
    } else {
        value = getVV(n2, radix);
        datas = n1;
    }

    least = findLowRadix(datas);
    most = (value + 1 > least + 1) ? value + 1 : least + 1;

    long long res = binarySearch(datas, least, most, value);

    if (res == -1) {
        cout << "Impossible" << endl;
    } else {
        cout << res << endl;
    }

    return 0;
}