# Maximize count of distinct profits possible by N transactions

Given three integers **N, X, **and **Y**, representing the total number of transactions, minimum and maximum profit respectively, the task is to find the count of distinct total profits that can be earned in **N** ( *N > 1*) transactions using** X** and **Y** at least once.

**Examples:**

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

Input:N = 3, X = 13, Y = 15Output:3Explanation:

The different possible transactions satisfying the conditions are as follows:

- In first two transactions, the profit earned is 13. In the last transaction, the profit earned is 15. Therefore, the total profit earned = 13 + 13 + 15 = 41.
- In first two transactions, the profit earned is 13 and 14 respectively. In the last transaction, the profit earned is 15. Therefore, the total profit earned = 13 + 14 + 15 = 42.
- In first transaction, profit earned is 13. In the last two transactions, profit earned is 15. Therefore, the total profit = 13 + 15 + 15 = 43.
Therefore, the total distinct profits earned is 3.

Input:N = 2, X = 10, Y = 17Output:1

**Approach: **The given problem can be solved based on the following observations:

- The minimum total profit that can be earned is:

S1 = (N-1)*X +Y.- The maximum total profit that can be earned is:

S2 = (N-1)*Y + X.- Now it can be observed that all the total profit will lie within the range
[S1, S2].

Follow the steps below to solve the problem:

- Print the value
**(S2-S1+1).**

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to count distinct` `// profits possible` `int` `numberOfWays(` `int` `N, ` `int` `X, ` `int` `Y)` `{` ` ` `// Stores the minimum total profit` ` ` `int` `S1 = (N - 1) * X + Y;` ` ` `// Stores the maximum total profit` ` ` `int` `S2 = (N - 1) * Y + X;` ` ` `// Return count of distinct profits` ` ` `return` `(S2 - S1 + 1);` `}` `// Driver code` `int` `main()` `{` ` ` `// Input` ` ` `int` `N = 3;` ` ` `int` `X = 13;` ` ` `int` `Y = 15;` ` ` `// Function call` ` ` `cout << numberOfWays(N, X, Y);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.util.Arrays;` `class` `GFG` `{` `// Function to count distinct` `// profits possible` `static` `int` `numberOfWays(` `int` `N, ` `int` `X, ` `int` `Y)` `{` ` ` `// Stores the minimum total profit` ` ` `int` `S1 = (N - ` `1` `) * X + Y;` ` ` `// Stores the maximum total profit` ` ` `int` `S2 = (N - ` `1` `) * Y + X;` ` ` `// Return count of distinct profits` ` ` `return` `(S2 - S1 + ` `1` `);` `}` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `// Input` ` ` `int` `N = ` `3` `;` ` ` `int` `X = ` `13` `;` ` ` `int` `Y = ` `15` `;` ` ` `// Function call` ` ` `System.out.println(numberOfWays(N, X, Y));` ` ` `}` `}` `// This code is contributed by jana_sayantan.` |

## Python3

`# Python3 program for the above approach` `# Function to count distinct` `# profits possible` `def` `numberOfWays(N, X, Y):` ` ` ` ` `# Stores the minimum total profit` ` ` `S1 ` `=` `(N ` `-` `1` `) ` `*` `X ` `+` `Y` ` ` `# Stores the maximum total profit` ` ` `S2 ` `=` `(N ` `-` `1` `) ` `*` `Y ` `+` `X` ` ` `# Return count of distinct profits` ` ` `return` `(S2 ` `-` `S1 ` `+` `1` `)` `# Driver code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `# Input` ` ` `N ` `=` `3` ` ` `X ` `=` `13` ` ` `Y ` `=` `15` ` ` `# Function call` ` ` `print` `(numberOfWays(N, X, Y))` ` ` `# This code is contributed by SURENDRA_GANGWAR` |

## C#

`// C# program for the above approach` `using` `System;` ` ` `class` `GFG` `{` `// Function to count distinct` `// profits possible` `static` `int` `numberOfWays(` `int` `N, ` `int` `X, ` `int` `Y)` `{` ` ` `// Stores the minimum total profit` ` ` `int` `S1 = (N - 1) * X + Y;` ` ` `// Stores the maximum total profit` ` ` `int` `S2 = (N - 1) * Y + X;` ` ` `// Return count of distinct profits` ` ` `return` `(S2 - S1 + 1);` `}` ` ` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` `// Input` ` ` `int` `N = 3;` ` ` `int` `X = 13;` ` ` `int` `Y = 15;` ` ` `// Function call` ` ` `Console.WriteLine(numberOfWays(N, X, Y));` ` ` `}` `}` `// This code is contributed by code_hunt.` |

## Javascript

`<script>` `// JavaScript program for the above approach` `// Function to count distinct` `// profits possible` `function` `numberOfWays( N, X, Y)` `{` ` ` `// Stores the minimum total profit` ` ` `let S1 = (N - 1) * X + Y;` ` ` `// Stores the maximum total profit` ` ` `let S2 = (N - 1) * Y + X;` ` ` `// Return count of distinct profits` ` ` `return` `(S2 - S1 + 1);` `}` `// Driver code` ` ` `// Input` ` ` `let N = 3;` ` ` `let X = 13;` ` ` `let Y = 15;` ` ` `// Function call` ` ` `document.write(numberOfWays(N, X, Y));` ` ` `// This code is contributed by shivanisinghss2110` `</script>` |

**Output:**

3

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