أنماط الخوارزميات الشائعة

نهج الأنماط

معظم مشاكل البرمجة تتبع أنماطاً يمكن التعرف عليها. أتقن 5-6 أنماط أساسية ويمكنك حل 80% من أسئلة المقابلة. يركز هذا الدرس على أنماط مُكيفة لسياقات ML.

النمط 1: المؤشران

متى تستخدم:

• مشاكل تتضمن مصفوفات مرتبة
• إيجاد أزواج بخصائص محددة
• عكس أو إعادة ترتيب العناصر
• مقارنة التسلسلات

القالب الأساسي:

def two_pointers(arr):
    left, right = 0, len(arr) - 1

    while left < right:
        # معالجة العناصر في left وright
        if condition:
            left += 1
        else:
            right -= 1

    return result

مثال مقابلة ML: إيجاد زوج بمجموع مستهدف

def find_pair_sum(numbers, target):
    """
    إيجاد رقمين يجمعان إلى المستهدف في مصفوفة مرتبة

    الوقت: O(n)
    المساحة: O(1)
    """
    left, right = 0, len(numbers) - 1

    while left < right:
        current_sum = numbers[left] + numbers[right]

        if current_sum == target:
            return [left, right]
        elif current_sum < target:
            left += 1  # نحتاج مجموعاً أكبر
        else:
            right -= 1  # نحتاج مجموعاً أصغر

    return None

# اختبار
print(find_pair_sum([1, 2, 3, 4, 6], target=6))  # [1, 3] (2+4=6)

متقدم: إزالة التكرارات في المكان

def remove_duplicates(arr):
    """
    إزالة التكرارات من مصفوفة مرتبة في المكان

    مثال: [1,1,2,2,3] -> [1,2,3] (length=3)
    إرجاع الطول الجديد

    الوقت: O(n)
    المساحة: O(1)
    """
    if not arr:
        return 0

    write = 1  # موضع لكتابة العنصر الفريد التالي

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

    return write

# اختبار
arr = [1, 1, 2, 2, 3, 4, 4]
length = remove_duplicates(arr)
print(arr[:length])  # [1, 2, 3, 4]

---

النمط 2: النافذة المنزلقة

متى تستخدم:

• مشاكل تتضمن مصفوفات فرعية/سلاسل فرعية
• حسابات جارية على نوافذ ذات حجم ثابت
• إيجاد مصفوفة فرعية مثلى
• مشاكل السلاسل الزمنية

القالب الأساسي:

def sliding_window(arr, k):
    window_start = 0
    window_sum = 0
    result = []

    for window_end in range(len(arr)):
        # أضف عنصر جديد للنافذة
        window_sum += arr[window_end]

        # النافذة بحجم k
        if window_end >= k - 1:
            result.append(window_sum)
            # أزل أقدم عنصر
            window_sum -= arr[window_start]
            window_start += 1

    return result

مثال مقابلة ML: أقصى مجموع لمصفوفة فرعية

def max_sum_subarray(arr, k):
    """
    إيجاد أقصى مجموع لأي مصفوفة فرعية متصلة بحجم k

    مثال: arr=[2,1,5,1,3,2], k=3
    الجواب: 9 (المصفوفة الفرعية [5,1,3])

    الوقت: O(n)
    المساحة: O(1)
    """
    max_sum = float('-inf')
    window_sum = 0
    window_start = 0

    for window_end in range(len(arr)):
        window_sum += arr[window_end]

        # بمجرد أن نصل لحجم النافذة k
        if window_end >= k - 1:
            max_sum = max(max_sum, window_sum)
            # حرّك النافذة
            window_sum -= arr[window_start]
            window_start += 1

    return max_sum

# اختبار
print(max_sum_subarray([2, 1, 5, 1, 3, 2], k=3))  # 9

---

النمط 3: البحث الثنائي

متى تستخدم:

• البحث في مصفوفات مرتبة
• إيجاد عتبات أو حدود
• مشاكل التحسين بخاصية أحادية
• سياقات ضبط المعلمات الفائقة

القالب الأساسي:

def binary_search(arr, target):
    left, right = 0, len(arr) - 1

    while left <= right:
        mid = (left + right) // 2

        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1

    return -1  # لم يُعثر عليه

---

النمط 4: خرائط التجزئة (القواميس)

متى تستخدم:

• عد التكرار
• إيجاد التكرارات
• تخزين العناصر المرئية
• بناء جداول البحث

مثال مقابلة ML: إيجاد الفئة الأكثر تكراراً

from collections import Counter

def most_frequent_class(predictions):
    """
    إيجاد الفئة الأكثر تنبؤاً بشكل متكرر

    مثال: [1,2,1,3,1,2] -> 1

    الوقت: O(n)
    المساحة: O(k) حيث k = عدد الفئات الفريدة
    """
    counter = Counter(predictions)
    return counter.most_common(1)[0][0]

# اختبار
print(most_frequent_class([1, 2, 1, 3, 1, 2]))  # 1

---

النمط 5: المكدس

متى تستخدم:

• تحليل التعبيرات
• مطابقة الأقواس
• الحفاظ على الترتيب مع القيود
• مشاكل التراجع

مثال مقابلة ML: أقواس صحيحة

def valid_parentheses(s):
    """
    تحقق مما إذا كانت السلسلة لديها أقواس صحيحة

    مثال: "({[]})" -> True
             "({[})" -> False

    الوقت: O(n)
    المساحة: O(n)
    """
    stack = []
    pairs = {')': '(', '}': '{', ']': '['}

    for char in s:
        if char in '({[':
            stack.append(char)
        elif char in ')}]':
            if not stack or stack[-1] != pairs[char]:
                return False
            stack.pop()

    return len(stack) == 0

# اختبار
print(valid_parentheses("({[]})"))  # True
print(valid_parentheses("({[})"))   # False

---

دليل التعرف على الأنماط

دليل المشكلة	النمط	التعقيد الزمني
"مصفوفة فرعية بحجم k"	نافذة منزلقة	O(n)
"مصفوفة مرتبة" + بحث	بحث ثنائي	O(log n)
"عنصران يجمعان إلى..."	مؤشران أو خريطة تجزئة	O(n)
"الأكثر/الأقل تكراراً"	خريطة تجزئة + كومة	O(n log k)
"أقواس/أقواس صحيحة"	مكدس	O(n)
"K أقرب/أكبر/أصغر"	كومة	O(n log k)

النقاط الرئيسية

1. تعرّف على الأنماط - لا تحل من الصفر كل مرة
2. ابدأ بالقوة الغاشمة - حسّن بعد أن يكون لديك حل عملي
3. ارسم أمثلة - تصوّر الخوارزمية على الورق
4. اذكر التعقيد - اذكر دائماً الوقت والمساحة
5. اختبر الحالات الحدية - مصفوفات فارغة، عناصر واحدة، تكرارات

ما التالي؟

في الوحدة 3، سنطبق هذه المهارات الخوارزمية على أسئلة مقابلة خاصة بـ ML، تغطي خوارزميات التعلم الموجه، والشبكات العصبية، وتقنيات التحسين.

:::