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

Iteration - அடிப்படை புரிதல்

ஒரு array என்பது பல தரவுகளை (values) ஒரே இடத்தில் வைத்திருக்கும் ஒரு அமைப்பு.

இந்த தரவுகளைப் பயன்படுத்த வேண்டுமெனில், அவற்றை ஒன்றன் பின் ஒன்றாக அணுக வேண்டும். இந்த செயல்முறையே Iteration எனப்படுகிறது.

எளிய விளக்கம்:

ஒரு array-இல் உள்ள ஒவ்வொரு value-ஐ தனித்தனியாகப் பார்த்து செயல்படுத்துவது Iteration.

அடிப்படை Loop உதாரணம்

nums = [10, 20, 30]

for x in nums:
    print(x)

விளக்கம்

nums array-இல் உள்ள values: 10, 20, 30

loop ஒவ்வொரு value-ஐ எடுத்துக் கொண்டு செயல்படுகிறது

அதனால் output:

10
20
30

Index (இடம்) பயன்படுத்த வேண்டிய சூழல்

சில சமயங்களில் value மட்டும் போதாது, அதன் position (index) முக்கியமாக இருக்கும்.

nums = [10, 20, 30]

for i in range(len(nums)):
    print(i, nums[i])

விளக்கம்

• i → index (0, 1, 2)
• nums[i] → அந்த index-இல் உள்ள value

Output:

0 10
1 20
2 30

எப்போது பயன்படுத்த வேண்டும்?

• அடுத்த value-ஐ ஒப்பிட வேண்டியபோது
• values-ஐ மாற்ற வேண்டியபோது
• position அடிப்படையிலான logic தேவைப்பட்டால்

Range-based iteration - range_based_iteration

Range-based iteration என்பது: Python range() மூலம் எந்த index-களை பார்க்க வேண்டும் என்று தேர்வு செய்து, arr[i]-ஐ பயன்படுத்துவது.

அனைத்து index-களும்

nums = [10, 20, 30]

for i in range(len(nums)):
    print(nums[i])

array-இன் ஒரு பகுதி மட்டும்

range(start, stop) → start முதல் stop - 1 வரை (stop index உட்பட இல்லை).

nums = [10, 20, 30, 40, 50]

# indices 1, 2, 3 மட்டும்
for i in range(1, 4):
    print(nums[i])

step (இடைவெளி)

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

# indices 0, 2, 4
for i in range(0, len(nums), 2):
    print(nums[i])

Index math, subrange, அல்லது step தேவைப்பட்டால் range(...) பயன்படுத்துங்கள்.

Conditional Filtering (நிபந்தனை அடிப்படையிலான தேர்வு) - conditional_filtering

Iteration செய்யும் போது, எல்லா values-ஐயும் பயன்படுத்த வேண்டிய அவசியம் இல்லை. சில values மட்டும் தேவையாக இருக்கலாம்.

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

result = []

for x in nums:
    if x % 2 == 0:
        result.append(x)

print(result)

விளக்கம்

• ஒவ்வொரு value-ஐ சரிபார்க்கிறோம்
• even number என்றால் மட்டும் சேமிக்கிறோம்

Output:

[2, 4]

Threshold filtering - threshold_filtering

Threshold filtering என்பது: ஒரு எண் வரம்பு (threshold) அடிப்படையில் values-ஐ தேர்வு அல்லது எண்ண செய்வது.

உதாரணங்கள்:

• தேர்ச்சி மதிப்பெண்: >= 40
• பட்ஜெட்: விலை <= 100
• எச்சரிக்கை: வெப்பநிலை > 37.5

scores = [55, 38, 72, 40, 22]
pass_mark = 40

passed = [s for s in scores if s >= pass_mark]
print(passed)  # [55, 72, 40]

count = sum(1 for s in scores if s >= pass_mark)
print(count)  # 3

இது filtering-ஐப் போலவே - இங்கு நிபந்தனை பொதுவாக ஒரு boundary எண்ணுடன் < / > / <= / >=.

Count Tracking (எண்ணிக்கை கண்காணித்தல்) - count_tracking

சில பிரச்சினைகளில் values-ஐ சேமிப்பதற்குப் பதிலாக, எண்ணிக்கை மட்டும் தேவையாக இருக்கும்.

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

count = 0

for x in nums:
    if x > 0:
        count += 1

print(count)

விளக்கம்

• count ஆரம்பத்தில் 0
• condition சரியானபோது increment செய்கிறோம்

Output:

2

Timeline processing - timeline_processing

Timeline processing என்பது: array நேர வரிசையில் (நாள் 0, 1, 2, … அல்லது மணி வரிசை) ordered ஆக இருப்பதால், அந்த வரிசையிலேயே இடது→வலது scan செய்து - பெரும்பாலும் running total அல்லது முந்தைய படிகளை சார்ந்த விதி - செயலாக்குவது.

உதாரணம்: ஒவ்வொரு நாளுக்கும் events

events_per_day = [0, 2, 1, 0, 3]
running = 0

for day, count in enumerate(events_per_day):
    running += count
    print(day, "மொத்தம் =", running)

Index நேர வரிசை என்றால் ஒரே loop போதும்.

வரிசை முக்கியம்

தரவு நேர வரிசையில் இல்லை என்றால் முதலில் sort செய்ய வேண்டும் - பிரச்சினை “timestamp” கொடுத்தால் கவனிக்கவும்.

Two-pass algorithm - two_pass_algorithm

சில நேரங்களில் ஒரு scan போதாது - ஏனெனில் ஒவ்வொரு element-க்கும் விதி முழு array பற்றிய தகவல் தேவை.

nums = [10, 20, 30, 40]

# கட்டம் 1 - summary (இங்கு: average)
total = 0
for x in nums:
    total += x

avg = total / len(nums)

# கட்டம் 2 - summary-ஐ பயன்படுத்தி ஒவ்வொன்றையும் சோதி
for x in nums:
    if x > avg:
        print(x)

Output:

30
40

நேரம்: O(n) + O(n) = O(n) - இன்னும் linear.

Two-pass logic - two_pass_logic

Two-pass logic என்பது வடிவமைப்பு: பிரச்சினையை கட்டங்களாகப் பிரி, ஒவ்வொரு கட்டத்திற்கும் ஒரு தெளிவான வேலை.

பொதுவாக:

1. கட்டம் A (aggregate): அனைத்து values-ஐயும் பார்த்து summary (sum, max, …)
2. கட்டம் B (apply): ஒவ்வொரு value-க்கும் A-வின் முடிவைப் பயன்படுத்து

ஏன்?

• சரியான தன்மை: > average போன்ற விதிகள் summary இல்லாமல் element-wise மட்டும் முடியாது.
• தெளிவு: ஒரு trickier one-pass இருந்தாலும் இரண்டு குட்டி loop படிக்க எளிது.

இது two_pass_algorithm pattern-உடன் ஒன்றே - இங்கு பல கட்டங்களாகப் பிரித்தல் என்பதை stress செய்கிறோம்.

Frequency Array Comparison (சிறு அறிமுகம்)

சில நேரங்களில் இரண்டு arrays-ல் உள்ள values ஒன்றேதானா என்று மட்டும் அல்ல,
ஒவ்வொரு value எத்தனை முறை வந்துள்ளது என்பதையும் ஒப்பிட வேண்டும்.

உதாரணம்:

a = [1, 2, 2, 3]
b = [2, 1, 3, 2]

இரண்டு arrays-லும்:

• 1 -> 1 முறை
• 2 -> 2 முறை
• 3 -> 1 முறை

அதனால் இவை frequency அடிப்படையில் சமம்.

Python-ல் சுருக்கமாக:

from collections import Counter
print(Counter(a) == Counter(b))  # True

செயல்திறன் (Time Complexity)

• ஒரு loop → O(n)
• இரண்டு loop → O(n) + O(n) = O(n) - two_pass_algorithm / two_pass_logic பார்க்கவும்

அதாவது, இரண்டு loop இருந்தாலும் செயல்திறன் பாதிக்கப்படாது.

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

• தேவையில்லாமல் index loop பயன்படுத்துதல்
• condition எழுத மறந்து விடுதல்
• count initialize செய்யாமல் விடுதல்
• அனைத்து logic-ஐ ஒரே loop-ல் நிரப்ப முயற்சித்தல்

பயிற்சி

• 10-ஐ விட பெரிய values எத்தனை?
• அனைத்து odd numbers-ஐ print செய்யுங்கள்
• 5-ஆல் வகுபடும் values-ஐ சேமிக்கவும்
• negative values எண்ணிக்கை காண்க
• indices 2 முதல் 4 வரை print செய்ய - range(2, 5) பயன்படுத்தவும்
• pass mark threshold-இல் scores filter (threshold_filtering)
• நாள் வாரியான array-இல் running total (timeline_processing)
• average பிறகு ஒப்பிடு எடுத்துக்காட்டில் கட்டம் 1 vs 2 பெயரிடு (two_pass_logic)

முக்கிய குறிப்புகள்

• Iteration → values-ஐ ஒன்றன்பின் ஒன்று அணுகுதல்
• Loop → iteration செய்யும் கருவி
• range(...) → எந்த index-களை நடக்க வேண்டும் என்று தேர்வு (range-based iteration)
• Condition → தேர்வு; threshold எண் வரம்பு → threshold_filtering
• நேர வரிசை தரவு → index order-இல் scan (timeline_processing)
• Count → அளவை கண்காணிக்க பயன்படும்
• முழு summary முதலில் வேண்டுமெனில் இரண்டு கட்டம் (two_pass_algorithm, two_pass_logic)

அடுத்த படி

Iteration பற்றி புரிந்த பின், அடுத்ததாக கற்றுக்கொள்ள வேண்டியது:

• Sum
• Minimum
• Maximum

Continue here:

/resources/arrays/traversal-patterns