| 0876 |[Middle of the Linked List](src/main/kotlin/g0801_0900/s0876_middle_of_the_linked_list/Solution.kt)| Easy | Two_Pointers, Linked_List | 136 | 76.52

| 0876 |[Middle of the Linked List](src/main/kotlin/g0801_0900/s0876_middle_of_the_linked_list/Solution.kt)| Easy | Two_Pointers, Linked_List | 136 | 76.52

| 0876 |[Middle of the Linked List](src/main/kotlin/g0801_0900/s0876_middle_of_the_linked_list/Solution.kt)| Easy | Two_Pointers, Linked_List | 136 | 76.52

| 0875 |[Koko Eating Bananas](src/main/kotlin/g0801_0900/s0875_koko_eating_bananas/Solution.kt)| Medium | Array, Binary_Search | 267 | 93.85

| 0876 |[Middle of the Linked List](src/main/kotlin/g0801_0900/s0876_middle_of_the_linked_list/Solution.kt)| Easy | Two_Pointers, Linked_List | 136 | 76.52

| 0878 |[Nth Magical Number](src/main/kotlin/g0801_0900/s0878_nth_magical_number/Solution.kt)| Hard | Math, Binary_Search | 124 | 100.00

| 0877 |[Stone Game](src/main/kotlin/g0801_0900/s0877_stone_game/Solution.kt)| Medium | Array, Dynamic_Programming, Math, Game_Theory | 136 | 88.24

| 0876 |[Middle of the Linked List](src/main/kotlin/g0801_0900/s0876_middle_of_the_linked_list/Solution.kt)| Easy | Two_Pointers, Linked_List, Algorithm_I_Day_5_Two_Pointers, Programming_Skills_I_Day_10_Linked_List_and_Tree, Level_1_Day_4_Linked_List, Udemy_Linked_List | 136 | 76.52

| 0875 |[Koko Eating Bananas](src/main/kotlin/g0801_0900/s0875_koko_eating_bananas/Solution.kt)| Medium | Array, Binary_Search, Binary_Search_II_Day_4 | 267 | 93.85

package g0801_0900.s0875_koko_eating_bananas

class Solution {

fun minEatingSpeed(piles: IntArray, h: Int): Int {

var maxP = piles[0]

var sumP = 0L

for (pile in piles) {

maxP = maxP.coerceAtLeast(pile)

sumP += pile.toLong()

}

// binary search

var low = ((sumP - 1) / h + 1).toInt()

var high = maxP

while (low < high) {

val mid = low + (high - low) / 2

if (isPossible(piles, mid, h)) {

high = mid

} else {

low = mid + 1

}

}

return low

}

private fun isPossible(piles: IntArray, k: Int, h: Int): Boolean {

var sum = 0

for (pile in piles) {

sum += (pile - 1) / k + 1

}

return sum <= h

}

}

875\. Koko Eating Bananas

Medium

Koko loves to eat bananas. There are `n` piles of bananas, the <code>i^th</code> pile has `piles[i]` bananas. The guards have gone and will come back in `h` hours.

Koko can decide her bananas-per-hour eating speed of `k`. Each hour, she chooses some pile of bananas and eats `k` bananas from that pile. If the pile has less than `k` bananas, she eats all of them instead and will not eat any more bananas during this hour.

Koko likes to eat slowly but still wants to finish eating all the bananas before the guards return.

Return _the minimum integer_ `k` _such that she can eat all the bananas within_ `h` _hours_.

**Example 1:**

**Input:** piles = [3,6,7,11], h = 8

**Output:** 4

**Example 2:**

**Input:** piles = [30,11,23,4,20], h = 5

**Output:** 30

**Example 3:**

**Input:** piles = [30,11,23,4,20], h = 6

**Output:** 23

**Constraints:**

* <code>1 <= piles.length <= 10⁴</code>

* <code>piles.length <= h <= 10⁹</code>

* <code>1 <= piles[i] <= 10⁹</code>

package g0801_0900.s0876_middle_of_the_linked_list

import com_github_leetcode.ListNode

class Solution {

fun middleNode(head: ListNode?): ListNode? {

var fast = head

var slow = head

while (fast?.next != null) {

fast = fast.next!!.next

slow = slow!!.next

}

return slow

}

}

876\. Middle of the Linked List

Easy

Given the `head` of a singly linked list, return _the middle node of the linked list_.

If there are two middle nodes, return **the second middle** node.

**Example 1:**

**Input:** head = [1,2,3,4,5]

**Output:** [3,4,5]

**Explanation:** The middle node of the list is node 3.

**Example 2:**

**Input:** head = [1,2,3,4,5,6]

**Output:** [4,5,6]

**Explanation:** Since the list has two middle nodes with values 3 and 4, we return the second one.

**Constraints:**

* The number of nodes in the list is in the range `[1, 100]`.

* `1 <= Node.val <= 100`

package g0801_0900.s0877_stone_game

class Solution {

fun stoneGame(piles: IntArray): Boolean {

var low = 0

var high = piles.size - 1

var alice = 0

var bob = 0

while (low < high) {

alice += piles[low].coerceAtLeast(piles[high])

bob += piles[low].coerceAtMost(piles[high])

low++

high--

}

return alice > bob

}

}

877\. Stone Game

Medium

Alice and Bob play a game with piles of stones. There are an **even** number of piles arranged in a row, and each pile has a **positive** integer number of stones `piles[i]`.

The objective of the game is to end with the most stones. The **total** number of stones across all the piles is **odd**, so there are no ties.

Alice and Bob take turns, with **Alice starting first**. Each turn, a player takes the entire pile of stones either from the **beginning** or from the **end** of the row. This continues until there are no more piles left, at which point the person with the **most stones wins**.

Assuming Alice and Bob play optimally, return `true` _if Alice wins the game, or_ `false` _if Bob wins_.

**Example 1:**

**Input:** piles = [5,3,4,5]

**Output:** true

**Explanation:**

Alice starts first, and can only take the first 5 or the last 5.

Say she takes the first 5, so that the row becomes [3, 4, 5].

If Bob takes 3, then the board is [4, 5], and Alice takes 5 to win with 10 points.

If Bob takes the last 5, then the board is [3, 4], and Alice takes 4 to win with 9 points.

This demonstrated that taking the first 5 was a winning move for Alice, so we return true.

**Example 2:**

**Input:** piles = [3,7,2,3]

**Output:** true

**Constraints:**

* `2 <= piles.length <= 500`

* `piles.length` is **even**.

* `1 <= piles[i] <= 500`

* `sum(piles[i])` is **odd**.

package g0801_0900.s0878_nth_magical_number

@Suppress("NAME_SHADOWING")

class Solution {

fun nthMagicalNumber(n: Int, a: Int, b: Int): Int {

val c = lcm(a.toLong(), b.toLong())

var l: Long = 2

var r = n * c

var ans = r

while (l <= r) {

val mid = l + (r - l) / 2

val cnt = mid / a + mid / b - mid / c

if (cnt < n) {

l = mid + 1

} else {

ans = mid

r = mid - 1

}

}

return (ans % MOD).toInt()

}

private fun lcm(a: Long, b: Long): Long {

return a * b / gcd(a, b)

}

private fun gcd(a: Long, b: Long): Long {

var a = a

var b = b

var t: Long

while (b != 0L) {

t = b

b = a % b

a = t

}

return a

}

companion object {

private const val MOD = 1000000007

}

}

878\. Nth Magical Number

Hard

A positive integer is _magical_ if it is divisible by either `a` or `b`.

Given the three integers `n`, `a`, and `b`, return the <code>n^th</code> magical number. Since the answer may be very large, **return it modulo** <code>10⁹ + 7</code>.

**Example 1:**

**Input:** n = 1, a = 2, b = 3

**Output:** 2

**Example 2:**

**Input:** n = 4, a = 2, b = 3

**Output:** 6

**Constraints:**

* <code>1 <= n <= 10⁹</code>

* <code>2 <= a, b <= 4 * 10⁴</code>

package g0801_0900.s0875_koko_eating_bananas

import org.hamcrest.CoreMatchers.equalTo

import org.hamcrest.MatcherAssert.assertThat

import org.junit.jupiter.api.Test

internal class SolutionTest {

@Test

fun minEatingSpeed() {

assertThat(Solution().minEatingSpeed(intArrayOf(3, 6, 7, 11), 8), equalTo(4))

}

@Test

fun minEatingSpeed2() {

assertThat(Solution().minEatingSpeed(intArrayOf(30, 11, 23, 4, 20), 5), equalTo(30))

}

@Test

fun minEatingSpeed3() {

assertThat(Solution().minEatingSpeed(intArrayOf(30, 11, 23, 4, 20), 6), equalTo(23))

}

}

package g0801_0900.s0876_middle_of_the_linked_list

import com_github_leetcode.LinkedListUtils.createSinglyLinkedList

import org.hamcrest.CoreMatchers.equalTo

import org.hamcrest.MatcherAssert.assertThat

import org.junit.jupiter.api.Test

internal class SolutionTest {

@Test

fun middleNode() {

val head = createSinglyLinkedList(listOf(1, 2, 3, 4, 5))

assertThat(

Solution().middleNode(head).toString(),

equalTo(createSinglyLinkedList(listOf(3, 4, 5)).toString())

)

}

@Test

fun middleNode2() {

val head = createSinglyLinkedList(listOf(1, 2, 3, 4, 5, 6))

assertThat(

Solution().middleNode(head).toString(),

equalTo(createSinglyLinkedList(listOf(4, 5, 6)).toString())

)

}

}

package g0801_0900.s0877_stone_game

import org.hamcrest.CoreMatchers.equalTo

import org.hamcrest.MatcherAssert.assertThat

import org.junit.jupiter.api.Test

internal class SolutionTest {

@Test

fun stoneGame() {

assertThat(Solution().stoneGame(intArrayOf(5, 3, 4, 5)), equalTo(true))

}

@Test

fun stoneGame2() {

assertThat(Solution().stoneGame(intArrayOf(3, 7, 2, 3)), equalTo(true))

}

}