Develop

app/src/main/java/com/example/algorithmstudy/CalculatorUtil.kt

@@ -2,8 +2,52 @@ package com.example.algorithmstudy
 
 class CalculatorUtil {
 
-    fun solution(arr1: Array<IntArray>, arr2: Array<IntArray>): Array<IntArray> {
-        var answer = arrayOf<IntArray>()
+    fun sortWithDivisor(arr: IntArray, divisor: Int): IntArray {
+        val answerArray = ArrayList<Int>()
+
+        arr.forEach {
+            if (it % divisor == 0) {
+                answerArray.add(it)
+            }
+        }
+
+        answerArray.sort()
+
+        return if (answerArray.size == 0) {
+            intArrayOf(-1)
+        } else {
+            answerArray.toIntArray()
+        }
+    }
+
+    fun numberWithGap(x: Int, n: Int): LongArray {
+        var answer = longArrayOf()
+        var answerArray = ArrayList<Long>()
+
+        var inputData = x.toLong()
+
+        for (count in 0 until n) {
+            answerArray.add(inputData)
+            inputData += x
+        }
+
+        return answerArray.toLongArray()
+    }
+
+    fun divideFibonacci(n: Int): Int {
+        return doFibonacci(n) % 1234567
+    }
+
+    fun doFibonacci(n: Int): Int {
+        return if (n <= 1) {
+            n
+        } else {
+            doFibonacci(n - 2) + doFibonacci(n - 1)
+        }
+    }
+
+    fun solution(numbers: String): Int {
+        var answer = 0
         return answer
     }
 }

app/src/main/java/com/example/algorithmstudy/DFS.kt

@@ -24,7 +24,6 @@ class DFS {
                 visitedQueue.offer(input[0][0])
 
                 for (index in 1 until input[0].size) {
-
                     needVisitedStack.add(input[0][index])
                 }
             } else {
@@ -47,7 +46,6 @@ class DFS {
                 }
 
                 println()
-
             }
         }
 

app/src/main/java/com/example/algorithmstudy/SortUtil.kt

@@ -0,0 +1,70 @@
+package com.example.algorithmstudy
+
+import java.util.*
+
+class SortUtil {
+
+    // 시간복잡도 O(n^2)
+    // 공간복잡도 O(n)
+    fun doSelectionSort(target: ArrayList<Int>): ArrayList<Int> {
+        var tempInt: Int
+        for (x in target.indices) {
+            tempInt = target[x]
+
+            for (y in x + 1 until target.size) {
+                if (target[y] < tempInt) {
+                    tempInt = target[y]
+
+                    // swap
+                    target[y] = target[x]
+                    target[x] = tempInt
+                }
+            }
+        }
+
+        return target
+    }
+
+    /**
+     * https://www.youtube.com/watch?v=g-PGLbMth_g
+     */
+    // 시간복잡도 O(n^2)
+    // 공간복잡도 O(n)
+    fun doInsertionSort(arr: IntArray): IntArray {
+        var currentMinimum: Int
+        var tempInt: Int
+
+        for (x in arr.indices) {
+            currentMinimum = x
+
+            for (y in x + 1 until arr.size) {
+                if (arr[currentMinimum] > arr[y]) {
+                    currentMinimum = y
+                }
+            }
+
+            tempInt = arr[x]
+            arr[x] = arr[currentMinimum]
+            arr[currentMinimum] = tempInt
+        }
+
+        return arr
+    }
+
+    fun doBubbleSort(arr: IntArray): IntArray {
+        var tempInt: Int
+
+        for (x in 1 until arr.size) {
+
+            for (y in 0 until arr.size - 1) {
+                if (arr[x] < arr[y]) {
+                    tempInt = arr[x]
+                    arr[x] = arr[y]
+                    arr[y] = tempInt
+                }
+            }
+        }
+
+        return arr
+    }
+}

app/src/main/java/com/example/algorithmstudy/StackSolution.kt

@@ -0,0 +1,126 @@
+package com.example.algorithmstudy
+
+import java.util.*
+
+class StackSolution {
+
+    /**
+     * 트럭 여러 대가 강을 가로지르는 일 차선 다리를 정해진 순으로 건너려 합니다. 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 알아내야 합니다. 트럭은 1초에 1만큼 움직이며, 다리 길이는 bridge_length이고 다리는 무게 weight까지 견딥니다.
+    ※ 트럭이 다리에 완전히 오르지 않은 경우, 이 트럭의 무게는 고려하지 않습니다.
+    예를 들어, 길이가 2이고 10kg 무게를 견디는 다리가 있습니다. 무게가 [7, 4, 5, 6]kg인 트럭이 순서대로 최단 시간 안에 다리를 건너려면 다음과 같이 건너야 합니다.
+    경과 시간	다리를 지난 트럭	다리를 건너는 트럭	대기 트럭
+    0	[]	[]	[7,4,5,6]
+    1~2	[]	[7]	[4,5,6]
+    3	[7]	[4]	[5,6]
+    4	[7]	[4,5]	[6]
+    5	[7,4]	[5]	[6]
+    6~7	[7,4,5]	[6]	[]
+    8	[7,4,5,6]	[]	[]
+    따라서, 모든 트럭이 다리를 지나려면 최소 8초가 걸립니다.
+    solution 함수의 매개변수로 다리 길이 bridge_length, 다리가 견딜 수 있는 무게 weight, 트럭별 무게 truck_weights가 주어집니다. 이때 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 return 하도록 solution 함수를 완성하세요.
+     */
+
+    fun solution(bridge_length: Int, weight: Int, truck_weights: IntArray): Int {
+        val truckQueue: Queue<Int> = LinkedList()
+        val bridgeQueue: Queue<Truck> = LinkedList()
+
+        truck_weights.toCollection(truckQueue)
+
+        var answer = 0
+
+        while (truckQueue.isNotEmpty() || bridgeQueue.isNotEmpty()) {
+
+            println("count : $answer")
+
+
+            if (bridgeQueue.size != 0) {
+
+                bridgeQueue.forEach {
+                    it.progress++
+                }
+
+                if (bridgeQueue.peek()?.progress == bridge_length) {
+                    println("polling : ${bridgeQueue.poll()}")
+                }
+            }
+
+            truckQueue.peek()?.let {
+
+                println("estimated : ${bridgeQueue.map { truck -> truck.truckWeight }.sum() + truckQueue.peek()}")
+
+                if (bridgeQueue.map { truck -> truck.truckWeight }.sum() + it <= weight) {
+                    println("adding")
+                    bridgeQueue.offer(Truck(truckQueue.poll()!!, 0))
+                }
+            }
+
+//            println("count : $answer ")
+            println("current truck queue")
+            truckQueue.forEach {
+                println("$it")
+            }
+
+            println("current bridge queue")
+            bridgeQueue.forEach {
+                println("$it")
+            }
+            println()
+
+            answer++
+        }
+
+
+        return answer
+    }
+
+    data class Truck(val truckWeight: Int, var progress: Int)
+
+
+    /**
+     * 프로그래머스 팀에서는 기능 개선 작업을 수행 중입니다. 각 기능은 진도가 100%일 때 서비스에 반영할 수 있습니다.
+    또, 각 기능의 개발속도는 모두 다르기 때문에 뒤에 있는 기능이 앞에 있는 기능보다 먼저 개발될 수 있고, 이때 뒤에 있는 기능은 앞에 있는 기능이 배포될 때 함께 배포됩니다.
+    먼저 배포되어야 하는 순서대로 작업의 진도가 적힌 정수 배열 progresses와 각 작업의 개발 속도가 적힌 정수 배열 speeds가 주어질 때 각 배포마다 몇 개의 기능이 배포되는지를 return 하도록 solution 함수를 완성하세요.
+    제한 사항
+    작업의 개수(progresses, speeds배열의 길이)는 100개 이하입니다.
+    작업 진도는 100 미만의 자연수입니다.
+    작업 속도는 100 이하의 자연수입니다.
+    배포는 하루에 한 번만 할 수 있으며, 하루의 끝에 이루어진다고 가정합니다. 예를 들어 진도율이 95%인 작업의 개발 속도가 하루에 4%라면 배포는 2일 뒤에 이루어집니다.
+     */
+    fun improvementTest(progresses: IntArray, speeds: IntArray): IntArray {
+        val answer = ArrayList<Int>()
+
+        val queue: Queue<Int> = LinkedList()
+
+        for (index in progresses.indices) {
+            val amountToFinish = 100 - progresses[index]
+
+            if (amountToFinish % speeds[index] != 0) {
+                queue.offer(amountToFinish / speeds[index] + 1)
+            } else {
+                queue.offer(amountToFinish / speeds[index])
+            }
+
+        }
+
+        var dateCount = 1
+        var releaseCount = 0
+
+        while (queue.size != 0) {
+            if (queue.peek() == dateCount) {
+                while (queue.size > 0 && queue.peek() <= dateCount) {
+
+                    queue.poll()
+                    releaseCount++
+                }
+
+                answer.add(releaseCount)
+            }
+
+            releaseCount = 0
+
+            dateCount++
+        }
+
+        return answer.toIntArray()
+    }
+}

app/src/main/java/com/example/algorithmstudy/StringUtil.kt

@@ -151,7 +151,7 @@ class StringUtil {
         }
     }
 
-    fun solution(s: String): String {
+    fun smallAndBig(s: String): String {
         val charArray = s.split(' ')
         val answerBuffer = StringBuffer()
         var biggest = -999999999
@@ -170,4 +170,57 @@ class StringUtil {
         answerBuffer.append("$smallest $biggest")
         return answerBuffer.toString()
     }
+
+    // TODO Not yet solved!
+    fun solution(s: String): String {
+        val charArray = s.split(' ')
+        val answerBuffer = StringBuffer()
+
+        charArray.forEach { word ->
+
+            if (word.isNotEmpty()) {
+                if (word[0].isLetter()) {
+                    word.toLowerCase().apply {
+                        answerBuffer.append(this[0].toUpperCase())
+                    }
+
+                    answerBuffer.append("${word.toLowerCase().substring(1)} ")
+                } else {
+                    answerBuffer.append("${word.toLowerCase()} ")
+                }
+            }
+
+        }
+
+        answerBuffer.deleteCharAt(answerBuffer.length - 1)
+
+        return answerBuffer.toString()
+    }
+
+    fun cutAndArrange(target : String, length: Int): String {
+        var remainingString = target
+        val resultBuffer = StringBuffer()
+
+        while (remainingString.isNotBlank()) {
+            if (target.length < length) {
+                return target
+            } else {
+                resultBuffer.append(remainingString.substring(0, length))
+                resultBuffer.append("\n")
+                remainingString = remainingString.substring(length, remainingString.length)
+            }
+
+            println("remain : $remainingString")
+        }
+
+        return resultBuffer.toString()
+    }
+
+    fun testFuction() {
+        val intArray = intArrayOf(7,3,2,9,4)
+        val sortArray = ArrayList<Int>()
+
+        intArray.toCollection(sortArray)
+    }
+
 }

app/src/test/java/com/example/algorithmstudy/AlgorithmTest.kt

@@ -89,4 +89,34 @@ class AlgorithmTest {
     fun checkSumBetweenNumber() {
         println(StringUtil().sumBetweenNumber(3,15))
     }
+
+    @Test
+    fun checkString() {
+//        println(StringUtil().solution("3people unFollowed me"))
+//        println(StringUtil().solution("3"))
+//        println(StringUtil().solution("1a"))
+//        println(StringUtil().solution("a"))
+//        println(StringUtil().solution("A kdnkEen 3333FonernE EEoeno"))
+        println(StringUtil().solution("      1i anti ELNflkoif EnKei"))
+        println(StringUtil().solution("3People and thRee pEoPlE"))
+
+
+    }
+
+    @Test
+    fun truckTest() {
+        println("result : ${StackSolution().solution(2 ,10, intArrayOf(7,4,5,6))}")
+//        println("result : ${StackSolution().solution(100 ,100, intArrayOf(10))}")
+    }
+
+    @Test
+    fun cutAndArrangeTest() {
+        println(StringUtil().cutAndArrange("aaa bbbbbb cccdd", 4))
+        println(StringUtil().cutAndArrange("X", 4))
+    }
+
+    @Test
+    fun fibonacciTest() {
+        CalculatorUtil().divideFibonacci(3)
+    }
 }