diff --git a/.idea/misc.xml b/.idea/misc.xml
index 6c5519f9..40e1197f 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,9 +1,10 @@
-
-
-
-
-
-
-
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/README.md b/README.md
index eb0d9e98..69f1c0a8 100644
--- a/README.md
+++ b/README.md
@@ -1,20 +1,86 @@
-# Contest Kotlin
+# LeetCode Kotlin Project
-# Description
+This project is a curated collection of solutions to a wide variety of LeetCode problems, all
+implemented in modern, idiomatic Kotlin. It's designed to be a valuable resource for anyone
+preparing for technical interviews, learning Kotlin, or exploring different algorithmic approaches
+to common problems.
-This repository contains problems of leetcode. We might use this repo how get solution for define
-problem from leetcode. Also We might clone this repo and run or debug problems in android studio.
+## Key Features
-# How to use
+* **Comprehensive Problem Coverage:** The project includes solutions for a diverse set of problems,
+ covering many important data structures and algorithms.
+* **Organized by Topic:** Solutions are neatly organized into packages based on the primary data
+ structure or algorithm used, making it easy to find examples and study specific topics.
+* **Idiomatic Kotlin:** The code is written in a clean, readable, and idiomatic Kotlin style,
+ demonstrating best practices and modern language features.
+* **Educational Resource:** By studying the solutions, you can learn how to approach different types
+ of algorithmic problems and how to implement them effectively in Kotlin.
-1. Each problem will be in contest module
-2. Each problem have a few solutions. Main solution with using down level code. Alternative Solution
- with other approaches. Prod Variant - this code might be in prod in application or service. This
- code using std lib kotlin
-3. For search each problem have kotlin doc with name and number problem. Also each problem have tag
- for commit for search in github.
-4. Each Topic have package which contains problem
+## Why Use This Project?
+
+There are several great reasons to use this project:
+
+* **Accelerate Your Learning:** If you're learning algorithms and data structures, this project
+ provides a rich library of examples that you can study and learn from.
+* **Prepare for Interviews:** The problems in this collection are representative of what you might
+ encounter in a technical interview. You can use these solutions to practice and prepare.
+* **Discover Kotlin Best Practices:** The code in this project demonstrates how to write clean,
+ efficient, and expressive Kotlin. It's a great way to see how the language is used in a practical
+ context.
+
+## Getting Started: How to Use the Solutions
+
+The solutions in this project are organized into functions. To use a solution, you can simply call
+the function with the required input.
+
+Here is an example of how you could call the `getCommon` function from the `HashTableLeetcode.kt`
+file within a `main` function:
+
+```kotlin
+
+fun main() {
+ // Example usage of the getCommon function
+ val nums1 = intArrayOf(1, 2, 3)
+ val nums2 = intArrayOf(2, 4)
+ val common = getCommon(nums1, nums2)
+
+ if (common != -1) {
+ println("The minimum common value is: $common")
+ } else {
+ println("No common value was found.")
+ }
+}
+```
+
+## Table of Contents by Topic
+
+Here is a list of the topics covered in this project, with a reference to the corresponding package:
+
+| Topic | Package |
+|----------------------|--------------------------------------|
+| **Array** | `com.github.contest.array` |
+| **Backtracking** | `com.github.contest.backtracking` |
+| **Binary Search** | `com.github.contest.binarySearch` |
+| **Binary Tree** | `com.github.contest.binaryTree` |
+| **Bit Manipulation** | `com.github.contest.bitManipulation` |
+| **Design** | `com.github.contest.design` |
+| **Dynamic Prog.** | `com.github.contest.dp` |
+| **Graph** | `com.github.contest.graph` |
+| **Hash Table** | `com.github.contest.hashTable` |
+| **Heap** | `com.github.contest.heap` |
+| **Linked List** | `com.github.contest.linkedList` |
+| **Math** | `com.github.contest.math` |
+| **Priority Queue** | `com.github.contest.priorityqueue` |
+| **Queue** | `com.github.contest.queue` |
+| **Recursion** | `com.github.contest.recursion` |
+| **Sliding Window** | `com.github.contest.slidingWindow` |
+| **Sorting** | `com.github.contest.sorting` |
+| **Stack** | `com.github.contest.stack` |
+| **Strings** | `com.github.contest.strings` |
+| **Two Pointer** | `com.github.contest.twoPointer` |
+
+``
diff --git a/contest/src/main/java/com/github/contest/Execute.kt b/contest/src/main/java/com/github/contest/Execute.kt
index d8021b70..f90fcfd7 100644
--- a/contest/src/main/java/com/github/contest/Execute.kt
+++ b/contest/src/main/java/com/github/contest/Execute.kt
@@ -1,9 +1,8 @@
package com.github.contest
-import com.github.contest.binaryTree.TreeNode
-import com.github.contest.binaryTree.findTilt
import com.github.contest.math.numberOfPowerfulInt
+import com.github.contest.math.replaceNonCoPrimes
import com.github.contest.slidingWindow.customStructure.rabinKarpMultiPattern
import com.github.contest.slidingWindow.customStructure.slidingWindowClassic
import com.github.contest.strings.fullJustify
@@ -16,12 +15,9 @@ import java.util.TreeMap
fun main() {
- val root = TreeNode(1)
- root.left = TreeNode(2)
- root.right = TreeNode(3)
-
- findTilt(root).also { println(it) }
+ val data = listOf(287, 41, 49, 287, 899, 23, 23, 20677, 5, 825).toIntArray()
+ replaceNonCoPrimes(data).also { println(it) }
}
diff --git a/contest/src/main/java/com/github/contest/math/MathLeetcode.kt b/contest/src/main/java/com/github/contest/math/MathLeetcode.kt
index 669d5e58..3a08eb2d 100644
--- a/contest/src/main/java/com/github/contest/math/MathLeetcode.kt
+++ b/contest/src/main/java/com/github/contest/math/MathLeetcode.kt
@@ -231,3 +231,48 @@ fun triangleType(nums: IntArray): String {
}
}
+/**
+ * 2197. Replace Non-Coprime Numbers in Array
+ */
+
+fun replaceNonCoPrimes(nums: IntArray): List {
+ if (nums.hasSingle()) return listOf(nums[0])
+
+ val res = mutableListOf()
+
+ for (num in nums) {
+ var currentNum = num
+ while (res.isNotEmpty() && isNonCoprime(res.last(), currentNum)) {
+ val last = res.removeLast()
+ currentNum = lcm(last, currentNum)
+ }
+ res.add(currentNum)
+ }
+
+ return res
+}
+
+fun isNonCoprime(first: Int, second: Int) = gcd(first, second) > 1
+
+fun IntArray.hasSingle() = when {
+ this.size == 1 -> true
+ else -> false
+}
+
+fun gcd(first: Int, second: Int): Int {
+ if (first == 1 || second == 1) return 1
+ if (first == second) return first
+
+ val maxValue = maxOf(first, second)
+ val minValue = minOf(first, second)
+
+ if (maxValue % minValue == 0) return minValue
+
+ return gcd(minValue, maxValue % minValue)
+}
+
+fun lcm(first: Int, second: Int): Int {
+ if (first == second) return first
+ val product = (first.toLong() / gcd(first, second)) * second
+ return abs(product).toInt()
+}