MTA ga kirish

Axborot va ma'lumot

ma'lumot va information — computing va qaror qabul qilish sohasidagi eng muhim tushunchalardan biridir. ma'lumot deb strukturaga ega bo'lmagan ma'lumotlarga aytiladi: matn, kuzatuvlar, tasvirlar, belgilar va tavsiflar. Information esa qayta ishlangan, tartibga solingan va strukturalangan datani anglatadi. U faktlarga kontekst beradi va qaror qabul qilishni osonlashtiradi.

Ma'lumot nima?

Ma'lumot — bu xom (raw) va tartibga solinmagan fakt bo'lib, ma'noga ega bo'lishi uchun qayta ishlanishi (processing) talab etiladi. Uni ma'lumotnoma yoki tahlil uchun to'plangan faktlar va statistik ko'rsatkichlar sifatida qarash mumkin.

Ma'lumot — bu axborotning alohida birliklari. Analitik jarayonlarda data o'zgaruvchilar (variables) orqali ifodalanadi. Ma'lumot har doim inson yoki mashina tomonidan interpretatsiya qilinadi va shundan so'ng ma'no kasb etadi. Ya'ni, data o'z-o'zicha ma'nosizdir. Data tarkibida xom holatdagi raqamlar, iboralar va belgilar bo'ladi.

Ma'lumot turlari

Data ikki turga bo'linadi:

Quantitative — miqdoriy, ya'ni raqamli ma'lumot: vazn, bo'y va hokazo.
Qualitative — sifatiy, ya'ni raqamli bo'lmagan ma'lumot: fikrlar, idroklar (perceptions) va hokazo.

Axborot nima?

Axborot — bu strukturalangan, tartibga solingan va qayta ishlangan data bo'lib, uni kerakli odam uchun dolzarb va foydali qiladigan kontekstda taqdim etiladi. Ma'lumot esa shaxslar, joylar yoki boshqa masalalarga oid xom faktlar va ko'rsatkichlar bo'lib, raqamlar, harflar yoki belgilar ko'rinishida ifodalanadi.

Axborot — bu tushunarli shaklga o'zgartirilgan va tasniflangan bilim bo'lib, undan qaror qabul qilish jarayonida foydalanish mumkin. Qisqacha aytganda, bilim muloqotda maqsadli ma'no kasb etganda, u information deb ataladi. U xabar beradi va, mohiyatan, aniq bir savolga javob taqdim etadi. Uni turli manbalardan olish mumkin: gazetalar, internet, televidenie, odamlar, kitoblar va boshqalar.

Ma'lumot va Axborot o'rtasidagi farq

Tamoyil	Ma'lumot	Axborot
Ta'rif	Ma'lumot — strukturaga ega bo'lmagan ma'lumot: matn, kuzatuvlar, tasvirlar, belgilar va tavsiflar. Boshqacha aytganda, data aniq bir vazifani bajarmaydi va o'z-o'zicha ma'noga ega emas.	Axborot — qayta ishlangan, tartibga solingan va strukturalangan Ma'lumot. U faktlarga kontekst beradi va qaror qabul qilishni osonlashtiradi. Ya'ni, Axborot — bu biz uchun mantiqiy bo'lgan qayta ishlangan Ma'lumot.
Maqsad	Ma'lumot — g'oya va xulosalarni shakllantirishga yordam beradigan o'zgaruvchilar.	Axborot — ma'noga ega data.
Tabiati	Ma'lumot — matn va raqamli qiymatlar.	Axborot — haqiqiy Ma'lumotning tozalangan (refined) shakli.
Bog'liqlik	Ma'lumot informationga bog'liq emas.	Axborot esa dataga bog'liq.
O'lchov	Ma'lumotning o'lchov birligi — bit va bayt.	Axborot ma'noli birliklarda o'lchanadi: vaqt, miqdor va hokazo.
Struktura	Jadval ko'rinishidagi data, grafiklar va Ma'lumot daraxtlari (Ma'lumot trees) sifatida oson strukturalanadi.	Axborot til, g'oyalar va fikrlar shaklida ham strukturalanishi mumkin.
Maqsadlilik	Ma'lumot hech qanday aniq maqsadga ega emas.	Axborot datani interpretatsiya qilish orqali berilgan ma'noni tashiydi.
Bilim darajasi	Bu — quyi darajadagi (low-level) bilim.	Bu — bilimning ikkinchi darajasi.
Qaror qabul qilish	Ma'lumot qaror qabul qilishga bevosita yordam bermaydi.	Axborot qaror qabul qilishga bevosita yordam beradi.
Ma'no	Ma'lumot — o'z-o'zicha ma'nosi bo'lmagan faktlar to'plami.	Axborot o'sha faktlarni kontekstga joylashtiradi.
Misol	Ma'lumotga misol: talabalarning test natijalari.	Axborotga misol: shu datadan kelib chiqqan sinfning o'rtacha bali.

Ma'lumot va Axborot misollari

Ma'lumot misollari

Temperature Readings (harorat o'lchovlari): kun davomidagi haroratni ifodalovchi raqamlar, masalan 72°F, 68°F, 75°F.
Student Grades (talaba baholari): talabalar testda olgan raqamli ballar ro'yxati, masalan 85, 92, 78.
Stock Prices (aksiya narxlari): kompaniya aksiyasining kunlik yopilish narxlari, masalan $50.25, $48.90, $52.10.

Axborot misollari

Weather Report (ob-havo ma'lumoti): harorat o'lchovlari asosida ob-havo hisoboti shakllantiriladi.
Grade Average (o'rtacha ball): talaba baholari asosida sinfning o'rtacha bali hisoblab chiqiladi.
Market Analysis (bozor tahlili): aksiya narxlaridan kelib chiqib, "bugun fond bozori biroz o'sdi" degan xulosa chiqariladi.

Har bir holatda xom Ma'lumot (harorat o'lchovlari, talaba baholari, aksiya narxlari) qayta ishlangan, tahlil qilingan va tegishli kontekstda taqdim etilgandan so'ng ma'noli Axborotga aylanadi.

MTA ga kirish

Ma'lumot Tuzilmalari

Ma'lumot Tuzilmasi

Ma'lumot Tuzilmasi — ma'lumotni kompyuter xotirasida ma’lum bir tartibda tashkil qilish, saqlash va boshqarish usulidir. U ma'lumot ustida samarali ishlash, jumladan uni samarali qidirish, o‘qish, qo‘shish, o‘zgartirish va o‘chirish imkonini beradi.

Ma'lumot Tuzilmasi ma'lumoting mantiqiy yoki matematik modelini, elementlar o‘rtasidagi munosabatlarni hamda ushbu modelning kompyuter dasturida qanday amalga oshirilishini — ya’ni uning implementation’ini ifodalaydi.

Ma'lumot Tuzilmalarining tasnifi

Ma'lumot Tuzilmalar elementlarning qanday tashkil qilinishiga ko‘ra ikki asosiy toifaga bo‘linadi:

chiziqli ma'lumot tuzilmalar (linear data structure)
chiziqli bo'lmagan ma'lumot tuzilmalar (non-linear data structure)

chiziqli ma'lumot tuzilmalar

chiziqli ma'lumot tuzilmalar — elementlari mantiqiy jihatdan ketma-ket, ya’ni bitta chiziq bo‘ylab tashkil qilingan ma'lumot tuzilmalardir.

Bunday tuzilmalarda elementlar ma’lum tartibda joylashadi va odatda birinchi elementdan boshlab keyingi elementlarga ketma-ket o‘tish mumkin.

TEXT

A → B → C → D

Linear data structure’larga quyidagilar misol bo‘ladi:

array;
linked list;
stack;
queue;
deque.

chiziqli bo'lmagan ma'lumot tuzilmalar

chiziqli bo'lmagan ma'lumot tuzilma — elementlari bitta ketma-ket chiziq bo‘ylab tashkil qilinmaydigan data structure’dir.

Bunday tuzilmalarda elementlar ierarxik yoki tarmoqli munosabatda joylashadi. Bitta element bir nechta boshqa element bilan bog‘lanishi mumkin.

TEXT

    A    / \   B   C  / \ D   E

Bu tuzilmada elementlar oddiy ketma-ketlikni emas, balki bir nechta yo‘nalishga ega munosabatni hosil qiladi.

Non-linear data structure’larga quyidagilar misol bo‘ladi:

tree;
graph.

MTA ga kirish

Real-world analoglar: kitob javoni, do'kon navbati, oila shajarasi, shahar xaritasi

a

MTA ga kirish

Chiziqli va Chiziqli Bo'lmagan Tuzilmalar (Linear vs non-linear structures)

a

MTA ga kirish

Abstract Data Type (ADT) Va Implementation

a

MTA ga kirish

Algoritm

a

MTA ga kirish

Yaxshi Algoritmning Xususiyatlari: to'g'rilik, cheklilik, aniqlik, samaradorlik

a

MTA ga kirish

Kundalik hayotdagi Algorithmlar: retseptlar, manzilga borish yo‘llari va kartalarni tartiblash.

a

MTA ga kirish

Algoritmlarni ifodalash: pseudocode and flowchart lar

a

MTA ga kirish

Bitta muammo, ko'plab algoritmlar - nima uchun ba'zilari yaxshiroq

a

MTA ga kirish

Ma’lumotlar tuzilmalari va algoritmlarning o‘zaro ta’siri

a

MTA ga kirish

Tartiblanmagan va tartiblangan ro‘yxatda qidirish: motivatsion misol

a

Murakkablik tahlili (Complexity Analysis)

RM

Counting operations — the intuition behind fast and slow
Best case, average case, worst case
What Big-O means (intuitive + formal)
Common classes: O(1), O(log n), O(n), O(n log n), O(n²), O(2ⁿ), O(n!)
Big-Ω and Big-Θ — lower and tight bounds
Analyzing loops and nested loops
Analyzing recursive code (intro)
Constraints → complexity: n ≤ 10⁵ means what fits?
Space complexity — measuring memory
Auxiliary space vs total space
Time–space tradeoffs

Arraylar

RM

Contiguous memory, indexing, O(1) access
Traversal, insertion, deletion — and their costs
Static vs dynamic arrays (resizing, amortized O(1))
2D arrays and matrices: traversal, transpose, rotation
Two-pointer technique
Sliding window — fixed size
Sliding window — variable size
Prefix sums (1D and 2D)
Kadane's algorithm — maximum subarray
In-place operations and array rotation

Arraylar

Array

Array nima

Array — bu bir-xil yoki turli(dasturlash tiliga bog'liq) ma'lumot turlariga mansub qiymarlar to'plamini, xotirada ketma-ket (contiguous) joylarda saqlovchi chiziqli ma'lumot tuzilmasi hisoblanadi. Array ichida saqlanadigan har bir qiymat array element deb ataladi. U dasturlashda qo'llaniladigan eng mashhur va eng sodda ma'lumot tuzilmalaridan biridir.

Array ning xotiradagi ifodasi

Array elementlari odatda xotiraning ketma-ket — contiguous memory location’larida saqlanadi. Shu sababli array ichidagi istalgan elementga uning tartib raqami orqali tez va to‘g‘ridan-to‘g‘ri murojaat qilish mumkin. Bu tartib raqam index deb atatladi va aksariyat dasturlash tillarida index 0 dan boshlanadi.

Masalan, har bir element 4 byte joy egallaydigan array quyidagicha joylashishi mumkin:

TEXT

Index:       0      1      2      3      4          +------+------+------+------+------+Element:  |  10  |  20  |  30  |  40  |  50  |          +------+------+------+------+------+Manzil:    1000   1004   1008   1012   1016           (har bir int = 4 bayt, ketma-ket joylashgan)

Birinchi element 1000 address’da joylashgan bo‘lsa, keyingi elementlar har biri 4 byte masofada saqlanadi.

Shu sababli kompyuter istalgan elementning memory address’ini quyidagi mantiq asosida hisoblay oladi:

TEXT

element address = base address + index × element size

Bu yerda:

base address — array’ning birinchi elementi joylashgan address;
index — kerakli elementning pozitsiyasi;
element size — bitta element egallaydigan memory hajmi.

Masalan, index 2 dagi elementning address’i:

TEXT

1000 + 2 × 4 = 1008

Shu xususiyat array elementiga index orqali tez va to‘g‘ridan-to‘g‘ri murojaat qilish imkonini beradi.

Array elementi — array ichida saqlanadigan alohida qiymat.

Array index — array ichidagi elementning joylashuv pozitsiyasini bildiradigan raqam.

Array’ni turli programming language’larda e’lon qilish

#include <stdio.h>int main(void) {    // 1-usul: length va boshlang‘ich qiymatlar bilan e’lon qilish    int numbers1[5] = {10, 20, 30, 40, 50};    // 2-usul: length’ni qiymatlar soniga qarab aniqlash    int numbers2[] = {10, 20, 30, 40, 50};    // 3-usul: avval e’lon qilish, keyin elementlarga qiymat berish    int numbers3[5];    numbers3[0] = 10;    numbers3[1] = 20;    numbers3[2] = 30;    numbers3[3] = 40;    numbers3[4] = 50;    // 4-usul: qisman initialization    // Qolgan elementlar avtomatik ravishda 0 qiymatini oladi    int numbers4[5] = {10, 20};    printf("numbers1[0]: %d\n", numbers1[0]);    printf("numbers2[1]: %d\n", numbers2[1]);    printf("numbers3[2]: %d\n", numbers3[2]);    printf("numbers4[4]: %d\n", numbers4[4]);    return 0;}

#include <array>#include <iostream>#include <vector>int main() {    // 1-usul: C-style array    int numbers1[5] = {10, 20, 30, 40, 50};    // 2-usul: C-style array length’ini avtomatik aniqlash    int numbers2[] = {10, 20, 30, 40, 50};    // 3-usul: std::array yordamida fixed-size array    std::array<int, 5> numbers3 = {10, 20, 30, 40, 50};    // 4-usul: std::array va uniform initialization    std::array<int, 5> numbers4{10, 20, 30, 40, 50};    // 5-usul: zero-initialized std::array    std::array<int, 5> numbers5{};    numbers5[0] = 10;    numbers5[1] = 20;    numbers5[2] = 30;    numbers5[3] = 40;    numbers5[4] = 50;    // 6-usul: dynamic array sifatida std::vector    std::vector<int> numbers6 = {10, 20, 30, 40, 50};    numbers6.push_back(60);    std::cout << "numbers1[0]: " << numbers1[0] << '\n';    std::cout << "numbers2[1]: " << numbers2[1] << '\n';    std::cout << "numbers3[2]: " << numbers3[2] << '\n';    std::cout << "numbers4[3]: " << numbers4[3] << '\n';    std::cout << "numbers5[4]: " << numbers5[4] << '\n';    std::cout << "numbers6[5]: " << numbers6[5] << '\n';    return 0;}

package mainimport "fmt"func main() {	// 1-usul: var va aniq array type bilan e’lon qilish	var numbers1 [5]int = [5]int{10, 20, 30, 40, 50}	// 2-usul: var va type inference orqali e’lon qilish	var numbers2 = [5]int{10, 20, 30, 40, 50}	// 3-usul: qisqa e’lon qilish	numbers3 := [5]int{10, 20, 30, 40, 50}	// 4-usul: length’ni elementlar soniga qarab aniqlash	numbers4 := [...]int{10, 20, 30, 40, 50}	// 5-usul: zero value bilan e’lon qilish	var numbers5 [5]int	numbers5[0] = 10	numbers5[1] = 20	numbers5[2] = 30	numbers5[3] = 40	numbers5[4] = 50	// 6-usul: faqat ma’lum index’larga qiymat berish	numbers6 := [5]int{		0: 10,		2: 30,		4: 50,	}	fmt.Println("numbers1:", numbers1)	fmt.Println("numbers2:", numbers2)	fmt.Println("numbers3:", numbers3)	fmt.Println("numbers4:", numbers4)	fmt.Println("numbers5:", numbers5)	fmt.Println("numbers6:", numbers6)}

from array import arraydef main():    # 1-usul: qiymatlar bilan list yaratish    numbers1 = [10, 20, 30, 40, 50]    # 2-usul: bo‘sh list yaratib, elementlarni qo‘shish    numbers2 = []    numbers2.append(10)    numbers2.append(20)    numbers2.append(30)    numbers2.append(40)    numbers2.append(50)    # 3-usul: oldindan ma’lum sondagi elementlarni yaratish    numbers3 = [0] * 5    numbers3[0] = 10    numbers3[1] = 20    numbers3[2] = 30    numbers3[3] = 40    numbers3[4] = 50    # 4-usul: list comprehension yordamida yaratish    numbers4 = [number for number in range(10, 60, 10)]    # 5-usul: array module yordamida typed array yaratish    numbers5 = array("i", [10, 20, 30, 40, 50])    # 6-usul: bo‘sh typed array yaratib, elementlarni qo‘shish    numbers6 = array("i")    numbers6.append(10)    numbers6.append(20)    numbers6.append(30)    numbers6.append(40)    numbers6.append(50)    print("numbers1:", numbers1)    print("numbers2:", numbers2)    print("numbers3:", numbers3)    print("numbers4:", numbers4)    print("numbers5:", numbers5.tolist())    print("numbers6:", numbers6.tolist())if __name__ == "__main__":    main()

package main;import java.util.Arrays;public class Main {    public static void main(String[] args) {        // 1-usul: qiymatlar bilan to‘g‘ridan-to‘g‘ri e’lon qilish        int[] numbers1 = {10, 20, 30, 40, 50};        // 2-usul: new orqali length ko‘rsatib array yaratish        int[] numbers2 = new int[5];        numbers2[0] = 10;        numbers2[1] = 20;        numbers2[2] = 30;        numbers2[3] = 40;        numbers2[4] = 50;        // 3-usul: new orqali qiymatlar bilan array yaratish        int[] numbers3 = new int[]{10, 20, 30, 40, 50};        // 4-usul: variable’ni avval e’lon qilib, keyin array yaratish        int[] numbers4;        numbers4 = new int[]{10, 20, 30, 40, 50};        // 5-usul: kamroq tavsiya etiladigan declaration syntax        int numbers5[] = {10, 20, 30, 40, 50};        // 6-usul: zero value’lar bilan array yaratish        int[] numbers6 = new int[5];        // int elementlarining default value qiymati 0        numbers6[0] = 10;        numbers6[2] = 30;        numbers6[4] = 50;        System.out.println("numbers1: " + Arrays.toString(numbers1));        System.out.println("numbers2: " + Arrays.toString(numbers2));        System.out.println("numbers3: " + Arrays.toString(numbers3));        System.out.println("numbers4: " + Arrays.toString(numbers4));        System.out.println("numbers5: " + Arrays.toString(numbers5));        System.out.println("numbers6: " + Arrays.toString(numbers6));    }}

Stringlar

Rm

Strings as character arrays; immutability
Common operations and their costs
Palindromes and reversal problems
Anagrams and frequency counting
Efficient string building
Naive pattern matching (baseline for later)

Rekursiya (Recursion)

RM

Base case + recursive case
The call stack visualized
Classics: factorial, Fibonacci, sum of digits
Tracing recursion by hand
Recursion on arrays and strings
Multiple recursive calls (branching)
Recursion trees and complexity of recursion
Tail recursion; recursion vs iteration
Pitfalls: stack overflow, repeated work

Qidirish Algoritmlari (Searching)

RM

Linear search
Binary search (iterative + recursive)
Binary search variations: first/last occurrence, boundaries
Binary search on the answer (advanced pattern)

Qidirish Algoritmlari (Searching)

Liner Search

Linear search — elementlarni boshidan oxirigacha ketma-ket tekshirib, kerakli qiymatni topishga xizmat qiladigan search algorithm’dir. U sequential search deb ham ataladi.

Bu usulda array’dagi har bir element navbatma-navbat ko‘rib chiqiladi va qidirilayotgan qiymat — target element bilan solishtiriladi.

Agar joriy element target elementga teng bo‘lsa, qidiruv muvaffaqiyatli yakunlanadi. Odatda algoritm topilgan elementning index’ini qaytaradi.

Agar array’dagi barcha elementlar tekshirilsa-yu, target element topilmasa, qidiruv muvaffaqiyatsiz yakunlanadi.

Linear search jarayonini quyidagicha tasvirlash mumkin:

TEXT

Array: [12, 45, 7, 33, 18] Target: 33

Algoritm elementlarni boshidan boshlab tekshiradi:

TEXT

12 ≠ 33 45 ≠ 33 7 ≠ 33 33 = 33 → topildi

Bu misolda 33 qiymati index 3 da joylashgan. Algoritm moslik topilgach, qidiruvni to‘xtatadi.

Linear search’da array oldindan tartiblangan bo‘lishi shart emas. Shu sababli u sorted va unsorted array’larda ham ishlaydi.

Ammo algoritm target elementni topish uchun ba’zan array’dagi barcha elementlarni tekshirishi kerak bo‘ladi. Bu quyidagi holatlarda yuz beradi:

target element array’ning oxirida joylashgan bo‘lsa;
target element array’da umuman mavjud bo‘lmasa.

Bu holatlar linear search’ning worst-case holati hisoblanadi va uning time complexity’si: O(n) - Bu yerda n — array’dagi elementlar soni.

Tartiblash Algoritmlari (Sorting)

RM

Bubble sort
Selection sort
Insertion sort
Stability + comparing the basic three
Merge sort (divide & conquer)
Quick sort and partitioning
Quick sort analysis: pivot choice, worst case
Non-comparison sorts: counting, radix, bucket
Choosing a sort; built-in sorts and custom comparators

Linked List lar

RM

Nodes and pointers — why linked lists exist
Traversal and insertion (head, tail, middle)
Deletion and edge cases
Arrays vs linked lists — tradeoffs
Reversing a list (iterative + recursive)
Fast & slow pointers — finding the middle
Cycle detection (Floyd's algorithm)
Merging two sorted lists
Doubly linked lists
Circular linked lists

Stack lar

Page 1

LIFO — push, pop, peek
Implementation: array-based and list-based
Applications: balanced parentheses, undo, function calls
Monotonic stack — next greater element
Expression evaluation: infix → postfix

Navbatkar (Queues)

RM

FIFO — enqueue, dequeue
Implementation: array, circular buffer, linked list
Deque — double-ended queue
Queue via two stacks / stack via queues
Monotonic deque — sliding window maximum

Hashlash (Hashing)

RM

Hash functions — mapping keys to indices
Collisions: separate chaining
Collisions: open addressing (linear/quadratic probing)
Load factor and rehashing
Hash map vs hash set
Frequency maps and counting patterns
Two-sum pattern and O(1) lookups
Grouping and deduplication
Limits of hashing: worst cases, when you need order

Tree lar

RM

Terminology: root, leaf, depth, height, subtree
Binary tree structure and representation
DFS traversals: preorder, inorder, postorder
BFS traversal: level order
Recursive tree problems: height, count, sum
Diameter, balanced check, lowest common ancestor
Binary Search Trees — the BST property
BST: search, insert, delete
Validate BST; inorder = sorted order
Degenerate BSTs — why balancing matters
AVL trees and rotations
Red-black trees (overview)
B-trees — why databases use them (overview)

Heap lar & Priority Queues

RM

Heap property; array representation
Insert (sift up) and extract (sift down)
Build-heap in O(n); heap sort
The priority queue interface
Top-K problems
Kth largest / smallest
Merge K sorted lists
Two heaps — median of a stream

Graflar (Graphs)

RM

Directed, undirected, weighted graphs
Adjacency matrix vs adjacency list
Degree, paths, cycles, connectivity
BFS on graphs
DFS on graphs (recursive + iterative)
Connected components
Cycle detection: undirected and directed
Grids as graphs: islands, flood fill
DAGs and topological sort (DFS method)
Kahn's algorithm (BFS method)
Dependency / course-schedule problems
BFS for unweighted shortest path
Dijkstra's algorithm
Bellman-Ford — negative weights
Floyd-Warshall — all pairs
Minimum spanning trees: the concept
Prim's algorithm
Union-Find: the connectivity problem
Union by rank + path compression
Union-Find applications: components, cycle detection
Kruskal's algorithm (built on Union-Find)

Divide & Conquer and Greedy

RM

Divide & conquer: the paradigm (revisiting merge sort, binary search)
Recurrence relations and the Master Theorem
Classic D&C: count inversions, closest pair (intuition)
Greedy choice property — when greedy is correct
Activity selection / interval scheduling
Interval merging and overlaps
Huffman coding (concept)
When greedy fails — counterexamples

Backtracking & Dynamic Programming

RM

Backtracking template: choose → explore → un-choose
Subsets and permutations
Combinations and combination sum
N-Queens
Sudoku solver, word search
DP: overlapping subproblems + optimal substructure
Memoization (top-down): Fibonacci done right
Tabulation (bottom-up) + space optimization
1D DP: climbing stairs, house robber
2D DP: grid paths, obstacles
Knapsack: 0/1 and unbounded
Longest common subsequence & edit distance
Longest increasing subsequence
DP on strings: palindromic substrings
Recognizing and designing DP solutions

Murakkab Ma'lumot Tuzilmalari

RM

Tries: prefix tree structure
Trie: insert, search, startsWith
Trie applications: autocomplete, word problems
Segment tree: build, query, update
Lazy propagation (overview)
Fenwick tree (Binary Indexed Tree)
Bit manipulation: AND, OR, XOR, NOT, shifts
Bit tricks: check/set/clear bit, power of two
XOR patterns: single number problems
Bitmasking for subsets
Rabin-Karp (rolling hash)
KMP (prefix function)
Z-algorithm (overview)

Mahorat va amaliyot

RM

Breaking down a problem statement
Pattern recognition — mapping problems to techniques
Optimizing brute force step by step
Edge cases, testing, and debugging strategy
Practice ladder: easy — arrays, strings, hashing (20 problems)
Practice ladder: medium — trees, heaps, two pointers (20 problems)
Practice ladder: medium — graphs, backtracking (20 problems)
Practice ladder: medium/hard — dynamic programming (20 problems)
Practice ladder: hard — mixed techniques (15 problems)
Explaining solutions clearly (interview skill)
Choosing data structures for real applications
Competitive programming — next steps

Applied Algorithms — Caching, Load Balancing & Real Systems

RM

Why caching? Locality, hit rate, and eviction policies
LRU cache — design and the hash map + doubly linked list trick
LRU cache — full implementation walkthrough (O(1) get/put)
LFU cache — frequency-based eviction (concept + design)
Other eviction policies: FIFO, MRU, random (when each wins)
Bloom filters — probabilistic membership testing
Load balancing: the problem and round robin
Weighted round robin and least-connections
Hashing-based routing and its rebalancing problem
Consistent hashing — the ring, virtual nodes
Rate limiting: token bucket and sliding window algorithms
Where these live in real systems: CDNs, databases, web servers