s_id
stringlengths 10
10
| p_id
stringlengths 6
6
| u_id
stringlengths 10
10
| date
stringlengths 10
10
| language
stringclasses 1
value | original_language
stringclasses 11
values | filename_ext
stringclasses 1
value | status
stringclasses 1
value | cpu_time
int64 0
100
| memory
stringlengths 4
6
| code_size
int64 15
14.7k
| code
stringlengths 15
14.7k
| problem_id
stringlengths 6
6
| problem_description
stringlengths 358
9.83k
| input
stringlengths 2
4.87k
| output
stringclasses 807
values | __index_level_0__
int64 1.1k
1.22M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s497593333
|
p00005
|
u009288816
|
1515077848
|
Python
|
Python
|
py
|
Accepted
| 10
|
4684
| 399
|
import sys
def gcd(a,b):
if(b):
return gcd(b,(a%b))
else:
return a
def lcm(a,b):
return a*b/gcd(a,b)
a = ""
for input in sys.stdin:
a += input
l = a.split()
for i in range(0,len(l),2):
if(int(l[i]) > int(l[i+1])):
print gcd(int(l[i]),int(l[i+1])),lcm(int(l[i]),int(l[i+1]))
else:
print gcd(int(l[i+1]),int(l[i])),lcm(int(l[i+1]),int(l[i]))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,802
|
s698044065
|
p00005
|
u706217959
|
1515390750
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5600
| 668
|
class GCD():
def __init__(self,a,b):
self.a = a
self.b = b
def gcd(self):
if self.a < self.b:
self.a, self.b = self.b, self.a
while self.b:
self.a, self.b= self.b, self.a % self.b
return self.a
def print(self):
lcm = self.a * self.b // self.gcd()
print(self.gcd(), lcm)
def main():
data =[]
while 1:
try:
n = input().split()
a = int(n[0])
b = int(n[1])
data.append(GCD(a, b))
except EOFError:
break
for array in data:
array.print()
if __name__ == "__main__":
main()
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,803
|
s321055167
|
p00005
|
u264972437
|
1516013706
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5612
| 696
|
def pd(n):
i = 2
ans = []
while i ** 2 <= n:
while n % i == 0:
n /= i
ans.append(i)
i += 1
if n > 1:
ans.append(n)
return ans
def gcd(a, b):
gcd = 1
pd_a = pd(a)
pd_b = pd(b)
for i in pd_a:
if i in pd_b:
pd_b.remove(i)
gcd *= i
return int(gcd)
def lcm(a, b):
lcm = a
pd_a = pd(a)
pd_b = pd(b)
for i in pd_a:
if i in pd_b:
pd_b.remove(i)
for j in pd_b:
lcm *= j
return int(lcm)
while True:
try:
s = input()
a,b = [int(i) for i in s.split(' ')]
except:
break
print(gcd(a, b), lcm(a, b))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,804
|
s935140766
|
p00005
|
u043254318
|
1516201313
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5596
| 418
|
def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
for l in range(len(N)):
a,b = [int(i) for i in N[l].split()]
A = a
B = b
if(a<b):
c = a
a = b
b = c
while b > 0:
nexta = b
nextb = a % b
a = nexta
b = nextb
g = a
print(g, int(A*B/g))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,805
|
s440391822
|
p00005
|
u150984829
|
1516551595
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5664
| 99
|
import math,sys
for e in sys.stdin:
a,b=list(map(int,e.split()));g=math.gcd(a,b)
print(g,a*b//g)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,806
|
s953612884
|
p00005
|
u150984829
|
1516551970
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5604
| 101
|
import sys
for e in sys.stdin:
g,d=a,b=list(map(int,e.split()))
while d:g,d=d,g%d
print(g,a*b//g)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,807
|
s984955497
|
p00005
|
u150984829
|
1516552103
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5604
| 101
|
import sys
for e in sys.stdin:
a,b=list(map(int,e.split()));p=a*b
while b:a,b=b,a%b
print(a,p//a)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,808
|
s064347431
|
p00005
|
u803045841
|
1516564564
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5600
| 144
|
import sys
for e in sys.stdin:
a, b = map(int, e.split())
p = a * b
while b:
a, b = b, a%b
pass
print (a,p//a)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,809
|
s950785733
|
p00005
|
u536089081
|
1517566531
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5656
| 139
|
from sys import stdin
from math import gcd
for line in stdin:
a, b = map(int, line.split())
g = gcd(a, b)
print(g, a // g * b)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,810
|
s116133607
|
p00005
|
u328199937
|
1519037563
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5596
| 334
|
while True:
try:
a, b = map(int, input().split(" "))
if a < b:
key = a
a = b
b = key
A = a
B = b
while a % b != 0:
key = a % b
a = b
b = key
key = int(A * B / b)
print(b, key)
except:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,811
|
s226175465
|
p00005
|
u780025254
|
1519186759
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5600
| 240
|
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
while True:
try:
x, y = map(int, input().split())
print(gcd(x, y), lcm(x, y))
except:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,812
|
s506786308
|
p00005
|
u553148578
|
1519818346
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5652
| 138
|
import math
while True:
try:
a, b = map(int, input().split())
print(int(math.gcd(a,b)),(a*b) // int(math.gcd(a,b)))
except:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,813
|
s291765113
|
p00005
|
u613534067
|
1520063971
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5600
| 404
|
import sys
# 最大公約数(greatest common divisor)を求める関数
def gcd(a, b):
while b:
a, b = b, a % b
return a
# 最小公倍数(least common multiple)を求める関数
# //は切り捨て除算
def lcm(a, b):
return a * b // gcd(a, b)
lines = sys.stdin.readlines()
for line in lines:
a = list(map(int, line.split(" ")))
print(gcd(a[0], a[1]), lcm(a[0], a[1]))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,814
|
s922617134
|
p00005
|
u352394527
|
1523610933
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5652
| 160
|
import math
while True:
try:
a,b = list(map(int,input().split()))
x = math.gcd(a,b)
y = a * b // x
print(x,y)
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,815
|
s073990614
|
p00005
|
u027874809
|
1523930365
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5596
| 425
|
while True:
try:
r = sorted(list(map(int, input().split())))
def euclidfunc(a, b):
while b != 0:
a, b = b, a % b
return a
def lcmfunc(a, b):
return a * b // euclidfunc(a, b)
print("{a} {b}".format(a=euclidfunc(r[1], r[0]), b=lcmfunc(r[1], r[0])))
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,816
|
s576359097
|
p00005
|
u533681846
|
1525024539
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5600
| 240
|
while 1:
try:
a = list(map(int, input().split()))
b=list(a)
a.sort()
while a[1]%a[0] != 0:
a[1] %= a[0]
a.sort()
print(a[0], int(b[0]*b[1]/a[0]))
except:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,817
|
s423415805
|
p00005
|
u533681846
|
1525024635
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5656
| 149
|
import math
while 1:
try:
a,b = map(int, input().split())
print(math.gcd(a,b), int(a*b/math.gcd(a,b)))
except:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,818
|
s288120917
|
p00005
|
u724548524
|
1525731449
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5600
| 238
|
import sys
for i in sys.stdin:
a, b = map(int, i.split())
p, q = max(a, b), min(a, b)
while True:
if p % q == 0:
break
else:
p, q = q, p % q
print("{} {}".format(q, int(a * b / q)))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,819
|
s435400915
|
p00005
|
u724548524
|
1525731499
|
Python
|
Python3
|
py
|
Accepted
| 30
|
5600
| 185
|
import sys
for i in sys.stdin:
a, b = map(int, i.split())
p, q = max(a, b), min(a, b)
while p % q != 0:
p, q = q, p % q
print("{} {}".format(q, int(a * b / q)))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,820
|
s312003141
|
p00005
|
u945249026
|
1525772564
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5604
| 232
|
def F(x, y):
if x % y == 0:
return y
return F(y, x % y)
while True:
try:
x, y = map(int,input().split())
print('{0} {1}'.format(F(x, y), int(x * y / F(x, y))))
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,821
|
s532265042
|
p00005
|
u223900719
|
1526209290
|
Python
|
Python
|
py
|
Accepted
| 10
|
4640
| 217
|
def gcd(a,b):
if a%b==0:
return b
else:
r=a%b
return gcd(b,r)
def lcm(a,b):
return a*b/gcd(a,b)
while True:
try:
a,b=map( int, raw_input().split() )
print gcd(a,b),lcm(a,b)
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,822
|
s297404622
|
p00005
|
u940977872
|
1526366935
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5656
| 193
|
import math
while True:
try:
a, b = map(int, input().split())
gcd = math.gcd(a, b)
lcm = (a * b) // gcd
print(gcd, lcm)
except Exception:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,823
|
s141649715
|
p00005
|
u802537549
|
1526808065
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5676
| 207
|
import math
while True:
try:
a, b = [int(i) for i in input().split()]
gcd = math.gcd(a, b)
lcm = a * b // gcd
print(f'{gcd} {lcm}')
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,824
|
s426881058
|
p00005
|
u136916346
|
1527349898
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5608
| 206
|
import sys
def gcd(a,b):
if a%b==0:
return b
return gcd(b,a%b)
r=[list(map(int,line.split())) for line in sys.stdin]
for i in r:
o=gcd(i[0],i[1])
p=i[0]*i[1]/o
print(o,int(p))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,825
|
s742326447
|
p00005
|
u986478725
|
1527571169
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5596
| 729
|
# Vol0005.
import sys
def intinput():
a = input().split()
for i in range(len(a)):
a[i] = int(a[i])
return a
def get_gcd(x, y):
if x < y: return get_gcd(y, x)
# x >= yのときはx % yを計算してyとx % yの話にする。
# ここでx % yのところが0ならばyが求める答えとなる。
if y == 0: return x
return get_gcd(y, x % y)
def main():
data = []
lines = sys.stdin.readlines()
for line in lines:
data.append(line.split())
N = len(data)
for i in range(N):
a = int(data[i][0]); b = int(data[i][1])
gcd = get_gcd(a, b)
lcm = (a // gcd) * b
print('%d %d' % (gcd, lcm))
if __name__ == "__main__":
main()
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,826
|
s872021498
|
p00005
|
u002010345
|
1527725732
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5600
| 256
|
def main():
while True:
try:
a,b=(int(x) for x in input().split())
except:
break
a1=a
b1=b
while b!=0:
c=a%b
a=b
b=c
print(a, a1*b1//a)
main()
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,827
|
s301525293
|
p00005
|
u458530128
|
1528364589
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5600
| 267
|
def f(x, y):
if x % y == 0:
return y
return f(y, x % y)
a = []
while True:
try:
a.append(list(map(int, input().split())))
except EOFError:
break
for i in a:
g = f(i[0], i[1])
l = (i[0] * i[1]) / g
print(g, int(l))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,828
|
s469508341
|
p00005
|
u847467233
|
1528506876
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5604
| 309
|
# AOJ 0005 GCD and LCM
# Python3 2018.6.9 bal4u
def lcm(a, b):
return a // gcd(a, b) * b
def gcd(a, b):
while b != 0:
r = a % b
a = b
b = r
return a
while True:
try:
a = list(map(int, input().split()))
print(gcd(a[0], a[1]), lcm(a[0], a[1]))
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,829
|
s364346794
|
p00005
|
u328733599
|
1528535254
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5652
| 340
|
from sys import stdin
import math
def GCD(a,b):
if(a%b==0):
return b
else:
c = a%b
return GCD(b,c)
def LCM(a,b):
gcd = GCD(a,b)
return int(a*b/gcd)
for line in stdin:
a,b = line.split(" ")
a = int(a)
b = int(b)
gcd = GCD(a,b)
lcm = LCM(a,b)
print(str(gcd)+" "+str(lcm))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,830
|
s022552253
|
p00005
|
u563075864
|
1529164245
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5600
| 245
|
import sys
def euc(n,m):
if max(n,m)%min(n,m) == 0:
return min(n,m)
else:
return euc(min(n,m), max(n,m)%min(n,m))
for line in sys.stdin:
a,b = [int(i) for i in line.split()]
print(euc(a,b),int(a*b/euc(a,b)))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,831
|
s915568384
|
p00005
|
u650035614
|
1530634569
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5596
| 382
|
def gcd(x, y):
if x > y:
x, y = y, x
while x > 0:
x, y = y%x, x
return y
def lcm(x, y):
z = gcd(x, y)
return x*y//z
if __name__ == "__main__":
while True:
try:
a, b = map(int, input().split())
g = gcd(a, b)
l = lcm(a, b)
print("{} {}".format(g, l))
except:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,832
|
s289049130
|
p00005
|
u995990363
|
1530677653
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5600
| 424
|
import sys
def gcd(a,b):
while a % b != 0:
a, b = b, a % b
return b
def lcm(a,b,g):
_a = a // g
_b = b // g
return _a * _b * g
def run():
data = []
for n in sys.stdin:
a, b = list(map(int, n.split()))
data.append((a,b))
for _data in data:
a, b = _data
g = gcd(a,b)
l = lcm(a,b,g)
print(g, l)
if __name__ == '__main__':
run()
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,833
|
s277479651
|
p00005
|
u263247628
|
1344422478
|
Python
|
Python
|
py
|
Accepted
| 10
|
4220
| 300
|
def gcd(a, b):
r = a % b
if r == 0: return b
else: return gcd(b, r)
def lcm(a, b):
return a*b/gcd(a,b)
while True:
try:
x = map(int, raw_input().split(" "))
print "%d %d" % (gcd(x[0], x[1]), lcm(x[0], x[1]))
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,834
|
s260313632
|
p00005
|
u517745281
|
1344573558
|
Python
|
Python
|
py
|
Accepted
| 10
|
4236
| 189
|
import sys;print"\n".join("%d %d"%(lambda x:(x[2],x[0]/x[2]*x[1]))((lambda f,x:(x[0],x[1],f(f,x[0],x[1])))(lambda f,a,b:a%b==0 and b or f(f,b,a%b),map(int,s.split(' '))))for s in sys.stdin)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,835
|
s228514011
|
p00005
|
u108432367
|
1344659341
|
Python
|
Python
|
py
|
Accepted
| 10
|
4232
| 226
|
import sys
def gcd(a,b):
if b != 0:
return gcd(b,a%b)
else:
return a
def lcm(a,b,g):
return b / g * a
for s in sys.stdin:
ls = map(int,s.split(' '))
print "%d %d" % (gcd(ls[0],ls[1]),lcm(ls[0],ls[1],gcd(ls[0],ls[1])))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,836
|
s541998475
|
p00005
|
u108432367
|
1344668980
|
Python
|
Python
|
py
|
Accepted
| 10
|
4232
| 191
|
import sys;print"\n".join("%d %d"%(lambda l:(l[0],l[2]/l[0]*l[1]))((lambda f,l:(f(f,l),l[0],l[1]))(lambda f,l:l[1]==0 and l[0] or f(f,[l[1],l[0]%l[1]]),map(int,s.split())))for s in sys.stdin)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,837
|
s674913748
|
p00005
|
u894941280
|
1344734738
|
Python
|
Python
|
py
|
Accepted
| 10
|
4228
| 257
|
def gcd(a,b):
if b == 0:
return a
else:
return gcd(b,a%b)
def lcm(a,b):
d = (a*b) / gcd(a,b)
print d
while True:
try:
x = map(int,raw_input().split(" "))
a,b = x[0],x[1]
print gcd(a,b),(a*b)/gcd(a,b)
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,838
|
s893580909
|
p00005
|
u891318575
|
1346476467
|
Python
|
Python
|
py
|
Accepted
| 10
|
4236
| 459
|
# -*- coding: utf-8 -*-
while True:
try:
list = [int(x) for x in raw_input().split(" ")]
list.sort(lambda x, y: y - x)
gcd = lcm = 0
m = list[0]
n = list[1]
while True:
r = m%n
if r == 0:
gcd = n
break
m = n
n = r
lcm = list[0] * list[1] / gcd
print(str(gcd) + " " + str(lcm))
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,839
|
s849601045
|
p00005
|
u724947062
|
1346482030
|
Python
|
Python
|
py
|
Accepted
| 10
|
4232
| 356
|
import sys
def gcd(a, b):
if b == 0:
return a
else:
r = a % b
return gcd(b, r)
def calc(a, b):
gcd_val = gcd(a, b)
lcm_val = a * b / gcd_val
return (gcd_val, lcm_val)
for line in sys.stdin.readlines():
line = line.strip()
a, b = map(int, line.split())
print "{0[0]:d} {0[1]:d}".format(calc(a, b))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,840
|
s037935006
|
p00005
|
u894941280
|
1347477779
|
Python
|
Python
|
py
|
Accepted
| 10
|
4224
| 209
|
def gcd(a,b):
if b == 0: return a
return gcd(b,a%b)
def lcm(c,d):
return c*d/gcd(a,b)
while True:
try:
a,b = map(int,raw_input().split())
c,d = a,b
print gcd(a,b),lcm(c,d)
except EOFError: break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,841
|
s676917118
|
p00005
|
u126791750
|
1350217868
|
Python
|
Python
|
py
|
Accepted
| 10
|
4224
| 291
|
#coding:UTF-8
def gcd(x,y):
r = x % y
if r==0: return y
else: return gcd(y,r)
def lcm(x,y):
return x * y / gcd(x,y)
while True:
try:
n = map(int, raw_input().split())
print "%d %d"%(gcd(n[0],n[1]),lcm(n[0],n[1]))
except Exception:
break;
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,842
|
s963089962
|
p00005
|
u647766105
|
1350910137
|
Python
|
Python
|
py
|
Accepted
| 20
|
4220
| 208
|
import sys
def gcd(a,b):
if b==0:return a
return gcd(b,a%b)
def lcm(a,b):
return a*b/gcd(a,b)
for i in sys.stdin.readlines():
a,b=map(int,i.split())
print "{} {}".format(gcd(a,b),lcm(a,b))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,843
|
s535208477
|
p00005
|
u719737030
|
1350912906
|
Python
|
Python
|
py
|
Accepted
| 10
|
5948
| 258
|
import sys
def gcd(x,y):
if(y>0):
return gcd(y,x%y)
else:
return x
def lcm(x,y):
return x/gcd(x,y)*y
for x in sys.stdin.readlines():
n = [float(y) for y in x.split()]
print "%d %d" % (gcd(n[0], n[1]),(lcm(n[0], n[1])))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,844
|
s080178744
|
p00005
|
u779627195
|
1352373612
|
Python
|
Python
|
py
|
Accepted
| 10
|
4224
| 283
|
#coding: utf-8
def GCM(m, n):
while 1:
if n == 0: return m
m -= (m/n)*n
m,n = n,m
while 1:
try:
a,b = map(int, raw_input().split())
x = GCM(a,b)
y = a*b / x
print "%d %d" % (x, y)
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,845
|
s442904398
|
p00005
|
u504990413
|
1354020391
|
Python
|
Python
|
py
|
Accepted
| 10
|
5056
| 371
|
while True:
try:
x = map(int, raw_input().split(' '))
if x[0] < x[1]:
m = x[1]
n = x[0]
else:
m = x[0]
n = x[1]
# m is greatrer than n
while n !=0:
m,n = n,m % n
print m,x[0]*x[1]/m
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,846
|
s499951888
|
p00005
|
u419407022
|
1355296643
|
Python
|
Python
|
py
|
Accepted
| 10
|
4996
| 371
|
def swap(a, b):
a = a ^ b
b = a ^ b
a = a ^ b
def gcd(x, y):
if(x < y):
swap(x, y)
mod = x % y
if mod == 0:
return y
else:
return gcd(y, mod)
def lcm(x, y):
return x * y / gcd(x, y)
while True:
try:
(a, b) = map(int ,raw_input().split())
except EOFError:
break
print gcd(a, b), lcm(a, b)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,847
|
s071234065
|
p00005
|
u665962315
|
1357422032
|
Python
|
Python
|
py
|
Accepted
| 10
|
4224
| 254
|
def gcd(a, b):
if b == 0: return a
else: return gcd(b, a % b)
def lcm(a, m):
return a * b / gcd(a, b);
while True:
try:
a, b = map(int, raw_input().split())
print gcd(a, b), lcm(a, b)
except (EOFError):
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,848
|
s097921245
|
p00005
|
u560838141
|
1358755150
|
Python
|
Python
|
py
|
Accepted
| 20
|
4224
| 294
|
def gcd(a, b):
r = a % b
if r == 0: return b
else: return gcd(b, r)
def lcm(a, b):
return a*b/gcd(a,b)
while True:
try:
x = map(int, raw_input().split(" "))
print "%d %d" % (gcd(x[0], x[1]), lcm(x[0], x[1]))
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,849
|
s334021130
|
p00005
|
u378761086
|
1360424919
|
Python
|
Python
|
py
|
Accepted
| 10
|
4232
| 266
|
#!/usr/bin/python
import sys
def gcd(a,b):
if b == 0:
return a
else:
return gcd(b, a%b)
def lcm(a,b):
return a / gcd(a,b) * b
for l in sys.stdin:
a = [int(s) for s in l.split()]
print str(gcd(a[0],a[1]))+" "+str(lcm(a[0],a[1]))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,850
|
s941121630
|
p00005
|
u782850731
|
1361796217
|
Python
|
Python
|
py
|
Accepted
| 30
|
5900
| 386
|
from __future__ import (division, absolute_import, print_function,
unicode_literals)
import sys
from fractions import gcd
from itertools import count
for line in sys.stdin:
small, large = sorted(int(n) for n in line .split())
for i in count(large, large):
if not i % small:
lcm = i
break
print(gcd(large, small), lcm)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,851
|
s070497435
|
p00005
|
u782850731
|
1361802088
|
Python
|
Python
|
py
|
Accepted
| 20
|
5896
| 285
|
from __future__ import (division, absolute_import, print_function,
unicode_literals)
import sys
from fractions import gcd
for line in sys.stdin:
small, large = sorted(int(n) for n in line .split())
G = gcd(large, small)
print(G, large // G * small)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,852
|
s520107838
|
p00005
|
u743065194
|
1363003769
|
Python
|
Python
|
py
|
Accepted
| 10
|
4220
| 150
|
import sys
def gcd(m,n):
if n==0: return m
return gcd(n,m%n)
for l in sys.stdin:
a,b=map(int,l.split())
d=gcd(a,b)
print d,a/d*b
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,853
|
s622759677
|
p00005
|
u282635979
|
1363863189
|
Python
|
Python
|
py
|
Accepted
| 10
|
4228
| 323
|
while True:
try:
while True:
ints = raw_input()
if ints != '':
x = map(int,ints.split(' '))
x.sort()
a = x[1]
b = x[0]
while True:
m=a%b
if m!=0:
a=b
b=m
continue
else:
break
n = x[1]*x[0]/b
print b,n
continue
else:
break
except: break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,854
|
s949520130
|
p00005
|
u585414111
|
1365344779
|
Python
|
Python
|
py
|
Accepted
| 20
|
4220
| 179
|
import sys
def gcd(a,b):
if (b == 0):
return a
return gcd(b,a%b)
for line in sys.stdin:
a,b = [int(x) for x in line.split()]
d = gcd(a,b)
print d,a*b/d
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,855
|
s641745360
|
p00005
|
u455516672
|
1365669846
|
Python
|
Python
|
py
|
Accepted
| 10
|
4220
| 142
|
import sys
def g(a,b):
if b==0: return a
return g(b,a%b)
for l in sys.stdin:
a,b=map(int,l.split())
c=g(a,b)
print c,a/c*b
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,856
|
s411039679
|
p00005
|
u350508326
|
1367943890
|
Python
|
Python
|
py
|
Accepted
| 10
|
4236
| 332
|
while True:
try:
a = map(int,raw_input().split())
n = [a[0],a[1]]
while True:
if a[0] < a[1]:
tmp = a[0]
a[0] = a[1]
a[1] = tmp
a[0] = a[0] - a[1]
if a[0] == 0:
break
b = n[0]*n[1]/a[1]
print "%d %d" % (a[1],b)
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,857
|
s065388113
|
p00005
|
u542421762
|
1368111306
|
Python
|
Python
|
py
|
Accepted
| 20
|
5892
| 324
|
import sys
import fractions
import re
def lcm(a, b):
return a / fractions.gcd(a, b) * b
#input_file = open(sys.argv[1], "r")
#for line in input_file:
for line in sys.stdin:
ab = map(int, re.split(" +", line))
a, b = tuple(ab)
gcd_ab = fractions.gcd(a, b)
lcm_ab = lcm(a, b)
print gcd_ab, lcm_ab
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,858
|
s811894434
|
p00005
|
u093607836
|
1369118432
|
Python
|
Python
|
py
|
Accepted
| 10
|
4224
| 202
|
while True:
try:
n = map(int, raw_input().split())
a = max(n)
b = min(n)
ab = a * b
while b != 0 :
c = a % b
a = b
b = c
print str(a) + " " + str(ab / a)
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,859
|
s374964337
|
p00005
|
u843960735
|
1374702283
|
Python
|
Python
|
py
|
Accepted
| 10
|
4220
| 228
|
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
def lcm(a, b):
return a*b/gcd(a, b)
try :
while True :
(a,b) = map(int, raw_input().split())
print gcd(a,b), lcm(a,b)
except EOFError :
pass
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,860
|
s951266104
|
p00005
|
u536245846
|
1374762535
|
Python
|
Python
|
py
|
Accepted
| 10
|
4220
| 221
|
def gcd(a, b):
while b > 0:
a, b = b, a%b
return a
while True:
try:
a,b = map(int, raw_input().split())
c = gcd(a, b)
print "{0} {1}".format(c, a*b/c)
except:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,861
|
s250663836
|
p00005
|
u912573907
|
1375168696
|
Python
|
Python
|
py
|
Accepted
| 10
|
4228
| 229
|
import sys
def gcd(a, b):
return gcd(b, a % b) if a % b else b
def lcm(a, b):
return a * b / gcd(a, b)
for line in sys.stdin:
data = map(int, line.split())
a, b = data
print "%d %d" % (gcd(a, b), lcm(a, b))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,862
|
s069524509
|
p00005
|
u912237403
|
1376732643
|
Python
|
Python
|
py
|
Accepted
| 10
|
4220
| 282
|
def gcm(a, b):
if a<b: a,b = b,a
if (a%b ==0):
return b
else:
return gcm(b, a%b)
def lcm(a, b):
return a/gcm(a,b)*b
while True:
try:
a, b = map(int, raw_input().split())
except:
break
print "%d %d" %(gcm(a,b), lcm(a,b))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,863
|
s378543817
|
p00005
|
u813384600
|
1379307874
|
Python
|
Python
|
py
|
Accepted
| 20
|
5888
| 179
|
import fractions
while True:
try:
(a, b) = map(int, raw_input().split())
c = fractions.gcd(a, b)
print c, ((a*b)/c)
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,864
|
s531062257
|
p00005
|
u492005863
|
1381235265
|
Python
|
Python
|
py
|
Accepted
| 10
|
4220
| 278
|
# GCD and LCM
import sys
def gcd(x, y):
while x != y:
if x > y:
x -= y
else:
y -= x
return x
datas = []
for line in sys.stdin:
datas.append(map(int, line.split()))
for data in datas:
g = gcd(data[0], data[1])
print "{0} {1}".format(g, data[0] * data[1] / g)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,865
|
s477673521
|
p00005
|
u511257811
|
1381941955
|
Python
|
Python
|
py
|
Accepted
| 20
|
4208
| 351
|
import sys
for line in sys.stdin:
a, b = sorted(map(int, line.split(' ')))
gcd = 1
d = 2
while a >= d:
amod, bmod = a % d, b % d
if amod == 0 and bmod == 0:
gcd *= d
a, b = a/d, b/d
d = 2
continue
else:
d += 1
lcm = gcd * a * b
print gcd, lcm
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,866
|
s178290764
|
p00005
|
u351182591
|
1382020654
|
Python
|
Python
|
py
|
Accepted
| 10
|
4220
| 439
|
while 1:
try:
a, b = map(int,raw_input().split())
except EOFError:
break
ac, bc = a, b
while 1:
if a < b:
b = b - a
elif b < a:
a = a - b
elif a == b:
x = [a,ac*bc/a]
print "{:.10g} {:.10g}".format(*x)
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,867
|
s664246336
|
p00005
|
u093607836
|
1384846829
|
Python
|
Python
|
py
|
Accepted
| 10
|
4204
| 180
|
import sys
def gcd(a,b):
if b == 0:
return a
else:
return gcd(b,a%b)
def lcm(a,b):
return a*b/gcd(a,b)
for s in sys.stdin:
i = map(int,s.split())
print gcd(*i), lcm(*i)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,868
|
s466731566
|
p00005
|
u912237403
|
1388821738
|
Python
|
Python
|
py
|
Accepted
| 10
|
4204
| 207
|
import sys
def gcm(a, b):
if a<b: a,b=b,a
if (a%b==0):
return b
else:
return gcm(b,a%b)
for s in sys.stdin:
a,b=map(int,s.split())
c=gcm(a,b)
print "%d %d" %(c,a/c*b)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,869
|
s701205504
|
p00005
|
u912237403
|
1388822348
|
Python
|
Python
|
py
|
Accepted
| 10
|
4208
| 184
|
import sys
def gcm(a,b):
if a<b: a,b=b,a
if (a%b==0): return b
return gcm(b,a%b)
for s in sys.stdin:
a,b=map(int,s.split())
c=gcm(a,b)
print "%d %d" %(c,a/c*b)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,870
|
s709229275
|
p00005
|
u912237403
|
1388822727
|
Python
|
Python
|
py
|
Accepted
| 20
|
4204
| 151
|
import sys
def gcm(a,b):
if a%b==0: return b
return gcm(b,a%b)
for s in sys.stdin:
a,b=map(int,s.split())
c=gcm(a,b)
print c,a/c*b
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,871
|
s873998857
|
p00005
|
u912237403
|
1388823167
|
Python
|
Python
|
py
|
Accepted
| 10
|
4208
| 170
|
import sys
def gcm(a,b):
if a%b==0: return b
return gcm(b,a%b)
for s in sys.stdin:
a,b=map(int,s.split())
if a<b:a,b=b,a
c=gcm(a,b)
print c,a/c*b
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,872
|
s708123270
|
p00005
|
u912237403
|
1388823328
|
Python
|
Python
|
py
|
Accepted
| 10
|
4204
| 168
|
import sys
def gcm(a,b):
if b==0: return a
return gcm(b,a%b)
for s in sys.stdin:
a,b=map(int,s.split())
if a<b:a,b=b,a
c=gcm(a,b)
print c,a/c*b
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,873
|
s044277436
|
p00005
|
u912237403
|
1388823388
|
Python
|
Python
|
py
|
Accepted
| 10
|
4204
| 149
|
import sys
def gcm(a,b):
if b==0: return a
return gcm(b,a%b)
for s in sys.stdin:
a,b=map(int,s.split())
c=gcm(a,b)
print c,a/c*b
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,874
|
s642627968
|
p00005
|
u786185717
|
1389536205
|
Python
|
Python
|
py
|
Accepted
| 10
|
4204
| 184
|
import sys
for i in sys.stdin:
m, n = map(int, i.split())
t1, t2 = m, n
while True:
if m % n == 0:
break
m, n = n, m % n
a = n
b = (t1/ a) * t2
print("{} {}".format(a, b))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,875
|
s024415072
|
p00005
|
u912237403
|
1390119479
|
Python
|
Python
|
py
|
Accepted
| 20
|
4192
| 138
|
import sys
def gcm(a,b):
return gcm(b,a%b) if b else a
for s in sys.stdin:
a,b=map(int,s.split())
c=gcm(a,b)
print c,a/c*b
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,876
|
s850008764
|
p00005
|
u912237403
|
1390119602
|
Python
|
Python
|
py
|
Accepted
| 10
|
4200
| 146
|
import sys
def gcm(a,b):
x=gcm(b,a%b) if b else a
return x
for s in sys.stdin:
a,b=map(int,s.split())
c=gcm(a,b)
print c,a/c*b
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,877
|
s534659452
|
p00005
|
u912237403
|
1390119685
|
Python
|
Python
|
py
|
Accepted
| 10
|
4200
| 130
|
import sys
def g(a,b):
x=g(b,a%b) if b else a
return x
for s in sys.stdin:
a,b=map(int,s.split())
c=g(a,b)
print c,a/c*b
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,878
|
s557666100
|
p00005
|
u230836528
|
1392096723
|
Python
|
Python
|
py
|
Accepted
| 30
|
4312
| 524
|
# -*- coding: utf-8 -*-
import sys
def isprime(n):
for i in xrange(2, int(n ** 0.5)+1 ):
if n % i == 0: return False
return True
outList = []
for line in sys.stdin.readlines():
List = map(int, line.strip().split())
[a, b] = List
# LCM
LCM = 1
i = 1
while( i <= min(a, b) ):
i += 1
if not isprime(i): continue
while(a % i == 0 and b % i == 0):
LCM *= i
a /= i
b /= i
# GCD
GCD = List[0] * b
print LCM, GCD
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,879
|
s726211273
|
p00005
|
u124909914
|
1392269330
|
Python
|
Python
|
py
|
Accepted
| 10
|
4220
| 289
|
gcd, lcm = [], []
while True:
try:
a, b = map(int, raw_input().split())
if a > b:
m, n = a, b
else:
m, n = b, a
while n != 0:
m, n = n, m % n
gcd.append(m)
lcm.append(a * b / m)
except EOFError:
break
for gcd, lcm in zip(gcd, lcm):
print '%d %d' % (gcd, lcm)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,880
|
s003137888
|
p00005
|
u633068244
|
1393351051
|
Python
|
Python
|
py
|
Accepted
| 10
|
4208
| 273
|
while True:
try:
a, b = map(int, raw_input().split())
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
g = gcd(a,b)
l = a*b/g
print g, l
except:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,881
|
s675319984
|
p00005
|
u855866586
|
1394194830
|
Python
|
Python
|
py
|
Accepted
| 20
|
4224
| 215
|
import sys
def gcd(a,b):
if b==0:
return a
else:
return gcd(b,a%b)
for line in sys.stdin:
(a,b)=line.split(" ")
a=eval(a)
b=eval(b)
g=gcd(a,b)
print("%d %d" % (g,a*b/g))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,882
|
s683831321
|
p00005
|
u097334177
|
1394782148
|
Python
|
Python
|
py
|
Accepted
| 10
|
4212
| 338
|
def gcd(a, b):
if a < b:
a, b = b, a
r = a % b
if r == 0:
return b
else:
return gcd(b, r)
def lcm(a, b, g):
return a * b / g
while True:
try:
a, b = map(int, raw_input().split())
except EOFError:
break
g = gcd(a, b)
print "{} {}".format(g, lcm(a,b,g))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,883
|
s664410163
|
p00005
|
u193025715
|
1395394184
|
Python
|
Python
|
py
|
Accepted
| 20
|
4220
| 310
|
def get_gcd(a,b):
if a > b: a, b = b, a
if b % a == 0:
return a
else:
return get_gcd(a, b % a)
def get_lcm(a,b,g):
return a * b / g
while True:
try:
a,b = map(int, sorted(raw_input().split()))
GCD = get_gcd(a,b)
LCM = get_lcm(a,b,GCD)
print "{} {}".format(GCD, LCM)
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,884
|
s158589610
|
p00005
|
u140201022
|
1395852292
|
Python
|
Python
|
py
|
Accepted
| 10
|
4204
| 215
|
import sys
def gcd(a,b):
while a%b:
a,b=b,a%b
return b
def lcm(a,b):
return a*b/gcd(a,b)
for ab in sys.stdin:
a,b=map(int, ab.split())
a,b=max(a,b),min(a,b)
print gcd(a,b),lcm(a,b)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,885
|
s632011165
|
p00005
|
u491763171
|
1396339138
|
Python
|
Python
|
py
|
Accepted
| 20
|
5868
| 157
|
from fractions import gcd
while 1:
try:
a, b = map(int, raw_input().split())
print gcd(a, b), a * b / gcd(a, b)
except:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,886
|
s771760807
|
p00005
|
u246033265
|
1396604965
|
Python
|
Python
|
py
|
Accepted
| 20
|
4204
| 221
|
def gcd(a, b):
return a if b == 0 else gcd(b, a % b)
def lcm(a, b):
return a / gcd(a, b) * b
try:
while True:
a, b = map(int, raw_input().split())
print gcd(a, b), lcm(a, b)
except:
pass
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,887
|
s408064576
|
p00005
|
u708217907
|
1397881287
|
Python
|
Python
|
py
|
Accepted
| 10
|
4204
| 288
|
# coding:utf-8
import sys
# 最大公約数
def gcd(a, b):
while b > 0:
a, b = b, a%b
return a
# 最小公倍数
def lcm(a, b):
return a*b/gcd(a, b)
for s in sys.stdin:
a, b = map(int,s.split())
gcd_num = gcd(a, b)
lcm_num = lcm(a, b)
print "%d %d"%(gcd_num, lcm_num)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,888
|
s153581221
|
p00005
|
u146816547
|
1398860151
|
Python
|
Python
|
py
|
Accepted
| 30
|
5872
| 159
|
import fractions
while True:
try:
x,y = map(int,raw_input().split())
print '%d %d' % (fractions.gcd(x,y),x/fractions.gcd(x,y)*y)
except EOFError:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,889
|
s691868243
|
p00005
|
u436634575
|
1401128366
|
Python
|
Python3
|
py
|
Accepted
| 30
|
6720
| 212
|
def gcd(a, b):
while b: a, b = b, a % b
return a
while True:
try:
line = input()
except:
break
a, b = map(int, line.strip().split())
g = gcd(a, b)
print(g, a * b // g)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,890
|
s036439277
|
p00005
|
u557208833
|
1402200256
|
Python
|
Python
|
py
|
Accepted
| 10
|
4216
| 317
|
import sys
def readint():
for line in sys.stdin:
yield map(int,line.split())
def gcd(x,y):
[x,y] = [max(x,y),min(x,y)]
while 1:
z = x % y
if z == 0:
break
[x,y] = [y,z]
return y
for [x,y] in readint():
GCD = gcd(x,y)
mx = x/GCD
print GCD,mx*y
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,891
|
s478676308
|
p00005
|
u618672141
|
1403738679
|
Python
|
Python3
|
py
|
Accepted
| 30
|
6720
| 303
|
def gcd(u, v):
if (v == 0): return u
return gcd(v, u % v)
def lcm(u, v):
return (u * v) // gcd(u, v)
while 1:
try:
inp = input()
except EOFError:
break
else:
u, v = inp.split(' ')
u = int(u)
v = int(v)
print(gcd(u, v), lcm(u, v))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,892
|
s956329641
|
p00005
|
u747915832
|
1597074554
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5656
| 166
|
import math
while True:
try:
a, b = map(int, input().split())
except:
break
GCD = math.gcd(a, b)
LCM = (a*b)//GCD
print(GCD, LCM)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,893
|
s867453250
|
p00005
|
u525366883
|
1596069166
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5596
| 210
|
def gcd(y, x):
if x == 0:
return y
return gcd(x, y%x)
try:
while True:
a, b = sorted(map(int, input().split()), reverse=True)
print(gcd(a,b), a*b//gcd(a,b))
except:
pass
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,894
|
s132189694
|
p00005
|
u986283797
|
1595818051
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5664
| 215
|
# -*- coding: utf-8 -*-
import math
errerN=1
while errerN:
try:
a=list(map(int, input().split()))
gcdN=math.gcd(a[0],a[1])
print(gcdN, int(a[0]*a[1]/gcdN))
except :
errerN=0
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,895
|
s498899286
|
p00005
|
u599584311
|
1594992275
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5600
| 274
|
def gcd(a, b) :
if a % b == 0 :
return b
else :
return gcd(b, a % b)
while True :
try :
a, b = map(int, input().split())
except EOFError :
break
a, b = max(a, b), min(a, b)
x = gcd(a, b)
print(x, a * b // x)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,896
|
s027786427
|
p00005
|
u819143290
|
1594812789
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5596
| 347
|
#2-8
while True:
try:
def gcd(a,b):
if b == 0:
return a
else:
return gcd(b,a%b)
a = list(map(int,input().split()))
a.sort()
a.reverse()
ans1 = gcd(a[0],a[1])
ans2 = int(a[0]*a[1]/ans1)
print(ans1,ans2)
except:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,897
|
s674732233
|
p00005
|
u240091169
|
1594781529
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5592
| 274
|
def gcd(a, b) :
if a % b == 0 :
return b
else :
return gcd(b, a % b)
while True :
try :
a, b = map(int, input().split())
except EOFError :
break
a, b = max(a, b), min(a, b)
x = gcd(a, b)
print(x, a * b // x)
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,898
|
s897720467
|
p00005
|
u537939262
|
1594099726
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5596
| 238
|
def gcd(a,b):
if b==0:
return a
else:
return gcd(b,a%b)
def lcm(a,b):
return a*b//gcd(a,b)
while True:
try:
a,b=map(int,input().split())
print(gcd(a,b),lcm(a,b))
except:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,899
|
s708959658
|
p00005
|
u199192481
|
1594089785
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5596
| 306
|
while True:
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
def lcm(a, b):
return a*b/gcd(a, b)
try:
a, b = map(int, input().split())
except EOFError:
break
print(str(gcd(b, a%b)) + " " + str(int(lcm(a, b))))
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,900
|
s906553828
|
p00005
|
u187074069
|
1592189147
|
Python
|
Python3
|
py
|
Accepted
| 20
|
5616
| 296
|
while True:
try:
lst = list(map(int, input().split()))
a, b = lst[0], lst[1]
while b != 0:
a, b = b, a % b
c = lst[0]* lst[1]/ a
print('{:.0f}'.format(a), end = " ")
print('{:.0f}'.format(c))
except:
break
|
p00005
|
<H1>GCD and LCM</H1>
<p>
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given <var>a</var> and <var>b</var>.
</p>
<H2>Input</H2>
<p>
Input consists of several data sets. Each data set contains <var>a</var> and <var>b</var> separated by a single space in a line. The input terminates with EOF.
</p>
<h2>Constraints</h2>
<ul>
<li> 0 < <var>a, b</var> ≤ 2,000,000,000</li>
<li> LCM(<var>a, b</var>) ≤ 2,000,000,000</li>
<li> The number of data sets ≤ 50</li>
</ul>
<H2>Output</H2>
<p>
For each data set, print GCD and LCM separated by a single space in a line.
</p>
<H2>Sample Input</H2>
<pre>
8 6
50000000 30000000
</pre>
<H2>Output for the Sample Input</H2>
<pre>
2 24
10000000 150000000
</pre>
|
8 6
50000000 30000000
|
2 24
10000000 150000000
| 3,901
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.