റീസണിങ് കോഡിംഗ് മാസ്റ്റർ - ക്വിക്ക് റിവിഷൻ

# Reasoning-Coding-Master: ഒരു യാന്ത്രിക ചിന്താ-കോഡിംഗ് ഏജന്റ്

## 1. പരിചയം

**Reasoning-Coding-Master** (RCM) എന്നത് ഒരു യാന്ത്രിക ചിന്താ-കോഡിംഗ് ഏജന്റാണ്, ഇത് പ്രോബ്ലം സ്റ്റേറ്റ്മെന്റുകൾ വായിച്ച്, ആഴത്തിലുള്ള ചിന്തയിലൂടെ പോകുകയും, പിന്നെ കൃത്യമായ, പരിശോധിച്ച കോഡ് ഉത്പാദിപ്പിക്കുകയും ചെയ്യുന്നു.  
ഇത് ഒരു **ഏകദേശ ഘട്ടപ്രക്രിയ** അനുസരിക്കുന്നു:  
1. **വായനയും വിശകലനവും** – പ്രശ്നം മനസ്സിലാക്കുക.  
2. **ആഴത്തിലുള്ള ചിന്ത** – ഉപപ്രശ്നങ്ങൾ വിഭജിക്കുക, അല്ഗോരിതം തിരഞ്ഞെടുക്കുക, കോർണർ കേസുകൾ കൈകാര്യം ചെയ്യുക.  
3. **കോഡിംഗ്** – വ്യക്തമായ, വായിക്കാവുന്ന, കാര്യക്ഷമമായ കോഡ് എഴുതുക.  
4. **സ്വയം പരിശോധന** – ഉദാഹരണങ്ങൾക്കെതിരെ റൺ ചെയ്യുക, പിശകുകൾ പരിഹരിക്കുക, കമ്പ്ലക്സിറ്റി വിശകലനം ചെയ്യുക.  

ഈ ഏജന്റ് **ഒരു യഥാർത്ഥ മനുഷ്യൻപോലെ ചിന്തിക്കുന്നു**, പക്ഷേ **അതിന്റെ മുഴുവൻ ചിന്താ പ്രോസസും** ട്രാൻസ്പറന്റ് ആയി പ്രദർശിപ്പിക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് അതിന്റെ റീസണിംഗ് പാത്ത് കാണാം.

---

## 2. പ്രവർത്തന ഘടന

### 2.1 ഹൈ-ലെവൽ ഫ്ലോ

```mermaid
graph TD
    A[പ്രശ്നം ലഭിച്ചു] --> B[വായനയും വിശകലനവും]
    B --> C[ആഴത്തിലുള്ള ചിന്ത]
    C --> D[അല്ഗോരിതം തിരഞ്ഞെടുക്കൽ]
    D --> E[കോഡ് എഴുതൽ]
    E --> F[സ്വയം പരിശോധന]
    F --> G{പാസായോ?}
    G -->|അതെ| H[അന്തിമ ഉത്തരം]
    G -->|ഇല്ല| I[പിശക് പരിഹരിക്കൽ]
    I --> E

2.2 പ്രധാന ഘടകങ്ങൾ

ഘടകം ഉദ്ദേശ്യം
ProblemReader പ്രശ്നം പാര്സ് ചെയ്യുക, ഇൻപുട്ട്/ഔട്ട്പുട്ട് ഫോർമാറ്റുകൾ വ്യക്തമാക്കുക.
Reasoner ഉപപ്രശ്നങ്ങൾ വിഭജിക്കുക, അല്ഗോരിതം തിരഞ്ഞെടുക്കുക, കോർണർ കേസുകൾ കൈകാര്യം ചെയ്യുക.
Coder വ്യക്തമായ, വായിക്കാവുന്ന, കാര്യക്ഷമമായ കോഡ് ഉത്പാദിപ്പിക്കുക.
Tester ഉദാഹരണങ്ങൾക്കെതിരെ റൺ ചെയ്യുക, പിശകുകൾ കണ്ടെത്തുക, കമ്പ്ലക്സിറ്റി വിശകലനം ചെയ്യുക.

3. പ്രവർത്തന ക്രമം

3.1 ഘട്ടം 1: വായനയും വിശകലനവും

  1. പ്രശ്നം വായിക്കുക – മുഴുവൻ ടെക്സ്റ്റ് സ്കാൻ ചെയ്യുക.
  2. ഇൻപുട്ട്/ഔട്ട്പുട്ട് ഫോർമാറ്റ് വ്യക്തമാക്കുക – എന്താണ് നൽകിയിരിക്കുന്നത്, എന്താണ് പ്രതീക്ഷിക്കുന്നത്?
  3. നിയന്ത്രണങ്ങൾ കണ്ടെത്തുക – സമയം, മെമ്മറി, എഡ്ജ് കേസുകൾ.
  4. ഉദാഹരണങ്ങൾ പരിശോധിക്കുക – ഉദാഹരണ ഇൻപുട്ടുകളും ഔട്ട്പുട്ടുകളും മനസ്സിലാക്കുക.

ഉദാഹരണം:

പ്രശ്നം: ഒരു n x n ഗ്രിഡ് നൽകിയിട്ടുണ്ട്. ഓരോ സെല്ലും 0 (ഖാലി) അല്ലെങ്കിൽ 1 (തടസ്സം) ആകാം. ഖാലി സെല്ലുകളിൽ നിന്ന് ഏറ്റവും വലിയ വർഗ്ഗത്തിന്റെ വലിപ്പം കണ്ടെത്തുക.

വിശകലനം:

  • ഇൻപുട്ട്: grid[n][n]
  • ഔട്ട്പുട്ട്: int – ഏറ്റവും വലിയ വർഗ്ഗത്തിന്റെ വലിപ്പം
  • നിയന്ത്രണങ്ങൾ: 1 <= n <= 1000
  • ഉദാഹരണം: 
    ഇൻപുട്ട്: [[0,1],[1,0]]
ഔട്ട്പുട്ട്: 1

3.2 ഘട്ടം 2: ആഴത്തിലുള്ള ചിന്ത

  1. ഉപപ്രശ്നങ്ങൾ വിഭജിക്കുക
    • ഓരോ ഖാലി സെല്ലും ഒരു വർഗ്ഗത്തിന്റെ ഭാഗമാണോ?
    • ഓരോ വർഗ്ഗത്തിന്റെയും വലിപ്പം എങ്ങനെ കണക്കാക്കാം?
  2. അല്ഗോരിതം തിരഞ്ഞെടുക്കൽ
    • DFS (Depth-First Search) – ഓരോ ഖാലി സെല്ലിൽ നിന്നും DFS നടത്തുക.
    • BFS (Breadth-First Search) – ഓരോ ഖാലി സെല്ലിൽ നിന്നും BFS നടത്തുക.
  3. കോർണർ കേസുകൾ കൈകാര്യം ചെയ്യുക
    • എല്ലാ സെല്ലുകളും 1 ആണെങ്കിൽ?
    • എല്ലാ സെല്ലുകളും 0 ആണെങ്കിൽ?
    • n = 1 ആണെങ്കിൽ?

അല്ഗോരിതം തിരഞ്ഞെടുക്കൽ:

  • DFS റിക്രഷൻ പരിധി മറികടക്കാൻ സാധ്യതയുള്ളതിനാൽ BFS ഉപയോഗിക്കുക.

3.3 ഘട്ടം 3: കോഡിംഗ്

from collections import deque

def largest_square_area(grid):
    n = len(grid)
    if n == 0:
        return 0
    
    max_area = 0
    directions = [(-1,0), (1,0), (0,-1), (0,1)]
    
    for i in range(n):
        for j in range(n):
            if grid[i][j] == 0:
                # BFS ആരംഭിക്കുക
                queue = deque([(i, j)])
                grid[i][j] = 1  # സന്ദർശിച്ചതായി അടയാളപ്പെടുത്തുക
                area = 0
                
                while queue:
                    x, y = queue.popleft()
                    area += 1
                    
                    for dx, dy in directions:
                        nx, ny = x + dx, y + dy
                        if 0 <= nx < n and 0 <= ny < n and grid[nx][ny] == 0:
                            grid[nx][ny] = 1
                            queue.append((nx, ny))
                
                max_area = max(max_area, area)
    
    return max_area

3.4 ഘട്ടം 4: സ്വയം പരിശോധന

  1. ഉദാഹരണങ്ങൾക്കെതിരെ റൺ ചെയ്യുക
    • ഉദാഹരണം 1: [[0,1],[1,0]] → 1 ✔️
    • ഉദാഹരണം 2: [[0,0],[0,0]] → 4 ✔️
    • ഉദാഹരണം 3: [[1,1],[1,1]] → 0 ✔️
  2. പിശകുകൾ കണ്ടെത്തുക
    • ഓരോ സെല്ലും ഒരിക്കൽ മാത്രമേ സന്ദർശിക്കപ്പെടേണ്ടതുള്ളൂ.
    • grid മാറ്റുന്നത് ഓറിജിനൽ ഇൻപുട്ട് നശിപ്പിക്കും.
  3. പിശക് പരിഹരിക്കൽ
    • visited സെറ്റ് ഉപയോഗിക്കുക.

പരിഹാരം:

from collections import deque

def largest_square_area(grid):
    n = len(grid)
    if n == 0:
        return 0
    
    max_area = 0
    directions = [(-1,0), (1,0), (0,-1), (0,1)]
    visited = [[False for _ in range(n)] for _ in range(n)]
    
    for i in range(n):
        for j in range(n):
            if grid[i][j] == 0 and not visited[i][j]:
                queue = deque([(i, j)])
                visited[i][j] = True
                area = 0
                
                while queue:
                    x, y = queue.popleft()
                    area += 1
                    
                    for dx, dy in directions:
                        nx, ny = x + dx, y + dy
                        if 0 <= nx < n and 0 <= ny < n and grid[nx][ny] == 0 and not visited[nx][ny]:
                            visited[nx][ny] = True
                            queue.append((nx, ny))
                
                max_area = max(max_area, area)
    
    return max_area
  1. കമ്പ്ലക്സിറ്റി വിശകലനം
    • സമയ കമ്പ്ലക്സിറ്റി: O(n^2) – ഓരോ സെല്ലും ഒരിക്കൽ മാത്രം സന്ദർശിക്കുന്നു.
    • സ്പേസ് കമ്പ്ലക്സിറ്റി: O(n^2) – visited മാട്രിക്സിനായി.

4. ഉദാഹരണ പ്രവർത്തനം

4.1 പ്രശ്നം: “Two Sum”

പ്രശ്നം: ഒരു ഇന്റേജർ അറേയും ഒരു ടാർഗറ്റ് സംഖ്യയും നൽകിയിട്ടുണ്ട്. രണ്ട് സംഖ്യകളുടെ സമ്മാനം ടാർഗറ്റിന് തുല്യമാകുന്ന ഇൻഡെക്സുകൾ കണ്ടെത്തുക.

ഇൻപുട്ട്: nums = [2,7,11,15], target = 9
ഔട്ട്പുട്ട്: [0,1] (കാരണം 2 + 7 = 9)

4.2 ഘട്ടം 1: വായനയും വിശകലനവും

  • ഇൻപുട്ട്: List[int] nums, int target
  • ഔട്ട്പുട്ട്: List[int] – രണ്ട് ഇൻഡെക്സുകൾ
  • നിയന്ത്രണങ്ങൾ:
    • 2 <= len(nums) <= 10^4
    • ഓരോ ഇൻപുട്ടിനും കൃത്യമായ ഒരു പരിഹാരമുണ്ടാകും.

4.3 ഘട്ടം 2: ആഴത്തിലുള്ള ചിന്ത

  1. ഉപപ്രശ്നങ്ങൾ വിഭജിക്കുക
    • ഓരോ എലമെന്റും target - nums[i] എന്നത് അറേയിൽ ഉണ്ടോ എന്ന് പരിശോധിക്കുക.
  2. അല്ഗോരിതം തിരഞ്ഞെടുക്കൽ
    • ബ്രൂട്ട് ഫോഴ്സ്: O(n^2) – ഓരോ ജോഡിയും പരിശോധിക്കുക.
    • ഹാഷ് മാപ്പ്: O(n) – target - nums[i] എന്നത് മുമ്പ് കണ്ടിട്ടുണ്ടോ എന്ന് സ്റ്റോർ ചെയ്യുക.
  3. കോർണർ കേസുകൾ
    • nums = [3,3], target = 6 → [0,1] ✔️

അല്ഗോരിതം തിരഞ്ഞെടുക്കൽ: ഹാഷ് മാപ്പ് (O(n) സമയം).

4.4 ഘട്ടം 3: കോഡിംഗ്

def two_sum(nums, target):
    num_to_index = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in num_to_index:
            return [num_to_index[complement], i]
        num_to_index[num] = i
    return []

4.5 ഘട്ടം 4: സ്വയം പരിശോധന

  1. ഉദാഹരണങ്ങൾക്കെതിരെ റൺ ചെയ്യുക
    • ഉദാഹരണം 1: nums = [2,7,11,15], target = 9 → [0,1] ✔️
    • ഉദാഹരണം 2: nums = [3,2,4], target = 6 → [1,2] ✔️
    • ഉദാഹരണം 3: nums = [3,3], target = 6 → [0,1] ✔️
  2. കമ്പ്ലക്സിറ്റി വിശകലനം
    • സമയ കമ്പ്ലക്സിറ്റി: O(n) – ഓരോ എലമെന്റും ഒരിക്കൽ മാത്രം പരിശോധിക്കുന്നു.
    • സ്പേസ് കമ്പ്ലക്സിറ്റി: O(n) – ഹാഷ് മാപ്പിനായി.

5. കോർണർ കേസ് കൈകാര്യം ചെയ്യൽ

5.1 സാധാരണ കോർണർ കേസുകൾ

കേസ് പരിഹാരം
എല്ലാ ഇൻപുട്ടുകളും അസാധുവാണ് if not nums: return []
ഒറ്റ ഇൻപുട്ട് മാത്രം if len(nums) == 1: return []
നെഗറ്റീവ് സംഖ്യകൾ ഹാഷ് മാപ്പ് അതേപടി പ്രവർത്തിക്കുന്നു.
ഡുപ്ലിക്കേറ്റ് സംഖ്യകൾ ഹാഷ് മാപ്പ് ഇൻഡെക്സുകൾ ശരിയായി കൈകാര്യം ചെയ്യുന്നു.

5.2 ഉദാഹരണം: “Palindrome Number”

പ്രശ്നം: ഒരു ഇന്റേജർ നൽകിയിട്ടുണ്ട്. അത് ഒരു പാലിന്ഡ്രോം ആണോ എന്ന് പരിശോധിക്കുക.

ഇൻപുട്ട്: x = 121
ഔട്ട്പുട്ട്: True

കോർണർ കേസുകൾ:

  • നെഗറ്റീവ് സംഖ്യകൾ: എല്ലായ്പ്പോഴും False (ഉദാ. -121).
  • പൂജ്യം അവസാനത്തിലുള്ള സംഖ്യകൾ: False (ഉദാ. 10).

പരിഹാരം:

def is_palindrome(x):
    if x < 0:
        return False
    s = str(x)
    return s == s[::-1]

6. കമ്പ്ലക്സിറ്റി വിശകലനം

6.1 സമയ കമ്പ്ലക്സിറ്റി

അല്ഗോരിതം സമയ കമ്പ്ലക്സിറ്റി ഉദാഹരണം
ബ്രൂട്ട് ഫോഴ്സ് O(n^2) Two Sum (ബ്രൂട്ട് ഫോഴ്സ്)
ഹാഷ് മാപ്പ് O(n) Two Sum (ഹാഷ് മാപ്പ്)
BFS/DFS O(V + E) Largest Square Area

6.2 സ്പേസ് കമ്പ്ലക്സിറ്റി

അല്ഗോരിതം സ്പേസ് കമ്പ്ലക്സിറ്റി കാരണം
ഹാഷ് മാപ്പ് O(n) ഹാഷ് മാപ്പ് സ്റ്റോറേജ്
BFS O(n^2) ക്യൂ & വിസിറ്റഡ് മാട്രിക്സ്
DFS O(n^2) റിക്രഷൻ സ്റ്റാക്ക്

7. പിശക് പരിഹാരം

7.1 സാധാരണ പിശകുകൾ

പിശക് കാരണം പരിഹാരം
ഇൻഡെക്സ് ഔട്ട് ഓഫ് റേഞ്ച് അതിർത്തി പരിശോധിക്കാത്തത് 0 <= nx < n പരിശോധിക്കുക
ഇൻഫിനിറ്റ് ലൂപ്പ് വിസിറ്റഡ് അടയാളപ്പെടുത്താത്തത് visited സെറ്റ് ഉപയോഗിക്കുക
റിക്രഷൻ പരിധി ഡീപ് റിക്രഷൻ BFS ഉപയോഗിക്കുക

7.2 ഡീബഗ്ഗിംഗ് ഉദാഹരണം

പ്രശ്നം: largest_square_area ൽ visited ഇല്ലാത്തത് കാരണം ഇൻഫിനിറ്റ് ലൂപ്പ്.

പിശക്:

# തെറ്റായ കോഡ്
if grid[nx][ny] == 0:
    queue.append((nx, ny))  # visited അടയാളപ്പെടുത്തിയില്ല

പരിഹാരം:

if 0 <= nx < n and 0 <= ny < n and grid[nx][ny] == 0 and not visited[nx][ny]:
    visited[nx][ny] = True
    queue.append((nx, ny))

8. അന്തിമ ചെക്ക്‌ലിസ്റ്റ്

  • ഇൻപുട്ട്/ഔട്ട്പുട്ട് ഫോർമാറ്റ് ശരിയാണോ?
  • എല്ലാ കോർണർ കേസുകളും കൈകാര്യം ചെയ്തോ?
  • സമയ/സ്പേസ് കമ്പ്ലക്സിറ്റി വിശകലനം ചെയ്തോ?
  • ഉദാഹരണങ്ങൾക്കെതിരെ റൺ ചെയ്തോ?
  • കോഡ് വായിക്കാവുന്നതാണോ?

9. കൂടുതൽ ഉദാഹരണങ്ങൾ

9.1 പ്രശ്നം: “Merge Intervals”

പ്രശ്നം: ഓവർലാപ്പിംഗ് ഇന്റർവലുകൾ മെർജ് ചെയ്യുക.

ഇൻപുട്ട്: [[1,3],[2,6],[8,10],[15,18]]
ഔട്ട്പുട്ട്: [[1,6],[8,10],[15,18]]

അല്ഗോരിതം:

  1. ഇന്റർവലുകൾ സ്റ്റാർട്ട് ടൈം അനുസരിച്ച് സോർട്ട് ചെയ്യുക.
  2. ഓരോ ഇന്റർവലും പരിശോധിക്കുക, ഓവർലാപ്പ് ഉണ്ടെങ്കിൽ മെർജ് ചെയ്യുക.

കോഡ്:

def merge(intervals):
    if not intervals:
        return []
    
    intervals.sort(key=lambda x: x[0])
    merged = [intervals[0]]
    
    for current in intervals[1:]:
        last = merged[-1]
        if current[0] <= last[1]:
            last[1] = max(last[1], current[1])
        else:
            merged.append(current)
    
    return merged

9.2 പ്രശ്നം: “Valid Parentheses”

പ്രശ്നം: സ്ട്രിംഗ് ബാലൻസ്ഡ് പാരന്റസിസ് ആണോ എന്ന് പരിശോധിക്കുക.

ഇൻപുട്ട്: "()[]{}"
ഔട്ട്പുട്ട്: True

അല്ഗോരിതം:

  • സ്റ്റാക്ക് ഉപയോഗിക്കുക.
  • ഓപ്പണിംഗ് ബ്രാക്കറ്റ് കണ്ടാൽ പുഷ് ചെയ്യുക.
  • ക്ലോസിംഗ് ബ്രാക്കറ്റ് കണ്ടാൽ ടോപ്പ് പോപ്പ് ചെയ്ത് പരിശോധിക്കുക.

കോഡ്:

def is_valid(s):
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}
    
    for char in s:
        if char in mapping:
            top = stack.pop() if stack else '#'
            if mapping[char] != top:
                return False
        else:
            stack.append(char)
    
    return not stack

10. സമാപനം

Reasoning-Coding-Master എന്നത് ഒരു യാന്ത്രിക ഏജന്റാണ്, ഇത് വ്യക്തമായ റീസണിംഗ്, കൃത്യമായ കോഡിംഗ്, തീവ്രമായ ടെസ്റ്റിംഗ് എന്നിവയിലൂടെ പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നു.
ഇത് മനുഷ്യൻപോലെ ചിന്തിക്കുന്നു, പക്ഷേ അതിന്റെ മുഴുവൻ ചിന്താ പ്രോസസും ട്രാൻസ്പറന്റ് ആയി പ്രദർശിപ്പിക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് അതിന്റെ റീസണിംഗ് പാത്ത് കാണാം.

കുറിപ്പ്: ഈ ഏജന്റ് എല്ലാ പ്രശ്നങ്ങളും പരിഹരിക്കുന്നില്ല, പക്ഷേ അതിന്റെ റീസണിംഗ് പ്രോസസ്സ് മനസ്സിലാക്കാൻ സഹായിക്കുന്നു.


#### വൺ-ലൈനറുകൾ (20)  
1. A→1, B→2 … Z→26 – മുന്നോട്ടും പിന്നോട്ടും ചാടുന്നതിനായി വിരല്‍തുമ്പില്‍ സൂക്ഷിക്കുക.  
2. A-യുടെ എതിര്‍ദിശ Z ആണ് (1+26=27) – “27-നിയമം” മിറര്‍ കോഡുകള്‍ക്കായി ഉപയോഗിക്കുക.  
3. ഒരു വാക്കിന്റെ റിവേഴ്‌സ് എന്നത് ഓരോ അക്ഷരത്തിന്റെയും നമ്പറിന്റെ റിവേഴ്‌സ് ആണ്.  
4. +1, –1, ×2, ÷2 എന്നിവയാണ് ഏറ്റവും കൂടുതല്‍ ഉപയോഗിക്കുന്ന “ഓപ്പറേഷന്‍ ചെയിനുകള്‍”.  
5. “SENT → +1 each” കോഡില്‍, SENT = TFOU; Z→A ശേഷം വാപ്പ് ചെയ്യണമെന്ന് ഓര്‍ക്കുക.  
6. “GIFT → HJSU” എന്നത് +1, +2, +3, +4 പാറ്റേണ്‍ – വര്‍ദ്ധിച്ച പടികള്‍ ശ്രദ്ധിക്കുക.  
7. സ്വരം→വ്യഞ്ജനം സ്വാപ് കോഡുകള്‍: A↔B, E↔C, I↔D, O↔F, U↔G (സെറ്റുകളില്‍ ജനപ്രിയം).  
8. നമ്പര്‍ കോഡിംഗ്: അവസാന അക്ഷരത്തിന്റെ അക്ഷരമാല വിലയെ ആക്കി ഡിജിറ്റ് എടുക്കുക (CAT → 20).  
9. “A=%, B=@ …” എങ്കില്‍ – ആദ്യം 5-ചിഹ്ന × 5-അക്ഷര ഗ്രിഡ് വരച്ചു കാണുക.  
10. നിബന്ധന: “ആദ്യ അക്ഷരം സ്വരമെങ്കില്‍ → +2, അല്ലെങ്കില്‍ –1” – റിവേഴ്‌സ് ചെയ്യുന്നതിന് മുന്‍പ് പ്രയോഗിക്കുക.  
11. “SISTER 20-10-20-21-6-19 എന്ന് എഴുതുന്നു” – പ്ലേസ് വാല്യൂ 2-ഡിജിറ്റ് ഫോര്‍മാറ്റ് നിലനിര്‍ത്തുന്നു.  
12. “റിവേഴ്‌സ് + ഫോര്‍വേഡ്” മിക്സില്‍, പകുതികളെ വേറിട്ട് കൈകാര്യം ചെയ്യുക (PRACTICE → ECITCAR + EP).  
13. മാട്രിക്സ് കോഡുകള്‍ക്ക്, റോ = (pos – 1) ÷ 5; കോളം = ശിഷ്ടം (0→5).  
14. ഡിജിറ്റ്-അക്ഷര ബ്ലെന്‍ഡുകളില്‍, ഒറ്റക്കിടക്കുന്ന ഡിജിറ്റ് → 1 അക്ഷരം ഒഴിവാക്കുക, ഇരട്ട ഡിജിറ്റ് → 2 അക്ഷരങ്ങള്‍ ഒഴിവാക്കുക.  
15. “കോഡ് വിലകളുടെ SUM” ചോദ്യങ്ങള്‍ – ആദ്യം ചേര്‍ക്കുക, പിന്നെ 3/5 കൊണ്ട് ഹരിക്കുന്നതിന്റെ വിഭാജ്യത പരിശോധിക്കുക.  
16. കോഡില്‍ 3 ചിഹ്നങ്ങള്‍ മാത്രം ആവര്‍ത്തിക്കുന്നുണ്ടെങ്കില്‍, ട്രിപ്ലെറ്റ് സംശയിക്കുക (A→#, E→#, I→#).  
17. അവസാന-അക്ഷരം-ആദ്യ-അക്ഷരം ലിങ്ക്: അവസാന അക്ഷരത്തിന്റെ കോഡ് അടുത്ത വാക്കിന്റെ ആദ്യ നമ്പറായി മാറുന്നു.  
18. “പ്രൈം കൊണ്ട് ഷിഫ്റ്റ്” കോഡുകള്‍: 2, 3, 5, 7… – 26-ല്‍ താഴെയുള്ള പ്രൈംസ് ഒരിക്കല്‍ ലിസ്റ്റ് ചെയ്യുക.  
19. മിറര്‍ ജോഡി പരിശോധന: A-Z, B-Y… (13 ജോഡികള്‍) – 50 % സമയം ലാഭിക്കും.  
20. ഡീകോഡ് ചെയ്ത വാക്ക് ഉത്തര ഓപ്ഷനുകളില്‍ എപ്പോഴും പരിശോധിക്കുക – 3 ചോയിസുകള്‍ വേഗത്തില്‍ ഒഴിവാക്കാം.

#### ഫോർമുലകൾ/നിയമങ്ങൾ  

| ഫോർമുല / നിയമം | ഉപയോഗസാധ്യത |
|----------------|----------|
| 27 – pos = എതിര്‍ അക്ഷരം | തൽക്ഷണ മിറർ കോഡിംഗ് |
| (pos ± n) mod 26 → 0 ആണെങ്കിൽ 26 | ± ഷിഫ്റ്റുകൾക്ക് വ്രാപ്പ്-അറൗണ്ട് |
| Row = ⌈pos / 5⌉, Col = (pos–1) mod 5 + 1 | 5×5 മാട്രിക്സ് കോഡിംഗ് |
| ആദ്യ & അവസാന അക്ഷര കോഡുകളുടെ കൂട്ട് = മധ്യ അക്ഷര കോഡ് | മധ്യ-അക്ഷര പാറ്റേൺ പരിശോധിക്കുക |
| സ്വരസെറ്റ് {A,E,I,O,U} = {1,5,9,15,21} | വേഗത്തിൽ സ്വരം കണ്ടെത്തൽ |
| പ്രൈം പൊസിഷനുകൾ: 2,3,5,7,11,13,17,19,23 | പ്രൈം-ഷിഫ്റ്റ് കോഡിംഗ് |
| ഇവൻ-പൊസിഷൻ അക്ഷരങ്ങൾ ×2 → അക്കം; ഓഡ്-പൊസിഷൻ ÷2 → അക്കം | ഇവൻ-ഓഡ് സ്പ്ലിറ്റ് കോഡിംഗ് |
| Reverse(pos) = 27 – pos | റിവേഴ്സ് അൽഫബറ്റ് മൂല്യം |
| കോഡ് ചെയ്ത അക്കം → അക്ഷരം: 1=A, 2=B…9=I, 0=Z (വ്രാപ്പ്) | ഫോൺ-പാഡ് ശൈലി |
| ആദ്യ-അക്ഷര കോഡ് + അവസാന-അക്ഷര കോഡ് = സ്ഥിരം (k) | 3-വാക്ക് സെറ്റുകൾക്ക് k-നിയമം |

---

#### മെമ്മറി തന്ത്രങ്ങൾ (മനോനോമിക്‌സ്)  

1. **AZ-27**: “A-Z 27 ആണ്” – മിറർ സമ്മറി ഓർക്കാൻ ഒരു ഓട്ടോ-റിക്ഷ നമ്പർ ഓർക്കുക.  
2. **സ്വരങ്ങൾ 1-5-9-15-21**: “An Eagle Is On Umbrella” – ആദ്യാക്ഷരങ്ങളും നമ്പറുകളും ഉയരുന്നു.  
3. **5×5 മാട്രിക്സ്**: “അഞ്ച് സുഹൃത്തുക്കൾ അഞ്ച് വരികളിൽ” – വേഗത്തിൽ ഗ്രിഡ് വരയ്ക്കാൻ നിർബന്ധിക്കുന്നു.  
4. **ഷിഫ്റ്റ് പ്രൈംസ്**: “Two Three Five Seven – Two Thumbs For Victory” (2-3-5-7).  
5. **വ്രാപ്പ്-അറൗണ്ട്**: “Z-ക്ക് ശേഷം A വരുന്നു – ഞായറിന് ശേഷം തിങ്കളാഴ്ച പോലെ” – mod-26 ഒരിക്കലും മറക്കരുത്.

---

#### പൊതുവായ പിശകുകൾ

| സാധാരണ തെറ്റ് | ശരിയായ രീതി |
|---------------|------------------|
| Z+1→A പൊതിഞ്ഞില്ലെന്ന് മറക്കുക | എപ്പോഴും mod-26 പ്രയോഗിക്കുക; 0 ആണെങ്കിൽ 26 എന്ന് കണക്കാക്കുക |
| റിവേഴ്‌സ് ചെയ്ത് പിന്നെ ഷിഫ്റ്റ് ചെയ്യുന്നതും അതിന് മുമ്പ് ഷിഫ്റ്റ് ചെയ്ത് റിവേഴ്‌സ് ചെയ്യുന്നതും കൂട്ടിക്കുഴയ്ക്കുക | ചോദ്യത്തിലെ ക്രമം കൃത്യമായി പിന്തുടരുക |
| 26 ബാക്കി 0 എന്ന് എണ്ണുക | ബാക്കി 0 എന്നത് 26-ാമത്തെ അക്ഷരം (Z) എന്ന് അർത്ഥമാക്കുന്നു |
| A=0 എന്ന് ഉപയോഗിക്കുന്നത് A=1 എന്നതിന് പകരം | റെയിൽവേ സ്റ്റാൻഡേർഡുകൾ A=1 ഉപയോഗിക്കുന്നു; ഒരിക്കൽ ഉറപ്പാക്കുക |
| ഇരട്ട-അക്ഷര കോഡുകൾ (ഉദാ. CH, SH) അവഗണിക്കുക | digraph-കൾക്ക് പ്രത്യേക ചിഹ്നങ്ങൾ നൽകിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുക |

---

#### 5 ക്വിക്ക് MCQ-കൾ  

**Q1.** “ROSE” എന്നത് “58” ആയി കോഡ് ചെയ്താൽ “LOTUS”  
A) 60 B) 65 C) 70 D) 75  

**Q2.** ഒരു നിശ്ചിത കോഡിൽ “DELHI” എന്നത് “CDKGH” എന്ന് എഴുതുന്നു. “BCKGP” എന്ന് കോഡ് ചെയ്ത വാക്ക് ഏത്?  
A) CALIF B) CAMEL C) CABLE D) CADET  

**Q3.** A=#, B=@, C=%, D=$ എന്നിങ്ങനെയാണെങ്കിൽ “BAD”-ന്റെ കോഡ്  
A) @#$ B) @#% C) @%$ D) @$#  

**Q4.** “TEACH” → “HDIZX” എന്നത് മിറർ കോഡിംഗിലൂടെ. “EXAM” എന്താണ്?  
A) VCZN B) VCZO C) VCZN D) VEZO  

**Q5.** 2, 5, 10, 17, 26, … എന്ന പാറ്റേണിൽ ആറാമത്തെ പദത്തിന് ഏത് അക്ഷരമാണ് അനുബന്ധിക്കുന്നത്?  
A) Q B) R C) S D) T  

*(ഉത്തരങ്ങൾ: 1-B, 2-C, 3-A, 4-A, 5-D)*
RRB GROUP D

Exam Details

Practice Set

Previous Year Questions

Master Course RRB Group D Hinglish

Master Course RRB Group D English

RRB NTPC

Exam Details

Practice Set

Previous Year Questions

RPF SI

Exam Details

Practice Set

Previous Year Questions

RPF CONSTABLE

Exam Details

Previous Year Questions

RRB JE

Exam Details

Previous Year Questions

RRB ALP

Exam Details

Practice Set

Previous Year Questions

RRB TECHNICIAN

Exam Details

Practice Set

Previous Year Questions

NCERT Books

Class 06

Class 07

Class 08

Class 09

Class 10

Class 11

Class 12

Important Resources

Topic-wise Practice Hub

General Knowledge

Quick Revision

Railway GK

Maps

Contact Us

Forums

SATHEE Forums

icon  BETA

© 2014-2026 Copyright SATHEE

Privacy Policy

Powered by Prutor@IITK

sathee@iitk.ac.in
Media coverage of SATHEE
google

Play Store
apple

App Store
The Ministry of Education has launched the SATHEE initiative in association with IIT Kanpur to provide free guidance for competitive exams. SATHEE offers a range of resources, including reference video lectures, mock tests, and other resources to support your preparation. Please note that participation in the SATHEE program does not guarantee clearing any exam or admission to any institute.