L1-025. 正整数A+B（Java）PAT团体程序设计天梯赛-练习集

本题的目标很简单，就是求两个正整数A和B的和，其中A和B都在区间[1,1000]。稍微有点麻烦的是，输入并不保证是两个正整数。

输入格式：

输入在一行给出A和B，其间以空格分开。问题是A和B不一定是满足要求的正整数，有时候可能是超出范围的数字、负数、带小数点的实数、甚至是一堆乱码。

注意：我们把输入中出现的第1个空格认为是A和B的分隔。题目保证至少存在一个空格，并且B不是一个空字符串。

输出格式：

如果输入的确是两个正整数，则按格式“A + B = 和”输出。如果某个输入不合要求，则在相应位置输出“?”，显然此时和也是“?”。

输入样例1：

123 456

输出样例1：

123 + 456 = 579

输入样例2：

22 . 18

输出样例2：

? + 18 = ?

输入样例3：

-100 blabla bla…33

输出样例3：

? + ? = ?

---

大家注意看题目中的那个“注意”：我们把输入中出现的第1个空格认为是A和B的分隔。题目保证至少存在一个空格，并且B不是一个空字符串。

我刚开始还没死磕这个地方，就认为输入两个数或是字符串，用第一个空格分割，因为B可能是个字符串，中间也有空格。于是就写了两个输入，然后再判断，结果有个测试点就是过不去。

后来，我就看网上别人说的这个“注意”，题目说B不是一个空串，可能就隐含着A可能是一个空串，而且首先就输入一个空格，然后直接输入B。A为空。于是我就改了下代码，先判断第一个字符是不是空格，然后就过了。

import java.util.Scanner;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 先默认都是 '?'
        String A = "?";
        String B = "?";
        String result = "?";

        // 直接读取一行
        String temp = scanner.nextLine();

        // 如果输入的第一个字符就是空格
        if (temp.charAt(0) == ' ') {
            // 就认为 A为空，空格后面就是 B
            B = temp.substring(1);
        } else {
            // 如果第一个字符不是空格，就可以认为有两个字符串
            // 用空格分割一次
            String[] temps = temp.split(" ", 2);
            A = temps[0];   // 第一个是 A
            B = temps[1];   // 第二个是 B
        }

        // 编辑正则表达式，匹配数字 0-9
        Pattern pattern = Pattern.compile("[0-9]*");
        boolean A_ok = false;
        boolean B_ok = false;

        // 因为正常的 A,B in [1, 1000]，所以先从字符串长度判断，然后判断是不是数字
        // 如果是数字，再判断是不是在 [1, 1000]
        if (A.length() > 4 || !pattern.matcher(A).matches() ||
            Integer.parseInt(A) < 1 || Integer.parseInt(A) > 1000) {
            // 只要一个条件满足 ，A 就是错误字符
            A = "?";
        } else {
            // 否则 A 就是符合条件的整数，标记一下
            A_ok = true;
        }

        // 同判断 A 一样
        if (B.length() > 4 || !pattern.matcher(B).matches() ||
                Integer.parseInt(B) < 1 || Integer.parseInt(B) > 1000) {
            B = "?";
        } else {
            B_ok = true;
        }

        // 如果 A 、B 都符合条件，就计算和
        if (A_ok && B_ok) {
            int sum = Integer.parseInt(A) + Integer.parseInt(B);
            result = String.valueOf(sum);
        }

        // 输出结果
        System.out.println(A + " + " + B + " = " + result);

    }
}

---

可是后来看了一下别人的代码，发现并没有判断第一个字符是否为空格。比如先输入一个空格，再输入一个整数，控制台还会继续等待输入。这样提交后，发现也是都对的。

#include  

// 如果是1-1000的正整数, 则返回正确值；否则返回 -1 
int convert(const char *str)  
{  
    int sum = 0;  

    for (int i = 0; str[i] !='\0'; i++)  
    {  
        // 如果是数字 
        if(str[i] >= '0' && str[i] <= '9')
        {
            // 如果数字长度超过4位 
            if (i > 4) {
                return -1;
            } 
            sum = sum * 10 + str[i] - '0';
        }  
        else
        {
            // 否则返回 -1 
            return -1; 
        }  
    }  

    if(sum >= 1 && sum <= 1000)
    {
        return sum;
    } 

    return -1;
}  


int main()  
{  
    char A[10000], B[10000];  
    int a, b;  

    // 输入A，到第一个空格就停止 
    scanf("%s ", A);
    // 输入B，到行尾
    gets(B);

    // 转换判断 
    a = convert(A);  
    b = convert(B);  

    // 输出 
    if (a == -1)  
    {
        printf("? + ");
    } 
    else
    {
        printf("%d + ", a);
    }

    if (b == -1)  
    {
        printf("? = ");
    } 
    else
    {
        printf("%d = ", b);
    }

    if (a == -1 || b == -1)  
    {
        printf("?\n");
    }
    else
    {
        printf("%d\n", a + b);
    }

    return 0;  

}  

---

最后我发现，并不是那个条件的原因，不用管A是否为空，还是正常读取，不过我修改了一下输入，最终也通过了：

import java.util.Scanner;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 输入A，到第一个空格就停止 
        String A = scanner.next();
        // 输入B，到第二个空格
        // 如果直接使用 String B = scanner.nextLine(); 会出错
        // 它把 A 后面的那个空格也一起读取了，会对B的判断出错
        // 修改一下，分开读，如果B后面还有字符串，就是不合法
        String B = scanner.next();
        String afterB = scanner.nextLine();
        String result = "?";


        // 编辑正则表达式，匹配数字 0-9
        Pattern pattern = Pattern.compile("[0-9]*");
        boolean A_ok = false;
        boolean B_ok = false;

        // 因为正常的 A,B in [1, 1000]，所以先从字符串长度判断，然后判断是不是数字
        // 如果是数字，再判断是不是在 [1, 1000]
        if (A.length() > 4 || !pattern.matcher(A).matches() ||
            Integer.parseInt(A) < 1 || Integer.parseInt(A) > 1000) {
            // 只要一个条件满足 ，A 就是错误字符
            A = "?";
        } else {
            // 否则 A 就是符合条件的整数，标记一下
            A_ok = true;
        }

        // 如果B的长度大于4，或者包含非数字，或不在[1, 1000]范围内，或者B后面还有字符，都算非法
        if (B.length() > 4 || !pattern.matcher(B).matches() ||
            Integer.parseInt(B) < 1 || Integer.parseInt(B) > 1000 ||
            afterB.length() > 0) {
            B = "?";
        } else {
            B_ok = true;
        }

        // 如果 A 、B 都符合条件，就计算和
        if (A_ok && B_ok) {
            int sum = Integer.parseInt(A) + Integer.parseInt(B);
            result = String.valueOf(sum);
        }

        // 输出结果
        System.out.println(A + " + " + B + " = " + result);

    }
}