Add LeetCode 1752 solution and autofill template

Added a detailed solution markdown for LeetCode problem 1752 (Check if Array Is Sorted and Rotated) including explanation and C++ code. Also added a leetcode-autofill template for generating problem notes from clipboard URLs.

Author: bakisama

content/CP/leetcode/1752. Check if Array Is Sorted and Rotated.md

@@ -0,0 +1,119 @@
+---
+created: 2026-01-25
+modified: 
+completed: false
+leetcode-index: 1752 
+link: https://leetcode.com/problems/check-if-array-is-sorted-and-rotated
+difficulty: Easy 
+tags:
+   - cp/array 
+   - leetcode
+---
+# Check if Array Is Sorted and Rotated
+
+## Question
+Given an array `nums`, return `true`* if the array was originally sorted in non-decreasing order, then rotated some number of positions (including zero)*. Otherwise, return `false`.
+
+There may be duplicates in the original array.
+
+Note: An array `A` rotated by `x` positions results in an array `B` of the same length such that `B[i] == A[(i+x) % A.length]` for every valid index `i`.
+
+ 
+
+>[!Example]+ Example 1
+>**Input**: `nums = [3,4,5,1,2]`
+>**Output**: `true`
+>**Explanation**:
+>[1,2,3,4,5] is the original sorted array. You can rotate the array by x = 2 positions to begin on the element of value 3: [3,4,5,1,2]. 
+
+>[!Example]+ Example 2
+>**Input**: `nums = [2,1,3,4]`
+>**Output**: `false`
+>**Explanation**:
+>There is no sorted array once rotated that can make nums. 
+
+>[!Example]+ Example 3
+>**Input**: `nums = [1,2,3]`
+>**Output**: `true`
+>**Explanation**:
+>[1,2,3] is the original sorted array. You can rotate the array by x = 0 positions (i.e. no rotation) to make nums. 
+
+>[!warning]+ Constraints
+>- `1 <= nums.length <= 100`
+>
+>- `1 <= nums[i] <= 100`
+### Hints
+>[!Hint]- Hint 1
+>Brute force and check if it is possible for a sorted array to start from each position.
+
+---
+## Solution
+
+### Intuition
+
+A sorted array has **no places where the order decreases**.  
+If such an array is rotated, there will be **exactly one place** where the order breaks.
+
+So instead of simulating rotations, I can simply count how many times:
+
+nums[i] > nums[i + 1]
+
+occurs while traversing the array.
+
+- `0` breaks → already sorted  
+- `1` break  → sorted and rotated  
+- `>1` breaks → not possible by rotation  
+
+
+### Approach
+
+1. Traverse the array once.
+2. Count the number of indices `i` such that  
+   `nums[i] > nums[(i + 1) % n]`.
+3. If this count exceeds `1`, return `false`.
+4. Otherwise, return `true`.
+
+The modulo allows comparison of the **last element with the first**, which is required because rotation is circular.
+
+
+
+### Complexity
+
+#### Time complexity
+- **O(n)** — a single pass through the array.
+
+#### Space complexity
+- **O(1)** — no extra space used.
+
+### Code
+---
+```cpp
+// Conceptual brute force idea:
+// Sort the array, then try all rotations and compare.
+// This is not implemented here because it is unnecessary and inefficient.
+```
+---
+### Optimal Code
+---
+```cpp
+class Solution {
+public:
+    bool check(vector<int>& nums) {
+        int n = nums.size();
+        int drops = 0;
+
+        for (int i = 0; i < n; i++) {
+            if (nums[i] > nums[(i + 1) % n]) {
+                drops++;
+                if (drops > 1)
+                    return false;
+            }
+        }
+        return true;
+    }
+};
+```
+
+## Key Takeaway
+
+> A sorted and rotated array can have **at most one inversion** when treated as circular.