diff --git a/app/src/main/java/com/example/algorithmstudy/CalculatorUtil.kt b/app/src/main/java/com/example/algorithmstudy/CalculatorUtil.kt index d123e50..0f50972 100644 --- a/app/src/main/java/com/example/algorithmstudy/CalculatorUtil.kt +++ b/app/src/main/java/com/example/algorithmstudy/CalculatorUtil.kt @@ -2,8 +2,52 @@ package com.example.algorithmstudy class CalculatorUtil { - fun solution(arr1: Array, arr2: Array): Array { - var answer = arrayOf() + fun sortWithDivisor(arr: IntArray, divisor: Int): IntArray { + val answerArray = ArrayList() + + 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() + + 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 } } \ No newline at end of file diff --git a/app/src/main/java/com/example/algorithmstudy/DFS.kt b/app/src/main/java/com/example/algorithmstudy/DFS.kt index 9ecad2f..4680698 100644 --- a/app/src/main/java/com/example/algorithmstudy/DFS.kt +++ b/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() - } } diff --git a/app/src/main/java/com/example/algorithmstudy/SortUtil.kt b/app/src/main/java/com/example/algorithmstudy/SortUtil.kt new file mode 100644 index 0000000..b51c3dd --- /dev/null +++ b/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): ArrayList { + 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 + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/algorithmstudy/StackSolution.kt b/app/src/main/java/com/example/algorithmstudy/StackSolution.kt new file mode 100644 index 0000000..2fcc403 --- /dev/null +++ b/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 = LinkedList() + val bridgeQueue: Queue = 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() + + val queue: Queue = 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() + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/algorithmstudy/StringUtil.kt b/app/src/main/java/com/example/algorithmstudy/StringUtil.kt index ab4d179..6931e19 100644 --- a/app/src/main/java/com/example/algorithmstudy/StringUtil.kt +++ b/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() + + intArray.toCollection(sortArray) + } + } \ No newline at end of file diff --git a/app/src/test/java/com/example/algorithmstudy/AlgorithmTest.kt b/app/src/test/java/com/example/algorithmstudy/AlgorithmTest.kt index b9461ac..ff36e3b 100644 --- a/app/src/test/java/com/example/algorithmstudy/AlgorithmTest.kt +++ b/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) + } } diff --git a/app/src/test/java/com/example/algorithmstudy/SortTest.kt b/app/src/test/java/com/example/algorithmstudy/SortTest.kt new file mode 100644 index 0000000..1158dc9 --- /dev/null +++ b/app/src/test/java/com/example/algorithmstudy/SortTest.kt @@ -0,0 +1,39 @@ +package com.example.algorithmstudy + +import org.junit.Test + +class SortTest { + + @Test + fun selectionSortTest() { + SortUtil().doSelectionSort(arrayListOf(1, 5, 3, 2, 4, 9, 6)).forEach { + print("[$it]") + } + + println() + + SortUtil().doSelectionSort(arrayListOf(9, 9, 4, 3, 104, 2, 1, 2)).forEach { + print("[$it]") + } + } + + @Test + fun insertionSortTest() { + + SortUtil().doInsertionSort(intArrayOf(2,8,5,3,9,4,1)).forEach { + print("[$it]") + } + + println() + + SortUtil().doInsertionSort(intArrayOf(9, 4, 3, 104, 1, 2)).forEach { + print("[$it]") + } + + println() + + SortUtil().doBubbleSort(intArrayOf(9, 4, 3, 104, 1, 2)).forEach { + print("[$it]") + } + } +} \ No newline at end of file