OpenJudge-1.6.08:石头剪刀布

一、题目链接

http://noi.openjudge.cn/ch0106/08/

二、解题思路(Java)

◎ 每轮比赛均需要比较小A和小B的出拳，然后根据胜负情况计数各自获胜的次数；
◎ 通过数组A[NA]存储小A出拳的规律，通过数组B[NB]存储小B出拳的规律，在第i轮比赛中，可以通过A[i % NA]、B[i % NB]获得这一轮中小
A和小B的出拳，这里0 <= i < N；
◎ 第i轮比赛小A获胜的条件为：
	A[i % NA] == 0 && B[i % NB] == 2 || A[i % NA] == 2 && B[i % NB] == 5 || A[i % NA] == 5 && B[i % NB] == 0；
◎ 第i轮比赛小B获胜的条件为：
	A[i % NA] == 2 && B[i % NB] == 0 || A[i % NA] == 5 && B[i % NB] == 2 || A[i % NA] == 0 && B[i % NB] == 5；
◎ 方法public String whoWins(int N, int NA, int NB, int[] A, int[] B)处理所有业务逻辑：
	→ 参数N为int类型的整数，代表比赛的轮数；
	→ 参数NA为int类型的整数，代表小A出拳的周期长度；
	→ 参数NB为int类型的整数，代表小B出拳的周期长度；
	→ 参数A为int类型的数组，存储小A出拳的规律；
	→ 参数B为int类型的数组，存储小B出拳的规律；
	→ whoWins方法返回一个字符串："A"代表小A赢得多，"B"代表小B赢得多，"draw"代表打平；
◎ 定义String类型的对象ans，代表返回的结果；
◎ 定义两个int类型的整数winA、winB，分别代表小A赢的次数、小B赢的次数，初始时均为0；
◎ 从第一轮比赛开始，到最后一轮比赛为止，利用循环i处理如下：
	→ 如果当前轮小A获胜，则令winA++；
	→ 否则如果当前轮小B获胜，则令winB++；
	循环i结束后，winA、winB分别存储了小A赢的次数、小B赢的次数；
◎ 如果winA > winB，则令ans = "A"，否则如果winA < winB，则令ans = "B"，否则令ans = "draw"，返回ans；
◎ 在main方法中调用whoWins方法，注入相应的参数后即可获得计算结果。

三、解题思路(C++)

◎ 每轮比赛均需要比较小A和小B的出拳，然后根据胜负情况计数各自获胜的次数；
◎ 通过数组A[NA]存储小A出拳的规律，通过数组B[NB]存储小B出拳的规律，在第i轮比赛中，可以通过A[i % NA]、B[i % NB]获得这一轮中小
A和小B的出拳，这里0 <= i < N；
◎ 第i轮比赛小A获胜的条件为：
	A[i % NA] == 0 && B[i % NB] == 2 || A[i % NA] == 2 && B[i % NB] == 5 || A[i % NA] == 5 && B[i % NB] == 0；
◎ 第i轮比赛小B获胜的条件为：
	A[i % NA] == 2 && B[i % NB] == 0 || A[i % NA] == 5 && B[i % NB] == 2 || A[i % NA] == 0 && B[i % NB] == 5；
◎ 定义并输入三个int类型的整数N、NA、NB，分别代表比赛轮数、小A出拳的周期长度、小B出拳的周期长度；
◎ 定义两个int类型的数组A[NA]、B[NB]，分别存储小A出拳的规律、存储小B出拳的规律；
◎ 定义两个int类型的整数winA、winB，分别代表小A赢的次数、小B赢的次数，初始时均为0；
◎ 从第一轮比赛开始，到最后一轮比赛为止，利用循环i处理如下：
	→ 如果当前轮小A获胜，则令winA++；
	→ 否则如果当前轮小B获胜，则令winB++；
	循环i结束后，winA、winB分别存储了小A赢的次数、小B赢的次数；
◎ 如果winA > winB，则令ans = "A"，否则如果winA < winB，则令ans = "B"，否则令ans = "draw"，输出ans。

四、Java程序

import java.util.Scanner;

public class Main {
    /**
     * 返回小A和小B谁赢得次数多
     *
     * @param N  int类型的整数，代表比赛的轮数
     * @param NA int类型的整数，代表小A出拳的周期长度
     * @param NB int类型的整数，代表小B出拳的周期长度
     * @param A  int类型的数组，存储小A出拳的规律
     * @param B  int类型的数组，存储小B出拳的规律
     * @return "A"代表小A赢得多，"B"代表小B赢得多，"draw"代表打平
     */
    public String whoWins(int N, int NA, int NB, int[] A, int[] B) {
        String ans; // 返回结果
        int winA = 0; // 小A赢的次数，初始为0
        int winB = 0; // 小B赢的次数，初始为0
        /* 从第一轮开始，到最后一轮为止 */
        for (int i = 0; i < N; i++) {
            // 如果当前轮小A获胜
            if (A[i % NA] == 0 && B[i % NB] == 2 ||
                 A[i % NA] == 2 && B[i % NB] == 5 ||
                 A[i % NA] == 5 && B[i % NB] == 0) {
                winA++;
            }
            // 否则如果当前轮小B获胜
            else if (A[i % NA] == 2 && B[i % NB] == 0 ||
                      A[i % NA] == 5 && B[i % NB] == 2 ||
                      A[i % NA] == 0 && B[i % NB] == 5) {
                winB++;
            }
        }
        if (winA > winB) { // 如果小A赢得多
            ans = "A";
        }
        else if (winA < winB) { // 否则如果小B赢得多
            ans = "B";
        }
        else { // 否则，小A和小B打平
            ans = "draw";
        }
        return ans;
    }

    public static void main(String[] args) {
        Main test = new Main();
        Scanner input = new Scanner(System.in);
        int N = input.nextInt();
        int NA = input.nextInt();
        int NB = input.nextInt();
        int[] A = new int[NA];
        int[] B = new int[NB];
        for (int i = 0; i < NA; i++) {
            A[i] = input.nextInt();
        }
        for (int i = 0; i < NB; i++) {
            B[i] = input.nextInt();
        }
        System.out.print(test.whoWins(N, NA, NB, A, B));
    }
}

五、C++程序

#include <iostream>
using namespace std;

int main()
{
    int N; // 比赛轮数
    cin >> N;
    int NA; // 小A出拳的周期长度
    cin >> NA;
    int NB; // 小B出拳的周期长度
    cin >> NB;
    int A[NA]; // 存储小A出拳的规律
    int B[NB]; // 存储小B出拳的规律
    int winA = 0; // 小A赢的次数，初始为0
    int winB = 0; // 小B赢的次数，初始为0
    int i;
    /* 输入小A出拳的规律 */
    for (i = 0; i < NA; i++)
    {
        cin >> A[i];
    }
    /* 输入小B出拳的规律 */
    for (i = 0; i < NB; i++)
    {
        cin >> B[i];
    }
    /* 从第一轮开始，到最后一轮为止 */
    for (i = 0; i < N; i++)
    {
        // 如果当前轮小A获胜
        if (A[i % NA] == 0 && B[i % NB] == 2 ||
            A[i % NA] == 2 && B[i % NB] == 5 ||
            A[i % NA] == 5 && B[i % NB] == 0)
        {
            winA++;
        }
        // 否则如果当前轮小B获胜
        else if (A[i % NA] == 2 && B[i % NB] == 0 ||
                 A[i % NA] == 5 && B[i % NB] == 2 ||
                 A[i % NA] == 0 && B[i % NB] == 5)
        {
            winB++;
        }
    }
    if (winA > winB) // 如果小A赢得多
    {
        cout << "A";
    }
    else if (winA < winB) // 否则如果小B赢得多
    {
        cout << "B";
    }
    else // 否则，小A和小B打平
    {
        cout << "draw";
    }
    return 0;
}