Problem:


Score : 300 points

Problem Statement

Takahashi is organizing a party.

At the party, each guest will receive one or more snack pieces.

Takahashi predicts that the number of guests at this party will be A or B.

Find the minimum number of pieces that can be evenly distributed to the guests in both of the cases predicted.

We assume that a piece cannot be divided and distributed to multiple guests.

Constraints

1 \leq A, B \leq 10^5

A \neq B

All values in input are integers.

Input

Input is given from Standard Input in the following format:

A B

Output

Print the minimum number of pieces that can be evenly distributed to the guests in both of the cases with A guests and B guests.

Sample Input 1

2 3

Sample Output 1

6

When we have six snack pieces, each guest can take three pieces if we have two guests, and each guest can take two if we have three guests.

Sample Input 2

123 456

Sample Output 2

18696

Sample Input 3

100000 99999

Sample Output 3

9999900000



Sample input:
2 3


Sample output:
6

Submission status: Accepted

Solution code:
from collections import Counter,defaultdict,deque
import sys
import bisect
import math
import itertools
import string
import queue
import copy
# import numpy as np
# import scipy
from itertools import permutations, combinations
from heapq import heappop, heappush
# input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
 
def inp(): # n=1
    return int(input())
def inpm(): # x=1,y=2
    return map(int,input().split())
def inpl(): # a=[1,2,3,4,5,...,n]
    return list(map(int, input().split()))
def inpls(): # a=['1','2','3',...,'n']
    return list(input().split())
def inplm(n): # x=[] 複数行
    return list(int(input()) for _ in range(n))
def inpll(n): # [[1,1,1,1],[2,2,2,2],[3,3,3,3]]
    return [list(map(int, input().split())) for _ in range(n)]

def gcd(a, b): #最大公約数
    if b == 0:
        return a
    else:
        return gcd(b, a%b)

def lcm(a, b): #最小公約数
    return((a*b)//gcd(a,b))


def main():
    a,b=inpm()
    print(lcm(a,b))
    

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
A,B = map(int,input().split())
def gcd(x,y):
    if x<y:x,y=y,x
    if y==0:return x
    return gcd(y,x%y)
print(A*B//gcd(A,B))

Submission status: Accepted

Solution code:
def func(x,y):
    if y == 0:
        return x
    return func(y,x%y)

A,B = map(int,input().split())
print((A*B)//func(A,B))

Submission status: Accepted

Solution code:
from fractions import gcd

A, B = map(int, input().split())
g = gcd(A, B)
print(A*B//g)

Submission status: Accepted

Solution code:
from fractions import gcd
a,b = map(int,input().split())
print(a*b//(gcd(a,b)))

Submission status: Accepted

Solution code:
def gcd(a: int, b: int) -> int:
    """a, bの最大公約数(greatest common divisor:GCD)を求める
    計算量: O(log(min(a, b)))
    """
    if b == 0:
        return a
    return gcd(b, a%b)


def lcm(a, b):
    """a, bの最小公倍数(least common multiple:LCM)を求める
    計算量: O(log(min(a, b)))"""
    return (a * b) // gcd(a, b)
  
a, b = map(int, input().split())

print(lcm(a, b))

Submission status: Accepted

Solution code:
from fractions import gcd
from functools import reduce

def lcm_base(x,y):
    return (x*y) // gcd(x,y)

def lcm_list(numbers):
    return reduce(lcm_base,numbers)



A, B = map(int, input().split())

ans = lcm_base(A, B)
print(ans)

Submission status: Accepted

Solution code:
a, b = map(int, input().split())

from fractions import gcd
g = gcd(a, b)
print(a * b // g)

Submission status: Accepted

Solution code:
a, b = map(int, input().split())


def gcd(x, y):
    x, y = max(x, y), min(x, y)
    if y == 0:
        return x
    return gcd(y, x % y)


print(a*b//gcd(a, b))

Submission status: Accepted

Solution code:
import fractions
a,b = map(int,input().split())
print((a * b)//fractions.gcd(a,b))

Submission status: Accepted

Solution code:
# 入力が10**5とかになったときに100ms程度早い
import sys
read = sys.stdin.readline


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_matrix(H):
    '''
    H is number of rows
    '''
    return [list(map(int, read().split())) for _ in range(H)]


def read_map(H):
    '''
    H is number of rows
    文字列で与えられた盤面を読み取る用
    '''
    return [read()[:-1] for _ in range(H)]


def read_col(H, n_cols):
    '''
    H is number of rows
    n_cols is number of cols

    A列、B列が与えられるようなとき
    '''
    ret = [[] for _ in range(n_cols)]
    for _ in range(H):
        tmp = list(map(int, read().split()))
        for col in range(n_cols):
            ret[col].append(tmp[col])

    return ret


A, B = read_ints()
from fractions import gcd
G = gcd(A, B)
a = A // G
b = B // G
print(G * a * b)

Submission status: Accepted

Solution code:
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    def gcd(a,b):
        if a == 0:
            return b
        return gcd(b%a, a)
    a,b = LI()
    g = gcd(a,b)
    l = a*b//g
    print(l)
    return

#Solve
if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
minans = inf ;ans = 0 ;count = 0 ;pro = 1

def gcd(a, b):
    while(b != 0):
        a, b = b, a % b
    return a
    
def lcm(m,n):
    return (m*n)//gcd(m,n)

a,b=map(int,input().split())
print(lcm(a,b))

Submission status: Accepted

Solution code:
a, b = map(int,input().split())

def gcd(x, y):
    while x != 0 and y != 0:
        x, y = max(x, y), min(x, y)
        x %= y
    return y

print(a*b//gcd(a,b))

Submission status: Accepted

Solution code:
A, B = map(int, input().split())

# 最大公約数
def gcd(a, b) :
    if b > a : 
        a, b = b, a
    
    while b != 0 :
        a, b = b, a % b
    return a
    
# 最小公倍数
def lcm(a, b) :
    return a * b // gcd(a, b)
    
print(lcm(A, B))

Submission status: Accepted

Solution code:
def gcd(a, b):
  if a == 0:
    return b
  if b == 0:
    return a
  if a > b:
    return gcd(a%b, b)
  return gcd(a, b%a)

a, b = input().split()
a, b = int(a), int(b)
print(a * b // gcd(a, b))

Submission status: Accepted

Solution code:
def gcd(a,b):
    if a < b:
        a, b = b, a
    while b >= 1:
        a, b = b, a % b
    return a
def lcm(a,b):
	return a * b // gcd(a,b)

a, b = [ int(v) for v in input().split() ]
print(lcm(a,b))

Submission status: Accepted

Solution code:
from fractions import gcd
def lcm(a, b):
    return a * b // gcd(a, b)

A,B = map(int,input().split())
print(lcm(A,B))

Submission status: Accepted

Solution code:
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353

A , B = list(map(int, sys.stdin.buffer.readline().split()))
print( int(A * B / gcd(A, B)))

Submission status: Accepted

Solution code:
import itertools, heapq, bisect
from collections import defaultdict as ddic, deque, Counter

rr = raw_input
rri = lambda: int(raw_input())
rrm = lambda: map(int, raw_input().split())
MOD = 10 ** 9 + 7

###
X, Y = rrm()
from fractions import gcd
def lcm(a,b):
    return a*b/gcd(a,b)
print lcm(X, Y)

Submission status: Accepted

Solution code:
#import pysnooper
#import numpy
#import os,re,sys,operator
#from collections import Counter,deque
#from operator import itemgetter,mul
#from itertools import accumulate#,combinations,groupby,combinations_with_replacement,permutations
from sys import stdin,setrecursionlimit
#from bisect import bisect_left,bisect_right
#from copy import deepcopy
#import heapq
#import math
#import string
#from time import time
#from functools import lru_cache,reduce
#from math import factorial
#import sys
from fractions import gcd
setrecursionlimit(10**6)
input=stdin.readline

def lcm(n,m):
    return (n*m)//gcd(n,m)
a,b=map(int,input().split())
print(lcm(a,b))

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**6)
if sys.platform in (['ios','darwin','win32']):
	sys.stdin=open('Untitled.txt')
input = sys.stdin.readline
def INT(): return int(input())
def MAP(): return [int(s) for s in input().split()]

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

#a,bの最小公倍数
def lcm(a, b):
    return a * b // gcd (a, b)

def main():
	A, B = MAP()
	print(lcm(A, B))

if __name__ == '__main__':
	main()

Submission status: Accepted

Solution code:
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

A,B = inpl()
def gcd(a,b):
	while b:
		a,b = b, a%b
	return a

def lcm(a,b):
	return a*b // gcd(a,b)

print(lcm(A,B))

Submission status: Runtime Error

Solution code:
import math
a, b = map(int, raw_input().split());
print(a * b / math.gcd(a,b))

Submission status: Runtime Error

Solution code:
import numpy as np

A, B = map(int, input().split())

print(lcm(A, B))

Submission status: Runtime Error

Solution code:
import math

A, B = map(int, input().split())
print(a*b//math.gcd(a, b))

Submission status: Runtime Error

Solution code:
import math
a,b=map(int,input().split())
def lcm(x, y):
    return (x * y) // math.gcd(x, y)def lcm(x, y):
    return (x * y) // math.gcd(x, y)
print(lcm(a,b))

Submission status: Runtime Error

Solution code:
a, b = map(int, input().split())

lcm = 0
for i in range(1, B+1):
  if (A * i) % B == 0:
    lcm = A * i
  
print(lcm)

Submission status: Runtime Error

Solution code:
a,b=input().split()
a=int(a)
b=int(b)
c=1
d=0
if a>b:
  for i in range(1,a):
    if a%(a-i)==0 and b%(b-i)==0:
      a=a/(a-i)
      b=b/(a-i)
      c=c*(a-i)
  print(int(a*b*c))
if a<b:
  for i in range(1,b):
    if a%(b-i)==0 and b%(b-i)==0:
      a=a/(b-i)
      b=b/(a-i)
      c=c*(b-i)
  print(int(a*b*c))

Submission status: Runtime Error

Solution code:
a,b=input().split()
a=int(a)
b=int(b)
c=1
d=0
if a>b:
  for i in range(a):
    if a%i==0 and b%i==0:
      a=a/i
      b=b/i
      c=c*i
  print(a*b*c)
if a<b:
  for i in range(b):
    if a%i==0 and b%i==0:
      a=a/i
      b=b/i
      c=c*i
  print(a*b*c)

Submission status: Runtime Error

Solution code:
import math
a=int(input())
b=int(input())
def lcm(x, y):
    return (x * y) // math.gcd(x, y)

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
def lcm(x, y):
    return (x * y) // math.gcd(x, y)

def abc148c_snack():
    a, b = map(int, input().split())
    print(lcm(a, b))

abc148c_snack()

Submission status: Runtime Error

Solution code:
import math
a,b = map(int,input().split())
temp = math.gcd(a, b)
ans = a * b // temp
print(ans

Submission status: Runtime Error

Solution code:
def lcm(x, y):
    return (x * y) // math.gcd(x, y)
a,b=map(int,input(),split())
print(lcm(a, b))

Submission status: Runtime Error

Solution code:
a,b = map(int,input().split())
print(a*b//math.gcd(a,b))

Submission status: Runtime Error

Solution code:
import math

A,B=map(int,input())
print(A*B // math.gcd(A,B))

Submission status: Runtime Error

Solution code:
import math
a, b = map(int, input().split())
print(math.lcm(a, b))

Submission status: Runtime Error

Solution code:
import math

A, B =map(int, input().split())

print(A*B / gcd(A, B))

Submission status: Runtime Error

Solution code:
from math import gcd
a,b=int(input().split())
print(a*b/gcd(a,b))

Submission status: Runtime Error

Solution code:
from math import gcd
def main():
    a, b = = map(int, input().split())
    r = (a * b) // gcd(a, b)
    print(r)

if __name__ == '__main__':
    main()

Submission status: Runtime Error

Solution code:
import math
A,B=map(int,input().split())
print(return(A*B)//math.gcd(A,B))

Submission status: Runtime Error

Solution code:
import bisect,collections,copy,heapq,itertools,math,string
import sys
 
def lcm(x, y):
    return (x * y) // math.gcd(x, y)

def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
a, b = M()
ans = lcm(a, b)
print(ans)

Submission status: Runtime Error

Solution code:
import bisect,collections,copy,heapq,itertools,math,string
import sys

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
a, b = M()
ans = lcm(a, b)
print(ans)

Submission status: Runtime Error

Solution code:
import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline    ####
def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(input())
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print(k.join(list(map(str, lst))))
INF = float('inf')
# from math import ceil, floor, log2
# from collections import deque
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np
# from numpy import cumsum  # accumulate
# from fractions import gcd
from math import gcd
def lcm(x, y):
  return x // gcd(x, y) * y

def solve():
    a, b = MI()
    print(lcm(a, b))

if __name__ == '__main__':
    solve()

Submission status: Runtime Error

Solution code:
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect


def lcm(a, b):
    """最小公倍数"""
    from math import gcd
    return (a * b) // gcd(a, b)


# from decorator import stop_watch
# 
# 
# @stop_watch
def solve(A, B):
    print(lcm(A, B))


if __name__ == '__main__':
    A, B = map(int, input().split())
    solve(A, B)

Submission status: Runtime Error

Solution code:
import math
A,B=map(int,input().split())
print(math.gcd(A,B))

Submission status: Runtime Error

Solution code:
#C
from math import gcd
A,B=map(int,input().split())
LCM=A*B/gcd(A,B)
print(int(LCM))

Submission status: Runtime Error

Solution code:
import math

def lcm(x,y):
  return (x*y)//math.gcd(x,y)

A,B=map(int,input().split())
print(lcm(A,B))

Submission status: Runtime Error

Solution code:
A,B=map(int,input().split())

import math
print(A*B//math.gcd(A,B))

Submission status: Runtime Error

Solution code:
import math
input_line = list(map(int,input().split(' ')))

ans = input_line[0] * input_line[1] // math.gcd(input_line[0], input_line[1])
print(ans)

Submission status: Runtime Error

Solution code:
ma = lambda :map(int,input().split())
ni = lambda:int(input())
import collections
import math
import itertools
gcd = math.gcd
a,b = ma()
print(a*b//gcd(a,b))

Submission status: Runtime Error

Solution code:
import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9

def main():
    a,b = map(int, input().split())

    print(a*b//math.gcd(a, b))


if __name__ == '__main__':
    main()

Submission status: Runtime Error

Solution code:
import math
def lem(x,y):
	return (x * y) // math.gcd(x,y)

A,B = map(int, input().split())
print(lem(A,B))

Submission status: Runtime Error

Solution code:
import math
def lem(x,y):
	return (x * y) // math.gcd(x,y)

A,B = map(int, input().split())
print(lem(A,B))

Submission status: Runtime Error

Solution code:
import math
a,b = map(int, input().split())
print(a * b // math.gcd(a,b))

Submission status: Runtime Error

Solution code:
import franctions
a, b = map(int, input().split())

def lcm(a,b):
    return (a*b)//franctions.gcd(a,b)

print(lcm(a,b))

Submission status: Runtime Error

Solution code:
from math import gcd
a,b = map(int,input().split())
print(gcd(a,b))

Submission status: Runtime Error

Solution code:
import math
def lcm(x, y):
    return (x * y) // math.gcd(x, y)
a, b = map(int, input().split())
print(lcm(a, b))

Submission status: Runtime Error

Solution code:
import math
a, b = map(int, input().split())

print(int(a*b / math.gcd(a,b)))

Submission status: Runtime Error

Solution code:
a = list(map(int, input().split()))
b = a[0]
while b % a[1] != 0:
  b += a[0]
print(b

Submission status: Runtime Error

Solution code:
from math import gcd

a = list(map(int, input().split()))
print((a[0] * a[1]) // math.gcd(a[0], a[1]))

Submission status: Runtime Error

Solution code:
import math

a = list(map(int, input().split()))
print((a[0] * a[1]) // math.gcd(a[0], a[1]))

Submission status: Runtime Error

Solution code:
import math

a = list(map(int, input().split()))
print((a[0] * a[1]) // math.gcd(a[0], a[1]))

Submission status: Runtime Error

Solution code:
def resolve():
    A, B = map(int, input().split())
    ans = []
    for i in range(1, min(A, B+1)):
        if A%i == 0 and B%i == 0:
            ans.append(i)
    print(A*B//ans[-1])
resolve()

Submission status: Runtime Error

Solution code:
def resolve():
    import math
    A, B = map(int, input().split())
    print(A*B//math.gcd(A, B))
resolve()

Submission status: Runtime Error

Solution code:
from math import gcd

a,b = map(int,input().split())
c = a*b//gcd(a,b)
print(c)

Submission status: Runtime Error

Solution code:
from math import gcd

a,b = map(int,input().split())
print(a*b//gcd(a,b))

Submission status: Runtime Error

Solution code:
import math
a,b=map(int,input().split())
print(int(a*b/math.gcd(a,b)))

Submission status: Runtime Error

Solution code:
import math

a, b = map(int, input().split())

print((a * b) // math.gcd(a, b))

Submission status: Runtime Error

Solution code:
import math
A,B = map(int,input().split())
print(int((A*B)/math.gcd(A,B)))

Submission status: Runtime Error

Solution code:
import math
A,B = map(int,input().split())
ans = (A*B)//(math.gcd(A,B))
print(ans)

Submission status: Runtime Error

Solution code:
import math
A,B = map(int,input().split())
print((A*B) // math.gcd(A,B))

Submission status: Runtime Error

Solution code:
import math
A,B = map(int,input().split())
print((A*B)//math.gcd(A,B))

Submission status: Runtime Error

Solution code:
import math

A, B = map(int, input().split())

print(A*B//math.gcd(A, B))

Submission status: Runtime Error

Solution code:
import math

A, B = map(int, input().split())

print(int(A*B/math.gcd(A, B)))

Submission status: Runtime Error

Solution code:
import math

def lcm(x,y):
    return (x*y)//math.gcd(x,y)

a,b=map(int,input().split())
ans=lcm(a,b)
print(ans)

Submission status: Runtime Error

Solution code:
from math import lcm
a,b=map(int,input().split())
print(lcm(a,b))

Submission status: Runtime Error

Solution code:
a,b=map(int,input().split())
import math
l=math.gcd(a,b)
print(int(a*b/l))

Submission status: Runtime Error

Solution code:
import math
a, b = map(int, input().split())

print((a*b)//math.gcd(a,b))

Submission status: Runtime Error

Solution code:
from math import gcd
a, b = map(int, input().split())

print((a*b)//gcd(a,b))

Submission status: Runtime Error

Solution code:
from math import gcd
a, b = map(int, input().split())

print(a*b//gcd(a,b))

Submission status: Runtime Error

Solution code:
import math

a, b = map(int, input().split())
print(int(a * b / math.gcd(a, b)))

Submission status: Runtime Error

Solution code:
import math
a,b = map(int,input().split())
def lcm(x, y):
    return (x * y) // math.gcd(x, y)

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
import math

a, b = map(int, input().split())

print(a * b // math.gcd(a, b))

Submission status: Runtime Error

Solution code:
import math
a,b = map(int,input().split())
ans = a * b // math.gcd(a, b)
print(ans)

Submission status: Runtime Error

Solution code:
from fractions import math
A,B=map(int,input().split())
print(A*B//math.gcd(A,B))

Submission status: Runtime Error

Solution code:
from fractions import math
A,B=map(int,input().split())
print(A*B/math.gcd(A,B))

Submission status: Runtime Error

Solution code:
import math
a, b = map(int, input().split())
print(a*b//math.gcd(a,b))

Submission status: Runtime Error

Solution code:
a,b = map(int,input().split())
import math
ans = a*b // math.gcd(a,b)
print(ans)

Submission status: Runtime Error

Solution code:
import math

A, B = map(int, input().split())

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

print(lcm(A,B))

Submission status: Runtime Error

Solution code:
from math import gcd
A, B = map(int, input().split())
print(gcd(A, B))

Submission status: Runtime Error

Solution code:
import math

a, b = map(int,input().split())

def lcm(x, y):
    return (x*y)//math.gcd(x,y)
    
tmp = lcm(a, b)
print(tmp)

Submission status: Runtime Error

Solution code:
import math

a, b = map(int,input().split())

def lcm(x, y):
    return (x*y)//math.gcd(x,y)
    
print(lcm(a, b))

Submission status: Runtime Error

Solution code:
from fractions import Fraction

a,b = map(int,input().split())

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
import math

a,b = map(int,input().split())

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
import math
from fractions import gcd
a, b = map(int, input().split())

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
import math

a, b = map(int, input().split())

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
from fractions import math

a , b = map(int,input().split())

print(a * b // math.gcd(a, b))

Submission status: Runtime Error

Solution code:
import math

a , b = map(int,input().split())

print(a * b // math.gcd(a, b))

Submission status: Runtime Error

Solution code:
a,b = map(int,input().split())
import math
print(a * b // math.gcd(a, b))

Submission status: Runtime Error

Solution code:
A, B = map(int, input().split())

import math

print(str((A * B)//math.gcd(A, B)))

Submission status: Runtime Error

Solution code:
A, B = map(int, input().split())

import math

print(str((A * B) // math.gcd(A, B)))

Submission status: Runtime Error

Solution code:
A, B = map(int, input().split())

import math
def lcm(x, y):
    return (x * y) // math.gcd(x, y)

print(lcm(A, B))

Submission status: Runtime Error

Solution code:
A, B = map(int, input().split())

import math

print(int((A * B )/math.gcd(A, B)))

Submission status: Runtime Error

Solution code:
A, B = map(int, input().split())

import math

print(int((A * B )//math.gcd(A, B)))

Submission status: Runtime Error

Solution code:
A, B = map(int, input().split())

import math

print((A * B)//math.gcd(A, B))

Submission status: Runtime Error

Solution code:
A, B = map(int, input().split())

import math

print((A * B )//math.gcd(A, B))

Submission status: Runtime Error

Solution code:
import math
a,b=map(int,input().split())
print((a * b) // math.gcd(a, b))

Submission status: Runtime Error

Solution code:
a,b=map(int,input().split())
import math
print(math.gcd(a, b))

Submission status: Runtime Error

Solution code:
import math

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

a, b = map(int, input().split())
print(lcm(a, b))

Submission status: Runtime Error

Solution code:
A,B=map(int,input().split())

import math

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

print(lcm(A,B))

Submission status: Runtime Error

Solution code:
import math
A,B=map(int,input().split())
c=A*B/math.gcd(A,B)
print(int(c))

Submission status: Runtime Error

Solution code:
import math
A,B=map(int,input().split())
c=A*B//math.gcd(A,B)
print(c)

Submission status: Runtime Error

Solution code:
import math

a , b = (int(x) for x in input().split())

result = math.gcd(a, b)

print((a * b) // result)

Submission status: Runtime Error

Solution code:
import math

a , b = (int(x) for x in input().split())

print((a * b) // math.gcd(a, b))

Submission status: Runtime Error

Solution code:
import math

a , b = (int(x) for x in input().split())

print((a * b) // math.gcd(a, b))

Submission status: Runtime Error

Solution code:
import math
a,b=map(int,input().split())
c=math.gcd(a,b)
ans=a*b/c
print(int(ans))

Submission status: Runtime Error

Solution code:
from math import gcd
a,b=map(int,input().split())
c=gcd(a,b)
ans=a*b/c
print(int(ans))

Submission status: Runtime Error

Solution code:
import math

def main():
    x, y = map(int, input().split())
    print(x*y // math.gcd(x,y))

if __name__ == '__main__':
    main()

Submission status: Runtime Error

Solution code:
import math
A, B = map(int, input().split())
print(int(A * B / math.gcd(A, B)))

Submission status: Runtime Error

Solution code:
import math

A, B = map(int, input().split())

print(int(A * B / math.gcd(A, B)))

Submission status: Runtime Error

Solution code:
import math

A, B = map(int, input().split())

print(math.gcd(A, B))

Submission status: Runtime Error

Solution code:
import math
A,B = map(int, input().split())
print(int(A*B//math.gcd(A,B)))

Submission status: Runtime Error

Solution code:
a,b = map(int,input().split())
import math
print(a*b//math.gcd(a,b))

Submission status: Runtime Error

Solution code:
import numpy as np
a,b=map(int,input().split())
print((a*b)//np.gcd(a,b))

Submission status: Runtime Error

Solution code:
import math
a,b=map(int,input().split())
def lcm(x, y):
    return (x * y) // math.gcd(x, y)

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
# import sys
import math
# import itertools
# from collections import deque
# from collections import defaultdict
# import heapq
# import copy
# import bisect
# import numpy as np
# from scipy.special import comb

# def my_input(): return sys.stdin.readline().rstrip()
# sys.setrecursionlimit(100000)
# INF = 1001001001001
# MOD = 1000000007


def main():

    A, B = map(int, input().split())
    print(A * B // math.gcd(A, B))


if __name__ == '__main__':
    main()

Submission status: Runtime Error

Solution code:
# C - Snack
# https://atcoder.jp/contests/abc148/tasks/abc148_c

from math import gcd

def lcm(x, y):
    return (x * y) // gcd(x, y)

a, b = map(int, input().split())
print(lcm(a, b))

Submission status: Runtime Error

Solution code:
A, B = map(int, input().split())

import math

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

print(lcm(A, B))

Submission status: Runtime Error

Solution code:
import math
a,b = map(int, input().split())
def lcm(x,y):
    return x*y / math.gcd(x,y)
print(lcm(a,b))

Submission status: Runtime Error

Solution code:
import math
a,b = map(int, input().split())
print(a*b / math.gcd(a,b))

Submission status: Runtime Error

Solution code:
import math
a,b = map(int, input().split())
print(a*b // math.gcd(a,b))

Submission status: Runtime Error

Solution code:
import fractions
A,B = map(int,input.split())
ans = fractions.gcd(A, B)
print(ans)

Submission status: Runtime Error

Solution code:
import math
a, b = map(int, input().split())
print(a * b // math.gcd(a, b))

Submission status: Runtime Error

Solution code:
from math import gcd

n, m = map(int, input().split())

print(n * m // gcd(n, m))

Submission status: Runtime Error

Solution code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
MOD = 10 ** 9 + 7

from math import gcd

A, B = map(int, input().split())

print (A * B // gcd(A, B))

Submission status: Runtime Error

Solution code:
import math
A, B=map(int, input().split())
print(A*B//math.gcd(A, B))

Submission status: Runtime Error

Solution code:
import math
A, B = map(int, input().split())
print(A * B / gcd(A, B))

Submission status: Runtime Error

Solution code:
from math import gcd
A, B = map(int, input().split())
print(A * B / gcd(A, B))

Submission status: Runtime Error

Solution code:
a, b = map(int, input().split())

import math
print(a*b//math.gcd(a, b))

Submission status: Runtime Error

Solution code:
import sys
import math

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

a, b = map(int, readline().split())
print(a * b // math.gcd(a,b))

Submission status: Runtime Error

Solution code:
import math
a,b = map(int,input().split())
if (a < b):
    if b % a == 0:
        print(b)
    else:
        print(b * (a // math.gcd(a, b)))
else:
    if a % b == 0:
        print(a)
    else:
        print(a * (b // math.gcd(a, b)))

Submission status: Runtime Error

Solution code:

import math
a, b = map(int, input().split())

print(int(a * b / math.gcd(a,b)))

Submission status: Runtime Error

Solution code:
import math
a, b = map(int, input().split())
print(a * b / math.gcd(a, b))

Submission status: Runtime Error

Solution code:
import math

A, B = map(int, input().split())
ans = A * B // math.gcd(A,B)

print(ans)

Submission status: Runtime Error

Solution code:
from math import gcd

def lcm(a, b):
    res = a*b / gcd(a, b)
    return res

a, b = map(int, input().split())
ans = int(lcm(a, b))
print(ans)

Submission status: Runtime Error

Solution code:
from math import gcd

def lcm(a, b):
    return a*b / gcd(a, b)

a, b = map(int, input().split())
ans = int(lcm(a, b))
print(ans)

Submission status: Runtime Error

Solution code:
def gcd(a, b):
    while True:
        a, b = b, a%b
        if b == 0:
            return

def lcm(a, b):
    return int((a*b) // gcd(a, b))

a, b = map(int, input().split())

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
import math

def lcm(a, b):
    return int((a*b) // math.gcd(a, b))

a, b = map(int, input().split())

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
import math

a, b = map(int, input().split())

print((a*b) // math.gcd(a, b))

Submission status: Runtime Error

Solution code:
import math

def lcm(a, b):
    return (a*b) // math.gcd(a, b)

a, b = map(int, input().split())

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
import math

#最小公倍数を求める
def lcm(a, b):
    return (a*b) // math.gcd(a, b)

a, b = map(int, input().split())

print(lcm(a, b))

Submission status: Runtime Error

Solution code:
# C - Snack
# https://atcoder.jp/contests/abc148/tasks/abc148_c

import math

# 最小公倍数を求める問題
A,B = map(int,input().split())

print(A * B // math.gcd(A, B))

Submission status: Runtime Error

Solution code:
# C - Snack
# https://atcoder.jp/contests/abc148/tasks/abc148_c

import math

# 最小公倍数を求める問題
A,B = map(int,input().split())

print(int(A * B / math.gcd(A, B)))