emrevarol.com Materials
English Türkçe Español Kinyarwanda Français Deutsch العربية Português Kiswahili አማርኛ
A2SV
def solve(problem): understand(problem) manual_solve(example) design_algorithm() attack_own_idea() implement() test_comprehensively() simplify() return solution class Interview: def __init__(self): self.steps = 7 self.clarity = True self.speed = False # The Playbook for step in range(1, 8): execute(step) communicate(step) verify(step)

7 ውጤታማ
የችግር አፈታት ደረጃዎች

የቃለ መጠይቅ መመሪያ

A2SV - Emre Varol

ለምን መመሪያ?

  • ቃለ መጠይቆች ጫና ይፈጥራሉ
  • ጫና ያልተደራጀ አስተሳሰብን ያጠፋል
  • መመሪያ ወጥነት ይፈጥራል
  • ወጥነት አልፎ አልፎ ከሚመጣ ብልሃት ይበልጣል
ያልተደራጀ
↗ ↙ ↖ ↘
↓ ↑ → ←
↙ ↗ ↘ ↖
የተደራጀ
1. ተረዳ ↓ 2. በእጅ ↓ 3. ንደፍ ↓ 4. ጥቃት ↓ 5. ኮድ ↓ 6. ፈትን ↓ 7. አጽዳ

ችግሮችን መፍታት ብቻ ሳይሆን -
በጫና ውስጥ በአስተማማኝ ሁኔታ መፍታት

• የተሻለ ውሳኔ
• ሊቀሩ የሚችሉ ስህተቶች ማነስ
• ንጹህ ግንኙነት
• ተጨማሪ የቃለ መጠይቅ ድሎች

7ቱ ደረጃዎች

1
ችግሩን ተረዳ
2
ችግሩን በእጅ ፍታ
3
የመፍትሄ ሀሳብ ፍጠር
4
የራስህን ሀሳብ አጥቃ
5
ተግብር
6
በሰፊው ፈትን
7
አቅለል እና አጽዳ

የእጩው ትልቁ ስህተት

ኮድ መጻፍ በጣም ቀድሞ መጀመር

ውጤቶች

  • የተሳሳተ ግንዛቤ
  • የተሳሳተ algorithm
  • የተሳሳተ complexity
  • የባከነ ጊዜ
01
ችግሩን ተረዳ
  • በዝግታ አንብብ
  • እያንዳንዱን ዓረፍተ ነገር አስብ
  • ገደቦችን አውጣ
  • በራስህ ቃላት ድገም

ደረጃ 1: ጥሩ vs መጥፎ

መጥፎ

  • ችግሩን በፍጥነት ያልፋል
  • ምን እንደተጠየቀ ይገምታል
  • አንድ ጊዜ ካነበበ በኋላ ኮድ ይጀምራል

ጥሩ

  • ግብአት እና ውጤትን ይደግማል
  • ገደቦችን ይለያል
  • ምን መመለስ እንዳለበት ያረጋግጣል

የችግር ምሳሌ: Two Sum

የኢንቲጀር ድርድር nums እና ኢንቲጀር target ሲሰጥ፣ ድምራቸው ከ target ጋር የሚስማማ ሁለት ቁጥሮችን ኢንዴክስ መልስ። ትክክል ትክክለኛ መልስ አንድ ብቻ እንዳለ ግምት፣ እና ተመሳሳይ ንጥል ሁለት ጊዜ መጠቀም አይቻልም።
target = 9
2
0
7
1
11
2
15
3
2 + 7 = 9 → return [0, 1]

ጥሩ ደረጃ 1 በ Two Sum

እጩው ይላል:

  • ግብአት: ድርድር + target
  • ውጤት: ሁለት ኢንዴክሶች
  • ቦታዎችን እንመልሳለን፣ ዋጋዎችን ሳይሆን
  • ትክክል አንድ መልስ ብቻ አለ
  • ተመሳሳይ ንጥል እንደገና መጠቀም አይቻልም
ምንም አሻሚነት አልቀረም።
ጠቃሚ ገደቦች ተይዘዋል።

መጥፎ ደረጃ 1 በ Two Sum

የእጩ መጥፎ ባህሪ

  • "የሚደመሩ ሁለት ቁጥሮች ብቻ ያስፈልጉኛል"
  • ኢንዴክሶችን ከዋጋዎች ይረሳል
  • ትክክል-አንድ-መልስ ገደብን ችላ ይላል
  • ተመሳሳይ-ንጥል-አይጠቀሙ ህግን ችላ ይላል

ትክክል የሚመስል ኮድ አሁንም ስህተት ሊሆን ይችላል።

02
ችግሩን በእጅ ፍታ
"በእጅ ማድረግ ካልቻልህ፣ ኦቶሜት ማድረግ አትችልም።"
  • ከምሳሌው ጀምር
  • ውሳኔዎችህን ተከታተል
  • ድግግሞሽ ፈልግ
  • ቅርጹን አውጣ

ደረጃ 2: ጥሩ vs መጥፎ

መጥፎ

  • ከማንበብ ወደ ኮድ ይዘላል
  • "ዘዴውን ያውቃል ይመስለኛል" ይላል
  • ትንሽ ምሳሌ ፈጽሞ አይፈትሽም

ጥሩ

  • ከምሳሌ ግብአት ጋር ይሰራል
  • ተደጋጋሚ ድርጊት ያስተውላል
  • የትኛው መረጃ እንደሚረዳ ያወጣል

በእጅ ማሳያ: Two Sum

nums = [2, 7, 11, 15], target = 9
2
0
→
ያስፈልጋል 7
→
7
1
✓
መልስ: [0, 1]
ቅርጽ ተገኘ: ለእያንዳንዱ ቁጥር ተጓዳኙን ያስፈልገኛል።

"በእጅ ደጋግሜ የምፈትሸው ምንድን ነው?"

ለ Two Sum: "የሚያስፈልገው ቁጥር ቀድሞ ይኖራል?"

→ hash map → ፈጣን ፍለጋ → O(n) solution
03
የመፍትሄ ሀሳብ ፍጠር
  • የእጅ ሂደትህን ዳግም አስፋፋ
  • ትክክለኛውን የዳታ መዋቅር ምረጥ
  • የጊዜ complexity ፈትሽ
  • የቦታ complexity ፈትሽ
  • ከኮድ በፊት የሎጂክ ክፍተቶችን ሙላ

የ Complexity በር

ኮድ ከመጻፍ በፊት ጠይቅ:

  • Brute force በቂ ነው?
  • ገደቦቹ ምን ይፈቅዳሉ?
  • የረዳት ተግባራት ተጨማሪ ወጪ ይደብቃሉ?
  • ይህ ማለፍ እንደሚችል እርግጠኛ ነኝ?

ከዚህ በር በፊት ኮድ የለም።

ደረጃ 3: ጥሩ vs መጥፎ

መጥፎ O(n²)

  • "ኮድ አድርጌ እመለከታለሁ"
  • ስለ complexity ምንም ውይይት የለም
  • ግልጽ ያልሆነ ሎጂክ
  • የዳታ መዋቅር ያለ ምርጫ ተመርጧል

ጥሩ O(n)

  • መጀመሪያ brute force ይገልጻል
  • ሆን ብሎ ያሻሽላል
  • እንደ ፍላጎት መዋቅር ይመርጣል
  • ለምን ከገደቦች ጋር እንደሚስማማ ያብራራል

Two Sum: ጥሩ ንድፍ

Brute Force

ሁሉንም ጥንዶች ሞክር

O(n²)

የተሻለ

የታዩ ቁጥሮችን በ dict ያስቀምጡ፣ ተጓዳኝ ይፈትሹ

O(n)

→ መሻሻል →

Python: የ Two Sum ዋና ሀሳብ

def two_sum(nums, target): seen = {} for i, num in enumerate(nums): need = target - num if need in seen: return [seen[need], i] seen[num] = i
አጭር
ሊነበብ የሚችል
መዋቅር ከፍላጎት ጋር ይስማማል
Complexity ግልጽ ነው
04
የራስህን ሀሳብ አጥቃ
"የዲያብሎስ ጠበቃ ሁን። ከሁሉ የከፋ ጠላትህ ይህን ሀሳብ ያመጣ እንደሆነ አስብ። ለማፍረስ የተቻለህን ትፈጥራለህ።"
  • ከራስህ መፍትሄ ጋር የዲያብሎስ ጠበቃ ሁን
  • በተቃራኒ ግብአቶች ለመስበር ሞክር
  • የተደበቁ ግምቶችን ፈልግ
  • የድንበር ሁኔታዎችን ፈልግ
  • ቃለ-መጠይቅ አድራጊው ከማድረጉ በፊት የራስህን መፍትሄ ተቃወም

ደረጃ 4: ጥሩ vs መጥፎ

መጥፎ

  • "ይህ መስራት አለበት"
  • ስለ ድንበር ሁኔታ ምንም አስተሳሰብ የለም
  • ለመጀመሪያ ሀሳብ በስሜት ተያይዟል

ጥሩ

  • ውድቀቶችን በንቃት ይፈልጋል
  • ግምቶችን ይፈትሻል
  • የትኛው ግብአት ሎጂኩን እንደሚሰብር ይጠይቃል
  • ከራሱ መፍትሄ ላይ የዲያብሎስ ጠበቃ ይጫወታል

ስለ ድንበር ሁኔታ የሚጠየቁ ጥያቄዎች

የግብአት ድንበሮች

  • ባዶ ግብአት
  • ነጠላ ንጥል
  • ከፍተኛ መጠን

የዋጋ ድንበር ሁኔታዎች

  • ድግግሞሾች
  • አሉታዊ ቁጥሮች
  • ዜሮዎች

የግምት ፍተሻዎች

  • የተደረደረ vs ያልተደረደረ
  • ልዩ vs ተደጋጋሚ
  • Overflow

የተደበቀ ግምት ምሳሌ

መጥፎ ግምት: "ግብአቱ የተደረደረ ነው።"

  • ያ ዋስትና ነበረው?

ካልሆነ፣ የሁለት-ጠቋሚ ሀሳብ ሙሉ በሙሉ ሊሳካ ይችላል።

የተደረደረ
1
2
3
4
5
ያልተደረደረ
3
1
4
2
5
05
ተግብር
"አሁን ኮድ ጻፍ። ግን በስነ-ስርዓት ጻፍ:"
  • በብሎኮች ጻፍ
  • ግልጽ ስያሜዎችን ተጠቀም
  • ሲጠቅም ረዳት ተግባራትን ተጠቀም
  • እያንዳንዱ ብሎክ ምን እንደሚሰራ አብራራ

ደረጃ 5: ጥሩ vs መጥፎ

መጥፎ

  • ግዙፍ የኮድ ብሎክ
  • መጥፎ ሥያሜዎች
  • ምንም መዋቅር የለም
  • ለማብራራት ከባድ

ጥሩ

  • ንጹህ ስያሜ
  • ሲያስፈልግ ረዳት ተግባራት
  • ብሎክ-በ-ብሎክ ትግበራ
  • ለማብራራት ቀላል

መጥፎ ትግበራ

def f(a, t): d = {} for i in range(len(a)): x = t - a[i] if x in d: return [d[x], i] d[a[i]] = i
f?
a?
t?
d?
x?

ግልጽ ያልሆነ ስያሜ → ለማብራራት ከባድ → ዝቅተኛ ንባብነት → ራስን ለማደናገር ቀላል

የተሻለ ትግበራ

def two_sum(nums, target): value_to_index = {} for index, num in enumerate(nums): needed = target - num if needed in value_to_index: return [value_to_index[needed], index] value_to_index[num] = index
two_sum ✓
value_to_index ✓
needed ✓
index, num ✓

ሊነበብ ይችላል → ቃለ-መጠይቅ ወዳጅ → ለማረም ቀላል → ለመተረክ ቀላል

የረዳት ተግባር ቅርጽ: የግሪድ ችግሮች

2D ግሪድ ሲሰጥ፣ ውጤት ለማስላት ወይም ለማዘመን ትክክለኛ ጎረቤቶችን ጎብኝ።

def is_valid(row, col, rows, cols): return 0 <= row < rows and 0 <= col < cols
↑
←
c
→
↓

የአቅጣጫ ቬክተር ቅርጽ

directions = [ (-1, 0), # up (1, 0), # down (0, -1), # left (0, 1), # right ]
↑
←
c
→
↓
  • ያነሰ ተደጋጋሚ ኮድ
  • ያነሱ ስህተቶች
  • ንጹህ የመዘዋወር ሎጂክ
06
በሰፊው ፈትን
"ፍተሻ አማራጭ አይደለም። ፍተሻ የመፍትሄው ክፍል ነው።"
  • ምሳሌ ሁኔታ
  • ድንበር ሁኔታ
  • አስቸጋሪ ሁኔታ
  • ወሰን ሁኔታ

ደረጃ 6: ጥሩ vs መጥፎ

መጥፎ - "ያልተደራጀ"

  • ምሳሌ ግብአት ብቻ ይፈትሻል
  • የዘፈቀደ ዋጋዎችን ይሞክራል
  • ከመጀመሪያ ስኬት በኋላ ያቆማል

ጥሩ - "ሆን ተብሎ"

  • እያንዳንዱ ፍተሻ ምክንያት አለው
  • ግምቶችን ይቃጣል
  • ድንበሮችን እና ድግግሞሾችን ይሸፍናል

Two Sum: የፍተሻ ምሳሌዎች

[2, 7, 11, 15], target 9 መሰረታዊ ሁኔታ
[3, 3], target 6 ድግግሞሽ ዋጋዎች
[1, 2, 3, 4], target 7 መልስ መጨረሻ ላይ
[5, 4], target 9 በጣም ትንሽ ግብአት
ተመሳሳይ ዋጋ ሁለት ጊዜ ሲመጣ ሎጂኩ አሁንም ይሰራል?

ቃለ-መጠይቅ አድራጊዎች በፍተሻ ውስጥ የሚያስተውሉት

ሳይጠየቁ ሲፈትሹ፣ ምልክት ይሰጣሉ:

ስነ-ስርዓት
ባለቤትነት
ብስለት
የምህንድስና አስተሳሰብ
07
አቅለል እና አጽዳ
"ኮዱ አንዴ ከሰራ:"
  • ስያሜዎችን አሻሽል
  • ብዥታውን አስወግድ
  • ሎጂኩን አቅልል
  • ሲጠቅም ዝቅተኛ አስተያየቶችን ጨምር

ደረጃ 7: ጥሩ vs መጥፎ

መጥፎ

  • ግራ የሚያጋቡ ስያሜዎችን ይተዋል
  • የሞተ ኮድ ያቆያል
  • ምንም የመጨረሻ ግምገማ አያደርግም

ጥሩ

  • ብዥታውን ያስወግዳል
  • ግልጽነትን ያሻሽላል
  • የመጨረሻ ማብራሪያ ቀላል ያደርጋል

ስያሜ ከመቀየር በፊት እና በኋላ

በፊት
mp = {}
በኋላ
value_to_index = {}

ግልጽነት የትክክለኛነት ክፍል ነው።

የ3 ነጥብ ህግ

3
ሀሳቡ ምንድን ነው
ለምን ይሰራል
ለምን በቂ ውጤታማ ነው

10 ነጥቦች ካስፈለጉህ፣ ገና በግልጽ አልተረዳህም።

የ40 ደቂቃ ቃለ መጠይቅ የጊዜ ሰሌዳ

0-5 min
5-10
10-18
18-30
30-36
36-40
ተረዳ
& ድገም
በእጅ
ፍታ
ንደፍ &
complexity
ተግብር
ፈትን
አጽዳ
& ጠቅልል

የመቀየር ህግ

5-7 ደቂቃ ካሳለፉ እና:

  • Complexity ማረጋገጥ ካልቻሉ
  • በድንበር ሁኔታዎች ላይ ማለፍ ከቀጠሉ
  • ለምን እንደሚሰራ ማብራራት ካልቻሉ
PIVOT
አዲስ የዳታ መዋቅር
አዲስ እይታ
ቀላል ስሪት መጀመሪያ
ያተኮረ ፍንጭ ጠይቅ

ጥሩ የፍንጭ ጥያቄ vs መጥፎ የፍንጭ ጥያቄ

መጥፎ
"ተጣብቄያለሁ።"
የተሻለ
"O(n²) መፍትሄ አለኝ፣ ግን ገደቦቹ ፈጣን ነገር ይፈልጋሉ ብዬ አስባለሁ። hashing ወይስ sorting ላስብ?"

ለምን የተሻለ ነው: እድገት ያሳያል፣ ግንዛቤ ያሳያል፣ ያተኮረ ጥያቄ ይጠይቃል።

ደጋግመህ ልትጠቀምበት የምትችል የግንኙነት ስክሪፕት

  • "ችግሩን እንደገና ልግለጽ።"
  • "በትንሽ ምሳሌ እጀምራለሁ።"
  • "Brute force O(n²) ነው፣ ግን የተሻለ ማድረግ እንችላለን ብዬ አስባለሁ።"
  • "ይህን በሁለት ክፍል እተገብራለሁ።"
  • "አሁን edge cases እፈትናለሁ።"
II
ሙሉ ማሳያ: Image Smoother
"ሁሉንም 7 ደረጃዎች በሁለተኛ ችግር ላይ እንተግብር።"

ችግር: Image Smoother

የምስል ፒክሰል ዋጋዎችን የሚወክል 2D integer grid ተሰጥቶሃል። ለእያንዳንዱ ሴል፣ ከዙሪያው ያሉ ትክክለኛ ጎረቤት ሴሎች floor አማካይ አስላ፣ ሴሉን ራሱ ጨምሮ።
1
1
1
1
0
1
1
1
1

መሃል ሴል በteal ጎልቶ ይታያል፣ ጎረቤቶቹ ጥቁር ናቸው

ደረጃ 1: ተረዳ - Image Smoother

  • ግብዓት: m × n integer matrix
  • ውጤት: ሌላ m × n matrix
  • ትክክለኛ ጎረቤቶችን ብቻ ተጠቀም (ድንበር-ተቆጣጣሪ)
  • መሃል ሴሉን ራሱ በአማካይ ውስጥ ጨምር
  • አማካይ floor division ይጠቀማል
ጥግ: 3 ጎረቤቶች + ራስ = 4
c
n
×
n
n
×
×
×
×
መሃል: 8 ጎረቤቶች + ራስ = 9
n
n
n
n
c
n
n
n
n

ደረጃ 2: በእጅ ፍታ - Image Smoother

ለሴል (0,0) የተለሰለሰ ዋጋን በእጅ አስላ:

ግብዓት grid
1
1
1
1
0
1
1
1
1
Cell (0,0) = 1
ትክክለኛ ጎረቤቶች:
(0,1) = 1
(1,0) = 1
(1,1) = 0
Sum = 1 + 1 + 1 + 0 = 3
Count = 4
floor(3/4) = 0
ቅርጸት: ለእያንዳንዱ ሴል፣ ትክክለኛ ጎረቤቶችን ሰብስብ፣ ድመር፣ በቁጥር አካፍል።

ደረጃ 3: ንደፍ - Image Smoother

ቁልፍ ውሳኔዎች

  • 9 direction offsets ተጠቀም (መሃልን ጨምሮ)
  • is_valid bounds check ተጠቀም
  • አዲስ output matrix መድብ
  • በgrid ውስጥ ያለ እያንዳንዱን ሴል ዙር

Complexity

  • እያንዳንዱ ሴል እስከ 9 ጎረቤቶች ይፈትሻል
  • Total: O(m × n × 9) = O(m × n)
  • Space: O(m × n) for output
↖
↑
↗
←
c
→
↙
↓
↘

ደረጃ 4: ተቃወም - Image Smoother

የድንበር ጥያቄዎች

  • ጥግዎች 4 ሴሎች ብቻ አሏቸው (ራስን ጨምሮ)
  • ጠርዞች 6 ሴሎች ብቻ አሏቸው
  • 1×1 grid ቢሆንስ?

የዋጋ ጥያቄዎች

  • መሃል ሴሉ በአማካይ ውስጥ ተካትቷል?
  • Floor division፣ rounding አይደለም
  • ሁሉም ተመሳሳይ ዋጋዎች → ያልተለወጠ?

የአተገባበር ወጥመዶች

  • ግብዓትን በቦታው ማሻሻል (በኋላ ያሉ ንባቦችን ያበላሻል)
  • በbounds check ውስጥ off-by-one
  • Integer vs float division
ቁልፍ ግንዛቤ: ተለይቶ output matrix ያስፈልገናል ምክንያቱም ተመሳሳይ grid ማንበብ እና መጻፍ ውጤቶችን ያበላሻል።

ደረጃ 5: ተግብር - Image Smoother (ማዘጋጃ)

def image_smoother(img): rows, cols = len(img), len(img[0]) output = [[0] * cols for _ in range(rows)] neighbors = [ (-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 0), (0, 1), (1, -1), (1, 0), (1, 1), ]
-1,-1
-1,0
-1,1
0,-1
0,0
0,1
1,-1
1,0
1,1

ደረጃ 5: ተግብር - ሙሉ መፍትሄ

def image_smoother(img): rows, cols = len(img), len(img[0]) output = [[0] * cols for _ in range(rows)] neighbors = [ (-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 0), (0, 1), (1, -1), (1, 0), (1, 1), ] for row in range(rows): for col in range(cols): total = 0 count = 0 for dr, dc in neighbors: nr, nc = row + dr, col + dc if 0 <= nr < rows and 0 <= nc < cols: total += img[nr][nc] count += 1 output[row][col] = total // count return output

Step 6: Test - Image Smoother

[[1,1,1],[1,0,1],[1,1,1]] sample case - center cell surrounded
[[5,5,5],[5,5,5],[5,5,5]] all same values → output unchanged
[[7]] 1×1 grid → output is [[7]]
[[1,1,1],[1,0,1],[1,1,1]], cell (0,0) corner cell: (1+1+1+0)/4 = floor(3/4) = 0
Each test targets a specific boundary or assumption.

Step 7: Clean Up - Image Smoother

Before Cleanup

  • Variable name d for directions
  • Magic numbers like -1, 1 scattered
  • No comments on bounds check
  • In-place mutation risk

After Cleanup

  • neighbors is self-documenting
  • Direction offsets grouped visually
  • Separate output matrix is explicit
  • Code reads like the algorithm
Final check: Can you explain every line in one sentence?

Image Smoother: Good vs Bad

Bad

  • Starts coding loops immediately
  • Forgets output allocation
  • Forgets boundary checks
  • Repeats 9 conditions manually

Good

  • Identifies grid-neighbor problem
  • Uses neighbor offsets
  • Allocates output first
  • Handles bounds centrally

What Strong Candidates Do

Slow down at the start
Think before coding
Challenge their own ideas
Test intentionally
Communicate clearly
Recover calmly

What Weak Candidates Do

Rush into code
Ignore constraints
Hope the idea works
Skip edge cases
Panic when stuck
Never clean up

Clarity first.

Correctness second.

Speed third.

Speed without clarity creates wrong solutions.

“
The problem is not the problem. The problem is your attitude about the problem. Do you understand?
- Captain Jack Sparrow
1 / 56

Table of Contents