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: Runtime Error

Solution code:
import fractions
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 sys import stdin
import queue
import sys
import numpy

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

Submission status: Runtime Error

Solution code:
from sys import stdin
import queue
import sys
import math

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

Submission status: Runtime Error

Solution code:
from sys import stdin
import queue
import sys
import math

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

Submission status: Runtime Error

Solution code:
import math
# import numpy as np  # Pythonのみ！
# from operator import xor
# import re
# from scipy.sparse.csgraph import connected_components  # Pythonのみ！
# ↑cf.  https://note.nkmk.me/python-scipy-connected-components/
# from scipy.sparse import csr_matrix
# import string
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

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

resolve()

Submission status: Runtime Error

Solution code:
import math
# import numpy as np  # Pythonのみ！
# from operator import xor
# import re
# from scipy.sparse.csgraph import connected_components  # Pythonのみ！
# ↑cf.  https://note.nkmk.me/python-scipy-connected-components/
# from scipy.sparse import csr_matrix
# import string
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

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

Submission status: Runtime Error

Solution code:
import sys
import math

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

def lcm(x, y):
    return (x * y) // math.gcd(x, y)
    
A, B = lr()
print(lcm(A, B))

Submission status: Runtime Error

Solution code:
#!/usr/bin/env python3

import sys
import math
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
from itertools import count, cycle, repeat     # count(start[,step]), cycle(iter), repeat(elm[,n])
from itertools import groupby                  # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
from itertools import starmap                  # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product                # product(iter, repeat=n)
# from itertools import accumulate             # accumulate(iter[, f])
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy                    # to copy multi-dimentional matrix without reference


def main():
    mod = 1000000007                  # 10^9+7
    inf = float('inf')
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():  return int(input())
    def mi():  return map(int, input().split())
    def mi_0(): return map(lambda x: int(x)-1, input().split())
    def lmi(): return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():  return list(input())
    
    
    from fractions import gcd
    a, b = mi()
    # g = math.gcd(a, b)
    print(a * b // g)

if __name__ == "__main__":
    main()

Submission status: Runtime Error

Solution code:
#!/usr/bin/env python3

import sys
import math
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
from itertools import count, cycle, repeat     # count(start[,step]), cycle(iter), repeat(elm[,n])
from itertools import groupby                  # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
from itertools import starmap                  # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product                # product(iter, repeat=n)
# from itertools import accumulate             # accumulate(iter[, f])
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy                    # to copy multi-dimentional matrix without reference


def main():
    mod = 1000000007                  # 10^9+7
    inf = float('inf')
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():  return int(input())
    def mi():  return map(int, input().split())
    def mi_0(): return map(lambda x: int(x)-1, input().split())
    def lmi(): return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():  return list(input())
    
    
    a, b = mi()
    g = math.gcd(a, b)
    print(a * b // g)

if __name__ == "__main__":
    main()

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math
def lcm(x, y):
    return x // math.gcd(x, y) * y
a,b = map(int,input().split())
print(lcm(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
#入力:N(int:整数)
def input1():
	return int(input())

#入力:N,M(int:整数)
def input2():
	return map(int,input().split())

#入力:[n1,n2,...nk](int:整数配列)
def input_array():
	return list(map(int,input().split()))




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


a,b=input2()

print(lcm(a,b))

Submission status: Runtime Error

Solution code:
import math
#入力:N(int:整数)
def input1():
	return int(input())

#入力:N,M(int:整数)
def input2():
	return map(int,input().split())

#入力:[n1,n2,...nk](int:整数配列)
def input_array():
	return list(map(int,input().split()))




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


a,b=input2()

print(lcm(a,b))

Submission status: Runtime Error

Solution code:
import math
#入力:N(int:整数)
def input1():
	return int(input())

#入力:N,M(int:整数)
def input2():
	return map(int,input().split())

#入力:[n1,n2,...nk](int:整数配列)
def input_array():
	return list(map(int,input().split()))




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


a,b=input2()

print(lcm(a,b))

Submission status: Runtime Error

Solution code:
import sys
import math
sys.setrecursionlimit(20000000)


a,b=[int(i) for i in input().split()]

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

Submission status: Runtime Error

Solution code:
import sys

sys.setrecursionlimit(20000000)


a,b=[int(i) for i in input().split()]
import math
print(a*b//math.gcd(a,b))

Submission status: Runtime Error

Solution code:
import sys

sys.sys.setrecursionlimit(20000000)


a,b=[int(i) for i in input().split()]
import math
print(a*b//math.gcd(a,b))

Submission status: Runtime Error

Solution code:
a,b=[int(i) for i in input().split()]
import math
print(a*b//math.gcd(a,b))

Submission status: Runtime Error

Solution code:
import math

a,b=[int(i) for i in input().split()]
print(math.gcd(a,b))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
A, B = map(int, input().split())
from fraction import gcd
 
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:
A, B = map(int, input().split())
import math
C = math.gcd(A, B)
print(A * B // C)

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())
g=math.gcd(a,b)
print(a*b//g)

Submission status: Runtime Error

Solution code:
A,B=map(int,input().split())
if A>=B:
    x,y=A,B
else:
    x,y=B,A
i=1
while if x*i%y==0:
    i+=1
print(x*i)

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:
a,b=map(int,input().split())
import math
print(math.gcd(a,b))

Submission status: Runtime Error

Solution code:
from math import gcd

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

Submission status: Runtime Error

Solution code:
import math

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

def lcm(x, y):
    return x // gcd(x, y) * 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 // math.gcd(x, y) * 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 // math.gcd(x, y)* 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:
#!/usr/bin/env python3
import sys
import numpy as np
import math

def solve(A: int, B: int):
    print(A*B//math.gcd(A,B))
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    solve(A, B)

if __name__ == '__main__':
    main()

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

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

print(lcm(A,B))

Submission status: Runtime Error

Solution code:
import numpy as np

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

print(np.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:
a, b = map(int, input().split())
print(a * b / gcd(a, b))

Submission status: Runtime Error

Solution code:
def gcd(a,b):
    if a==0 or b==0:
        return max([a,b])
    else:
        if a>=b:
            return gcd(a-b,b)
        else:
            return gcd(a,b-a)

def lcm(a,b):
   return int(a*b/gcd(a,b)) 
a=input().split(" ")
print(lcm(int(a[0]),int(a[1])))

Submission status: Runtime Error

Solution code:
import math

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

gcb=math.gcd(A,B)

print(int(A*B/gcb))

Submission status: Runtime Error

Solution code:
def lcm(a,b):
    if a==0 or b==0:
        return max([a,b])
    else:
        if a>=b:
            return lcm(a-b,b)
        else:
            return lcm(a,b-a)
a=input().split(" ")
print(lcm(int(a[0]),int(a[1])))

Submission status: Runtime Error

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

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:
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())
from math import gcd
print(a * b / (gcd(a,b)))

Submission status: Runtime Error

Solution code:
import fraction 
X,Y = map(int, input().split())
def lcm(x, y):
    return (x * y) // fraction.gcd(x, y)
print(lcm(X,Y))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
A, B = list(map(int,input().split()))
if A % B == 0:
  print(A)
elif B % A = 0:
  print(B)
else:
  print(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:
a, b = map(int, intput().split())
import math
print(a*b//math.gcd(a,b))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import math

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

#c=int((a*b)/math.gcd(a,b))
c=math.gcd(a,b)

print(c)

Submission status: Runtime Error

Solution code:
num1, num2 = map(int, input().split())

import math
def factor(num):
  l = []
  a = math.ceil(math.sqrt(num))
  for i in range(2,a):
    if num%i==0:
      l.append(i)
  return l

l1 = factor(num1)
l2 = factor(num2)
l = set(l1,l2)

ans = 1
for _ in l:
  ans = ans * _
  
print(ans)

Submission status: Runtime Error

Solution code:
import math

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

c=int((a*b)/math.gcd(a,b))

c=0
print(c)

Submission status: Runtime Error

Solution code:
import math

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

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

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:
n1, n2 = map(int, input().split())
import math
print(math.gcd(n1,n2))

Submission status: Runtime Error

Solution code:
#!/usr/bin/env python3
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())
f=math.gcd(a,b)
f2=a*b//f
print(f2)

Submission status: Runtime Error

Solution code:
import fractions

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

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

Submission status: Runtime Error

Solution code:
import math

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

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

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:
A,B = map(int, input().split())
import math
print((A*B)//math.gcd(A,B))

Submission status: Runtime Error

Solution code:
import fractions

# 入力
A,B = map(int,input().split())

print(int((A * B) // math.fractions(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(int(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 math import gcd
def lcm(a, b):
    return a * b / gcd(a,b)
a, b = map(int, input().split())
print(int(lcm(a, b)))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import fractions
a,b=map(int, input().split())
f2=a*b//f # 最小公倍数はf2
print(f2)

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(123,456))

Submission status: Runtime Error

Solution code:
#!/usr/local/bin python
# -*- coding: utf-8 -*-
#
# ~/PycharmProjects/atcoder/C-Snack.py
#
import math

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

Submission status: Runtime Error

Solution code:
#!/usr/local/bin python
# -*- coding: utf-8 -*-
#
# ~/PycharmProjects/atcoder/C-Snack.py
#
import math

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


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


print(int(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:
from fracitons 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:
a,b = map(int, input().split())

ans = a * b
for i in range(a)
if ans % i**2:
	ans = ans // i
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:
#ABC148.C
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:
#ABC148.C
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())
ans = a*b/math.gcd(a,b)
print(int(ans))

#LCM = X*Y/GCD
#LCM = 最小公倍数
#GCD = 最大公約数

Submission status: Runtime Error

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

#LCM = X*Y/GCD
#LCM = 最小公倍数
#GCD = 最大公約数

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:
a,b = map(int, input().split())

import math
lcm = (a * b) / math.gcd(a, b)

lcm = int(lcm)

print(lcm)

Submission status: Runtime Error

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

lcm = int(lcm)
print(lcm)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

import math

lcm = a * b / math.gcd(a, b)

print(int(lcm))

Submission status: Runtime Error

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

if a < b:
    ttt = a
else:
    ttt = b
    
num_list = [1]
for i in range(2,ttt+1):
    mod_a = a % i
    mod_b = b % i
    if mod_a == 0 and mod_b == 0:
        c.append(i)

import numpy as np
if sum(c) == 1:
    print(a*b)
else:
    print(np.prod(np.array(c)))

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
from fractions import gcd

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

Submission status: Runtime Error

Solution code:
import math
A, B = 3, 4
lcm = A//math.gcd(A, B)*B

print(lcm)

Submission status: Runtime Error

Solution code:
from fractions import gcd

A, B = map(int, input().split())
lcm = A*B//fractions.gcd(A, B)

print(lcm)

Submission status: Runtime Error

Solution code:
from fractions import gcd

A, B = map(int, input().split())
lcm = A//fractions.gcd(A, B)*B

print(lcm)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
N=input()
S,T=input().split()
print(*[s+t for s,t in zip(S,T)],sep="")

Submission status: Runtime Error

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

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

Submission status: Runtime Error

Solution code:
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(a,b):
    return (a*b)//math.gcd(a,b)

print(lcm(a,b))

Submission status: Runtime Error

Solution code:
import numpy as np

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

print(np.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:
if B == 1:
  print(A)
  exit()
C = A*B
D = []
for i in range(1,int(math.sqrt(C))):
  if A % i == 0 and B % i == 0:
    A = A // i
    B = B // i
    D.append(i)
    C = A*B
for j in range(1,int(math.sqrt(C))):
  if A % j == 0 and B % j == 0:
    A = A // j
    B = B // j
    D.append(j)
    C = A*B
for k in range(1,int(math.sqrt(C))):
  if A % k == 0 and B % k == 0:
    A = A // k
    B = B // k
    D.append(k)
    C = A*B
p = np.prod(D)
if p != 0:
  C = C*p
print(C)

Submission status: Runtime Error

Solution code:
import math

data = input().split()
val = [int(n) for n in data]

res = val[0] * val[1] / math.gcd(val[0], val[1])

print(res)

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(int(lcm(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(int(lcm(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 numpy as np
# A,B = map(int,input().split())
# print(np.lcm(A,B))
# numpyのlcm関数は新しく追加された関数であり、AtCoderでは使用不可
import math

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

def lcm(A,B):
    return A * B // math.gcd(A,B)

print(lcm(A,B))

Submission status: Runtime Error

Solution code:
import numpy as np

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

print(np.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:
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 gcd
#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:
#!/usr/bin/env python3
import sys
import math


def solve(A: int, B: int):
    print(lcm(A, B))
    return


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


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    solve(A, B)

if __name__ == '__main__':
    main()

Submission status: Runtime Error

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

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

print(int(lcm(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(int(lcm(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(int(lcm(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(int(lcm(a,b)))

Submission status: Runtime Error

Solution code:
from math import gcd

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

print(ans)

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())
ans = a * b // math.gcd(a, b)

print(ans)

Submission status: Runtime Error

Solution code:
A,B = map(int,input().split())
import math
L = int(A / math.gcd(A, B) * B)
print(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 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

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

def lcm(A, B):
    return (A * B) // math.gcd(A, B)

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:
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)

print(lcm(A,B))

Submission status: Runtime Error

Solution code:
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 (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(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:
from sys import stdin
import math

a, b = [int(x) for x in stdin.readline().rstrip().split()]

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

Submission status: Runtime Error

Solution code:
import sys
input = sys.stdin.readline
import numpy as np

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

print(int(np.lcm(A,B)))

Submission status: Runtime Error

Solution code:
import sys
input = sys.stdin.readline
import math

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

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

Submission status: Runtime Error

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

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

if __name__ == '__main__':
	main()

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

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

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

if __name__ == '__main__':
    main()

Submission status: Runtime Error

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

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

if __name__ == '__main__':
    main()