Arrays-இல் Special Cases - படிப்படையாக புரிந்துகொள்வோம்

“Special Cases” என்றால் என்ன?

பொதுவாக arrays-ஐ நாம் நேராக (linear) பார்க்கிறோம்:

nums = [1, 2, 3, 4]

ஆனால் real problems-ல்:

• Array ஒரு circle போல நடக்கலாம்
• Duplicate values இருக்கலாம்
• Array-ஐ பகுதியாக reverse செய்ய வேண்டி வரலாம்
• Extra memory இல்லாமல் மாற்ற வேண்டும்

இந்த மாதிரியான சூழ்நிலைகளே special cases என்று அழைக்கப்படுகின்றன.

---

1. Circular array handling - circular_array_handling

Circular array என்றால் என்ன?

Array ஒரு வட்டமாக (circle) இணைக்கப்பட்டுள்ளது என்று நினைத்துக்கொள்ளுங்கள்:

[1, 2, 3, 4]
 ↑         ↓
 └─────────┘

Last element-க்குப் பின் மீண்டும் முதல் element வரும்.

முக்கிய யோசனை

Index-ஐ சரியா வைத்துக்கொள்ள modulo (%) பயன்படுத்துகிறோம்.

def get_value(nums, i):
    n = len(nums)
    return nums[i % n]

உதாரணம்

nums = [10, 20, 30, 40]

print(nums[4 % 4])  # index 0 → 10
print(nums[5 % 4])  # index 1 → 20

முக்கிய புரிதல்

• % n index-ஐ valid range-க்குள் வைத்திடும்
• Wrap-around தானாக வேலை செய்யும்

---

2. Circular traversal - circular_traversal

ஒரு குறிப்பிட்ட இடத்திலிருந்து தொடங்கி, அனைத்து elements-ஐ ஒருமுறை பார்க்க வேண்டும்.

def traverse(nums, start):
    n = len(nums)

    for step in range(n):
        i = (start + step) % n
        print(nums[i])

உதாரணம் / output

nums = [10, 20, 30, 40]
start = 2

30
40
10
20

முக்கிய யோசனை

(start + step) % n மூலம் சுற்றி செல்லலாம் - எல்லா elements-ஐ ஒருமுறை மட்டும் பார்க்கலாம்.

---

3. Duplicate handling - duplicate_handling

Array-இல் ஒரே value பலமுறை இருக்கலாம்.

வேறு வேறு problems → வேறு வேறு solutions.

Case 1: Sorted array-ல் duplicates remove

def remove_duplicates(nums):
    if not nums:
        return 0

    write = 0

    for read in range(1, len(nums)):
        if nums[read] != nums[write]:
            write += 1
            nums[write] = nums[read]

    return write + 1

உதாரணம்

nums = [1, 1, 2, 2, 3]

விளைவு (கருத்து):

[1, 2, 3, _, _] (unique பகுதி அளவு return ஆகும்)

முக்கிய யோசனை

• ஒரு pointer read
• மற்றொன்று unique values எழுதும்

---

Case 2: Duplicate count

from collections import Counter

nums = [1, 2, 2, 3]
print(Counter(nums))

பயன்பாடு

ஒவ்வொரு value எத்தனை முறை வந்துள்ளது என அறிய.

---

4. Group reversal - group_reversal

Array-ஐ பகுதிகளாக (groups) reverse செய்வது.

உதாரணம்

nums = [1, 2, 3, 4, 5, 6]
k = 2

விளைவு:

[2, 1, 4, 3, 6, 5]

Code

def reverse_range(arr, l, r):
    while l < r:
        arr[l], arr[r] = arr[r], arr[l]
        l += 1
        r -= 1


def reverse_in_groups(arr, k):
    for i in range(0, len(arr), k):
        reverse_range(arr, i, min(i + k - 1, len(arr) - 1))

முக்கிய யோசனை

• Array-ஐ blocks-ஆக பிரி
• ஒவ்வொரு block-ஐ reverse செய்
• கடைசி group சிறியதாயிருக்கும் போது தவறாமல் சரியான right bound பயன்படுத்துங்கள் - பொதுவாக min(i + k - 1, len(arr) - 1)

---

5. Sublist reversal - sublist_reversal

Sublist reversal என்பது: nums[l … r] (inclusive) என்ற continuous slice மட்டும் reverse செய்து, மீதமுள்ள array-ஐ மாற்றாமல் விடுவது.

இது reverse_range-இன் இரண்டு-pointer swap core-ஐயே பயன்படுத்துகிறது; இங்கு (l, r) எந்த window-க்கும் பொருந்தும் - k அளவு group மட்டும் அல்ல.

In-place (memory முக்கியமான போது)

def reverse_range(arr, l, r):
    while l < r:
        arr[l], arr[r] = arr[r], arr[l]
        l += 1
        r -= 1


nums = [10, 20, 30, 40, 50]
reverse_range(nums, 1, 3)
# nums → [10, 40, 30, 20, 50]

செலவு

அந்த slice-க்கு சுமார் O(r - l + 1); புதிய array தேவையில்லை.

Python shortcut (புதிய list உருவாகும்)

nums = [10, 20, 30, 40, 50]
nums[1:4] = nums[1:4][::-1]

சிறு script-க்கு போதும்; interview-கள் பெரும்பாலும் reverse_range போன்ற in-place mutation கேட்கும்.

மற்ற பாடங்களுடன் தொடர்பு

• group_reversal → ஒவ்வொரு k block-க்கும் sublist reversal மீண்டும்
• recursion_array_reversal → reverse_range-ஐ வேறு விதமாக எழுதுதல்

---

6. Recursion array reversal - recursion_array_reversal

மேலே reverse_range while loop மூலம் இரண்டு index-களை நகர்த்தி reverse செய்தீர்கள்.

Recursive வடிவம் அதே யோசனை, வேறு syntax:

1. வெளி ஜோடி arr[l] மற்றும் arr[r] swap
2. சிறிய window [l + 1 … r - 1] மீது recurse
3. l >= r என்றால் stop (swap இல்லை)

def reverse_range_rec(arr, l, r):
    if l >= r:
        return

    arr[l], arr[r] = arr[r], arr[l]
    reverse_range_rec(arr, l + 1, r - 1)


nums = [1, 2, 3, 4]
reverse_range_rec(nums, 0, len(nums) - 1)
# nums → [4, 3, 2, 1]

ஏன் recursion கற்க இது நல்ல pattern?

• ஒவ்வொரு call-லும் சிறிய subproblem
• தெளிவான base case (l >= r)
• ஒரு சிறிய படி (swap) + recursive call-ஐ நம்புதல்

நினைவில் வைக்கவும்

மிகப் பெரிய array-க்கு Python recursion depth limit வரலாம்; production-ல் பொதுவாக iterative loop பயன்படுத்துவார்கள். கற்றலுக்கு இந்த pattern பயனுள்ளது.

---

7. In-place modification - in_place_modification

சில problems-ல் extra memory பயன்படுத்த அனுமதி இருக்காது.

உதாரணம் - zeros-ஐ end-க்கு நகர்த்துதல்

def move_zeros(nums):
    pos = 0

    for i in range(len(nums)):
        if nums[i] != 0:
            nums[pos], nums[i] = nums[i], nums[pos]
            pos += 1

உதாரணம்

nums = [0, 1, 0, 3, 12]

விளைவு (அதே array-இல் in-place):

[1, 3, 12, 0, 0]

முக்கிய யோசனை

• swap பயன்படுத்தி மாற்றுதல்
• புதிய array உருவாக்காமல் செய்யுதல்

ஏன் in-place முக்கியம்?

• Memory save ஆகும்
• Interview-ல் முக்கியம்
• Performance மேம்படும்

---

8. In-place merge (sorted arrays) - in_place_merge

Interview-ல் அடிக்கடி வரும் ஒரு சிறப்பு case:

இரண்டு sorted arrays-ஐ merge செய்து, result-ஐ முதல் array-இலேயே (in-place) அமைக்க வேண்டும்.

nums1 = [1, 2, 3, 0, 0, 0]
m = 3
nums2 = [2, 5, 6]
n = 3

சிறந்த in-place யோசனை: பின்னால் இருந்து நிரப்புதல்.

def merge(nums1, m, nums2, n):
    i = m - 1
    j = n - 1
    k = m + n - 1

    while j >= 0:
        if i >= 0 and nums1[i] > nums2[j]:
            nums1[k] = nums1[i]
            i -= 1
        else:
            nums1[k] = nums2[j]
            j -= 1
        k -= 1

nums1-ல் கிடைக்கும் output:

[1, 2, 2, 3, 5, 6]

முக்கிய யோசனை:

• மீதமுள்ள பெரிய values-ஐ ஒப்பிடு
• வலப்புற கடைசி இடத்தில் இடு
• extra array memory தவிர்

---

அனைத்து concepts சுருக்கம்

Concept	முக்கிய யோசனை
Circular handling	% n மூலம் wrap
Circular traversal	(start + step) % n
Duplicate handling	Two pointers / Counter
Group reversal	Block-wise reverse
Sublist reversal	ஒரே [l … r] window-ஐ in-place reverse
Recursion reversal	விளிம்பு swap, [l+1 … r-1] மீது recurse
In-place merge	3 pointers வைத்து பின்னால் இருந்து merge
In-place	swap மூலம் மாற்றம்

---

பொதுவான பிழைகள்

• modulo பயன்படுத்த மறந்து விடுதல்
• off-by-one பிழைகள்
• unnecessary memory பயன்படுத்துதல்
• last group-ஐ தவறாக handle செய்தல் (min bound)

---

பயிற்சி

• Circular traversal செய்யுங்கள்
• Sorted array-ல் duplicates remove செய்யுங்கள்
• Array-ஐ k groups-ஆக reverse செய்யுங்கள்
• l…r slice மட்டும் in-place reverse (sublist_reversal)
• [l … r] range-ஐ recursion மூலம் reverse செய்யுங்கள்
• Zeros-ஐ end-க்கு நகர்த்துங்கள்
• Array rotate செய்யுங்கள் (modulo யோசனையுடன்)

---

இறுதி புரிதல்

Special cases என்பது:

• edge conditions-ஐ handle செய்வது
• careful logic தேவைப்படுவது
• efficient code எழுத உதவுவது