From c25c3d65cbd7c7b8545baaf7c27bd42cab566a69 Mon Sep 17 00:00:00 2001 From: sumanas27 Date: Sun, 18 May 2025 23:53:31 +0200 Subject: [PATCH 1/3] LinkedList Cycle Detection --- src/main/kotlin/Main.kt | 16 ++++++- .../LinkedListCycleDetection.kt | 48 +++++++++++++++++++ 2 files changed, 62 insertions(+), 2 deletions(-) create mode 100644 src/main/kotlin/dsalgoleetcode/LinkedListCycleDetection.kt diff --git a/src/main/kotlin/Main.kt b/src/main/kotlin/Main.kt index af0944f..1e277c1 100644 --- a/src/main/kotlin/Main.kt +++ b/src/main/kotlin/Main.kt @@ -1,5 +1,7 @@ package main.kotlin +import main.kotlin.dsalgoleetcode.LinkedListCycleDetection +import main.kotlin.dsalgoleetcode.ListNode import main.kotlin.dsalgoleetcode.LongestSubstring import main.kotlin.dsalgoleetcode.TwoSum @@ -11,11 +13,21 @@ fun main() { // Calling Two Sum class val twoSum = TwoSum() val result = twoSum.twoSum(nums = intArrayOf(1, 2, 3, 4, 5), target = 9) + println("Indices: ${result.joinToString(",")}") // Calling Longest Substring val longestSubstring = LongestSubstring() val lsResult = longestSubstring.lengthOfLongestSubstring(s = "abcabcbbb") - - println("Indices: ${result.joinToString(",")}") println("Longest Substring : $lsResult") + + // Calling LinkedList Cycle Detection + val linkedListCycleDetection = LinkedListCycleDetection() + val node1 = ListNode(1) + val node2 = ListNode(2) + val node3 = ListNode(3) + node1.next = node2 + node2.next = node3 + node3.next = node1 // cycle back to x + val llcdResult = linkedListCycleDetection.hasCycle(node1) + println("Has cycle $llcdResult") } \ No newline at end of file diff --git a/src/main/kotlin/dsalgoleetcode/LinkedListCycleDetection.kt b/src/main/kotlin/dsalgoleetcode/LinkedListCycleDetection.kt new file mode 100644 index 0000000..aa49aa6 --- /dev/null +++ b/src/main/kotlin/dsalgoleetcode/LinkedListCycleDetection.kt @@ -0,0 +1,48 @@ +package main.kotlin.dsalgoleetcode + +/** + * Linked List Cycle + * + * Given head, the head of a linked list, determine if the linked list has a cycle in it. + * There is a cycle in a linked list if there is some node in the list that can be reached + * again by continuously following the next pointer. Internally, pos is used to denote the + * index of the node that tail's next pointer is connected to. Note that pos is not passed + * as a parameter. + * + * Return true if there is a cycle in the linked list. Otherwise, return false. + * + * Input: head = [3,2,0,-4], pos = 1 + * Output: true + * Explanation: There is a cycle in the linked list, where the tail connects to + * the 1st node (0-indexed). + * */ + +class LinkedListCycleDetection { + + /** + * Example: + * var li = ListNode(5) + * var v = li.`val` + * Definition for singly-linked list. + * class ListNode(var `val`: Int) { + * var next: ListNode? = null + * } + */ + + fun hasCycle(head: ListNode?): Boolean { + var slow = head + var fast = head + while (fast != null && fast.next != null) { + slow = slow?.next + fast = fast.next?.next + if (slow == fast) + return true + } + return false + } +} + + +class ListNode(var `val`: Int) { + var next: ListNode? = null +} \ No newline at end of file From 93499b260db39a58dbc97641103e12fcd68e76ab Mon Sep 17 00:00:00 2001 From: sumanas27 Date: Mon, 19 May 2025 22:32:55 +0200 Subject: [PATCH 2/3] Find duplicate elements in an array --- src/main/kotlin/Main.kt | 7 +++++ .../dsalgoleetcode/ContainsDuplicate.kt.kt | 27 +++++++++++++++++++ 2 files changed, 34 insertions(+) create mode 100644 src/main/kotlin/dsalgoleetcode/ContainsDuplicate.kt.kt diff --git a/src/main/kotlin/Main.kt b/src/main/kotlin/Main.kt index 1e277c1..6f1119f 100644 --- a/src/main/kotlin/Main.kt +++ b/src/main/kotlin/Main.kt @@ -30,4 +30,11 @@ fun main() { node3.next = node1 // cycle back to x val llcdResult = linkedListCycleDetection.hasCycle(node1) println("Has cycle $llcdResult") + + // Calling Contains Duplicate + val `containsDuplicate.kt` = `ContainsDuplicate.kt`() + val containsDuplicateResult = `containsDuplicate.kt` + .containsDuplicate(intArrayOf(1,2,3,1,0,1)) + println("Contains Duplicate Integers $containsDuplicateResult") + } \ No newline at end of file diff --git a/src/main/kotlin/dsalgoleetcode/ContainsDuplicate.kt.kt b/src/main/kotlin/dsalgoleetcode/ContainsDuplicate.kt.kt new file mode 100644 index 0000000..b20745c --- /dev/null +++ b/src/main/kotlin/dsalgoleetcode/ContainsDuplicate.kt.kt @@ -0,0 +1,27 @@ +package main.kotlin.dsalgoleetcode + +/** + * Contains Duplicate + * Given an integer array nums, return true if any value appears at least twice in the + * array, and return false if every element is distinct. + * + * Example 1: + * Input: nums = [1,2,3,1] + * Output: true + * Explanation: + * The element 1 occurs at the indices 0 and 3. + * */ + +class `ContainsDuplicate.kt` { + + fun containsDuplicate(nums: IntArray): Boolean { + + val seen = mutableSetOf() + for(i in nums){ + if( i in seen) + return true + seen.add(i) + } + return false + } +} \ No newline at end of file From 8f4aaae79280a3a78a6d962805d222b84459e566 Mon Sep 17 00:00:00 2001 From: sumanas27 Date: Mon, 19 May 2025 22:40:41 +0200 Subject: [PATCH 3/3] Max profit on Buy and Sell stock --- src/main/kotlin/Main.kt | 11 +++++-- .../kotlin/dsalgoleetcode/BuyAndSellStock.kt | 33 +++++++++++++++++++ .../dsalgoleetcode/ContainsDuplicate.kt.kt | 2 +- 3 files changed, 43 insertions(+), 3 deletions(-) create mode 100644 src/main/kotlin/dsalgoleetcode/BuyAndSellStock.kt diff --git a/src/main/kotlin/Main.kt b/src/main/kotlin/Main.kt index 6f1119f..3d46f90 100644 --- a/src/main/kotlin/Main.kt +++ b/src/main/kotlin/Main.kt @@ -1,5 +1,7 @@ package main.kotlin +import main.kotlin.dsalgoleetcode.BuyAndSellStock +import main.kotlin.dsalgoleetcode.ContainsDuplicate import main.kotlin.dsalgoleetcode.LinkedListCycleDetection import main.kotlin.dsalgoleetcode.ListNode import main.kotlin.dsalgoleetcode.LongestSubstring @@ -32,9 +34,14 @@ fun main() { println("Has cycle $llcdResult") // Calling Contains Duplicate - val `containsDuplicate.kt` = `ContainsDuplicate.kt`() - val containsDuplicateResult = `containsDuplicate.kt` + val containsDuplicate = ContainsDuplicate() + val containsDuplicateResult = containsDuplicate .containsDuplicate(intArrayOf(1,2,3,1,0,1)) println("Contains Duplicate Integers $containsDuplicateResult") + // Calling Buy and Sell Stock + val buyAndSellStock = BuyAndSellStock() + val bnsResult = buyAndSellStock.maxProfit(intArrayOf(1,4,8,0,2)) + println("Max profit : $bnsResult") + } \ No newline at end of file diff --git a/src/main/kotlin/dsalgoleetcode/BuyAndSellStock.kt b/src/main/kotlin/dsalgoleetcode/BuyAndSellStock.kt new file mode 100644 index 0000000..385576b --- /dev/null +++ b/src/main/kotlin/dsalgoleetcode/BuyAndSellStock.kt @@ -0,0 +1,33 @@ +package main.kotlin.dsalgoleetcode + +/** + * You are given an array prices where prices[i] is the price of a given stock on the ith day. + * You want to maximize your profit by choosing a single day to buy one stock and choosing a + * different day in the future to sell that stock. + * Return the maximum profit you can achieve from this transaction. + * If you cannot achieve any profit, return 0. +Example 1: + +Input: prices = [7,1,5,3,6,4] +Output: 5 +Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5. +Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell. + * */ + +class BuyAndSellStock { + + fun maxProfit(prices: IntArray): Int { + + var minPrice = Int.MAX_VALUE + var maxProfit = 0 + + for (price in prices){ + if( price < minPrice){ + minPrice = price + } else{ + maxProfit = maxOf(maxProfit, price - minPrice) + } + } + return maxProfit + } +} \ No newline at end of file diff --git a/src/main/kotlin/dsalgoleetcode/ContainsDuplicate.kt.kt b/src/main/kotlin/dsalgoleetcode/ContainsDuplicate.kt.kt index b20745c..4e35c07 100644 --- a/src/main/kotlin/dsalgoleetcode/ContainsDuplicate.kt.kt +++ b/src/main/kotlin/dsalgoleetcode/ContainsDuplicate.kt.kt @@ -12,7 +12,7 @@ package main.kotlin.dsalgoleetcode * The element 1 occurs at the indices 0 and 3. * */ -class `ContainsDuplicate.kt` { +class ContainsDuplicate { fun containsDuplicate(nums: IntArray): Boolean {