Open In App

Even-odd turn game with two integers

Improve
Improve
Like Article
Like
Save
Share
Report

Given three positive integers X, Y and P. Here P denotes the number of turns. Whenever the turn is odd X is multiplied by 2 and in every even turn Y is multiplied by 2. The task is to find the value of max(X, Y) ÷ min(X, Y) after the complete P turns.

Examples : 

Input : X = 1, Y = 2, P = 1
Output : 1
Explanation: As turn is odd, X is multiplied by
2 and becomes 2. Now, X is 2 and Y is also 2. 
Therefore, 2 ÷ 2 is 1.

Input : X = 3, Y = 7, p = 2
Output : 2
Explanation: Here we have 2 turns. In the 1st turn which is odd
X is multiplied by 2. And the values are 6 and 7. 
In the next turn which is even Y is multiplied by 2.
Now the final values are 6 and 14. Therefore, 14 ÷ 6 is 2.

 

Recommended Practice

Lets play the above game for 8 turns : 
 

| i    | 0 | 1  | 2  | 3  | 4  | 5  | 6  | 7   | 8   |
|------|---|----|----|----|----|----|----|-----|-----|
| X(i) | X | 2X | 2X | 4X | 4X | 8X | 8X | 16X | 16X |
| Y(i) | Y | Y  | 2Y | 2Y | 4Y | 4Y | 8Y | 8Y  | 16Y |

Here we can easily spot a pattern : 
 

if i is even, then X(i) = z * X and Y(i) = z * Y.
if i is odd, then X(i) = 2*z * X and Y(i) = z * Y.

Here z is actually the power of 2. So, we can simply say – 
 

If P is even output will be max(X, Y) ÷ min(X, Y) 
else output will be max(2*X, Y) ÷ min(2*X, Y).

Below is the implementation : 

C++




// CPP program to find max(X, Y) / min(X, Y)
// after P turns
#include <bits/stdc++.h>
using namespace std;
  
int findValue(int X, int Y, int P)
{
    if (P % 2 == 0)
        return (max(X, Y) / min(X, Y));
  
    else
        return (max(2 * X, Y) / min(2 * X, Y));
}
  
// Driver code
int main()
{
    // 1st test case
    int X = 1, Y = 2, P = 1;
    cout << findValue(X, Y, P) << endl;
  
    // 2nd test case
    X = 3, Y = 7, P = 2;
    cout << findValue(X, Y, P) << endl;
}


C




// C program to find max(X, Y) / min(X, Y)
// after P turns
#include <stdio.h>
  
int findValue(int X, int Y, int P)
{
    int Max = X,Min = X;
    if(Max < Y)
      Max = Y;
    if(Min > Y)
      Min = Y;
    int Max2 = 2*X,Min2 = 2*X;
    if(Max2 < Y)
      Max2 = Y;
    if(Min2 > Y)
      Min2 = Y ; 
    if (P % 2 == 0)
        return (Max / Min);
    else
        return (Max2 / Min2);
}
  
// Driver code
int main()
{
    // 1st test case
    int X = 1, Y = 2, P = 1;
    printf("%d\n",findValue(X, Y, P));
  
    // 2nd test case
    X = 3, Y = 7, P = 2;
    printf("%d\n",findValue(X, Y, P));
}
  
// This code is contributed by kothvvsaakash.


Java




// Java program to find max(X, Y) / min(X, Y)
// after P turns
import java.util.*;
  
class Even_odd{
    public static int findValue(int X, int Y, 
                                        int P)
    {
        if (P % 2 == 0)
            return (Math.max(X, Y) / 
                            Math.min(X, Y));
  
        else
            return (Math.max(2 * X, Y) /
                            Math.min(2 * X, Y));
    }
      
    public static void main(String[] args)
    {
        // 1st test case
        int X = 1, Y = 2, P = 1;
        System.out.println(findValue(X, Y, P));
          
        // 2nd test case
        X = 3;
        Y = 7;
        P = 2;
        System.out.print(findValue(X, Y, P));
    }
}
  
//This code is contributed by rishabh_jain


Python3




# Python3 code to find max(X, Y) / min(X, Y)
# after P turns
  
def findValue( X , Y , P ):
    if P % 2 == 0:
        return int(max(X, Y) / min(X, Y))
  
    else:
        return int(max(2 * X, Y) / min(2 * X, Y))
  
# Driver code
# 1st test case
X = 1
Y = 2
P = 1
print(findValue(X, Y, P))
  
# 2nd test case
X = 3
Y = 7
P = 2
print((findValue(X, Y, P)))
  
# This code is contributed by "Sharad_Bhardwaj".


C#




// C# program to find max(X, Y) / min(X, Y)
// after P turns
using System;
  
class GFG
{
    public static int findValue(int X, int Y, 
                                        int P)
    {
        if (P % 2 == 0)
            return (Math.Max(X, Y) / 
                    Math.Min(X, Y));
  
        else
            return (Math.Max(2 * X, Y) /
                    Math.Min(2 * X, Y));
    }
      
    // Driver code
    public static void Main()
    {
        // 1st test case
        int X = 1, Y = 2, P = 1;
        Console.WriteLine(findValue(X, Y, P));
          
        // 2nd test case
        X = 3;
        Y = 7;
        P = 2;
        Console.WriteLine(findValue(X, Y, P));
    }
}
  
//This code is contributed by vt_m


PHP




<?php
// PHP program to find 
// max(X, Y) / min(X, Y)
// after P turns
  
function findValue($X, $Y, $P)
{
    if ($P % 2 == 0)
        return (int)(max($X, $Y) / 
                     min($X, $Y));
  
    else
        return (int)(max(2 * $X, $Y) / 
                     min(2 * $X, $Y));
}
  
// Driver code
  
// 1st test case
$X = 1;
$Y = 2;
$P = 1;
echo findValue($X, $Y, $P), "\n";
  
// 2nd test case
$X = 3; $Y = 7; $P = 2;
echo findValue($X, $Y, $P), "\n";
  
// This code is contributed by ajit
?>


Javascript




<script>
    // Javascript program to find max(X, Y) / min(X, Y)
    // after P turns
      
    function findValue(X, Y, P)
    {
        if (P % 2 == 0)
            return parseInt((Math.max(X, Y) / Math.min(X, Y)), 10);
  
        else
            return parseInt((Math.max(2 * X, Y) / Math.min(2 * X, Y)), 10);
    }
      
    // 1st test case
    let X = 1, Y = 2, P = 1;
    document.write(findValue(X, Y, P) + "</br>");
    
    // 2nd test case
    X = 3, Y = 7, P = 2;
    document.write(findValue(X, Y, P));
      
    // This code is contributed by divyeshrabadiya07.
</script>


Output

1
2

Time Complexity: O(1)
Auxiliary Space: O(1)



Last Updated : 17 Feb, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads