다시 올립니다. 
    public static int SqureBoard(int length, int height)
    {

        if(length>height)
        {
            length = length-height;
        }
        else if(length<height)
        {
            height = height-length;
        }
        else
        {
            return length;
        }

        return SqureBoard(length,height);
    }

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int l = 640, h =400;
        int a = SqureBoard(l,h); // a=80
        int squre = (l/a)*(h/a);    //흠....
        System.out.print(squre);

    }

}

from math import gcd

n1, n2 = 1980, 640
print(n1 * n2 // gcd(n1, n2)**2)

public static void main(String[] args) {
        int a = 1980;
        int b = 640;
        System.out.println((a * b) / (int) Math.pow(gcd(a, b), 2));
    }

    private static int gcd(int a, int b) {
        while (b != 0) {
            int temp = a % b;
            a = b;
            b = temp;
        }
        return a;
    }

파이썬입니다.

a, b = tuple(map(int, input('토지의 가로 세로 길이를 입력하세요 ex) 120 260 \n 입력 : ').split()))
c = a*b
while a: a, b = max(a, b) % min(a, b), min(a, b)   # n = gcd(a, b) = b
print(c/b**2)             # result = a/gcd(a,b) * b/gcd(a,b) = a*b / gcd(a,b)**2

결과

토지의 가로 세로 길이를 입력하세요 ex) 120 260 
 입력 : 1980 640
3168.0

파이썬으로

import re

a, b = [int(x) for x in re.findall("[0-9]+", input("토지 너비*길이를 입력하세요: "))[:2]]  # 첫 두 개의 정수를 a,b에

gcd = lambda x,y: x if x == y else gcd(max(x, y)-min(x,y), min(x,y))  # 최대공약수 (유클리드)

print("%d" % (a/gcd(a,b) * b/gcd(a,b)))

#include <stdlib.h>
#include <stdio.h>

int min( int x, int y )
{
    if( x <= y ) return x;
    else return y;
}

int max( int x, int y )
{
    if( x >= y ) return x;
    else return y;
}

int main(int argc, char * argv[])
{
    int i, num;
    int x = atoi(argv[1]);
    int y = atoi(argv[2]);
    int max_common_divisor = 1;
    int min_num = min(x,y);
    int max_num = max(x,y);

retry:
    num = max_num % min_num;
    if( num == 0 )
    {
        max_common_divisor = min_num;
    }
    else
    {
        max_num = min_num;
        min_num = num;
        goto retry;
    }

    printf("max common divisor : %d\n", max_common_divisor);
    printf("plant number : %d\n", (x * y) / (max_common_divisor*max_common_divisor));
    return 0;
}

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

w = int(input('농장 가로 길이: '))
h = int(input('농장 세로 길이: '))
n = gcd(w,h)
print('최대식물수: {}'.format(w/n*h/n))

using System;
using System.Collections.Generic;
using System.Linq;

namespace CD169
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("토지의 가로 세로 길이 입력 (ex. 640 400): ");
            // split on whitespace
            var input = Console.ReadLine()
                .Split(new char[0], StringSplitOptions.RemoveEmptyEntries).ToList(); 
            var landSize = new List<int>();
            input.ForEach(item => landSize.Add(int.Parse(item)));

            int a = landSize.Max(), b = landSize.Min();
            int landArea = a * b, plantArea = GCD(a, b) * GCD(a, b);
            Console.WriteLine((int)(landArea/plantArea));
        }

        // a, b (a > b)의 최대공약수(유클리드 호제법)
        static int GCD(int a, int b)
        {
            if (b == 0) { return a; }
            else { return GCD(b, a % b); }
        }
    }
}

최대공약수 함수는 써보고 싶지 않아서.......

def square(a,b):
          Max = max(a,b)
          Min = min(a,b)
          n = Max%Min
          if n != 0:
                    square(Min,n)
          else:
                    print(Min)

from math import gcd

a, b = 1980, 640
print(a * b // gcd(a, b)**2)
5

// ========================================
        int num1 = 640;
        int num2 = 400;

        int a = gcd(num1, num2);
        System.out.println((num1 * num2) / (a * a));
    }

    public static int gcd(int a, int b) {

        while (b != 0) {

            int temp = a % b;
            a = b;
            b = temp;

        }
        return Math.abs(a);
    }

def num_plant(x, y):
    G = gcd(x, y)
    return (x // G) * (y // G)

import java.util.Scanner;
public class GCD {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
            System.out.print("첫번째 값 : ");       
            int fir = input.nextInt();
            System.out.print("두번째 값 : ");       
            int sec = input.nextInt();
        for (int i = Math.min(fir,sec);i>0;i--){
            if ((fir%i==0)&&(sec%i==0)){
            System.out.println(i);
            break;

            }
        }
    }
}

number = list(map(int, input("두 자연수 입력 : ").split()))
big_box = []
for i in number :
    small_box = []
    x = 2
    while i > 1 :
        if i % x == 0 :
            i = i // x
            small_box.append(x)
        else : x += 1
    big_box.append(small_box)
    print(small_box)
print(big_box)
big_box.append(set(big_box[0]+big_box[1]))
print(big_box)

tmp = 1
for i in big_box[2] :
    if i in big_box[0] or big_box[1] :
        tmp *= (i**min(big_box[0].count(i), big_box[1].count(i)))
print(tmp)
print((eval('*'.join(map(str,big_box[0]))) / tmp) * (eval('*'.join(map(str,big_box[1]))) / tmp))

import math


area = input("'가로 세로'식으로 입력 ").split()


def divisor_make(n):
    divisor_list = set()
    for i in range(1, int(math.sqrt(n)) + 1):
        if n % i == 0:
            divisor_list.add(i)
            divisor_list.add(n//i)
    return divisor_list


max_divisor = max(divisor_make(int(area[0])) & divisor_make(int(area[1])))

print(int(int(area[0])/max_divisor)*int(int(area[1])/max_divisor))

num=input("가로 세로를 입력하시오:")
num_arr=list(num.split())
for x in range(0,len(num_arr)):
    num_arr[x]=int(num_arr[x])
if num_arr[0]%2==0 and num_arr[1]%2==0:
    while num_arr[0]%2==0 and num_arr[1]%2==0:
        num_arr[0]=num_arr[0]/2
        num_arr[1]=num_arr[1]/2
if num_arr[0]%3==0 and num_arr[1]%3==0:
    while num_arr[0]%3==0 and num_arr[1]%3==0:
        num_arr[0]/=3
        num_arr[1]/=3
if num_arr[0]%5==0 and num_arr[1]%5==0:
    while num_arr[0]%5==0 and num_arr[1]%5==0:
        num_arr[0]/=5
        num_arr[1]/=5
if num_arr[0]%7==0 and num_arr[1]%7==0:
    while num_arr[0]%7==0 and num_arr[1]%7==0:
        num_arr[0]/=7
        num_arr[1]/=7   
print(int(num_arr[0]*num_arr[1]))

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

N1 = int(input("농장의 가로길이 : "))
N2 = int(input("농장의 세로길이 : "))

def gcd(a, b) :
    if a > b :
        (a, b) = (b, a)
    while b != 0 :
        (a, b) = (b, a % b)
    return a

result = N1 * N2 / (gcd(N1, N2) * gcd(N1, N2))

print(round(result))

파이썬입니다

def gcd(a, b):
    if a < b:
        return gcd(b,a)
    if a%b== 0:
        return b
    return gcd(b, a%b)

def square(a, b):
    g = gcd(a, b)
    n = (a*b)/(g*g)
    print(n)

w, h =map(int,input('가로와 세로를 입력하세요: ').split(' '))
square(w, h)

list_0 = list(map(int, input().split()))
def Function(num):
    share = []
    while num > 1:
        for i in range(2, num+1):
            if num%i == 0:
                share.append(i)
                num = num//i
                break
    return share
set_1 = set()
list_1 = []
list_2 = []
list_3 = []
dict = {}
for i in list_0:
    a = Function(i)
    set_1 = set_1 | set(a)
    list_1.append(a)

for i in set_1:
    for j in range(len(list_1)):
        list_2.append(list_1[j].count(i))
    list_3.append(int(min(list_2)))
    list_2 = []
set_1 = list(set_1)
for i in range(len(set_1)):
    dict[set_1[i]] = list_3[i]
result = 1
for i in dict.keys():
    result *= i**dict[i]
print(int((list_0[0]*list_0[1])/(result**2)))

파이썬코드의 장점이 사라진 코드...

def gcd(a,b):
    value = min(a,b)
    while True :
        if a % value ==0 and b % value ==0:
            return value
        else :
            value -= 1

cd1 = int(input("농장 가로 입력 : "))
cd2 = int(input("농장 세로 입력 : "))
gcd_value = gcd(cd1,cd2)
result = int(cd1/gcd_value * cd2/gcd_value)
print(result)

#include <math.h>
int the_greatest_common_denominator(int a,b)
{
int result = 1;
int ArraySizeCount1 = 0, ArraySizeCount2 = 0;
int *a_denominator_Array = new int;
int *b_denominator_Array = new int;
while(a!=1)
{
for(int i =2; i<a;i++)
{
a%i == 0 ? a = a/i, a_denominator_Array[i]++ , i>ArraySizeCount1? ArraySizeCount1=i:0; : 0;
}
}
while(b!=1)
{
for(int i =2; i<b;i++)
{
b%i == 0 ? b= b/i, b_denominator_Array[i]++ , i>ArraySizeCount2? ArraySizeCount2=i:0; : 0;
}
}
int count = 0;
sizeof(a_denominator_Array) > sizeof(b_denominator_Array) ? count = sizeof(a_denominator_Array)/ sizeof(int): count = sizeof(b_denominator_Array)/ sizeof(int) ; 

for(int i =2;i<count;i++)
{
a_denominator_Array[i] > b_denominator_Array[i] && b_denominator_Array[i] >0 ? result*=(int)pow(i,b_denominator_Array[i]): 0;
b_denominator_Array[i] > a_denominator_Array[i] && a_denominator_Array[i] >0 ? result*=(int)pow(i,a_denominator_Array[i]): 0;
}
}
delete a_denominator_Array,b_denominator_Array;
return result;
}

h=int(input("가로의 길이를 입력하십시오: "))
v=int(input("세로의 길이를 입력하십시오: "))
# 두 수의 최대 공약수를 찾아서 가로, 세로를 각 각 나눈 결과를 곱하면 됨.
n=1
lst=[]
while n<v:
    if h%n==0 and v%n==0:
        lst.append(n)  #max(lst)가 최대 공약수
    n+=1
print(int((h/max(lst))*(v/max(lst)))) #(가로/최대공약수) x (세로/최대공약수)

a = int(input("가로:"))

b = int(input("세로:"))

gongyaksu=[]

for i in range(1, min(a,b)+1):

    if a%i ==0 and b%i == 0:

        gongyaksu.append(i)

    else: continue


print(int((a/max(gongyaksu))*(b/max(gongyaksu))))

from math import gcd

a = int(input()) b = int(input())

A = gcd(a, b) B = (ab)//(A*2) print(B)

def sep(a, b):
    for i in range(1, min(a, b)+1):
        if a%i==0 and b%i==0:
            max=i
    return a*b/max**2

def cal_plants_num(x, y):
    area = x * y
    gcd = max([i for i in range(1, max(x, y)) if x % i == 0 and y % i == 0])

    result = area // gcd ** 2
    return result


# answer: 40
case1 = 640, 400

# answer: 3168
case2 = (1980, 640)

if __name__ == "__main__":
    print(cal_plants_num(640, 400))
    print(cal_plants_num(1980, 640))

import java.util.ArrayList;
import java.util.Scanner;

public class Q168{
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        ArrayList<Integer> input = new ArrayList<Integer>();
        System.out.print("a? : ");
        input.add(scan.nextInt());
        System.out.print("b? : ");
        input.add(scan.nextInt());
        int temp;
        for(int i=2;; i++) {
            temp = input.get(i-2)%input.get(i-1);
            if(temp!=0) {
                input.add(temp);
            } else {
                break;
            }
        }

        System.out.println(input.get(0)*input.get(1)/(int)Math.pow(input.get(input.size()-1), 2));
    }
}

from math import gcd

class GetNumPlant:
    def __init__(self):
        self.num = 0
    def calNum(self,w,h):
        self.num = w*h/gcd(w,h)**2
        print (self.num)

a = GetNumPlant()
a.calNum(640,400)

def sosu(num):
    result = []

    for i in range(1,int(num)+1):
        if int(num) % i == 0:
            result.append(i)

    if len(set(result)) == 2:
        return True


def insu(num):
    temp = int(num)
    result = []
    result2 = []
    while temp != 1:
        for i in range(2,temp+1):
            if temp % i == 0 and sosu(i):
                result.append(i)
                temp = temp // i

    result.sort()
    result1 = list(set(result))
    result1.sort()

    for aa in result1:
        count = 0
        for bb in result:
            if bb == aa:
                count += 1
        result2.append(count)

    return [result1, result2]

def part(num):
    ins = []
    full = {}

    for aa in insu(num)[0]:
        if aa not in ins:
            ins.append(aa)
            full[aa] = insu(num)[1][insu(num)[0].index(aa)]

        if insu(num)[1][insu(num)[0].index(aa)] > full[aa]:
            continue

    return full

def gcd(a,b):
    _a = part(a)
    _b = part(b)
    result = {}

    for i in _a.keys():
        if i in _b:
            result[i] = min(_a[i],_b[i])
        else:
            result[1] = 1

    mult = 1
    for j in result.keys():
        mult = mult*(j**result[j])

    return mult

n1 = 1980
n2 = 640
print(n1/gcd(n1,n2)*n2/gcd(n1,n2))

from math import *

farm=input("write your farm [a,b] :")

for_farm=farm.split(",")

ggccdd=gcd(int(for_farm[0]),int(for_farm[1]))

first=int(for_farm[0])/ggccdd

second=int(for_farm[1])/ggccdd

print(first*second)

def farm(a, b):
    c = max(set([i for i in range(1, a + 1) if a % i == 0]) & set([i for i in range(1, b + 1) if b % i == 0]))
    return (a/c) * (b/c)


print(farm(640, 400))
print(farm(1980, 640))

from math import gcd
a = input().split(" ")
a1,a2 = int(a[0]),int(a[1])
new_gcd = gcd(a1,a2)

print(a1//new_gcd * a2//new_gcd)

x=int(input('가로'))
y=int(input('세로'))

common=[]

for i in range(1,x+1):
    if x % i == 0 and y % i == 0:
        common.append(i)

big=common[-1]

print(int((x/big) * (y/big)))

def dividing_to_max(a,b):
    gcd_out = math.gcd(int(a),int(b))
    return int(int(a)*int(b)/(gcd_out**2))

from math import gcd
def maxi(a,b):
    length = gcd(a,b)
    return print((a/length)*(b/length))

#codingdojing_farm_partition

#각 변의 최대공약수를 구한뒤 최종 넓이에서 나누어 준다.

def gcd(a, b):  #a/b = q r , b/r이 0인 r의 값

    if a%b == 0:
        return b
    else:
        return gcd(b, a%b)

a, b = map(eval,input('a, b: ').split(','))

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