#### Example 10 maximum common divisor

**Problem description**

There are three positive integers a, B, C (0

**input data**

Enter a n n in the first row to indicate that there are n groups of test data, and enter two positive integers a and B in the next n rows.

**Output format**

Output the corresponding C, each group of test data occupies a row.

**sample input **

2

6 2

12 4

**sample output **

4

8

##### (1) Programming ideas.

The greatest common divisor of two integers is obtained by the division of rolling phase. For example, the method to find the greatest common divisor of the integer m = 48, n = 18 is shown in the left figure.

The specific method is: if M% n = = 0, then n is the maximum common divisor, otherwise, calculate r = M% N, set M = n, n = R, and repeat the process until M% n = = 0.

Defining the greatest common divisor of integers m and N as a function

int gcd(int m,intn)； 。

In this question, because B is the greatest common divisor of a and C, and C! =b. So for C = 2 * B, 3 * B The minimum C that satisfies the condition can be reached by exhaustive judgment.

##### (2) Source program.

#include

int gcd(int m, int n)

{

int r;

while(m%n!=0)

{

r=m%n;

m = n;

n = r;

}

return n;

}

int main()

{

int t,a,b,c;

scanf(“%d”,&t);

while(t–)

{

scanf(“%d%d”,&a,&b);

c=2*b;

while(gcd(a,c)!=b)

c+=b;

printf(“%d\n”,c);

}

return 0;

}

#### Exercise 10

##### 10-1 Uniform Generator

This question is selected from OJ question bank of Hangzhou University of Electronic Science and technology（ http://acm.hdu.edu.cn/showproblem.php?pid=1014 )

**Problem Description**

Computer simulations often require random numbers. One way to generate pseudo-random numbers is via a function of the form

seed(x+1) = [seed(x) + STEP] % MOD

where ‘%’ is the modulus operator.

Such a function will generate pseudo-random numbers (seed) between 0 and MOD-1. One problem with functions of this form is that they will always generate the same pattern over and over. In order to minimize this effect, selecting the STEP and MOD values carefully can result in a uniform distribution of all values between (and including) 0 and MOD-1.

For example, if STEP = 3 and MOD = 5, the function will generate the series of pseudo-random numbers 0, 3, 1, 4, 2 in a repeating cycle. In this example, all of the numbers between and including 0 and MOD-1 will be generated every MOD iterations of the function. Note that by the nature of the function to generate the same seed(x+1) every time seed(x) occurs means that if a function will generate all the numbers between 0 and MOD-1, it will generate pseudo-random numbers uniformly with every MOD iterations.

If STEP = 15 and MOD = 20, the function generates the series 0, 15, 10, 5 (or any other repeating series if the initial seed is other than 0). This is a poor selection of STEP and MOD because no initial seed will generate all of the numbers from 0 and MOD-1.

Your program will determine if choices of STEP and MOD will generate a uniform distribution of pseudo-random numbers.

**Input**

Each line of input will contain a pair of integers for STEP and MOD in that order (1 <= STEP, MOD <= 100000).

**Output**

For each line of input, your program should print the STEP value right- justified in columns 1 through 10, the MOD value right-justified in columns 11 through 20 and either “Good Choice” or “Bad Choice” left-justified starting in column 25. The “Good Choice” message should be printed when the selection of STEP and MOD will generate all the numbers between and including 0 and MOD-1 when MOD numbers are generated. Otherwise, your program should print the message “Bad Choice”. After each output test set, your program should print exactly one blank line.

**Sample Input**

3 5

15 20

63923 99999

**Sample Output**

3 5 Good Choice

15 20 Bad Choice

63923 99999 Good Choice

(1) Programming ideas.

The meaning of the topic is: input two integers x and y, if x and y are mutually prime, then output “good choice”; otherwise, output “bad choice”.

If the greatest common divisor of two integers x and Y is 1, then x and y are coprime.

(2) Source program.

#include

int gcd(int a, int b)

{

int r;

while(a%b!=0)

{

r=a%b;

a = b;

b = r;

}

return b;

}

int main()

{

int x, y;

while(scanf(“%d %d”, &x, &y) != EOF)

{

if(gcd(x, y) == 1)

printf(“%10d%10d Good Choice\n\n”, x, y);

else

printf(“%10d%10d Bad Choice\n\n”,x, y);

}

return 0;

}

##### 10-2 Party

This question is selected from POJ question bank of Peking University（ http://poj.org/problem?id=3970 )

**Description**

The CEO of ACM (Association of Cryptographic Mavericks) organization has invited all of his teams to the annual all-hands meeting, being a very disciplined person, the CEO decided to give a money award to the first team that shows up to the meeting.

The CEO knows the number of employees in each of his teams and wants to determine X the least amount of money he should bring so that he awards the first team to show up such that all team members receive the same amount of money. You must write a program to help the CEO achieve this task.

**Input**

The input consists of multiple test cases, each test case is described on a line by itself, Each line starts with an integer N (1 <= N <= 20) the number of teams in the organization followed by N space separated positive integers representing the number of employees in each of the N teams. You may assume that X will always fit in a 32 bit signed integer. The last line of input starts with 0 and shouldn’t be processed.

**Output**

For each test case in the input print “The CEO must bring X pounds.”, where X is as described above or “Too much money to pay!” if X is 1000000 or more.

**Sample Input**

1 3000000

2 12 4

0

**Sample Output**

Too much money to pay!

The CEO must bring 12 pounds.

(1) Programming ideas.

The meaning of the question is to find the minimum common multiple of n positive integers. If the maximum common divisor of positive integers x and Y is GCD (x, y), then the minimum common multiple of X and Y is x * y / GCD (x, y).

(2) Source program.

#include

int lcm(int x,int y)

{

int r,a,b;

a=x; b=y;

while (a%b!=0)

{

r=a%b;

a=b;

b=r;

}

return x*y/b;

}

int main()

{

int n,i,x0,x1;

while(scanf(“%d”,&n) && n!=0)

{

scanf(“%d”,&x0);

for (i=2;i<=n;i++)

{

scanf(“%d”,&x1);

x0=lcm(x0,x1);

}

if (x0>=1000000)

printf(“Too much money to pay!\n”);

else

printf(“The CEO must bring %d pounds.\n”,x0);

}

return 0;

}

##### 10-3 encounter period

**Title Description**

Given the operation period of two satellites, find their encounter period.

**input**

The first line of input data is a positive integer T, which represents the number of groups of test data, and then a group of t test data. Each group of test data contains two groups of positive integers, separated by spaces. Each group contains two positive integers, representing the number of days needed to turn n-turn (26501 / 6335, representing 6335 days needed to turn 26501), separated by ‘/’.

**output**

For each group of test data, output their encounter period. If the encounter period is an integer, it is expressed as an integer, otherwise it is expressed as the simplest fraction.

**sample input **

2

26501/6335 18468/42

29359/11479 15725/19170

sample output

81570078/7

5431415

(1) Programming ideas.

Each fraction entered is the period of a satellite. Find the meeting period of two satellites, that is, find the minimum common multiple of the two periods. We can first divide the two fractions, find out the minimum common multiple of the two molecules after the common division, and then divide by the denominator after the common division, that is, the meeting period (minimum common multiple).

(2) Source program.

#include

long long gcd(long long m, long long n)

{

long long r;

while(m%n!=0)

{

r=m%n;

m = n;

n = r;

}

return n;

}

int main()

{

int t;

long long a,b,c,d,e,f,n,m,k;

scanf(“%d”,&t);

while(t–)

{

scanf(“%lld/%lld%lld/%lld”,&a,&b,&c,&d);

e=b*c;

f=a*d;

M = b * D; / / General

n=gcd(f,e);

n=f/n*e;

If (n% m = = 0) / / divisible

printf(“%lld\n”,n/m);

Else / / cannot divide. To simplify, output the score

{

K = GCD (m, n); / / find the maximum common divisor of molecular denominator

printf(“%lld/%lld\n”,n/k,m/k);

}

}

return 0;

}