# Solving Leetcode Interviews in Seconds with AI: Number of Ways to Rearrange Sticks With K Sticks Visible


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1866" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> There are n uniquely-sized sticks whose lengths are integers from 1 to n. You want to arrange the sticks such that exactly k sticks are visible from the left. A stick is visible from the left if there are no longer sticks to the left of it.  For example, if the sticks are arranged [1,3,2,5,4], then the sticks with lengths 1, 3, and 5 are visible from the left.  Given n and k, return the number of such arrangements. Since the answer may be large, return it modulo 109 + 7.   Example 1:  Input: n = 3, k = 2 Output: 3 Explanation: [1,3,2], [2,3,1], and [2,1,3] are the only arrangements such that exactly 2 sticks are visible. The visible sticks are underlined.  Example 2:  Input: n = 5, k = 5 Output: 1 Explanation: [1,2,3,4,5] is the only arrangement such that all 5 sticks are visible. The visible sticks are underlined.  Example 3:  Input: n = 20, k = 11 Output: 647427950 Explanation: There are 647427950 (mod 109 + 7) ways to rearrange the sticks such that exactly 11 sticks are visible.    Constraints:  1 <= n <= 1000 1 <= k <= n  

	# Explanation
	Here's the solution:

*   **Dynamic Programming:** The core idea is to use dynamic programming to build up the number of arrangements. `dp[n][k]` will store the number of arrangements of `n` sticks with `k` visible sticks.
*   **Base Cases and Transitions:** We initialize `dp[i][i] = 1` for all `i`, since there's only one way to have all sticks visible (ascending order). The transitions are based on where we place the longest stick (`n`). We can either place it at the beginning (making it visible) or somewhere else (not visible).
*   **Modulo Arithmetic:** We perform all calculations modulo 10^9 + 7 to prevent overflow.

*   **Time & Space Complexity:** O(n*k) time and space complexity, where n is the number of sticks and k is the number of visible sticks.

	
	# Code
	```python
	def rearrange_sticks(n: int, k: int) -> int:
    """
    Calculates the number of arrangements of n sticks such that exactly k sticks are visible from the left.

    Args:
        n: The number of sticks.
        k: The number of visible sticks.

    Returns:
        The number of arrangements modulo 10^9 + 7.
    """

    MOD = 10**9 + 7
    dp = [[0] * (k + 1) for _ in range(n + 1)]

    dp[0][0] = 1  # Base case: no sticks, no visible sticks, 1 way

    for i in range(1, n + 1):
        for j in range(1, k + 1):
            # Case 1: The longest stick (i) is visible.
            dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % MOD

            # Case 2: The longest stick (i) is not visible.
            dp[i][j] = (dp[i][j] + (dp[i - 1][j] * (i - 1)) % MOD) % MOD

    return dp[n][k]
	```