๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
Algorithm/Kotlin

[ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค • ์ฝ”ํ‹€๋ฆฐ] [์œ ํด๋ฆฐ๋“œ ํ˜ธ์ œ๋ฒ•]์ตœ๋Œ€๊ณต์•ฝ์ˆ˜์™€ ์ตœ์†Œ๊ณต๋ฐฐ์ˆ˜ #12940

by ํ‚ค์œค 2023. 11. 20.

#12940

๐ŸŽ„ Question ?

https://school.programmers.co.kr/learn/courses/30/lessons/12940

class Solution {
    fun solution(n: Int, m: Int): IntArray {
        var answer = intArrayOf()
        return answer
    }
}

๐Ÿงฉ Thought Process

  1. ์ตœ๋Œ€ ๊ณต์•ฝ์ˆ˜ variable์„ gcd(Greatest Common Divisor์˜ ์•ฝ์ž) ๋กœ ์ €์žฅํ•ด์ฃผ๊ณ  ์ดˆ๊ธฐ๊ฐ’์„ 1๋กœ ํ•œ๋‹ค.
  2. ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜ ์ฐพ๊ธฐ ๊ฐ€์žฅ ๋จผ์ € m์ด๋‚˜ n ์ค‘ ํฐ์ˆ˜๋ฅผ ์ž‘์€์ˆ˜๋กœ ๋‚˜๋ˆ„์–ด๋ณด๊ธฐ ! ๋‚˜๋ˆ„์–ด์ง€๋ฉด ์ž‘์€ ์ˆ˜๊ฐ€ ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜์ด๋‹ค!
  3. ๋งŒ์•ฝ ๋‚˜๋ˆ„์–ด์ง€์ง€ ์•Š๋Š”๋‹ค๋ฉด ์ž‘์€ ์ˆ˜์˜ ๊ฐ’์„ 1์”ฉ ์ค„์—ฌ๊ฐ€๋ฉฐ ํฐ์ˆ˜๋ฅผ ๋‚˜๋ˆ„์–ด์ค€๋‹ค. ๋‚˜๋ˆ„์–ด ๋–จ์–ด์ง€๋Š” ์ˆ˜๊ฐ€ ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜ !
  4. ์ตœ์†Œ ๊ณต๋ฐฐ์ˆ˜ variable ์„ lcm(Least Common Multiple ์˜ ์•ฝ์ž)๋ผ๊ณ  ๋‘”๊ณ  ์ดˆ๊ธฐ๊ฐ’์œผ๋กœ 1์„ ๋ถ€์—ฌํ•œ๋‹ค.
  5. ๊ฐ m ๊ณผ n์„ ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜๋กœ ๋‚˜๋ˆ„์–ด์ฃผ๊ณ  lcm์— ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜๋ฅผ ๊ณฑํ•ด์ค€๋‹ค.
  6. ์ตœ๋Œ€ ๊ณต์•ฝ์ˆ˜์˜ ๊ฐ’์„ 1์”ฉ ์ค„์—ฌ๊ฐ€๋ฉด์„œ ์ด๋ฏธ ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜๋กœ ๋‚˜๋ˆ„์–ด์ง„ m๊ณผ n์˜ ๊ฐ’์„ ๋‚˜๋ˆ„์–ด๋ณด๊ณ  ๋‘˜๋‹ค ๊ณตํ†ต์œผ๋กœ ๋‚˜๋ˆ„์–ด์ง€๋Š” ๊ฒฝ์šฐ์—๋Š” m๊ณผ n์˜ ๊ฐ’์„ ์‹ค์ œ๋กœ ๋‚˜๋ˆ„์–ด์ฃผ๊ณ  ๊ทธ ๊ฐ’์„ lcm์— ๊ณฑํ•ด์ค€๋‹ค.
  7. ๋‚˜๋ˆ„๋Š” ๊ฐ’์ด 2๊ฐ€ ๋ ๋•Œ๊นŒ์ง€ ๋‚˜๋ˆ„์–ด๋ณด๊ณ  ๋‚จ์€ n๊ณผ m์˜ ๊ฐ’์„ lcm์— ๋‘˜๋‹ค ๊ณฑํ•ด์ฃผ๋ฉด ์ตœ์†Œ๊ณต๋ฐฐ์ˆ˜๋ฅผ ์ฐพ์„ ์ˆ˜ ์žˆ๋‹ค!!
  8. ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜์™€ ์ตœ์†Œ๊ณต๋ฐฐ์ˆ˜๋ฅผ intArray์— ๋„ฃ์–ด ์ €์žฅํ•ด์ฃผ๊ณ  ๋ฆฌํ„ดํ•œ๋‹ค!
import kotlin.math.*

class Solution {
    fun solution(n: Int, m: Int): IntArray {
        var gcd = 1
        var lcm = 1
        var N = n
        var M = m
        
        // ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜ ์ฐพ๋Š” ์ฝ”๋“œ
        if (m%n == 0 || n%m == 0) {
            gcd = minOf(n, m)
        } else {
            for(i in 1 until minOf(n, m)-1) {
                if (maxOf(m, n)%(minOf(m, n)-i) == 0) {
                    gcd = minOf(n, m) - i
                    break
                } 
            }
        }
        // ์ตœ์†Œ ๊ณต๋ฐฐ์ˆ˜ ์ฐพ๋Š” ์ฝ”๋“œ
        for (j in 0 until gcd) {
            if ((M % (gcd - j) == 0) && (N % (gcd - j) == 0)) {
                N /= (gcd - j)
                M /= (gcd - j)
                lcm *= (gcd - j)
            }
        }
        lcm = lcm*M*N
        
        return intArrayOf(gcd, lcm)
    }
}

ํ…Œ์ŠคํŠธ ๋Œ€ ์‹คํŒจ ํ–ˆ๋‹น 25์ ์ด ๋ชจ์•ผ...ใ…œ

๋ญ๊ฐ€ ์ž˜๋ชป ๋œ๊ฑธ๊นŒ... ํ์Œ

another try:

import kotlin.math.*

class Solution {
    fun solution(n: Int, m: Int): IntArray {
        var answer = mutableListOf<Int>()

        if (n - m == 0) {
            answer.add(n)
        } else {
            var Max = maxOf(n, m)
            var Min = minOf(n, m)
            if (Max % Min == 0) {
                answer.add(Min)
            } else {
                for (i in 1 until Min) {
                    if (Max % (Min - i) == 0) {
                        answer.add(Min - i)
                        break
                }
            }
        }
        }
        answer.add(n*m/answer[0])
        return answer.toIntArray()
    }
}

minOf์™€ maxOfํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ ์•ˆ ์— ๋“ค์–ด๊ฐ€๋Š” ๊ฐ’์ด ๊ฐ™์€ ๊ฒฝ์šฐ๋ฅผ ๋”ฐ์ง€์ง€ ์•Š์•˜์–ด์„œ ๊ทธ ๊ฒฝ์šฐ๋ฅผ ์ถ”๊ฐ€ํ•˜๋‹ˆ ์—๋Ÿฌ๊ฐ€ ์ค„์—ˆ๋‹ค. ๊ทธ๋Ÿฐ๋ฐ ์—ฌ์ „ํžˆ ๋งŒ์ ์ด ์•ˆ๋‚˜์™”๋‹ค. ๊ฒฐ๊ตญ ๋‹ต ํ™•์ธ...

๐ŸŽ€ Answer

ํ•ด์„ค #1 ์œ ํด๋ฆฌ๋“œ ํ˜ธ์ œ๋ฒ• ์ด์šฉ

https://ko.wikipedia.org/wiki/%EC%9C%A0%ED%81%B4%EB%A6%AC%EB%93%9C_%ED%98%B8%EC%A0%9C%EB%B2%95

์œ ํด๋ฆฌ๋“œ ํ˜ธ์ œ๋ฒ• ๊ฐ„๋‹จ ์„ค๋ช…: ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜ ๊ณ„์‚ฐ ๋ฒ•. n๊ณผ m์˜ ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜๋Š” n์„ m (n>m)์œผ๋กœ ๋‚˜๋ˆ„์—ˆ์„ ๋•Œ ์˜ ๋‚˜๋จธ์ง€ r๊ณผ m์˜ ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜์™€ ๊ฐ™๋‹ค. ๊ทธ ๋‹ค์Œ m๊ณผ r์˜ ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜๋Š” m์„ r๋กœ ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€์™€ r์˜ ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜์™€ ๊ฐ™์„ ๊ฒƒ์ด๋‹ค.

// ๋‘ ๊ฐ’ a์™€ b๋ฅผ ์ธํ’‹ํ–ˆ์„ ๋•Œ ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•ด์ฃผ๋Š” ํ•จ์ˆ˜ ์ •์˜
fun gcd(a: Int, b:Int): Int = if(b != 0) gcd(b, a % b) else a
// b๊ฐ€ 0์ด ์•„๋‹Œ ๊ฒฝ์šฐ ํ•จ์ˆ˜ gcd๊ฐ€ ๋ฐ˜๋ณต๋˜๋„๋ก ์งœ์—ฌ์žˆ๋‹ค.

fun main(args : Array<String>) {
    var x = 4
    var y = 10
    println("์ตœ๋Œ€ ๊ณต์•ฝ์ˆ˜ : ${gcd(x, y)}")
    println("์ตœ์†Œ ๊ณต๋ฐฐ์ˆ˜ : ${x * y / gcd(x, y)}")

    x = 28
    y = 16
    println("์ตœ๋Œ€ ๊ณต์•ฝ์ˆ˜ : ${gcd(x, y)}")
    println("์ตœ์†Œ ๊ณต๋ฐฐ์ˆ˜ : ${x * y / gcd(x, y)}")
}

์œ„ ํ’€์ด๋ฅผ ์‘์šฉํ•ด์„œ ๋‚ด ๋ฐฉ์‹๋Œ€๋กœ ๋ฌธ์ œ๋ฅผ ํ’€์ดํ•ด๋ณด์•˜๋‹ค

class Solution {
    fun solution(n: Int, m: Int): IntArray {
        var answer = intArrayOf(gcd(maxOf(n, m), minOf(n, m)), n*m/gcd(maxOf(n, m), minOf(n, m)))
        return answer
    }
    
    fun gcd(a: Int, b: Int): Int = if(b != 0) gcd(b, a % b) else a
}

๐ŸŽ Result

https://github.com/eun-24k/Algorithm/blob/main/Programmers/kotlin/12940.kt

๐Ÿ† Comment

์œ ํด๋ฆฌ๋„ ํ˜ธ์ œ๋ฒ•์„ ๋ฐฐ์› ๋‹ค.

์œ ํด๋ฆฌ๋“œ ํ˜ธ์ œ๋ฒ•์„ ์ด์šฉํ•˜์ง€ ์•Š๋Š” ๋ฐฉ๋ฒ•์œผ๋กœ ๋ฌธ์ œ๋ฅผ ํ’€์–ด๋ณด๋ ค๊ณ  ํ–ˆ๋Š”๋ฐ ์ž˜ ๋˜์ง€ ์•Š์•˜๋‹ค. ๋‹ค์Œ์— ๊ธฐํšŒ๋˜๋ฉด ํ•œ๋ฒˆ ์‹œ๋„ํ•ด๋ณด๋ฉด ์ข‹์„ ๊ฑฐ ๊ฐ™๋‹ค.