diff --git a/src/main/kotlin/Main.kt b/src/main/kotlin/Main.kt
index af0944f..3d46f90 100644
--- a/src/main/kotlin/Main.kt
+++ b/src/main/kotlin/Main.kt
@@ -1,5 +1,9 @@
 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
 import main.kotlin.dsalgoleetcode.TwoSum
 
@@ -11,11 +15,33 @@ 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")
+
+    // Calling Contains Duplicate
+    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
new file mode 100644
index 0000000..4e35c07
--- /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 {
+
+    fun containsDuplicate(nums: IntArray): Boolean {
+
+        val seen = mutableSetOf<Int>()
+        for(i in nums){
+            if( i in seen)
+                return true
+            seen.add(i)
+        }
+        return false
+    }
+}
\ 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