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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s039628413 | p00005 | u779577827 | 1479474785 | Python | Python3 | py | Accepted | 50 | 10012 | 183 | import sys, fractions
[[print("{} {}".format(int(fractions.gcd(t[0], t[1])), int(t[0] * t[1] / fractions.gcd(t[0], t[1])))) for t in [[int(y) for y in x.split()]]] for x 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,702 |
s381983597 | p00005 | u542645301 | 1479479613 | Python | Python3 | py | Accepted | 60 | 10100 | 170 |
import sys
from fractions import gcd
[print("{} {}".format(gcd(k[0], k[1]), (k[0] * k[1]) // gcd(k[0], k[1]))) for i in sys.stdin for k in [[int(j) for j in i.split()]]] | 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,703 |
s350387228 | p00005 | u542645301 | 1479479696 | Python | Python3 | py | Accepted | 50 | 10112 | 170 |
import sys
from fractions import gcd
[print("{} {}".format(gcd(k[0], k[1]), (k[0] * k[1]) // gcd(k[0], k[1]))) for i in sys.stdin for k in [[int(j) for j in i.split()]]] | 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,704 |
s077070089 | p00005 | u546285759 | 1480413740 | Python | Python3 | py | Accepted | 20 | 7568 | 245 | while True:
try:
a, b = map(int, input().split())
if a < b:
b, a = a, b
x, y = a, b
while b: a, b = b, a%b
gcd = a
lcm = (x*y)//gcd
print(gcd, lcm)
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,705 |
s473656306 | p00005 | u123687446 | 1480656146 | Python | Python3 | py | Accepted | 30 | 7468 | 306 | def GCD(a, b):
b %= a
return b if a%b == 0 else GCD(b, a)
while True:
try:
a, b = list(map(float, input().split()))
except EOFError:
break
if a >= b:
a, b = b, a
gcd = GCD(a, b) if b%a != 0 else a
print("{0} {1}".format(int(gcd), int(a*b/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,706 |
s231919869 | p00005 | u166860661 | 1480774106 | Python | Python | py | Accepted | 10 | 6328 | 245 | #coding: utf-8
import sys
def gojo(a,b):
if b % a == 0:
return a
else:
return gojo(b % a, a)
for line in sys.stdin:
l = map(int,line.split())
l.sort()
a = l[0]
b = l[1]
print gojo(a,b),a*b/gojo(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,707 |
s340687312 | p00005 | u301729341 | 1481121906 | Python | Python3 | py | Accepted | 30 | 7484 | 275 | while True:
try:
As,Bs = map(int,input().split())
a,b = As, Bs
while True:
if a % b == 0:
gcd = b
break
a,b = b, a % b
print(gcd,int(As * Bs / gcd))
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,708 |
s540561906 | p00005 | u811733736 | 1481151140 | Python | Python3 | py | Accepted | 30 | 7552 | 476 | import sys
def calc_gcd(x, y):
""" ?????§??¬?´???°????¨?????????? """
if y == 0:
return x
else:
return int(calc_gcd(y, x % y))
def calc_lcm(x, y):
""" ????°???¬?????°????¨?????????? """
return int((x * y) / calc_gcd(x, y))
if __name__ == '__main__':
# ??????????????\?????¨???????????????
for line in sys.stdin:
x, y = map(int, line.split(' '))
print('{0} {1}'.format(calc_gcd(x, y), calc_lcm(x, 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,709 |
s881464284 | p00005 | u811773570 | 1481257008 | Python | Python3 | py | Accepted | 20 | 7524 | 340 | def main():
while True:
try:
a, b = map(int, input().split())
gcd = rec(a, b)
lcm = a * b / gcd
print(gcd, int(lcm))
except:
break
def rec(i, j):
if i % j == 0:
return j
return rec(j, i % j)
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,710 |
s272165987 | p00005 | u661290476 | 1482232975 | Python | Python3 | py | Accepted | 30 | 7568 | 194 | def gcd(a,b):
if a%b==0:
return b
return gcd(b,a%b)
while True:
try:
a,b=sorted(map(int,input().split()))
except:
break
print(gcd(a,b),a//gcd(a,b)*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,711 |
s930538282 | p00005 | u661290476 | 1483002413 | Python | Python3 | py | Accepted | 30 | 7724 | 184 | def gcd(x,y):
if y==0:
return x
return gcd(y,x%y)
while True:
try:
x,y=map(int,input().split())
except:
break
print(gcd(x,y),x*y//gcd(x,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,712 |
s429034253 | p00005 | u078042885 | 1483857453 | Python | Python3 | py | Accepted | 60 | 10104 | 143 | import fractions
while 1:
try:
a,b=map(int,input().split())
c=fractions.gcd(a,b)
print(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,713 |
s340495810 | p00005 | u711765449 | 1483966700 | Python | Python3 | py | Accepted | 20 | 7652 | 320 | # -*- coding:utf-8 -*-
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)
array = []
for i in sys.stdin:
array.append(i)
for i in range(len(array)):
n, m = array[i].split()
n, m = int(n), int(m)
print(int(gcd(n, m)),int(lcm(n, m))) | 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,714 |
s061438724 | p00005 | u923668099 | 1483978739 | Python | Python3 | py | Accepted | 60 | 10176 | 143 | import fractions
while 1:
try:
a,b=map(int,input().split())
c=fractions.gcd(a,b)
print(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,715 |
s065541491 | p00005 | u923668099 | 1483978989 | Python | Python3 | py | Accepted | 60 | 10252 | 165 |
import fractions
while 1:
try:
a, b = map(int, input().split())
c = fractions.gcd(a, b)
print(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,716 |
s584742810 | p00005 | u811773570 | 1484037553 | Python | Python3 | py | Accepted | 30 | 7724 | 320 | def rec(a, b):
if b == 0:
return a
return rec(b, a % b)
def main():
while True:
try:
i, j = map(int, input().split())
gcd = rec(i, j)
lcm = i * j // gcd
print(gcd, lcm)
except:
break
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,717 |
s812636317 | p00005 | u811773570 | 1484054915 | Python | Python3 | py | Accepted | 30 | 7656 | 292 | def main():
gcd = lambda n, m : gcd(m, n % m) if m != 0 else n
while True:
try:
n, m = map(int, input().split())
g = gcd(n, m)
l = n * m // g
print(g, l)
except:
break
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,718 |
s990875030 | p00005 | u376883550 | 1484093964 | Python | Python | py | Accepted | 20 | 7808 | 121 | import sys
import fractions as f
for l in sys.stdin.readlines():
a,b=map(int,l.split())
print f.gcd(a,b),a*b/f.gcd(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,719 |
s775519131 | p00005 | u376883550 | 1484097985 | Python | Python3 | py | Accepted | 20 | 7640 | 194 | import sys
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
for line in sys.stdin.readlines():
a, b = map(int, line.split())
print(gcd(a, b), a * b // gcd(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,720 |
s665141564 | p00005 | u376883550 | 1484098113 | Python | Python3 | py | Accepted | 60 | 10176 | 156 | import sys
import fractions
for line in sys.stdin.readlines():
a, b = map(int, line.split())
gcd = fractions.gcd(a, b)
print(gcd, a * b // 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,721 |
s322314093 | p00005 | u745277023 | 1484375489 | Python | Python3 | py | Accepted | 30 | 7624 | 389 | import sys
def gcd(inta, intb):
large = max(inta, intb)
small = min(inta,intb)
mod = large % small
if mod ==0:
return small
else:
return gcd(small, mod)
def lcm(inta, intb, intgcd):
return (inta * intb // intgcd)
sets = sys.stdin.readlines()
for line in sets:
a, b = map(int, line.split())
c = gcd(a, b)
print(c, lcm(a, b, c)) | 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,722 |
s452609878 | p00005 | u252414452 | 1485779946 | Python | Python | py | Accepted | 10 | 6252 | 370 | import sys
def to_i(e):
return int(e)
def calc_gcd(a, b):
if b > 0:
return calc_gcd(b, a % b)
else:
return a
def calc_lcm(a, b):
return ((a / calc_gcd(a, b)) * b)
while True:
line = sys.stdin.readline()
if not line: break
a, b = map(to_i, line.rstrip().split(" "))
gcd = calc_gcd(a, b)
lcm = calc_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,723 |
s031326284 | p00005 | u519227872 | 1486657574 | Python | Python3 | py | Accepted | 20 | 7636 | 320 | def gcd(a,b):
while True:
if a > b:
a %= b
else:
b %= a
if a == 0 or b == 0:
return max(a,b)
def lcm(a,b,g):
return int(a*b/g)
from sys import stdin
for l in stdin:
a,b = list(map(int,l.split()))
g = gcd(a,b)
print ("%s %s"%(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,724 |
s298594543 | p00005 | u301461168 | 1487774666 | Python | Python3 | py | Accepted | 30 | 7628 | 588 | import sys
nums = []
for line in sys.stdin:
nums.append(line)
for i in range(len(nums)):
input_line = nums[i].split(" ")
a = int(input_line[0])
b = int(input_line[1])
if a > b:
num_bigger = a
num_smaller = b
else:
num_bigger = b
num_smaller = a
r = 1 #?????????
while r > 0:
r = num_bigger % num_smaller
num_bigger = num_smaller
num_smaller = r
max_common_div = num_bigger
min_common_mpl = int((a * b)/max_common_div)
print(str(max_common_div) + " " + str(min_common_mpl)) | 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,725 |
s089397247 | p00005 | u901080241 | 1488950342 | Python | Python3 | py | Accepted | 30 | 7612 | 252 | import sys
def gcd(a,b):
if a%b == 0:
return b
else:
return gcd(b, a%b)
for line in sys.stdin:
a,b = map(int, line.split())
if a<b:
tem = a
a = b
b = tem
gc = gcd(a,b)
print(gc, a*b//gc) | 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,726 |
s353855838 | p00005 | u459418423 | 1488980710 | Python | Python3 | py | Accepted | 20 | 7656 | 229 | import sys
def gcd(m, n):
if n != 0:
return gcd(n, m % n)
else:
return m
for line in sys.stdin.readlines():
m, n = map(int, line.split())
g = gcd(m, n)
l = m * n // g # LCM
print(g, 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,727 |
s133455687 | p00005 | u810591206 | 1489037800 | Python | Python3 | py | Accepted | 30 | 7672 | 268 | import sys
def gcd(m, n):
r = m % n
if r == 0:
return n
else:
return gcd(n, r)
lines = sys.stdin.readlines()
for line in lines:
a, b = map(int, line.split())
m = max(a, b)
n = min(a, b)
print(gcd(m, n), m * n // gcd(m, n)) | 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,728 |
s510327923 | p00005 | u318658123 | 1489406826 | Python | Python3 | py | Accepted | 40 | 7616 | 433 | #coding:utf-8
import sys
def gcd(n):
x = n[0]
y = n[1]
while y:
x, y = y, x % y
return x
def lcm(n):
return int(n[0] * n[1] / gcd(n))
if __name__ == '__main__':
lines = []
for line in sys.stdin:
if line == "\n":
break
else :
lines.append([int(item) for item in line.split(" ")])
for n in lines:
print(str(gcd(n)) + " " + str(lcm(n))) | 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,729 |
s571285818 | p00005 | u623894175 | 1490413478 | Python | Python3 | py | Accepted | 30 | 7684 | 214 | import sys
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return int(a*b / gcd(a,b))
for s in sys.stdin:
a, b = map(int, s.split())
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,730 |
s688910518 | p00005 | u036236649 | 1490595719 | Python | Python3 | py | Accepted | 20 | 7656 | 180 | def gcd(a, b):
while(b > 0):
a, b = b, a % b
return a
import sys
for line in sys.stdin:
a, b = map(int, line.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,731 |
s371903079 | p00005 | u728901930 | 1490778200 | Python | Python3 | py | Accepted | 30 | 7668 | 192 | import sys
def gcd(a,b):
a,b=max(a,b),min(a,b)
while a%b:
a,b=b,a%b
return b
def lcm(a,b):
return a//gcd(a,b)*b
for i in sys.stdin:
a,b=map(int,i.split())
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,732 |
s573331362 | p00005 | u631113523 | 1491673444 | Python | Python3 | py | Accepted | 20 | 7488 | 245 | while True:
try:
a, b = map(int, input().split())
cross = a * b
if a < b:
a, b = b, a
while a % b != 0:
a, b = b, a % b
print(b, cross // 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,733 |
s016723439 | p00005 | u307520683 | 1491891649 | Python | Python | py | Accepted | 10 | 6148 | 294 |
def gcd(a,b):
while a%b :
a,b=b,a%b
return b
def lcm(a,b):
return a*b/gcd(a,b)
while True :
try:
a,b = map(int,raw_input().split())
a,b = max(a,b), min(a,b)
print "%d" % gcd(a,b),
print "%d" % 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,734 |
s173770249 | p00005 | u462831976 | 1492547679 | Python | Python3 | py | Accepted | 30 | 7656 | 348 | # -*- coding: utf-8 -*-
import sys
import os
def gcd(a, b):
# big - small
while a != b:
if a > b:
a, b = b, a
a, b = b - a, a
return a
def lcm(a, b):
return a * b // gcd(a, b)
lst = sys.stdin.readlines()
for s in lst:
a, b = map(int, s.split())
G = gcd(a, b)
L = lcm(a, b)
print(G, 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,735 |
s551211575 | p00005 | u000317780 | 1493785409 | Python | Python3 | py | Accepted | 20 | 7644 | 484 | import sys
def get_input():
return map(int, input().split(' '))
def gcd(i,j):
if i > j:
if i % j == 0:
return j
else:
return gcd(j, i % j)
else:
if j % i == 0:
return i
else:
return gcd(i, j % i)
def main():
for line in sys.stdin:
ls = list(map(int, line.split(' ')))
g = gcd(ls[0], ls[1])
print(g, int(ls[0]*ls[1]/g))
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,736 |
s461208800 | p00005 | u395334793 | 1493910573 | Python | Python3 | py | Accepted | 30 | 7596 | 442 | def gcd(a,b):
big,small=max(a,b),min(a,b)
while big%small!=0:
big,small=small,big%small
return small
def lcm(a,b):
return int(a*b/gcd(a,b))
def main():
while True:
try:
IN=input()
val=IN.split()
g=gcd(int(val[0]),int(val[1]))
l=lcm(int(val[0]),int(val[1]))
print(g,l)
except:
break
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,737 |
s979368235 | p00005 | u362104929 | 1494589031 | Python | Python3 | py | Accepted | 20 | 7600 | 261 | def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(a, b):
return (a * b) // gcd(a,b)
while True:
try:
a, b = [int(i) for i in 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,738 |
s967553335 | p00005 | u717959831 | 1494897860 | Python | Python3 | py | Accepted | 50 | 10072 | 202 | import sys
import fractions
lines = []
for line in sys.stdin:
num = line.split(" ")
a, b = int(num[0]), int(num[1])
gcd = fractions.gcd(a, b)
print("{0} {1:.0f}".format(gcd, (a*b)/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,739 |
s255177695 | p00005 | u922489088 | 1496019400 | Python | Python3 | py | Accepted | 20 | 7572 | 271 | import sys
def gcd(a,b):
r= b % a
while r != 0:
a,b = r,a
r = b % a
return a
def lcm(a,b):
return int(a*b/gcd(a,b))
for line in sys.stdin:
a,b = sorted(map(int, line.rstrip().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,740 |
s974651890 | p00005 | u905313459 | 1496059942 | Python | Python3 | py | Accepted | 60 | 10156 | 144 | import sys
from fractions import gcd
for line in sys.stdin:
a, b = sorted(map(int, line.split()))
print(gcd(a, b), (a * b) // gcd(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,741 |
s356001045 | p00005 | u421983421 | 1496061720 | Python | Python | py | Accepted | 10 | 6608 | 273 | def gcd(x, y):
if y == 0L:
return x
elif x < y:
return gcd(y, x)
else:
ny = x % y
return gcd(y, ny)
while True:
try:
inpt = map(long, raw_input().split())
g = gcd(inpt[0], inpt[1])
h = inpt[0] * inpt[1] / g
print str(g) + ' ' + str(h)
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,742 |
s213956671 | p00005 | u974788383 | 1496154473 | Python | Python3 | py | Accepted | 30 | 7516 | 393 | #! /usr/bin/env python3
import sys
get = sys.stdin.read().split('\n')
for g in get:
nums = list(map(int, g.split()))
output = ''
if (nums != []):
# print(nums)
[a, b] = nums
while ((a != 0) and (b != 0)):
larger = max([a, b])
smaller = min([a, b])
a = larger - smaller
b = smaller
output += str(max([a, b])) + ' ' + str((nums[0]*nums[1])//max([a,b]))
print(output) | 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,743 |
s988876892 | p00005 | u440180827 | 1496889434 | Python | Python3 | py | Accepted | 30 | 7488 | 271 | import sys
def gcd(a, b):
for i in range(1, a+1):
if a % i == 0:
t = a // i
if b % t == 0:
return t
for line in sys.stdin:
a, b = sorted(map(int, line.split()))
gcdab = gcd(a, b)
print(gcdab, a // gcdab * 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,744 |
s158411796 | p00005 | u440180827 | 1496889584 | Python | Python3 | py | Accepted | 20 | 7620 | 271 | import sys
def gcd(a, b):
for i in range(1, a+1):
if a % i == 0:
t = a // i
if b % t == 0:
return t
for line in sys.stdin:
a, b = sorted(map(int, line.split()))
gcdab = gcd(a, b)
print(gcdab, a // gcdab * 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,745 |
s458886331 | p00005 | u503263570 | 1499697443 | Python | Python3 | py | Accepted | 20 | 7608 | 129 | import sys
a=[map(int,i.split())for i in sys.stdin]
for i,j in a:
c,d=i,j
while d:
if c > d:c,d = d,c
d%=c
print(c,i//c*j) | 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,746 |
s561772211 | p00005 | u503263570 | 1499697480 | Python | Python3 | py | Accepted | 20 | 7664 | 125 | import sys
a=[map(int,i.split())for i in sys.stdin]
for i,j in a:
c,d=i,j
while d:
if c>d:c,d=d,c
d%=c
print(c,i//c*j) | 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,747 |
s855554734 | p00005 | u503263570 | 1499697524 | Python | Python3 | py | Accepted | 20 | 7604 | 129 | import sys
a=[map(int,i.split())for i in sys.stdin]
for i,j in a:
c,d=i,j
while d:
if c > d:c,d = d,c
d%=c
print(c,i//c*j) | 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,748 |
s637928489 | p00005 | u600821328 | 1499945031 | Python | Python3 | py | Accepted | 30 | 7744 | 317 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import sys
def gcd(a, b):
if b == 0: return a
return gcd(b, a % b)
def main():
for line in sys.stdin:
a, b = map(int, line.split())
d = gcd(a, b)
m = a * b // d
print("{} {}".format(d, m))
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,749 |
s276679462 | p00005 | u184989919 | 1500120776 | Python | Python3 | py | Accepted | 20 | 7588 | 314 | import sys
def GcdLCM():
for line in sys.stdin:
x,y=map(int,line.split())
if x==None:
break
gcd = Gcd(x,y)
lcm = int(x*y/gcd)
print("{} {}".format(gcd,lcm))
def Gcd(x,y):
while x!=0:
x,y=y%x,x
return y
GcdLCM() | 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,750 |
s946519215 | p00005 | u806182843 | 1500211694 | Python | Python3 | py | Accepted | 20 | 7708 | 182 | def main():
import sys
for line in sys.stdin:
a, b = map(int, line.split())
c = a*b
while a % b != 0:
a, b = b, a%b
print(b, c//b)
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,751 |
s864145550 | p00005 | u546285759 | 1500499285 | Python | Python3 | py | Accepted | 20 | 7516 | 155 | while True:
try:
a, b = map(int, input().split())
except:
break
ab = a*b
while b:
a, b = b, a%b
print(a, ab//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,752 |
s200202868 | p00005 | u011621222 | 1500521973 | Python | Python3 | py | Accepted | 30 | 7660 | 966 | # Aizu - 0005
def De(a):
res = []
tmp = 2
while a != 1:
while not (a % tmp):
a = round(a / tmp)
res.append(tmp)
tmp += 1
return res
while True:
try:
tmp = input()
a = [int(i) for i in tmp.split(' ')]
except:
break
b = De(a[1])
a = De(a[0])
pa, pb = 0, 0
GCD, LCM = 1, 1
while True:
if pa == len(a):
for i in range(pb, len(b)):
LCM *= b[i]
break;
if pb == len(b):
for i in range(pa, len(a)):
LCM *= a[i]
break;
if a[pa] == b[pb]:
GCD *= a[pa]
LCM *= a[pa]
pa += 1
pb += 1
continue
if a[pa] < b[pb]:
LCM *= a[pa]
pa += 1
continue
if a[pa] > b[pb]:
LCM *= b[pb]
pb += 1
continue
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,753 |
s956430230 | p00005 | u354053070 | 1501902332 | Python | Python3 | py | Accepted | 20 | 7724 | 243 | import sys
def gcd(x, y):
if x < y:
x, y = y, x
while y > 0:
x, y = y, x % y
return x
for line in sys.stdin:
a, b = list(map(int, line.split()))
print("{0} {1}".format(gcd(a, b), int((a * b) / gcd(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,754 |
s691249826 | p00005 | u214404619 | 1502748365 | Python | Python3 | py | Accepted | 20 | 7664 | 236 | 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 line in sys.stdin:
[a, b] = [int(num) for num in line.split()];
print(str(gcd(a, b)) + ' ' + str(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,755 |
s727558420 | p00005 | u584777171 | 1502933868 | Python | Python3 | py | Accepted | 20 | 7644 | 344 | import fileinput
for line in fileinput.input():
tokens = list(map(int, line.strip().split()))
a, b = tokens[0], tokens[1]
d = a * b
if a < b:
tmp = a
a = b
b = tmp
c = a % b
while(c != 0):
a = b
b = c
c = a % b
g = b
l = d / g
print(str(g)+" "+str(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,756 |
s932589802 | p00005 | u299798926 | 1502951920 | Python | Python3 | py | Accepted | 20 | 7588 | 293 | while 1:
try:
x,y=[int(i) for i in input().split()]
a=x
b=y
while 1:
c=x%y
if x%y==0:
print(y,a*b//y)
break
else:
x=y
y=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,757 |
s471759957 | p00005 | u821624310 | 1502960953 | Python | Python3 | py | Accepted | 30 | 7692 | 223 | def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
import fileinput
import math
for line in fileinput.input():
a, b = map(int, line.split())
g = gcd(a, b)
lcm = a * b // g
print(g, 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,758 |
s892984511 | p00005 | u234052535 | 1503226326 | Python | Python3 | py | Accepted | 30 | 7660 | 494 | # This program computes GCD and LCM
# -*- coding: utf-8
import sys
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
for i in range(max([a, b]), a*b + 1):
if(i % a == 0 and i % b == 0):
return i
return a*b
for i in sys.stdin:
try:
line = [int(k) for k in i.split(" ")]
g = gcd(min(line), max(line))
print(str(g) + " " + str(line[0]*line[1]//g)) # + str(lcm(line[0], line[1]))
except:
exit() | 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,759 |
s919354997 | p00005 | u234052535 | 1503226485 | Python | Python3 | py | Accepted | 20 | 7644 | 334 | # This program computes GCD and LCM
# -*- coding: utf-8
import sys
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
for i in sys.stdin:
try:
line = [int(k) for k in i.split(" ")]
g = gcd(min(line), max(line))
print(str(g) + " " + str(line[0]*line[1]//g))
except:
exit() | 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,760 |
s768352466 | p00005 | u193453446 | 1503470782 | Python | Python3 | py | Accepted | 20 | 7648 | 583 | import sys
def main():
""" ????????? """
MAX = 2000000000
istr = sys.stdin.read()
wi = istr.splitlines()
for i in wi:
a, b = list(map(int,i.split()))
if a < b:
a, b = b, a
""" ????????????????????????????????§?????§??¬?´???°????????? """
x = a
y = b
while y > 0:
z = x % y
x = y
y = z
""" a ??¨ b ????????? a ??¨ b ???????°???¬?´???°??§?????? """
l = a * b // x
print("{} {}".format(x,l))
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,761 |
s604421291 | p00005 | u508732591 | 1503619602 | Python | Python3 | py | Accepted | 20 | 7640 | 163 | import sys
def gcd(m,n):
return m if n==0 else gcd(n, m%n)
for m,n in [map(int,x.split()) for x in list(sys.stdin)]:
g = gcd(m,n)
print(g,(m//g)*n) | 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,762 |
s628947318 | p00005 | u508732591 | 1503619736 | Python | Python3 | py | Accepted | 30 | 7564 | 161 | import sys
def gcd(m,n):
return m if n==0 else gcd(n, m%n)
for m,n in [map(int,x.split()) for x in list(sys.stdin)]:
g = gcd(m,n)
print(g,m//g*n) | 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,763 |
s003060708 | p00005 | u508732591 | 1503619740 | Python | Python3 | py | Accepted | 20 | 7560 | 161 | import sys
def gcd(m,n):
return m if n==0 else gcd(n, m%n)
for m,n in [map(int,x.split()) for x in list(sys.stdin)]:
g = gcd(m,n)
print(g,m//g*n) | 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,764 |
s317922475 | p00005 | u508732591 | 1503620179 | Python | Python3 | py | Accepted | 30 | 7636 | 139 | import sys
for m,n in [map(int,x.split()) for x in list(sys.stdin)]:
g,r = m,n
while r!=0:
g,r = r,g%r
print(g,m//g*n) | 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,765 |
s364604404 | p00005 | u508732591 | 1503620184 | Python | Python3 | py | Accepted | 20 | 7588 | 139 | import sys
for m,n in [map(int,x.split()) for x in list(sys.stdin)]:
g,r = m,n
while r!=0:
g,r = r,g%r
print(g,m//g*n) | 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,766 |
s876228033 | p00005 | u508732591 | 1503620324 | Python | Python3 | py | Accepted | 20 | 7536 | 130 | import sys
for s in sys.stdin:
m,n = map(int,s.split())
g,r = m,n
while r!=0:
g,r = r,g%r
print(g,m//g*n) | 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,767 |
s977613982 | p00005 | u428982301 | 1503886003 | Python | Python3 | py | Accepted | 30 | 7604 | 472 | import sys
def calc(i1, i2):
a = i1
b = i2
if (i1 < i2):
a = i2
b = i1
r = a % b
while r != 0:
a = b
b = r
r = a % b
gcd = b
lcm = (i1 * i2) / gcd
return gcd, lcm
for line in sys.stdin:
datas =line.split()
if (len(datas)):
li = list(map(int, datas))
a = li[0]
b = li[1]
x, y = calc(a, b)
print("%d %d" % (x, y))
else:
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,768 |
s215266997 | p00005 | u123964252 | 1504093934 | Python | Python3 | py | Accepted | 60 | 10120 | 396 | import fractions
lst = []
for i in range(200):
try:
lst.append(input())
except EOFError:
break
nums = [list(map(int, elem.split(' '))) for elem in lst]
# gcd
res_gcd = [fractions.gcd(num[0], num[1]) for num in nums]
# lcm
res_lcm = [nums[i][0] * nums[i][1] // res_gcd[i] for i in range(len(nums))]
for (a, b) in zip(res_gcd, res_lcm):
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,769 |
s889469259 | p00005 | u855694108 | 1504103023 | Python | Python3 | py | Accepted | 20 | 7588 | 397 | import sys
def main():
for line in sys.stdin:
a,b = map(int, line.split())
if a > b:
a,b = b,a
p = a * b #product
while True:
hoge = a
a = b % a
b = hoge
if a == 0:
gcd = b
break
lcm = p // gcd
print(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,770 |
s793779455 | p00005 | u957021183 | 1504683852 | Python | Python3 | py | Accepted | 40 | 7692 | 406 | # Aizu Problem 0006: GCD and LCM
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def gcd(a, b):
while b != 0:
t = b
b = a % b
a = t
return a
def lcm(a, b):
return (a * b) // gcd(a, b)
for line in sys.stdin:
a, b = [int(_) for _ in line.split()]
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,771 |
s191881532 | p00005 | u877201735 | 1505712179 | Python | Python3 | py | Accepted | 20 | 7628 | 287 | def gcd(a, b):
if (a % b) == 0:
return b
return gcd(b, a%b)
def lcd(a, b):
return a * b // gcd(a, b)
while True:
try:
nums = list(map(int, input().split()))
print(gcd(nums[0], nums[1]), lcd(nums[0], nums[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,772 |
s776768724 | p00005 | u741801763 | 1505741979 | Python | Python3 | py | Accepted | 20 | 7696 | 399 | import fileinput as fi
def gcd_euler(a,b):
if b == 0: return a
u = a
v = b
r = u % v
while True:
if r == 0:return v
u = v
v = r
r = u % v
if __name__ == "__main__":
for line in fi.input():
a,b = list(map(int,line.strip().split()))
if a > b:gcd=gcd_euler(a,b)
else:gcd=gcd_euler(b,a)
print(gcd,int((a*b)/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,773 |
s757776986 | p00005 | u933096856 | 1505799665 | Python | Python3 | py | Accepted | 20 | 7644 | 231 | try:
while True:
x=list(sorted(map(int, input().split())))
a=x[0]
b=x[1]
while b%a != 0:
c=a
a=b%a
b=c
print(a, x[0]*x[1]//a)
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,774 |
s486237781 | p00005 | u146816547 | 1506135376 | Python | Python | py | Accepted | 10 | 6452 | 271 | def gcd(x, y):
if y == 0:
return x
else:
return gcd(y, x%y)
def lcm(x,y):
return x/gcd(x, y)*y
while True:
try:
x, y = map(int, raw_input().split())
except EOFError:
break
print "%d %d" % (gcd(x, y), lcm(x, 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,775 |
s593776018 | p00005 | u197615397 | 1506156361 | Python | Python3 | py | Accepted | 30 | 7704 | 133 | import sys
for line in sys.stdin:
a, b = map(int, line.split())
n = a*b
while b:
a, b = b, a%b
print(a, n//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,776 |
s275762819 | p00005 | u531482846 | 1506204348 | Python | Python3 | py | Accepted | 20 | 7688 | 214 | import sys
def gcd(x, y):
if y == 0:
return x
else:
return gcd(y, x%y)
def lcm(x, y):
return x * y //gcd(x,y)
for line in sys.stdin:
x, y = map(int, line.split())
print(gcd(x, y), lcm(x,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,777 |
s681264892 | p00005 | u742505495 | 1507700378 | Python | Python3 | py | Accepted | 50 | 7772 | 301 | import math
import sys
while True:
try:
a,b = map(int, input().split())
p = a
q = b
while True:
r = p%q
if r == 0:
x = q
break
else:
p = q
q = r
i = 1
while True:
if a*i%b == 0:
y = a*i
break
else:
i = i+1
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,778 |
s610754711 | p00005 | u256256172 | 1508402958 | Python | Python3 | py | Accepted | 20 | 7760 | 268 | import sys
for line in sys.stdin:
a,b = map(int, line.split())
if a < b:
a,b = b,a
def gcd(x,y):
while y > 0:
x,y = y,x%y
return x
def lcm(x,y):
return x * y / gcd(x, y)
print(gcd(a,b), 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,779 |
s280600470 | p00005 | u197670577 | 1508421507 | Python | Python | py | Accepted | 10 | 6448 | 237 | #!/usr/bin/python
# coding: utf-8
def gcd(a,b):
while b != 0:
a, b = b, a % b
return a
while True:
try:
a, b = map(int, raw_input().split())
except:
break
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,780 |
s198228173 | p00005 | u422087503 | 1508810929 | Python | Python3 | py | Accepted | 20 | 7724 | 208 | import sys
def lcm(a,b):
return a*b//gcd(a,b)
def gcd(a,b):
while True:
a,b = b,a%b
if b==0:
return a
for line in sys.stdin:
a,b = map(int, line.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,781 |
s912796776 | p00005 | u424041287 | 1509112499 | Python | Python3 | py | Accepted | 20 | 7608 | 211 | t = 0
while t == 0:
try:
x,y=[int(i) for i in input().split()]
except:
break
else:
a = x * y
if x < y:
x,y =y,x
while y > 0:
r = x % y
x = y
y = r
print(str(x) + " " + str(int(a / 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,782 |
s739666546 | p00005 | u914007790 | 1509346651 | Python | Python3 | py | Accepted | 20 | 7648 | 432 | def gcd(a, b):
while b != 0:
y = a % b
a = b
b = y
return a
d = []
m = []
while True:
try:
a, b = map(int, input().split())
if a > b:
num = gcd(a, b)
elif a < b:
num = gcd(b, a)
else:
num = a
d.append(num)
m.append(int(a*b/num))
except EOFError:
break
for i in range(len(d)):
print(d[i], m[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,783 |
s432906507 | p00005 | u776758454 | 1510675619 | Python | Python3 | py | Accepted | 60 | 10080 | 251 | import sys
import fractions
def main():
dataset = sys.stdin.readlines()
for data in dataset:
a, b = map(int, data.split())
gcd_num = fractions.gcd(a, b)
print('%d %d' % (gcd_num, a * b / gcd_num))
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,784 |
s004111882 | p00005 | u917432951 | 1510722838 | Python | Python3 | py | Accepted | 80 | 10220 | 219 | import sys
import fractions
def lcm(a,b):
return int(a*b/fractions.gcd(a,b))
if __name__ == '__main__':
for line in sys.stdin:
a,b = map(int,line.split())
print(int(fractions.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,785 |
s736724264 | p00005 | u488038316 | 1510918749 | Python | Python | py | Accepted | 10 | 6396 | 556 | # -*-coding:utf-8
import fileinput
def main():
for line in fileinput.input():
tokens = list(map(int, line.strip().split()))
a, b = tokens[0], tokens[1]
if a < b:
a, b = b, a
ansGCD = GreatestCommonDivisor(a, b)
ansLCM = LeastCommonMultiple(a, b)
print('{0} {1}'.format(ansGCD, ansLCM))
def GreatestCommonDivisor(a, b):
while b:
a, b = b, a%b
return a
def LeastCommonMultiple(a, b):
return (a*b) / GreatestCommonDivisor(a, b)
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,786 |
s457592640 | p00005 | u742178809 | 1511330055 | Python | Python3 | py | Accepted | 30 | 7636 | 317 | import sys
#from me.io import dup_file_stdin
def gcd(x,y):
t = x % y
if(t==0):
return y
else:
return gcd(y, t)
#@dup_file_stdin
def solve():
for line in sys.stdin:
x,y = map(int,line.split(" "))
f = gcd(x,y)
print("{} {}".format(f, x//f*y))
solve()
| 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,787 |
s165074072 | p00005 | u548155360 | 1512381440 | Python | Python3 | py | Accepted | 20 | 5596 | 594 | # coding=utf-8
def solve_gcd(number1: int, number2: int) -> int:
two_list = [number1, number2]
two_list.sort()
if two_list[1] % two_list[0] == 0:
return two_list[0]
r = two_list[1] % two_list[0]
return solve_gcd(two_list[0], r)
def solve_lcm(number1: int, number2: int, number3: int) -> int:
return number1*number2//number3
if __name__ == '__main__':
while True:
try:
a, b = map(int, input().split())
except EOFError:
break
gcd = solve_gcd(a, b)
lcm = solve_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,788 |
s679930026 | p00005 | u024715419 | 1513245624 | Python | Python3 | py | Accepted | 20 | 5588 | 178 | while True:
try:
a, b = map(int, input().split())
x, y = a, b
while y:
x, y = y, x%y
print(x,int(a*b/x))
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,789 |
s367649024 | p00005 | u846136461 | 1513435796 | Python | Python | py | Accepted | 10 | 4656 | 345 | # coding: utf-8
while True:
try:
data = map(int, raw_input().split())
if data[0] > data[1]:
a = data[0]
b = data[1]
else:
a = data[1]
b = data[0]
r = 1
while r > 0:
q = a / b
r = a - b * q
a = b
b = r
gcd = a
lcm = data[0] * data[1] / 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,790 |
s805936040 | p00005 | u471400255 | 1513698916 | Python | Python3 | py | Accepted | 20 | 5672 | 144 | from math import gcd
from sys import stdin
for line in stdin:
a,b = [int(i) for i in line.split()]
g = gcd(a,b)
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,791 |
s713017278 | p00005 | u546285759 | 1513929680 | Python | Python3 | py | Accepted | 20 | 5600 | 252 | def GCD(m, n):
while n:
m, n = n, m % n
return m
while True:
try:
a, b = map(int, input().split())
except:
break
if a < b:
a, b = b, a
gcd = 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,792 |
s997164972 | p00005 | u480287988 | 1514101868 | Python | Python3 | py | Accepted | 20 | 5596 | 247 | import sys
for i in sys.stdin:
a,b=list(map(int, i.split()))
d=a*b
if a>b:
temp=a
a=b
b=temp
c=a%b
while c!=0:
a=b
b=c
c=a%b
g=b
l=int(d/g)
print("{} {}".format(g,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,793 |
s131373758 | p00005 | u764789069 | 1514132400 | Python | Python | py | Accepted | 10 | 4632 | 236 | def GCD(a,b):
while (a % b) != 0:
a,b = b, a%b
return b
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:
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,794 |
s870913137 | p00005 | u298999032 | 1514247278 | Python | Python3 | py | Accepted | 20 | 5596 | 220 | import sys
for i in sys.stdin:
a,b=map(int,i.split())
if a<b:a,b=b,a
def gcd(x,y):
while y>0:x,y=y,x%y
return x
def lcm(x,y):
return x*y/gcd(x,y)
print(gcd(a,b),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,795 |
s741327405 | p00005 | u600263347 | 1514274635 | Python | Python3 | py | Accepted | 20 | 5592 | 316 | def main():
while True:
try:
a,b = map(int,input().split())
c = a*b
if a < b:
a,b = b,a
while a%b != 0:
a,b = b,a%b
print(b,c//b)
except EOFError:
exit()
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,796 |
s427880809 | p00005 | u183079216 | 1514294894 | Python | Python3 | py | Accepted | 20 | 5604 | 410 | def gcd(a,b):
if a > b:
x = a
y = b
else:
x = b
y = a
while y > 0:
r = x % y
x = y
y = r
return x
def lcm(a,b,c):
return int(a*b/c)
while 1:
try:
a,b = [int(x) for x in input().split()]
res_gcd = gcd(a,b)
res_lcm = lcm(a,b,res_gcd)
print('{} {}'.format(res_gcd,res_lcm))
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,797 |
s160448290 | p00005 | u585035894 | 1514534670 | Python | Python3 | py | Accepted | 20 | 5600 | 181 | import sys
def gcd(x, y):
if x % y != 0:
return gcd(y, x % y)
return y
for i in sys.stdin:
x, y = map(int, i.split())
g = gcd(x,y)
print(g, int(x*y/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,798 |
s237748259 | p00005 | u028347703 | 1514555827 | Python | Python3 | py | Accepted | 20 | 5604 | 272 | import sys
def gcd(m, n):
if n > m:
m, n = n, m
if n == 0:
return m
else:
return gcd(n, m % n)
for line in sys.stdin:
try:
a, b = [int(i) for i in line.split()]
g = gcd(a, b)
l = a * b / g
print("%d %d" % (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,799 |
s824771522 | p00005 | u764789069 | 1514697315 | Python | Python | py | Accepted | 0 | 4632 | 236 | def GCD(a,b):
while (a % b) != 0:
a,b = b, a%b
return b
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:
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,800 |
s536145301 | p00005 | u273843182 | 1514719857 | Python | Python3 | py | Accepted | 20 | 5596 | 182 | 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())
d = gcd(max(a,b),min(a,b))
print(d,a*b//d)
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,801 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.