📜  一系列剪刀石头布游戏中每位玩家的获胜次数

📅  最后修改于: 2021-04-29 04:44:29             🧑  作者: Mango

两名球员正在玩剪刀石头布的一系列游戏。一共有K个游戏。玩家1具有以字符串A表示的字符串移动,而玩家2同样具有字符串B。如果任何玩家到达其字符串的末尾,他们将移回字符串的开头。任务是计算正好进行K场比赛时每个玩家赢得的比赛数。

例子:

方法:将字符串a的长度设为n ,将字符串b的长度设为m 。这里的观察结果是,游戏将在n * m次移动后重复进行。因此,我们可以模拟n * m个游戏的过程,然后计算重复的次数。对于其余的游戏,由于它现在小于n * m ,因此我们可以再次模拟该过程。例如,在上面的第一个示例中, n = 2m = 1 。因此,游戏将在每n * m = 2 * 1 = 2次移动后重复执行,(Player2,Draw)(Player2,Draw) ,….., (Player2,Draw)

下面是上述方法的实现:

C++
// C++ implementation of the above approach
#include 
using namespace std;
 
// Function that returns 1 if first player wins,
// 0 in case of a draw and -1 if second player wins
int compare(char first, char second)
{
    // If both players have the same move
    // then it's a draw
    if (first == second)
        return 0;
 
    if (first == 'R') {
        if (second == 'S')
            return 1;
        else
            return -1;
    }
    if (first == 'P') {
        if (second == 'R')
            return 1;
        else
            return -1;
    }
    if (first == 'S') {
        if (second == 'P')
            return 1;
        else
            return -1;
    }
}
 
// Function that returns the count of games
// won by both the players
pair countWins(int k, string a, string b)
{
    int n = a.length();
    int m = b.length();
    int i = 0, j = 0;
 
    // Total distinct games that can be played
    int moves = n * m;
    pair wins = { 0, 0 };
    while (moves--) {
        int res = compare(a[i], b[j]);
 
        // Player 1 wins the current game
        if (res == 1)
            wins.first++;
 
        // Player 2 wins the current game
        if (res == -1)
            wins.second++;
        i = (i + 1) % n;
        j = (j + 1) % m;
    }
 
    // Number of times the above n * m games repeat
    int repeat = k / (n * m);
 
    // Update the games won
    wins.first *= repeat;
    wins.second *= repeat;
 
    // Remaining number of games after
    // removing repeated games
    int rem = k % (n * m);
    while (rem--) {
        int res = compare(a[i], b[j]);
 
        // Player 1 wins the current game
        if (res == 1)
            wins.first++;
 
        // Player 2 wins the current game
        if (res == -1)
            wins.second++;
        i = (i + 1) % n;
        j = (j + 1) % m;
    }
    return wins;
}
 
// Driver code
int main()
{
    int k = 4;
    string a = "SR", b = "R";
    auto wins = countWins(k, a, b);
    cout << wins.first << " " << wins.second;
}


Java
// Java implementation of the above approach
import java.util.*;
import java.awt.Point;
 
class GFG{
     
// Function that returns 1 if first player wins,
// 0 in case of a draw and -1 if second player wins
public static int compare(char first, char second)
{
     
    // If both players have the same move
    // then it's a draw
    if (first == second)
        return 0;
   
    if (first == 'R')
    {
        if (second == 'S')
            return 1;
        else
            return -1;
    }
    if (first == 'P')
    {
        if (second == 'R')
            return 1;
        else
            return -1;
    }
    if (first == 'S')
    {
        if (second == 'P')
            return 1;
        else
            return -1;
    }
     
    return 0;
}
   
// Function that returns the count of games
// won by both the players
public static Point countWins(int k, String a,
                                     String b)
{
    int n = a.length();
    int m = b.length();
    int i = 0, j = 0;
   
    // Total distinct games that
    // can be played
    int moves = n * m;
    Point wins = new Point (0, 0);
  
    while (moves-- > 0)
    {
        int res = compare(a.charAt(i),
                          b.charAt(j));
   
        // Player 1 wins the current game
        if (res == 1)
            wins = new Point(wins.x + 1,
                             wins.y);
   
        // Player 2 wins the current game
        if (res == -1)
            wins = new Point(wins.x,
                             wins.y + 1);
                              
        i = (i + 1) % n;
        j = (j + 1) % m;
    }
   
    // Number of times the above
    // n * m games repeat
    int repeat = k / (n * m);
   
    // Update the games won
    wins = new Point(wins.x * repeat,
                     wins.y * repeat);
     
    // Remaining number of games after
    // removing repeated games
    int rem = k % (n * m);
     
    while (rem-- > 0)
    {
        int res = compare(a.charAt(i),
                          b.charAt(j));
   
        // Player 1 wins the current game
        if (res == 1)
            wins = new Point(wins.x + 1,
                             wins.y);
   
        // Player 2 wins the current game
        if (res == -1)
            wins = new Point(wins.x,
                             wins.y + 1);
                              
        i = (i + 1) % n;
        j = (j + 1) % m;
    }
    return wins;
} 
 
// Driver code
public static void main(String[] args)
{
    int k = 4;
    String a = "SR", b = "R";
    Point wins = countWins(k, a, b);
 
    System.out.println(wins.x + " " + wins.y);
}
}
 
// This code is contributed by divyeshrabadiya07


Python3
# Python3 implementation of the above approach
 
# Function that returns 1 if first
# player wins, 0 in case of a draw
# and -1 if second player wins
def compare(first, second):
 
    # If both players have the same
    # move then it's a draw
    if (first == second):
        return 0
 
    if (first == 'R'):
        if (second == 'S'):
            return 1
        else:
            return -1
     
    if (first == 'P'):
        if (second == 'R'):
            return 1
        else:
            return -1
     
    if (first == 'S'):
        if (second == 'P'):
            return 1
        else:
            return -1
 
# Function that returns the count
# of games won by both the players
def countWins(k, a, b):
 
    n = len(a)
    m = len(b)
    i = 0
    j = 0
 
    # Total distinct games that
    # can be played
    moves = n * m
    wins = [ 0, 0 ]
     
    while (moves > 0):
        res = compare(a[i], b[j])
 
        # Player 1 wins the current game
        if (res == 1):
            wins[0] += 1
 
        # Player 2 wins the current game
        if (res == -1):
            wins[1] += 1
             
        i = (i + 1) % n
        j = (j + 1) % m
        moves -= 1
 
    # Number of times the above
    # n * m games repeat
    repeat = k // (n * m)
 
    # Update the games won
    wins[0] *= repeat
    wins[1] *= repeat
 
    # Remaining number of games after
    # removing repeated games
    rem = k % (n * m)
    while (rem > 0):
        res = compare(a[i], b[j])
 
        # Player 1 wins the current game
        if (res == 1):
            wins[0] += 1
 
        # Player 2 wins the current game
        if (res == -1):
            wins[1] += 1
             
        i = (i + 1) % n
        j = (j + 1) % m
         
    return wins
 
# Driver code
if __name__ == "__main__":
     
    k = 4
    a = "SR"
    b = "R"
     
    wins = countWins(k, a, b);
     
    print(wins[0], wins[1])
 
# This code is contributed by chitranayal


C#
// C# implementation of the above approach
using System;
using System.Collections.Generic; 
 
class GFG{
     
// Function that returns 1 if first player
// wins, 0 in case of a draw and -1 if
// second player wins
static int compare(char first, char second)
{
     
    // If both players have the same
    // move then it's a draw
    if (first == second)
        return 0;
         
    if (first == 'R')
    {
        if (second == 'S')
            return 1;
        else
            return -1;
    }
    if (first == 'P')
    {
        if (second == 'R')
            return 1;
        else
            return -1;
    }
    if (first == 'S')
    {
        if (second == 'P')
            return 1;
        else
            return -1;
    }
    return 0;
}
    
// Function that returns the count of games
// won by both the players
static Tuple countWins(int k, string a,
                                        string b)
{
    int n = a.Length;
    int m = b.Length;
    int i = 0, j = 0;
    
    // Total distinct games that
    // can be played
    int moves = n * m;
    Tuple wins = Tuple.Create(0, 0);
   
    while (moves-- > 0)
    {
        int res = compare(a[i], b[j]);
         
        // Player 1 wins the current game
        if (res == 1)
            wins = Tuple.Create(wins.Item1 + 1,
                                wins.Item2);
    
        // Player 2 wins the current game
        if (res == -1)
            wins = Tuple.Create(wins.Item1,
                                wins.Item2 + 1);
                                 
        i = (i + 1) % n;
        j = (j + 1) % m;
    }
    
    // Number of times the above
    // n * m games repeat
    int repeat = k / (n * m);
    
    // Update the games won
    wins = Tuple.Create(wins.Item1 * repeat,
                        wins.Item2 * repeat);
      
    // Remaining number of games after
    // removing repeated games
    int rem = k % (n * m);
      
    while (rem-- > 0)
    {
        int res = compare(a[i], b[j]);
         
        // Player 1 wins the current game
        if (res == 1)
            wins = Tuple.Create(wins.Item1 + 1,
                                wins.Item2);
    
        // Player 2 wins the current game
        if (res == -1)
            wins = Tuple.Create(wins.Item1,
                                wins.Item2 + 1);
                               
        i = (i + 1) % n;
        j = (j + 1) % m;
    }
    return wins;
}
 
// Driver Code
static void Main()
{
    int k = 4;
    string a = "SR", b = "R";
    Tuple wins = countWins(k, a, b);
  
    Console.WriteLine(wins.Item1 + " " +
                      wins.Item2);
}
}
 
// This code is contributed by divyesh072019


输出:
0 2

时间复杂度: O(N * M)