id stringlengths 1 4 | instruction stringlengths 35 887 | topic stringclasses 18
values | subtopic stringclasses 199
values | difficulty stringclasses 3
values | problem_type stringclasses 7
values | think stringlengths 50 1.49k | answer stringlengths 45 1.43k | unit_tests listlengths 0 5 |
|---|---|---|---|---|---|---|---|---|
158 | اكتب دالة لإنشاء جميع المجموعات الفرعية الممكنة من قائمة معينة. | مجموعات | Subset | متوسط | كتابة دالة | المشكلة تطلب توليد جميع المجموعات الفرعية (powerset) من قائمة. عدد المجموعات الفرعية لقائمة طولها n هو 2^n.
الفكرة الأساسية: نبدأ بمجموعة الفرعيات المبدئية [[]]، ثم لكل عنصر جديد في القائمة نُضيف نسخاً من جميع المجموعات الفرعية الحالية مضافاً إليها هذا العنصر. هكذا نبني الـ powerset تدريجياً.
تطبيق على مثال: [1,2]. ن... | def subsets(lst):
result = [[]]
for item in lst:
result += [subset + [item] for subset in result]
return result | [
{
"input": "[[1,2]]",
"expected": "[[],[1],[2],[1,2]]"
},
{
"input": "[[]]",
"expected": "[[]]"
},
{
"input": "[[1]]",
"expected": "[[],[1]]"
}
] |
982 | اكتب دالة تأخذ رسمًا بيانيًا وعُقدة ابتدائية، وتعيد ترتيب زيارة العُقد باستخدام BFS. | رسوم بيانية | BFS | متوسط | كتابة دالة | المشكلة تطلب تنفيذ خوارزمية BFS على رسم بياني موجه مُمثَّل كقاموس adjacency list وإرجاع ترتيب زيارة العقد.
الفكرة الأساسية لـ BFS: نستخدم طابور queue يبدأ بعقدة البداية. في كل خطوة نسحب عقدة من مقدمة الطابور نُضيفها للنتيجة ثم نُضيف جيرانها غير المزارين للطابور. نستمر حتى يفرغ الطابور. نستخدم collections.deque لسرعة p... | from collections import deque
def bfs_traversal(graph, start):
visited = {start}
queue = deque([start])
result = []
while queue:
node = queue.popleft()
result.append(node)
for neighbor in graph.get(node, []):
if neighbor not in visited:
visited.a... | [] |
60 | اكتب دالة `find_unique_elements` تستلم قائمة وتعيد قائمة تحتوي على العناصر الفريدة فقط (أي العناصر التي تظهر مرة واحدة). | مجموعات | العناصر الفريدة | سهل | كتابة دالة | المطلوب كتابة دالة تقوم بحساب أو معالجة البيانات وفق الوصف المطلوب. نحدد أولا المعطيات والنتيجة المرجوة، ثم نختار الخوارزمية المناسبة لحل المسألة مع مراعاة الحالات الحدية مثل القيم الفارغة أو الأعداد السالبة أو الفهارس خارج النطاق. | def find_unique_elements(lst):
from collections import Counter
return [k for k, v in Counter(lst).items() if v == 1] | [
{
"input": "[1, 2, 2, 3, 4, 4, 5]",
"expected": "[1,3,5]"
},
{
"input": "[1, 1, 1]",
"expected": "[]"
},
{
"input": "[1, 2, 3]",
"expected": "[1,2,3]"
},
{
"input": "[]",
"expected": "[]"
}
] |
592 | لديك سلسلة نصية وعدد `k`. اكتب دالة تعيد أطول سلسلة فرعية تحتوي على الأكثر `k` حرف مختلف. استخدم تقنية النافذة المنزلقة لتحسين الكفاءة. | نافذة منزلقة | تكرار الأحرف | متوسط | كتابة دالة | هذه المسألة الكلاسيكية تُحل بامتياز عبر 'النافذة المنزلقة' (Sliding Window) ومع قاموس لتسجيل تكرار كل حرف ضمن النافذة الحالية. نُحرك المؤشر الأيمن لإضافة الحروف، وإذا تجاوز عدد الحروف الفريدة في القاموس قيمة `k`، نبدأ بتحريك المؤشر الأيسر ونُقصي الحروف القديمة حتى نعود لحالة مقبولة. في كل خطوة صالحة، نقيس عرض النافذة و... | def longest_k_distinct(s, k):
if not s or k == 0:
return ""
char_counts = {}
left = 0
max_len = 0
best_left = 0
for right in range(len(s)):
char = s[right]
char_counts[char] = char_counts.get(char, 0) + 1
while len(char_counts) > k:
left_... | [
{
"input": "{\"s\":\"eceba\",\"k\":2}",
"expected": "\"ece\""
},
{
"input": "{\"s\":\"aa\",\"k\":1}",
"expected": "\"aa\""
}
] |
420 | اكتب دالة `bfs_simple(graph, start)` تُرجع جميع العقد التي يمكن الوصول إليها من نقطة البداية باستخدام BFS. | طوابير | BFS مبسط | سهل | كتابة دالة | خوارزمية البحث بالعرض (BFS) تستكشف الرسوم البيانية مستوى تلو الآخر. لتنفيذها نحتاج لهيكلين أساسيين: طابور (Queue) لتتبع العقد التي سنقوم بزيارتها لاحقاً، ومجموعة (Set) لتسجيل العقد التي زرناها لضمان عدم الدوران في حلقات مفرغة، وقائمة لتخزين ترتيب الزيارة. نبدأ بإضافة عقدة البداية للطابور وللمجموعة. في كل خطوة، نسحب أول... | def bfs_simple(graph, start):
if start not in graph:
return []
visited = set([start])
queue = [start]
res = []
while queue:
node = queue.pop(0)
res.append(node)
for neighbor in graph.get(node, []):
if neighbor not in visited:
visited.add(ne... | [
{
"input": "{\"graph\":{\"A\":[\"B\"],\"B\":[\"C\"]},\"start\":\"A\"}",
"expected": "[\"A\",\"B\",\"C\"]"
},
{
"input": "{\"graph\":{\"A\":[]},\"start\":\"A\"}",
"expected": "[\"A\"]"
},
{
"input": "{\"graph\":{},\"start\":\"A\"}",
"expected": "[]"
}
] |
7 | اكتب دالة `partial_sort(arr, start, end)` ترتب فقط العناصر بين الفهرسين start و end. | ترتيب | ترتيب جزئي | سهل | كتابة دالة | المطلوب ترتيب الشريحة arr[start:end+1] فقط وترك باقي القائمة كما هي. الفهرسان start وend شاملان كلاهما بناءً على الاختبارات.
نتحقق من الاختبار الأول: [5,2,8,1,9] مع start=1, end=3. الشريحة هي [2,8,1] عند الفهارس 1 إلى 3. بعد الترتيب تصبح [1,2,8]. إذن القائمة النهائية [5,1,2,8,9] تطابق المتوقع، مما يؤكد أن end شامل.
ا... | def partial_sort(arr, start, end):
arr = list(arr)
arr[start:end+1] = sorted(arr[start:end+1])
return arr | [
{
"input": "\"[5, 2, 8, 1, 9], 1, 3\"",
"expected": "[5, 1, 2, 8, 9]"
},
{
"input": "\"[1, 2, 3], 0, 2\"",
"expected": "[1, 2, 3]"
},
{
"input": "\"[9, 8, 7, 6, 5], 2, 4\"",
"expected": "[9, 8, 5, 6, 7]"
}
] |
813 | اكتب دالة تنفذ بحثاً ثنائياً للعثور على عنصر في مصفوفة مرتبة. | بحث | بحث ثنائي | سهل | كتابة دالة | البحث الثنائي يقوم بتقسيم النطاق لنصفين في كل خطوة لتقليص مساحة البحث للوصول لأداء O(log N). | 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 | [] |
1432 | اكتب دالة تُحسب عمق أكبر تداخل في هيكل بيانات متداخل مثل القوائم أو القواميس. | استدعاء ذاتي | أقصى عمق | متوسط | كتابة دالة | كما חللناها سابقاً: فحص نوع الكائن واستدعاء الدالة بشكل ذاتي لعناصره. | def calculate_max_depth(obj):
if isinstance(obj, list):
if not obj:
return 1
return 1 + max((calculate_max_depth(item) for item in obj), default=0)
elif isinstance(obj, dict):
if not obj:
return 1
return 1 + max((calculate_max_depth(val) for val in obj.val... | [] |
253 | الدالة التالية تُستخدم لتدوير قائمة بمقدار k خطوات إلى اليمين. ولكن يوجد خطأ في الكود. عيّن الخطأ وصوّبه.
```python
def rotate_list(lst, k):
if not lst:
return lst
k = k % len(lst)
return lst[-k:] + lst[:-k]
```
| قوائم | تدوير قائمة | متوسط | إيجاد الخطأ | المطلوب تدوير قائمة k خطوات إلى اليمين، أي أن العناصر الأخيرة تنتقل إلى المقدمة.
التدوير إلى اليمين بمقدار k يعني أن القائمة الناتجة هي lst[-k:] + lst[:-k]، أي آخر k عنصر تليها بقية العناصر. هذا هو بالضبط ما ينفّذه الكود.
لنتتبع lst=[1,2,3,4,5] و k=2: يُحسب k = 2%5 = 2. ثم lst[-2:] = [4,5] و lst[:-2] = [1,2,3]. النتي... | def rotate_list(lst, k):
if not lst:
return lst
k = k % len(lst)
return lst[-k:] + lst[:-k] | [
{
"input": "{\"lst\":[1,2,3,4,5],\"k\":2}",
"expected": "[4,5,1,2,3]"
},
{
"input": "{\"lst\":[1,2,3],\"k\":4}",
"expected": "[3,1,2]"
}
] |
328 | اكتب دالة لحساب جميع القواسم لأي عدد. الكود التالي يعمل لكنه بطيء جدًا.
```python
def divisors_slow(n):
divs = []
for i in range(1, n + 1):
if n % i == 0:
divs.append(i)
return divs
```
| رياضيات | القواسم | صعب | تحسين الكفاءة | الكود الأصلي يتحقق من كل عدد من 1 حتى n ليرى إن كان يقسم n بدون باقٍ، وبالتالي تعقيده الزمني O(n) وهو مقبول للأعداد الصغيرة لكنه يصبح بطيئاً للأعداد الكبيرة. الملاحظة الأساسية التي تقود إلى التحسين هي: القواسم تأتي دائماً في أزواج. إذا كان i قاسماً لـ n فإن n/i أيضاً قاسم، وبالتالي لا نحتاج للبحث تجاوز الجذر التربيعي ل... | def divisors(n):
divs = []
i = 1
while i * i <= n:
if n % i == 0:
divs.append(i)
if i != n // i:
divs.append(n // i)
i += 1
return sorted(divs) | [
{
"input": "12",
"expected": "[1, 2, 3, 4, 6, 12]"
},
{
"input": "1",
"expected": "[1]"
},
{
"input": "17",
"expected": "[1, 17]"
}
] |
1459 | اكتب دالة `sliding_average` تأخذ مصفوفة من الأعداد الصحيحة وحجم النافذة `k`، وتعيد متوسط كل نافذة منزلقة. | نافذة منزلقة | المتوسط | متوسط | كتابة دالة | نقوم بتحليل المشكلة التي تتطلب حساب المتوسط المنزلق (Sliding Window Average) لمصفوفة معينة بحجم نافذة محدد. الفكرة الأساسية للحل الفعال هي استخدام تقنية النافذة المنزلقة (Sliding Window). بدلاً من إعادة حساب مجموع العناصر في كل نافذة من الصفر مما يؤدي إلى تعقيد زمني بطيء $O(N \times K)$، يمكننا حساب مجموع النافذة الأول... | def sliding_average(arr, k):
if not arr or k <= 0 or len(arr) < k:
return []
window_sum = sum(arr[:k])
res = [window_sum / k]
for i in range(k, len(arr)):
window_sum += arr[i] - arr[i - k]
res.append(window_sum / k)
return res | [] |
742 | في الكود التالي، هناك خطأ في حساب عوامل القسمة:
```python
def factors(n):
result = []
for i in range(1, n+1):
if n % i == 0:
result.append(i)
return result
```
هل ترى الخطأ؟ | رياضيات | القواسم | متوسط | إيجاد الخطأ | برمجياً، هذا الكود سليم 100% ويقوم بإرجاع عوامل القسمة الصحيحة. الخطأ الوحيد هنا هو 'الخطأ الأدائي' (Performance Issue). بدلاً من البحث في نطاق من `1` إلى `n` (تعقيد O(N))، يكفي البحث حتى `sqrt(n)` مما يقلل التعقيد بشكل كبير. | # الكود المعروض ليس خاطئاً وظيفياً، ولكنه يعتبر بطيئاً للأعداد الكبيرة O(N).
# الخطأ الأدائي يُعالج بالمرور حتى الجذر التربيعي للعدد O(sqrt(n)):
def factors(n):
result = set()
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
result.add(i)
result.add(n // i)
return sorted(li... | [] |
453 | لديك مصفوفة من الأعداد الصحيحة. قم بفرز العناصر بحيث تكون الأعداد الزوجية في البداية تليها الأعداد الفردية. استخدم طريقة فرز جزئي لتحسين الكفاءة. | مؤشرين | تقسيم قائمة | سهل | كتابة دالة | تطلب المشكلة فرز المصفوفة إلى قسمين فقط (أرقام زوجية في البداية ثم الفردية)، ويمكننا فعل ذلك دون استخدام دوال فرز تقليدية لتحسين الأداء إلى الحد الأقصى عبر استخدام مؤشرين (Partitioning). نضع مؤشراً في بداية المصفوفة وآخر في نهايتها. يستمر المؤشر الأول بالتقدم طالما أنه يشير لعدد زوجي. والمؤشر الثاني يتراجع للوراء طالما... | def sort_even_odd(arr):
left, right = 0, len(arr) - 1
while left < right:
if arr[left] % 2 == 0:
left += 1
elif arr[right] % 2 != 0:
right -= 1
else:
arr[left], arr[right] = arr[right], arr[left]
left += 1
right -= 1
return ... | [
{
"input": "[3,1,2,4]",
"expected": "[4,2,1,3]"
},
{
"input": "[0]",
"expected": "[0]"
},
{
"input": "[1,3,5]",
"expected": "[1,3,5]"
}
] |
1347 | اكتب دالة تأخذ مصفوفة من الأعداد وتعيد جميع المجموعات الفرعية الممكنة منها. | استدعاء ذاتي | المجموعات الفرعية | متوسط | كتابة دالة | لإيجاد كل المجموعات الفرعية (Subsets / Power Set) لمصفوفة، يمكننا استخدام خوارزمية التراجع (Backtracking). ننشئ دالة تستدعي نفسها، تأخذ مؤشر البداية ومجموعة فرعية مؤقتة. في كل خطوة، نضيف المجموعة الحالية للنتائج، ثم ندور على العناصر المتبقية ونلحق العنصر، ونستدعي الدالة للمؤشر التالي، ثم نتراجع بحذف العنصر. هذه الطريقة... | def subsets(nums):
res = [[]]
for num in nums:
res += [curr + [num] for curr in res]
return res | [] |
13 | اكتب دالة تعيد قائمة بجميع مضاعفات عدد معين أقل من أو تساوي عدد آخر. | رياضيات | المضاعفات | سهل | كتابة دالة | المطلوب إيجاد جميع مضاعفات العدد n التي تقع في النطاق من n إلى limit شاملاً، أي الأعداد n, 2n, 3n, ... مادامت أصغر من أو تساوي limit.
الفكرة مباشرة: نولّد المضاعفات بالتسلسل بدءاً من n نفسه حتى نتجاوز limit. يمكن تحقيق ذلك بحلقة range تبدأ من n وتتقدم بخطوة n وتنتهي عند limit+1 لضمان الشمول.
نتحقق من الاختبارات: n=3,... | def multiples(n, limit):
return list(range(n, limit + 1, n)) | [
{
"input": "[3,10]",
"expected": "[3,6,9]"
},
{
"input": "[5,20]",
"expected": "[5,10,15,20]"
},
{
"input": "[7,5]",
"expected": "[]"
},
{
"input": "[1,3]",
"expected": "[1,2,3]"
}
] |
433 | نريد ترتيب جزئي لمصفوفة حسب ترتيب معين. إليك الكود الخاطئ:
```python
def partial_sort(arr, order):
order_map = {v: i for i, v in enumerate(order)}
remaining = [x for x in arr if x not in order_map]
ordered_part = sorted([x for x in arr if x in order_map], key=lambda x: order_map[x])
return ordered_part ... | ترتيب | ترتيب جزئي | سهل | فهم الكود | الكود المقدم هو تنفيذ صحيح تماماً لمشكلة الترتيب الجزئي لقائمة من العناصر استناداً إلى قائمة ترتيب مخصصة. تعتمد فكرة الكود على فصل المصفوفة إلى قسمين أساسيين: قسم يحتوي على العناصر الموجودة في الترتيب المخصص `ordered_part`، وقسم آخر للعناصر غير المذكورة `remaining`. يتم ترتيب القسم الأول وفقاً لأسبقية ظهوره في خريطة ال... | def partial_sort(arr, order):
order_map = {v: i for i, v in enumerate(order)}
remaining = [x for x in arr if x not in order_map]
ordered_part = sorted([x for x in arr if x in order_map], key=lambda x: order_map[x])
return ordered_part + remaining | [
{
"input": "[[1,2,3,4],[2,1]]",
"expected": "[2,1,3,4]"
},
{
"input": "[[5,6,7],[7,5]]",
"expected": "[7,5,6]"
}
] |
615 | اكتب دالة بلغة Python لحساب جميع التوافقيات الممكنة لعدد n من العناصر المأخوذة r في كل مرة، دون تكرار. يجب أن تستخدم تقنية Backtracking. | استدعاء ذاتي | التوافيق Combinations | متوسط | كتابة دالة | الخوارزمية هي إنشاء توافيق (Combinations) لعناصر مرقمة من 1 إلى n (كما هو متعارف عليه). نستخدم دالة `backtrack` تحمل معها مسار التوليد وفهرس البداية `start` لضمان أننا لا نعود للخلف، مما يمنع التكرار (لتكون توافيق وليس تباديل). وعندما يصبح طول المسار معادلاً لـ r نقوم بإضافته للنتائج. | def combine(n, r):
result = []
def backtrack(start, path):
if len(path) == r:
result.append(path[:])
return
for i in range(start, n + 1):
path.append(i)
backtrack(i + 1, path)
path.pop()
backtrack(1, [])
return resu... | [] |
394 | اكتب دالة تأخذ قائمة بأزواج تمثل فترات زمنية [(start, end)]، وتعيد عدد أقصى عدد من الفترات غير المتداخلة. | جشع | Interval Scheduling | سهل | كتابة دالة | مسألة جدولة الفترات الكلاسيكية تُحل بخوارزمية جشعة. الهدف هو اختيار أكبر عدد من الفترات بحيث لا تتداخل أي فترتين مختارتين. الملاحظة الأساسية هي أن اختيار الفترة التي تنتهي أولاً يترك أكبر مساحة ممكنة للفترات اللاحقة.
الخوارزمية: نرتب الفترات تصاعدياً حسب وقت الانتهاء. نبدأ بعدّاد صفر ومتغير last_end يمثل نهاية آخر فتر... | def max_non_overlapping(intervals):
if not intervals:
return 0
intervals.sort(key=lambda x: x[1])
count = 0
last_end = float('-inf')
for start, end in intervals:
if start >= last_end:
count += 1
last_end = end
return count | [
{
"input": "[[1,3],[2,4],[3,5]]",
"expected": "2"
},
{
"input": "[[1,2],[3,4],[5,6]]",
"expected": "3"
},
{
"input": "[[1,4],[2,3]]",
"expected": "1"
},
{
"input": "[]",
"expected": "0"
},
{
"input": "[[1,1]]",
"expected": "1"
}
] |
1443 | اكتب دالة `extract_patterns(text, pattern)` تعيد جميع المواقع التي يظهر فيها النمط في النص. | سلاسل نصية | البحث في النصوص | متوسط | كتابة دالة | تكرار למسألة. الاستعانة بـ `re.finditer` مع النظرة المستقبلية `(?=pattern)` للعثور على כל الحالات بما فيها المتداخلة. | import re
def extract_patterns(text, pattern):
if not pattern:
return []
matches = re.finditer(f'(?=({re.escape(pattern)}))', text)
return [match.start() for match in matches] | [] |
317 | نريد حساب قيمة متسلسلة فيبوناتشي باستخدام الاستدعاء الذاتي. يوجد خطأ في الكود التالي:
```python
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
```
| استدعاء ذاتي | Fibonacci | صعب | تحليل كود | المطلوب حساب الحد n من متتالية فيبوناتشي باستخدام الاستدعاء الذاتي. تُعرَّف المتتالية بالعلاقة: F(0)=0، F(1)=1، وF(n)=F(n-1)+F(n-2) لكل n أكبر من 1.
الخوارزمية تعتمد على التعريف الرياضي مباشرةً: الحالات الأساسية عندما n≤1 تُعيد n مباشرة لأن F(0)=0 وF(1)=1. لكل قيمة أكبر من 1 تُحلّل المسألة إلى مسألتين فرعيتين أصغر ثم ... | def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2) | [
{
"input": "0",
"expected": "0"
},
{
"input": "1",
"expected": "1"
},
{
"input": "5",
"expected": "5"
},
{
"input": "10",
"expected": "55"
}
] |
1298 | اكتب دالة `sort_dict_by_value(d)` تعيد قاموساً جديدًا مرتبًا حسب القيم تصاعديًا. | قواميس | ترتيب | متوسط | كتابة دالة | الترتيب يعتمد على ميزة `d.items()` التي تعطي قائمة من الأزواج `(key, value)`. نمرر هذه الأزواج إلى الدالة `sorted` مع تحديد معامل الفرز (key) ليقرأ العنصر ذو الفهرس [1] (أي القيمة). وأخيراً نحول النتيجة مجدداً إلى قاموس (بدءاً من بايثون 3.7 تحافظ القواميس على الترتيب). | def sort_dict_by_value(d):
# ترتيب القاموس بالاعتماد على العنصر الثاني (القيمة)
sorted_items = sorted(d.items(), key=lambda item: item[1])
return dict(sorted_items) | [] |
389 | اكتب دالة تأخذ مجموعتين وتُرجع مجموعة تحتوي على العناصر المشتركة بينهما. | مجموعات | تقاطع | سهل | كتابة دالة | المطلوب إيجاد العناصر المشتركة بين مجموعتين، وهو ما يُعرف بعملية التقاطع. الفكرة الخوارزمية هي المرور على عناصر إحدى المجموعتين والتحقق من وجود كل عنصر في المجموعة الأخرى. إذا كان العنصر موجوداً في كلتيهما نضيفه إلى مجموعة النتيجة.
بما أن التحقق من وجود عنصر في مجموعة يتم بزمن O(1) في المتوسط، فإن التعقيد الكلي هو O(m... | def intersection(set1, set2):
result = set()
for item in set1:
if item in set2:
result.add(item)
return result | [
{
"input": "[{\"__set__\":[1,2,3]},{\"__set__\":[2,3,4]}]",
"expected": "{\"__set__\":[2,3]}"
},
{
"input": "[{\"__set__\":[1,2]},{\"__set__\":[3,4]}]",
"expected": "{\"__set__\":[]}"
},
{
"input": "[{\"__set__\":[1,2,3]},{\"__set__\":[1,2,3]}]",
"expected": "{\"__set__\":[1,2,3]}"
... |
663 | اكتب دالة باستخدام الاستدعاء الذاتي لحساب العامل (Factorial) لعدد صحيح موجب. | استدعاء ذاتي | Factorial | سهل | كتابة دالة | دالة المضروب الكلاسيكية. إذا كان n مساوياً للصفر أو الواحد، نرجع 1 كحالة أساسية. غير ذلك، نرجع n مضروباً في استدعاء الدالة لـ n-1. | def factorial(n):
if n < 0:
raise ValueError("المضروب غير معرف للأعداد السالبة")
if n <= 1:
return 1
return n * factorial(n - 1) | [] |
598 | لديك سلسلة نصية. اكتب دالة تعيد السلسلة بعد ضغطها باستخدام تكرار الحروف (مثل: aabcccccaaa -> a2b1c5a3). استخدم خوارزمية ضغط النص لتحسين الكفاءة. | سلاسل نصية | ضغط النصوص | متوسط | كتابة دالة | خوارزمية RLE (Run-Length Encoding). لضمان الكفاءة القصوى وتجنب بطء التسلسل `+` المتكرر في السلاسل النصية، نستخدم قائمة لجمع النتائج. نعد الحروف المتجاورة المتطابقة، وعند الاختلاف نلحق الحرف وعدده في القائمة، ثم نعيد ضبط العداد. أخيراً ندمج القائمة باستخدام `join`. | def compress_string(s):
if not s:
return ""
result = []
count = 1
for i in range(1, len(s)):
if s[i] == s[i - 1]:
count += 1
else:
result.append(s[i - 1] + str(count))
count = 1
# إضافة آخر مجموعة
result.append(s[-1] + str(count))
c... | [] |
28 | اكتب دالة `fibonacci(n)` تعيد الحد النوني في متتالية فيبوناتشي باستخدام الاستدعاء الذاتي. | استدعاء ذاتي | Fibonacci | سهل | كتابة دالة | متتالية فيبوناتشي تُعرَّف تكرارياً بشكل مباشر: F(0) = 0 و F(1) = 1 وF(n) = F(n-1) + F(n-2) لكل n >= 2. المسألة تطلب صراحةً استخدام الاستدعاء الذاتي، بالتالي نترجم هذا التعريف مباشرة إلى كود.
الدالة تتحقق من الحالات الأساسية أولاً: إذا كان n=0 تعيد 0، وإذا كان n=1 تعيد 1. في أي حالة أخرى تستدعي نفسها مع n-1 وn-2 وتجمع ... | def fibonacci(n):
if n == 0:
return 0
if n == 1:
return 1
return fibonacci(n - 1) + fibonacci(n - 2) | [
{
"input": "{\"n\":0}",
"expected": "0"
},
{
"input": "{\"n\":1}",
"expected": "1"
},
{
"input": "{\"n\":5}",
"expected": "5"
},
{
"input": "{\"n\":7}",
"expected": "13"
}
] |
984 | اكتب دالة تأخذ مصفوفة وقيمة، وتعيد آخر موقع يظهر فيه القيمة في المصفوفة. إذا لم توجد، أعد -1. | بحث | بحث خطي | سهل | كتابة دالة | تبدأ عملية الحل بتحديد طبيعة المتطلب، وهو العثور على عنصر معين، أو فرز عناصر بناءً على معيار مبسط، أو استخراج بيانات من القائمة. بما أن المشكلة لا تتطلب تعقيدات خوارزمية مركبة، فإن الفكرة الأساسية تكمن في استخدام حلقة تكرارية خطية للمرور على العناصر ومقارنتها بالشرط المطلوب. لماذا يعتبر هذا المرور البسيط كافياً؟ لأن ال... | def find_last_index(arr, target):
for i in range(len(arr) - 1, -1, -1):
if arr[i] == target:
return i
return -1 | [] |
665 | اكتب دالة تأخذ مصفوفة وترتب جزءًا معينًا منها حسب المدى المحدد. | ترتيب | ترتيب جزئي | سهل | كتابة دالة | بايثون تدعم 'Slicing' أو التقطيع بفعالية لتحديد جزء من المصفوفة وإعادة تعيينه. نقوم بتمرير المدى (start, end) ونرتب الجزء المحدد بواسطة `sorted()` ثم نعيّنه مرة أخرى في مكانه بالمصفوفة. | def partial_sort(arr, start, end):
if not arr or start < 0 or end > len(arr) or start >= end:
return arr
# ترتيب الجزء المخصص في مكانه
arr[start:end] = sorted(arr[start:end])
return arr | [] |
641 | في هذا السؤال، تم إعطاؤك كوداً بطيئاً لتقسيم قائمة إلى عدة قوائم فرعية. قم بتحسين الكود لزيادة الكفاءة.
```python
def split_list(lst, n):
result = []
for i in range(0, len(lst), n):
sub = []
for j in range(i, min(i+n, len(lst))):
sub.append(lst[j])
result.append(sub)
retu... | قوائم | تقسيم قائمة | سهل | تحسين الكود | الكود يستخدم حلقة متداخلة للنسخ اليدوي `append` لكل عنصر. في لغة بايثون، تعتبر عملية 'التقطيع' (Slicing) هي الأكثر كفاءة وأسرع بكثير لأنها تنفذ عبر محرك الـ C الخاص ببايثون. | def split_list(lst, n):
# التحسين باستخدام تقنية List Comprehension وتقطيع القوائم (Slicing)
return [lst[i:i + n] for i in range(0, len(lst), n)] | [] |
930 | اكتب دالة `reverse_stack(stack)` تعكس ترتيب عناصر المكدس باستخدام مكدس آخر أو متغيرات مؤقتة فقط. | مكدسات | عكس المكدس | متوسط | كتابة دالة | عكس המكدس בاستخدام متغيرات مؤقتة يتم بشكل مثالي בاستدعاء ذاتي (Recursion)، حيث تُخزن العناصر בـ Call Stack الذاكرة المؤقتة للبرنامج. | def reverse_stack(stack):
if not stack:
return
temp = stack.pop()
reverse_stack(stack)
insert_at_bottom(stack, temp)
def insert_at_bottom(stack, item):
if not stack:
stack.append(item)
return
temp = stack.pop()
insert_at_bottom(stack, item)
stack.append(temp) | [] |
572 | فيما يلي كود لحساب عدد مرات تكرار كل عنصر في قائمة. الكود يعمل بشكل صحيح لكنه غير فعال. قم بتحسينه:
```python
def count_elements(lst):
counts = {}
for item in lst:
if item in counts:
counts[item] += 1
else:
counts[item] = 1
return counts
``` | قواميس | عد التكرارات | سهل | تحسين الكود | الكود يعمل بزمن O(N) وهو جيد، ولكن من منظور أسلوب لغة بايثون (Pythonic)، يعتبر غير كفء نظراً لوجود تحققات شرطية لكل عنصر والتي تُبطئ التنفيذ الفعلي في لغة بايثون. استخدام `collections.Counter` هو الأسلوب الأمثل والمُحسن داخلياً في لغة C، مما يجعله أسرع وأقصر. | from collections import Counter
def count_elements(lst):
# استخدام Counter يوفر أداءً أعلى ومكتوب بلغة C داخلياً
return dict(Counter(lst)) | [] |
1083 | لديك سلسلة نصية وسلسلة فرعية. اكتب دالة لإيجاد جميع المواقع التي تظهر فيها السلسلة الفرعية داخل السلسلة الرئيسية. | سلاسل نصية | البحث في النصوص | متوسط | كتابة دالة | تبدأ عملية الحل بتحديد طبيعة المتطلب، وهو العثور على عنصر معين، أو فرز عناصر بناءً على معيار مبسط، أو استخراج بيانات من القائمة. بما أن المشكلة لا تتطلب تعقيدات خوارزمية مركبة، فإن الفكرة الأساسية تكمن في استخدام حلقة تكرارية خطية للمرور على العناصر ومقارنتها بالشرط المطلوب. لماذا يعتبر هذا المرور البسيط كافياً؟ لأن ال... | import re
def find_all_occurrences(text, pattern):
if not pattern:
return []
return [m.start() for m in re.finditer(f'(?=({re.escape(pattern)}))', text)] | [] |
1321 | اكتب دالة تُرجع العناصر الفريدة من قائمة معينة. | قوائم | إزالة التكرار | سهل | كتابة دالة | אם كان الترتيب مهماً نستخدم `dict.fromkeys()`، ولكن إذا לא يهم، تحويلها لـ `set` ثم `list` هو المباشر. | def get_unique_items(lst):
# استخدام dict للحفاظ على الترتيب الأصلي وهو أفضل ممارسة
return list(dict.fromkeys(lst)) | [] |
1370 | أوجد أول عنصر يظهر أكثر من مرة في القائمة. الكود التالي يحتوي على خطأ:
```python
def first_duplicate(nums):
seen = set()
for num in nums:
if num in seen:
return num
seen.add(num)
return -1
```
هل تعتقد أن الكود صحيح؟ جرب المدخلات التالية. | قوائم | أول عنصر متكرر | متوسط | إيجاد الخطأ | تبدأ عملية الحل بتحديد طبيعة المتطلب، وهو العثور على عنصر معين، أو فرز عناصر بناءً على معيار مبسط، أو استخراج بيانات من القائمة. بما أن المشكلة لا تتطلب تعقيدات خوارزمية مركبة، فإن الفكرة الأساسية تكمن في استخدام حلقة تكرارية خطية للمرور على العناصر ومقارنتها بالشرط المطلوب. لماذا يعتبر هذا المرور البسيط كافياً؟ لأن ال... | def find_first_duplicate(arr):
seen = set()
for num in arr:
if num in seen:
return num
seen.add(num)
return -1 | [] |
1099 | اكتب دالة تحسب عدد مرات تكرار كل عنصر في قاموس وتعيد أعلى قيمة تكرار. | قواميس | أعلى تكرار | سهل | كتابة دالة | إِذا كـان الـمـطـلـوب (تـكـرار קـيـم הـقـامـوس) نـسـتـخـدم `Counter` לـ `dict.values()`. | from collections import Counter
def max_value_frequency(d):
if not d:
return 0
counts = Counter(d.values())
return counts.most_common(1)[0][1] | [] |
661 | اكتب دالة `max_unique_in_window` تستقبل نصًا وعددًا `k`، وتعيد الحد الأقصى لعدد الأحرف غير المكررة في أي نافذة بطول `k`. | نافذة منزلقة | أحرف غير مكررة | متوسط | كتابة دالة | نستخدم خوارزمية النافذة المنزلقة (Sliding Window) مع قاموس لحساب التكرارات الحالية. في كل خطوة، نضيف الحرف الجديد من يمين النافذة ونطرح الحرف القديم من يسارها. حجم القاموس يعبر عن عدد الحروف الفريدة في النافذة، نسجل أقصى قيمة. | def max_unique_in_window(s, k):
if not s or k <= 0 or k > len(s):
return 0
char_counts = {}
max_unique = 0
# معالجة النافذة الأولى
for i in range(k):
char_counts[s[i]] = char_counts.get(s[i], 0) + 1
max_unique = len(char_counts)
# الانزلاق عبر السل... | [] |
404 | اكتب دالة `search_in_array(arr, target)` تعيد `True` إذا وُجد العنصر `target` في المصفوفة `arr`، و`False` غير ذلك. | بحث | البحث في مصفوفة | سهل | كتابة دالة | المطلوب إرجاع قيمة منطقية تشير إلى وجود أو عدم وجود العنصر المستهدف داخل المصفوفة. أبسط وأكثر طريقة مباشرة لتحقيق ذلك هي البحث الخطي، حيث نمر على كل عنصر في المصفوفة بالتسلسل. بمجرد أن نجد العنصر المطلوب، نرجع قيمة تدل على الصواب لإنهاء البحث فوراً. إذا انتهت المصفوفة ولم يظهر العنصر، نرجع قيمة تدل على الخطأ. في بايثون... | def search_in_array(arr, target):
return target in arr | [
{
"input": "{\"arr\":[1,2,3,4,5],\"target\":3}",
"expected": "true"
},
{
"input": "{\"arr\":[1,2,3],\"target\":6}",
"expected": "false"
},
{
"input": "{\"arr\":[],\"target\":1}",
"expected": "false"
}
] |
64 | اكتب دالة `max_intervals_scheduled` تستلم قائمة فواصل زمنية (كل فاصل على شكل [بدء، انتهاء]) وتعيد الحد الأقصى لعدد الفواصل غير المتداخلة التي يمكن جدولتها. | جشع | Interval Scheduling | سهل | كتابة دالة | المطلوب كتابة دالة تقوم بحساب أو معالجة البيانات وفق الوصف المطلوب. نحدد أولا المعطيات والنتيجة المرجوة، ثم نختار الخوارزمية المناسبة لحل المسألة مع مراعاة الحالات الحدية مثل القيم الفارغة أو الأعداد السالبة أو الفهارس خارج النطاق. | def max_intervals_scheduled(intervals):
if not intervals: return 0
intervals.sort(key=lambda x: x[1])
cnt, end = 1, intervals[0][1]
for s, e in intervals[1:]:
if s >= end:
cnt += 1
end = e
return cnt | [
{
"input": "[[1,3],[2,4],[3,6]]",
"expected": "2"
},
{
"input": "[[1,2],[3,4],[5,6]]",
"expected": "3"
},
{
"input": "[[1,4],[2,3]]",
"expected": "1"
},
{
"input": "[]",
"expected": "0"
}
] |
451 | يُطلب منك حساب الحد النوني لمتتالية فيبوناتشي. الكود التالي يعمل لكنه بطيء:
```python
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
``` | برمجة ديناميكية | متتاليات | سهل | فهم الكود | الاستدعاء الذاتي المباشر لمتتالية فيبوناتشي ينتج شجرة استدعاءات هائلة التعقيد، مما يجعله خوارزمية أسية O(2^n) بالغة البطء بالنسبة للأرقام الكبيرة. لتصحيح هذا الأداء وجعله أفضل بكثير، نستخدم أسلوب البرمجة الديناميكية من أسفل إلى أعلى (Bottom-Up). عن طريق الاحتفاظ بأحدث قيمتين فقط `a` و `b` والبدء من الأساس وتحديثهما تصا... | def fibonacci(n):
if n <= 1:
return n
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
return a | [
{
"input": "5",
"expected": "5"
},
{
"input": "0",
"expected": "0"
},
{
"input": "10",
"expected": "55"
}
] |
1451 | اكتب دالة `partition_list(head, x)` تقسم قائمة مرتبطة بحيث تكون كل العقد التي قيمتها أقل من `x` قبل العقد التي قيمتها أكبر أو تساوي `x`. | قوائم | قوائم مرتبطة | متوسط | كتابة دالة | لتقسيم (Partition) قائمة مرتبطة حول الـ `x`، נبني قائمتين: واحدة للأصغر وواحدة للأكبر أو הمساوي. ثم نربط نهاية الأصغر ببداية الأكبر. | class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
def partition_list(head, x):
less_head = ListNode(0)
less = less_head
greater_head = ListNode(0)
greater = greater_head
curr = head
while curr:
if curr.val < x:
les... | [] |
362 | اكتب دالة `split_list(lst, k)` تأخذ قائمة وعدد صحيح `k` وتعيد قائمة تحتوي على `k` قوائم فرعية متساوية الحجم (باستثناء الأخيرة). | قوائم | تقسيم قائمة | سهل | كتابة دالة | المطلوب تقسيم قائمة إلى k أجزاء متساوية الحجم قدر الإمكان، حيث يُسمح للجزء الأخير بأن يكون أصغر إذا لم يقبل الطول القسمة التامة على k.
الفكرة هي حساب حجم كل جزء بالتقريب للأعلى باستخدام القسمة الصحيحة مع الجبر: size = (len(lst) + k - 1) // k. هذه الصيغة تعادل الدالة ceil وتضمن أن الأجزاء الأولى تحصل على size عنصر بينم... | def split_list(lst, k):
if not lst:
return []
size = (len(lst) + k - 1) // k
result = []
for i in range(0, len(lst), size):
result.append(lst[i:i+size])
return result | [
{
"input": "{\"lst\":[1,2,3,4,5,6],\"k\":3}",
"expected": "[[1,2],[3,4],[5,6]]"
},
{
"input": "{\"lst\":[1,2,3,4,5],\"k\":2}",
"expected": "[[1,2,3],[4,5]]"
},
{
"input": "{\"lst\":[],\"k\":2}",
"expected": "[]"
},
{
"input": "{\"lst\":[1,2,3],\"k\":1}",
"expected": "[[1,... |
1229 | اكتب دالة `factorial_mod(n, mod)` تحسب العامل n! modulo mod باستخدام الاستدعاء الذاتي بطريقة فعالة. | استدعاء ذاتي | Factorial | سهل | كتابة دالة | العامل (M مضروب) لعدد صحيح موجب يتم تعريفه بضرب العدد في جميع الأعداد الصحيحة الموجبة التي تسبقه. الخوارزمية المتكررة (الاستدعاء الذاتي) مثالية هنا لأن n! يساوي n مضروباً في (n-1)!. لحل المسألة بالاستدعاء الذاتي، نحدد أولاً شرط التوقف أو الحالة الأساسية: عندما يصل n إلى 0 أو 1، يجب أن ترجع الدالة 1 فوراً لأن 0! = 1 و 1... | def factorial(n):
if n <= 1:
return 1
return n * factorial(n - 1) | [] |
369 | اكتب دالة تقبل مصفوفة مرتبة تحتوي على أعداد صحيحة موجبة متوالية، ولكن ينقصها عدد واحد، وتعيد العدد المفقود. | بحث | عنصر مفقود | سهل | كتابة دالة | المصفوفة تحتوي على n-1 عدداً من متتالية الأعداد الطبيعية من 1 إلى n، وينقصها عدد واحد. المطلوب إيجاد هذا العدد.
الفكرة الجوهرية: مجموع الأعداد من 1 إلى n معادلته الرياضية n(n+1)/2. إذا طرحنا مجموع عناصر المصفوفة الفعلية من هذا المجموع المنتظر حصلنا على العدد المفقود مباشرة، دون الحاجة إلى بحث أو مقارنة.
المصفوفة تحتو... | def find_missing(arr):
n = len(arr) + 1
expected_sum = n * (n + 1) // 2
return expected_sum - sum(arr) | [
{
"input": "[1,2,4,5]",
"expected": "3"
}
] |
360 | اكتب دالة `sort_complex_list(lst)` ترتب عناصر قائمة تحتوي على قواميس حسب مفتاح معين. | ترتيب | ترتيب عناصر معقدة | سهل | كتابة دالة | المطلوب ترتيب قائمة من القواميس تصاعدياً حسب قيمة مفتاح معين. الدالة تقبل وسيطَين: lst وهي القائمة، وkey وهو المفتاح الذي نرتب بحسبه مع قيمة افتراضية "name" إذا لم يُحدَّد.
الفكرة هي استخدام دالة sorted مع وسيط key الذي يُخبر الدالة بكيفية استخراج قيمة المقارنة من كل عنصر. نمرر lambda تأخذ قاموساً وتُرجع قيمة المفتاح ... | def sort_complex_list(lst, key="name"):
return sorted(lst, key=lambda x: x[key]) | [
{
"input": "[[{\"name\":\"Ali\"},{\"name\":\"Zaid\"}]]",
"expected": "[{\"name\":\"Ali\"},{\"name\":\"Zaid\"}]"
},
{
"input": "[[{\"age\":25},{\"age\":20}],\"age\"]",
"expected": "[{\"age\":20},{\"age\":25}]"
}
] |
999 | اكتب دالة تحذف التكرارات من قائمة معينة وتحتفظ بترتيب العناصر. | قوائم | إزالة التكرار | سهل | كتابة دالة | المطلوب كتابة دالة تقوم بحساب أو معالجة البيانات وفق الوصف المطلوب. نحدد أولا المعطيات والنتيجة المرجوة، ثم نختار الخوارزمية المناسبة لحل المسألة مع مراعاة الحالات الحدية مثل القيم الفارغة أو الأعداد السالبة أو الفهارس خارج النطاق. | def remove_duplicates_keep_order(lst):
return list(dict.fromkeys(lst)) | [] |
325 | اكتب دالة للبحث عن عناصر في قائمة تحقق شرطًا معينًا. الكود التالي بطيء جدًا.
```python
def search_with_condition_slow(data, condition):
result = []
for item in data:
if condition(item):
result.append(item)
return result
```
| بحث | البحث بشرط | صعب | تحسين الكفاءة | المطلوب تحسين دالة تُصفّي عناصر قائمة وتُعيد فقط تلك التي تحقق شرطاً معيناً. الكود الأصلي يستخدم حلقة for صريحة مع append لكل عنصر يحقق الشرط.
التحسين يعتمد على استخدام list comprehension بدلاً من الحلقة الصريحة. list comprehension في Python مُحسَّنة على مستوى المفسّر وتُنفَّذ بشكل أسرع من حلقة for مع append، وذلك لأن... | def search_with_condition(data, condition):
return [item for item in data if condition(item)] | [
{
"input": "\"([1, 2, 3, 4, 5], lambda x: x > 3)\"",
"expected": "[4, 5]"
},
{
"input": "\"([], lambda x: x > 0)\"",
"expected": "[]"
}
] |
885 | لديك قائمة من الأعداد الصحيحة والمطلوب هو إيجاد زوج من العناصر بحيث يكون مجموعها مساوياً لقيمة معينة target. اكتب دالة تعيد أول زوج من العناصر يحقق هذا الشرط. استخدم خوارزمية بكفاءة O(n). | مجموعات | Pair Sum | سهل | كتابة دالة | تبدأ عملية الحل بتحديد طبيعة المتطلب، وهو العثور على عنصر معين، أو فرز عناصر بناءً على معيار مبسط، أو استخراج بيانات من القائمة. بما أن المشكلة لا تتطلب تعقيدات خوارزمية مركبة، فإن الفكرة الأساسية تكمن في استخدام حلقة تكرارية خطية للمرور على العناصر ومقارنتها بالشرط المطلوب. لماذا يعتبر هذا المرور البسيط كافياً؟ لأن ال... | def find_pair_sum(arr, target):
seen = set()
for num in arr:
complement = target - num
if complement in seen:
return (complement, num)
seen.add(num)
return None | [] |
1235 | اكتب دالة `gcd_of_array(arr)` تعيد العامل المشترك الأكبر لجميع عناصر المصفوفة. | رياضيات | GCD | متوسط | كتابة دالة | لإيجاد القاسم المشترك الأكبر (GCD) لمجموعة كاملة من الأرقام في مصفوفة، نعتمد على خاصية تجميعية رياضية تنص على أن: GCD(a, b, c) = GCD(GCD(a, b), c). بناءً على ذلك، يكفي استخدام دالة تحسب القاسم لعددين (أفضلها خوارزمية إقليدس) وتطبيقها بشكل تراكمي على جميع عناصر المصفوفة. نبدأ بتعيين أول عنصر كقاسم مشترك مبدئي، ثم نمر بح... | import math
from functools import reduce
def gcd_of_array(arr):
if not arr:
return 0
return reduce(math.gcd, arr) | [] |
1569 | لديك مجموعتان A و B. اكتب دالة تعيد اتحاد المجموعتين (جميع العناصر من A و B دون تكرار).
```python
def set_union(A, B):
result = A[:]
for item in B:
if item not in result:
result.append(item)
return result
``` | مجموعات | تقاطع | سهل | تحسين الكفاءة | تبدأ عملية الحل بتحديد طبيعة المتطلب، وهو العثور على عنصر معين، أو فرز عناصر بناءً على معيار مبسط، أو استخراج بيانات من القائمة. بما أن المشكلة لا تتطلب تعقيدات خوارزمية مركبة، فإن الفكرة الأساسية تكمن في استخدام حلقة تكرارية خطية للمرور على العناصر ومقارنتها بالشرط المطلوب. لماذا يعتبر هذا المرور البسيط كافياً؟ لأن ال... | def intersection(set1, set2):
return sorted(set1 & set2) | [] |
1510 | اكتب دالة `generate_permutations(nums)` تستخدم الاستدعاء الذاتي لتوليد جميع التباديل الممكنة للقائمة nums. يجب أن تُرجع قائمة تحتوي على جميع التباديل الممكنة. | استدعاء ذاتي | توليد التباديل | متوسط | كتابة دالة | الهدف من المشكلة هو توليد جميع التباديل (Permutations) الممكنة لمجموعة من العناصر. الفكرة الأساسية لحل هذا النوع من المسائل التوافقية هي استخدام التتبع الخلفي (Backtracking). لماذا ينجح التتبع الخلفي؟ لأنه يسمح لنا باستكشاف جميع المسارات الممكنة لترتيب العناصر بشكل منهجي، مع التراجع عند الوصول إلى نهاية المسار. نبدأ بت... | def generate_permutations(nums):
result = []
def backtrack(current, remaining):
if not remaining:
result.append(current[:])
return
for i in range(len(remaining)):
current.append(remaining[i])
backtrack(current, remaining[:i] + remaining[i+1:])
... | [] |
419 | اكتب دالة `lcm(a, b)` لحساب المضاعف المشترك الأصغر لعددين. | رياضيات | المضاعفات | سهل | كتابة دالة | المضاعف المشترك الأصغر (LCM) لعددين هو أصغر عدد يقبل القسمة عليهما معاً بدون باقي. يمكن إيجاد المضاعف المشترك الأصغر باستخدام العلاقة الرياضية الثابتة التي تربطه بالقاسم المشترك الأكبر (GCD)، حيث ينص القانون على أن حاصل ضرب عددين يساوي حاصل ضرب قاسمهما المشترك الأكبر في مضاعفهما المشترك الأصغر. بالتالي، لحساب المضاعف، ... | def lcm(a, b):
if a == 0 or b == 0:
return 0
def gcd(x, y):
while y:
x, y = y, x % y
return x
return abs(a * b) // gcd(a, b) | [
{
"input": "{\"a\":4,\"b\":6}",
"expected": "12"
},
{
"input": "{\"a\":7,\"b\":5}",
"expected": "35"
},
{
"input": "{\"a\":0,\"b\":5}",
"expected": "0"
}
] |
1252 | اكتب دالة لإزالة التكرارات من قائمة مرتبطة بدون استخدام هيكل بيانات إضافي. | مؤشرين | إزالة التكرار | متوسط | كتابة دالة | تبدأ عملية الحل بتحديد طبيعة المتطلب، وهو العثور على عنصر معين، أو فرز عناصر بناءً على معيار مبسط، أو استخراج بيانات من القائمة. بما أن المشكلة لا تتطلب تعقيدات خوارزمية مركبة، فإن الفكرة الأساسية تكمن في استخدام حلقة تكرارية خطية للمرور على العناصر ومقارنتها بالشرط المطلوب. لماذا يعتبر هذا المرور البسيط كافياً؟ لأن ال... | def remove_duplicates_sorted(arr):
if not arr:
return 0
insert_idx = 1
for i in range(1, len(arr)):
if arr[i] != arr[i-1]:
arr[insert_idx] = arr[i]
insert_idx += 1
return insert_idx | [] |
1352 | في الكود التالي، هناك خطأ في حساب متتالية فيبوناتشي. صححه.
```python
def fib(n):
if n <= 1:
return n
return fib(n-1) + fib(n-2)
``` | برمجة ديناميكية | Memoization | متوسط | تحسين الكود | الاستدعاء الذاتي البسيط هنا يستغرق وقتاً أسياً O(2^n) بسبب الحسابات المتكررة لنفس القيم. للتحسين وجعله خطياً O(N)، يمكن استخدام التخزين المؤقت (Memoization) عبر مزخرف `@lru_cache` المدمج في بايثون، أو إعادة كتابته برمجياً بشكل تكراري (Iterative) وهو الأفضل لتجنب تجاوز حد الاستدعاء الذاتي. | from functools import lru_cache
# التحسين الأول باستخدام التخزين المؤقت:
@lru_cache(maxsize=None)
def fibonacci_memo(n):
if n <= 1:
return n
return fibonacci_memo(n - 1) + fibonacci_memo(n - 2)
# التحسين الثاني والأفضل (Iterative) O(N) وبلا مخاطر امتلاء المكدس:
def fibonacci(n):
if n <= 1: return ... | [] |
141 | لديك قائمة من الأعداد وعدد معين، اكتب دالة تعيد أول موقع يظهر فيه العدد في القائمة. إليك كود بطيء: def find_first_occurrence(arr, target):
for i in range(len(arr)):
if arr[i] == target:
for j in range(i):
pass # loop for no reason
return i
return -1
قم بتحسين ال... | بحث | أول ظهور | سهل | تحسين الكفاءة | المشكلة تطلب إيجاد أول موقع لعنصر في قائمة. الكود الأصلي يحتوي على حلقة داخلية فارغة لا تفعل شيئاً، مما يزيد التعقيد الزمني دون أي فائدة.
الفكرة الأساسية هي أن Python توفر الدالة المدمجة index للقوائم والتي تُرجع أول موقع للعنصر مباشرة، أو نستخدم enumerate للمرور على العناصر مرة واحدة والعودة فور أول تطابق. كلا النهجي... | def find_first_occurrence(arr, target):
try:
return arr.index(target)
except ValueError:
return -1 | [
{
"input": "\"[1,2,3,2,4], 2\"",
"expected": "1"
},
{
"input": "\"[1,2,3], 5\"",
"expected": "-1"
},
{
"input": "\"[5,5,5], 5\"",
"expected": "0"
},
{
"input": "\"[], 1\"",
"expected": "-1"
},
{
"input": "\"[1], 1\"",
"expected": "0"
}
] |
827 | اكتب دالة تجد أكبر مجموع لعناصر في نافذة منزلقة بحجم k داخل قائمة. | نافذة منزلقة | أكبر مجموع | متوسط | كتابة دالة | تكرار لمسألة أكبر مجموع. نستخدم النافذة المنزلقة لجمع العناصر وتقليل التعقيد إلى O(N). | def max_sliding_window_sum(arr, k):
if not arr or k <= 0 or len(arr) < k:
return 0
window_sum = sum(arr[:k])
max_sum = window_sum
for i in range(k, len(arr)):
window_sum += arr[i] - arr[i - k]
max_sum = max(max_sum, window_sum)
return max_sum | [] |
994 | اكتب دالة تُقيّم تعبيرًا رياضيًا معطى على شكل سلسلة نصية باستخدام مكدس. افترض أن التعبير يحتوي فقط على الأرقام، والعمليات (+، -، *، /)، والأقواس (). | مكدسات | تقييم التعابير | صعب | كتابة دالة | לتقييم تعبير Infix (بأقواس وعمليات)، מن الأفضل بناء دالة להتحويل لـ Postfix ثم التقييم أو הاستخدام המباشر לـ Recursive Descent أو মكدسين (للعمليات والأرقام). هنا דالة `eval()` المدمجة هي الـ built-in ولكن لتطبيق מكدس سنستخدم مكدسين. | def evaluate_expression(expression):
def precedence(op):
if op in ('+', '-'): return 1
if op in ('*', '/'): return 2
return 0
def apply_op(a, b, op):
if op == '+': return a + b
if op == '-': return a - b
if op == '*': return a * b
if op == '/': return... | [] |
1427 | اكتب دالة تُعرف مجموع الأرقام في عدد صحيح باستخدام الاستدعاء الذاتي. على سبيل المثال، إذا كان المدخل 123، فإن الناتج يجب أن يكون 6. | استدعاء ذاتي | مجموع الأرقام | متوسط | كتابة دالة | نقوم بتحليل المشكلة التي تتطلب تطبيق عملية رياضية أو منطقية متكررة، مثل حساب القوة، العاملي، أو مجموع الأرقام. الفكرة الأساسية هي حل المشكلة باستخدام الاستدعاء الذاتي (Recursion)، حيث نقوم بتقسيم المشكلة الكبيرة إلى مشاكل فرعية أصغر من نفس النوع. لماذا ينجح الاستدعاء الذاتي؟ لأنه يبسط المنطق ويقربه من التعريف الرياضي، ... | def sum_of_digits(n):
n = abs(n)
if n == 0:
return 0
return (n % 10) + sum_of_digits(n // 10) | [] |
801 | اكتب دالة تعيد العامل (Factorial) لعدد معين باستخدام الاستدعاء الذاتي (Recursion). | استدعاء ذاتي | مضروب العدد | سهل | كتابة دالة | الاستدعاء الذاتي لمضروب العدد `n` يعتمد على العلاقة `n * (n-1)!`. وشرط التوقف (Base Case) هو عندما يصل العدد إلى 1 أو 0 نُرجع 1. | def factorial_recursive(n):
if n < 0:
raise ValueError("المضروب غير معرف للأعداد السالبة")
if n in (0, 1):
return 1
return n * factorial_recursive(n - 1) | [] |
716 | اكتب دالة `merge_sorted_lists(list1, list2)` تدمج قائمتين مرتبتين في قائمة واحدة مرتبة. | قوائم | دمج قائمتين | متوسط | كتابة دالة | إذا كانت القائمتان `list` وليست `LinkedList`، فالطريقة الأسرع في بايثون هي استخدام دالة الفرز `sorted(list1 + list2)` والتي تعتمد على `Timsort` وتكتشف الأجزاء المرتبة مسبقاً وتدمجها بتعقيد يقارب O(N) في هذه الحالة السعيدة. لغرض عرض المهارة سأكتب الخوارزمية يدوياً بمؤشرين. | def merge_sorted_lists(list1, list2):
result = []
i, j = 0, 0
while i < len(list1) and j < len(list2):
if list1[i] < list2[j]:
result.append(list1[i])
i += 1
else:
result.append(list2[j])
j += 1
# إضافة المتبقي
result.extend(list1[i:])
... | [] |
553 | اكتب دالة `gcd(a, b)` لحساب القاسم المشترك الأكبر لعددين. | رياضيات | GCD | متوسط | كتابة دالة | لإيجاد القاسم المشترك الأكبر (GCD) لعددين، يُعتبر تنفيذ خوارزمية إقليدس هو الأمثل من حيث الكفاءة والبساطة. الفكرة تعتمد على استبدال العدد الأكبر بباقي قسمته على العدد الأصغر بشكل متكرر. في بايثون، يمكننا كتابة ذلك بسطرين تقريباً باستخدام حلقة `while`، حيث نعين في كل تكرار `a, b = b, a % b`. تتوقف الحلقة عندما يصبح `b` ... | def gcd(a, b):
while b:
a, b = b, a % b
return a | [
{
"input": "{\"a\":48,\"b\":18}",
"expected": "6"
},
{
"input": "{\"a\":101,\"b\":10}",
"expected": "1"
}
] |
932 | في الكود التالي، هناك خطأ يؤدي إلى حساب عدد التكرارات الخاطئة في النافذة المنزلقة:
```python
def max_frequency_in_window(s, k):
from collections import defaultdict
count = defaultdict(int)
left = 0
max_freq = 0
for right in range(len(s)):
count[s[right]] += 1
while (right - left + 1)... | نافذة منزلقة | أكبر مجموع | صعب | إيجاد الخطأ | الخطأ הخفي يكمن в `max(count.values())` بعد إزالة العنصر `del count[s[left]]`. אם أصبحت `count` فارغة، فاستدعاء `max()` הثاني يرمي `ValueError: max() arg is an empty sequence`. | الخطأ הبرمجي القاتل هو استدعاء `max(count.values())` כאשר يصبح القاموس `count` فارغاً (بعد استخدام `del`). هذا سيؤدي לـ `ValueError`.
التحسين: يمكن الاستغناء عن جلب `max()` בכל دورة وتتبع `max_freq` بشكل تراكمي، או إضافة `default=0` للحد الأقصى. | [] |
542 | اكتب دالة `find_all_occurrences(text, pattern)` تعيد جميع المواقع التي يظهر فيها النمط `pattern` داخل النص. | سلاسل نصية | البحث داخل النص | متوسط | كتابة دالة | للبحث عن كافة مواقع ظهور نمط معين داخل سلسلة نصية، يمكننا المرور عبر السلسلة باستخدام حلقة تكرارية تفحص كل مقطع بطول النمط المنشود. نبدأ من الفهرس 0 وحتى الطول الكلي للسلسلة ناقص طول النمط لتجنب أخطاء الخروج عن حدود النص. في كل خطوة، نستخدم التقطيع النصي لاستخراج جزء من السلسلة. إذا طابق هذا الجزء النمط المطلوب، نقوم ب... | def find_all_occurrences(text, pattern):
if not pattern:
return []
res = []
k = len(pattern)
for i in range(len(text) - k + 1):
if text[i:i+k] == pattern:
res.append(i)
return res | [
{
"input": "{\"text\":\"aaaa\",\"pattern\":\"aa\"}",
"expected": "[0,1,2]"
},
{
"input": "{\"text\":\"hello world\",\"pattern\":\"world\"}",
"expected": "[6]"
}
] |
3 | اكتب دالة `max_unique_chars(s, k)` تعيد الحد الأقصى لعدد الأحرف غير المكررة ضمن نافذة بطول k. | نافذة منزلقة | تكرار الأحرف | سهل | كتابة دالة | نستخدم تقنية النافذة المنزلقة (Sliding Window). نستعين بقاموس `dict` لحساب تكرارات الحروف المتواجدة בنافذة طولها `k`. نزيح النافذة تدريجياً، عدد المفاتيح בالقاموس יمثل عدد الأحرف الفريدة בالنافذة الحالية. | def max_unique_chars(s, k):
if k > len(s):
return 0
freq = {}
unique_count = 0
max_unique = 0
for i in range(k):
freq[s[i]] = freq.get(s[i], 0) + 1
if freq[s[i]] == 1:
unique_count += 1
max_unique = unique_count
for i in range(k, len(s)):
incoming ... | [
{
"input": "\"\\\"aababc\\\", 3\"",
"expected": "3"
},
{
"input": "\"\\\"abcdef\\\", 6\"",
"expected": "6"
},
{
"input": "\"\\\"aabbcc\\\", 3\"",
"expected": "1"
},
{
"input": "\"\\\"aaaa\\\", 2\"",
"expected": "0"
}
] |
785 | لديك مصفوفة من الأعداد، عددها n. اجعل الأعداد الزوجية تأتي أولاً ثم الأعداد الفردية، مع الحفاظ على ترتيب كل نوع. | ترتيب | فرز مستقر (Stable Sort) | متوسط | كتابة دالة | المطلوب الحفاظ على الترتيب الأصلي (Stable Sort) وتقسيمها لزوجي وفردي. ميزة دالة بايثون `.sort` أو `sorted` أنها مستقرة (Stable). عند فرزها باستخدام باقي القسمة `x % 2` (حيث الزوجي 0 والفردي 1)، فإن الأعداد ستحافظ على ترتيبها الأولي داخلياً. | def stable_even_odd_sort(arr):
# الفرز في بايثون مستقر، الفرز بـ modulo سيحافظ على الترتيب الداخلي
return sorted(arr, key=lambda x: x % 2) | [] |
823 | اكتب دالة تأخذ عددًا صحيحًا وترجع قيمته مرفوعة لأس معين. لا تستخدم الدالة المدمجة pow(). | رياضيات | حساب القوى | متوسط | كتابة دالة | العملية يمكن إجراؤها خطياً عن طريق الضرب المتكرر للأس، أو بأداء O(log N) عبر تقنية Exponentiation by Squaring. سنتناول التحسين الأدائي لأنه الأفضل. | def custom_pow(base, exp):
if exp == 0:
return 1
if exp < 0:
base = 1 / base
exp = -exp
result = 1
while exp > 0:
if exp % 2 == 1:
result *= base
base *= base
exp //= 2
return result | [] |
677 | اكتب دالة `prime_factors(n)` تعيد قائمة بجميع العوامل الأولية للعدد n. | رياضيات | عوامل أولية | متوسط | كتابة دالة | الخوارزمية المثالية تستخرج العوامل 2 مراراً وتكراراً، ثم تنتقل لاختبار العوامل الفردية من 3 وصولاً إلى الجذر التربيعي. وأخيراً، الرقم المتبقي إذا كان أكبر من 1 يضاف كعامل. | def prime_factors(n):
factors = []
# إزالة الزوجية
while n % 2 == 0:
factors.append(2)
n //= 2
# إزالة العوامل الفردية حتى الجذر
d = 3
while d * d <= n:
while n % d == 0:
factors.append(d)
n //= d
d += 2
# الباقي كعامل أولي أخير
if ... | [] |
1260 | في الكود التالي، المطلوب هو البحث عن قيمة معينة في مصفوفة مرتبة بشكل جزئي. ولكن يوجد خطأ في الكود.
```python
def search_in_sorted_array(arr, target):
left, right = 0, len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == target:
return mid
elif arr[mid] ... | بحث | بحث ثنائي | سهل | إيجاد الخطأ | الخطأ الجوهري في تنفيذ خوارزمية البحث الثنائي هنا يكمن في تحديد النطاقات. أولاً، تم تعيين `right` ليكون `len(arr)`، وبما أن حلقة الدوران تعمل بشرط `left <= right`، فإن الفهرس `right` قد يتم اختباره كـ `mid` مما يؤدي إلى تجاوز حدود المصفوفة `IndexError` لأن الفهرس الأخير الصالح هو `len(arr) - 1`. ثانياً، عند تحديث النطا... | الـخـطـأ فـي الـسـطـر הـأـخـيـر מـن הـחـلـقـة: `right = mid`.
بـמـا أن הـشـرط ہـو `left <= right`، فـعـנـدمـا يـكـون `left == right` سـتـظـل قـيـمـة `mid` كـמـا هـي وسـيـبـقـى الـبـرנـامـج פـي חـلـقـة لا נـهـائـيـة (Infinite Loop).
الـتـصـويـب يـجـب أن يـتـخـطـى הـمـنـتـצـف: `right = mid - 1`. | [] |
1067 | الكود التالي يُفترض أن يُرجع آخر موقع لعنصر في قائمة، لكنه يحتوي على خطأ. عيّن الخطأ وصوّبه.
```python
def last_index(arr, target):
index = -1
for i in range(len(arr)):
if arr[i] == target:
index = i
return index
``` | بحث | بحث خطي | سهل | إيجاد الخطأ | الـכـود هـذا صـحـيـح ويـعـمـל. لـكـن הـبـحـث مـن الـبـدايـة يـعـנـي הـمـرور עـلـى كـل הـעـנـاصـר. الـمـنـطـק يـقـول ابـحـث مـن הـנـهـايـة. | الـكـود יـعـمـل بـشـכـل صـحـيـح ويـسـتـخـرج آخـر מـوقـع بـالـפـעـل. ولـكـن الـخـطـأ هـו פـي (الـكـפـاءة).
يـקـوم الـכـود بـالـبـحـث مـن הـبـدايـة מـمـا يـجـبـره عـلـى الـمـرور بـكـل الـعـנـاصـر. الـتـצـويـب הـو الـبـحـث (מـن الـנـهـايـة إـلـى الـبـدايـة) لـلـتـوقـف פـور إيـجـاد הـهـدف بـأقـل جـهـد:
`for i in range(len(... | [] |
534 | اكتب دالة `reverse_stack(stack)` تُعيد المكدس معكوسًا دون استخدام دوال مدمجة. | مكدسات | Reverse Stack | متوسط | كتابة دالة | لعكس مكدس (Stack) دون استخدام دوال مدمجة مثل `reverse()` أو إنشاء مصفوفات جديدة، نلجأ إلى الاستدعاء الذاتي (Recursion). الحل يتطلب دالتين: الدالة الرئيسية `reverse_stack` تقوم بسحب (pop) العنصر العلوي من المكدس ثم تستدعي نفسها لعكس باقي المكدس. بعد أن ينعكس الباقي، تستخدم دالة مساعدة أخرى `insert_at_bottom` لإدخال العن... | def insert_at_bottom(stack, item):
if not stack:
stack.append(item)
else:
temp = stack.pop()
insert_at_bottom(stack, item)
stack.append(temp)
def reverse_stack(stack):
if stack:
temp = stack.pop()
reverse_stack(stack)
insert_at_bottom(stack, temp)
... | [
{
"input": "{\"stack\":[1,2,3]}",
"expected": "[3,2,1]"
},
{
"input": "{\"stack\":[]}",
"expected": "[]"
}
] |
512 | اكتب دالة `is_balanced` تستقبل سلسلة نصية تحتوي على أقواس وتعيد True إذا كانت الأقواس متوازنة. | مكدسات | الأقواس المتوازنة | متوسط | كتابة دالة | للتحقق من توازن الأقواس في سلسلة نصية (بمعنى أن كل قوس فتح يغلق بقوس إغلاق من نفس النوع وبالترتيب الصحيح)، بنية البيانات المثلى هي المكدس (Stack). نستخدم قائمة فارغة كمكدس، ونقوم بإنشاء قاموس للربط بين أقواس الإغلاق وأقواس الفتح المقابلة لها (مثلاً `')': '('`). نمر على كل حرف في السلسلة النصية؛ إذا كان الحرف قوس فتح (م... | def is_balanced(s):
stack = []
mapping = {')': '(', '}': '{', ']': '['}
for char in s:
if char in mapping.values():
stack.append(char)
elif char in mapping.keys():
if not stack or stack.pop() != mapping[char]:
return False
return len(stack) == 0 | [
{
"input": "{\"s\":\"()[]{}\"}",
"expected": "true"
},
{
"input": "{\"s\":\"([)]\"}",
"expected": "false"
},
{
"input": "{\"s\":\"{[]}\"}",
"expected": "true"
}
] |
491 | اكتب دالة `longest_consecutive(nums)` تُرجع أطول سلسلة أرقام متتالية في قائمة. | قوائم | أطول سلسلة متجاورة | متوسط | كتابة دالة | للبحث عن أطول تتابع لأرقام متتالية (مثل 1, 2, 3...) في مصفوفة غير مرتبة، الحل الأمثل يتطلب تحويل المصفوفة إلى مجموعة (Set) لضمان عمليات بحث سريعة في زمن O(1). بعد ذلك، نمر عبر كل رقم في المجموعة. لمعرفة ما إذا كان الرقم يمكن أن يكون بداية لسلسلة، نتحقق مما إذا كان الرقم الذي يسبقه مباشرة (`num - 1`) موجوداً في المجموعة... | def longest_consecutive(nums):
num_set = set(nums)
longest_streak = 0
for num in num_set:
if num - 1 not in num_set:
current_num = num
current_streak = 1
while current_num + 1 in num_set:
current_num += 1
current_streak += 1
... | [
{
"input": "{\"nums\":[100,4,200,1,3,2]}",
"expected": "4"
},
{
"input": "{\"nums\":[0,3,7,2,5,8,4,6,0,1]}",
"expected": "9"
},
{
"input": "{\"nums\":[]}",
"expected": "0"
}
] |
570 | فيما يلي كود لحساب القواسم المشتركة بين عددين. اكتشف الخطأ في الكود:
```python
def common_divisors(a, b):
divisors_a = {i for i in range(1, a + 1) if a % i == 0}
divisors_b = {i for i in range(1, b + 1) if b % i == 0}
return list(divisors_a & divisors_b)
``` | رياضيات | القواسم | متوسط | إيجاد الخطأ | الكود المعطى يقوم بحساب النتيجة بشكل صحيح للأعداد الموجبة، ولكنه يعاني من مشكلة كبيرة في الكفاءة (Time Limit Exceeded) للأعداد الكبيرة لأنه يمر على جميع الأرقام من 1 إلى a و b. كما أنه يفشل إذا كان أحد العددين سالباً أو صفراً. النهج الأمثل والأصح رياضياً هو حساب القاسم المشترك الأكبر (GCD) أولاً، ثم إيجاد قواسم هذا الـ... | # الخطأ هو عدم الكفاءة القصوى (O(N)) وعدم معالجة الأرقام الصفرية أو السالبة.
# الكود المحسن (O(sqrt(GCD))):
import math
def common_divisors(a, b):
if a == 0 or b == 0: return []
g = math.gcd(a, b)
divisors = set()
for i in range(1, int(math.sqrt(g)) + 1):
if g % i == 0:
divisors.add(... | [] |
639 | في هذا السؤال، تم إعطاؤك كوداً بطيئاً لحل مشكلة knapsack. قم بتحسين الكود باستخدام البرمجة الديناميكية.
```python
def knapsack(weights, values, capacity):
def helper(i, cap):
if i == 0 or cap == 0:
return 0
if weights[i-1] > cap:
return helper(i-1, cap)
else:
... | برمجة ديناميكية | Knapsack | متوسط | تحسين الكود | الكود يستخدم الاستدعاء الذاتي بدون حفظ (Memoization)، مما ينتج تعقيداً أسياً O(2^N). التحسين الأسهل هو استيراد وتطبيق ديكوراتور `@lru_cache` لجعله يحفظ النتائج تلقائياً بتعقيد O(N*W). | from functools import lru_cache
def knapsack(weights, values, capacity):
# استخدام lru_cache لحفظ النتائج (Memoization) مما يخفض التعقيد إلى O(N*W)
@lru_cache(maxsize=None)
def helper(i, cap):
if i == 0 or cap == 0:
return 0
if weights[i-1] > cap:
return helper(i-1, ... | [] |
1142 | اكتب دالة `find_missing(nums)` تجد العنصر المفقود من تسلسل أعداد صحيحة من 0 إلى n. | رياضيات | العدد المفقود | سهل | كتابة دالة | المطلوب إيجاد العدد الغائب من التسلسل [0, 1, 2, ..., n] حيث القائمة المُعطاة تحتوي على n عنصراً من هذا التسلسل.
الملاحظة الجوهرية: مجموع الأعداد من 0 إلى n معطى بالصيغة المغلقة n*(n+1)/2. بما أن القائمة تحتوي على n عنصراً (أي طولها n)، فإن n = len(nums)، وبالتالي المجموع الكامل المتوقع هو n*(n+1)//2. الفرق بين هذا الم... | def find_missing(nums):
n = len(nums)
expected = n * (n + 1) // 2
return expected - sum(nums) | [] |
393 | اكتب دالة تأخذ سلسلة نصية وتعيد الحرف الأكثر تكرارًا (تجاهل المسافات). | سلاسل نصية | أكثر حرف تكراراً | سهل | كتابة دالة | المطلوب إيجاد الحرف الأكثر تكراراً في سلسلة نصية مع تجاهل المسافات. الفكرة هي عدّ تكرار كل حرف غير المسافة ثم إيجاد الحرف ذي العدّاد الأعلى.
نبني قاموساً لحصر التكرارات. نمر على كل حرف في السلسلة ونتجاهل المسافات. لكل حرف غير مسافة نزيد عدّاده. بعد بناء القاموس نبحث عن الحرف ذي القيمة الأعلى.
نتتبع مثالاً: السلسلة "أ... | def most_frequent_char(s):
freq = {}
for ch in s:
if ch != ' ':
freq[ch] = freq.get(ch, 0) + 1
if not freq:
return ""
best_char = None
best_count = 0
for ch in s:
if ch != ' ' and freq.get(ch, 0) > best_count:
best_count = freq[ch]
best... | [
{
"input": "\"\\u0645\\u0631\\u062d\\u0628\\u0627 \\u0628\\u0643\"",
"expected": "\"\\u0628\""
},
{
"input": "\"\\u0623\\u0623\\u0623 \\u0628\\u0628\\u0628 \\u062c\"",
"expected": "\"\\u0623\""
},
{
"input": "\" \"",
"expected": "\"\""
},
{
"input": "\"\\u062a\\u0633\\u062a... |
1520 | اكتب دالة تأخذ قائمتين وتعيد قائمة تحتوي على العناصر المشتركة بين القائمتين مع الحفاظ على التكرارات كما في القائمة الأولى. | قوائم | تقاطع قائمتين | سهل | كتابة دالة | المطلوب إيجاد العناصر الموجودة في كلتا القائمتين مع إزالة التكرار من النتيجة، وإعادتها بالترتيب الذي تظهر فيه في القائمة الأولى.
الفكرة الأساسية هي تحويل القائمة الثانية إلى مجموعة للبحث الفوري بزمن O(1)، ثم المرور على عناصر القائمة الأولى وإضافة كل عنصر موجود في المجموعة الثانية إلى النتيجة، مع تتبع العناصر المضافة ب... | def intersection(list1, list2):
set2 = set(list2)
seen = set()
result = []
for x in list1:
if x in set2 and x not in seen:
result.append(x)
seen.add(x)
return result | [] |
696 | اكتب دالة `max_subarray_sum(arr, k)` تعيد أكبر مجموع لعناصر نافذة متحركة بحجم k. | نافذة منزلقة | أكبر مجموع | متوسط | كتابة دالة | باستخدام تقنية 'النافذة المنزلقة'. نحسب مبدئياً مجموع أول `k` عناصر. ثم نمرّ عبر المصفوفة ونُزيح النافذة: نضيف العنصر الجديد ونطرح العنصر القديم الذي خرج من نطاق النافذة. هذه التقنية تضمن كفاءة زمنية قدرها O(N). | def max_subarray_sum(arr, k):
if not arr or k <= 0 or k > len(arr):
return 0
current_sum = sum(arr[:k])
max_sum = current_sum
for i in range(k, len(arr)):
current_sum += arr[i] - arr[i - k]
max_sum = max(max_sum, current_sum)
return max_sum | [] |
1360 | الكود التالي يهدف إلى تقسيم قائمة إلى جزأين متساويين، لكنه يحتوي على خطأ. عيّن الخطأ وصحيحه.
```python
def split_list(lst):
mid = len(lst) // 2
return lst[:mid], lst[mid+1:]
``` | قوائم | تقاطع قائمتين | متوسط | إيجاد الخطأ | تبدأ عملية الحل بتحديد طبيعة المتطلب، وهو العثور على عنصر معين، أو فرز عناصر بناءً على معيار مبسط، أو استخراج بيانات من القائمة. بما أن المشكلة لا تتطلب تعقيدات خوارزمية مركبة، فإن الفكرة الأساسية تكمن في استخدام حلقة تكرارية خطية للمرور على العناصر ومقارنتها بالشرط المطلوب. لماذا يعتبر هذا المرور البسيط كافياً؟ لأن ال... | # استخدام المجموعات يُلغي التكرارات والترتيب. إذا كان المطلوب الحفاظ على عدد مرات تكرار المشترك (كما هو شائع)، يجب استخدام قاموس لحساب التكرار.
# الكود البديل للحفاظ على التكرارات:
from collections import Counter
def intersection(list1, list2):
counts = Counter(list1)
res = []
for num in list2:
if c... | [] |
704 | اكتب دالة `first_recurring_element(lst)` تُرجع أول عنصر يتكرر في القائمة. إذا لم يكن هناك تكرار، أعد None. | مجموعات | تكرار أولي | سهل | كتابة دالة | للحصول على 'أول' عنصر يتكرر (من منظور الترتيب المكاني)، يجب بناء مجموعة (Set) وإضافة العناصر إليها الواحد تلو الآخر. بمجرد إيجاد العنصر الحالي متواجداً مسبقاً في المجموعة، يتم إرجاعه فوراً وتُنهى الدالة. | def first_recurring_element(lst):
seen = set()
for item in lst:
if item in seen:
return item
seen.add(item)
return None | [] |
1283 | اكتب دالة `coin_change(coins, amount)` تعيد أقل عدد من العملات لتكوين المبلغ `amount`. افترض أن كل عملة يمكن استخدامها أكثر من مرة. | برمجة ديناميكية | Coin Change | سهل | كتابة دالة | مسألة صرف العملات تسأل عن أقل عدد من العملات لتكوين مبلغ معين. الحل بالبرمجة الديناميكية يبني الجواب من المبالغ الصغيرة إلى الكبيرة: نعرّف dp[i] على أنه أقل عدد من العملات لتكوين المبلغ i. القاعدة dp[0]=0 لأن المبلغ صفر لا يحتاج عملات. لكل مبلغ i من 1 حتى amount نجرب كل عملة: إذا كانت قيمة العملة أصغر أو تساوي i وكانت ... | def coin_change(coins, amount):
dp = [float('inf')] * (amount + 1)
dp[0] = 0
for i in range(1, amount + 1):
for coin in coins:
if coin <= i:
dp[i] = min(dp[i], dp[i - coin] + 1)
return dp[amount] if dp[amount] != float('inf') else -1 | [] |
133 | اكتب دالة تُرجع تقاطع عنصرين من مجموعتين. الكود التالي غير فعال:
```python
def intersection(set1, set2):
result = []
for item in set1:
if item in set2:
result.append(item)
return result
```
| مجموعات | تقاطع | سهل | تحسين الكفاءة | المشكلة تطلب إيجاد العناصر المشتركة بين مجموعتين. الكود الأصلي يتحقق من كل عنصر في set1 هل هو موجود في set2، وهو نهج O(n) لكنه يبني قائمة يدوياً.
الفكرة الأساسية هي استخدام عملية التقاطع المدمجة في Python عبر المعامل & أو الدالة intersection، إذ تُنفَّذ داخلياً باستخدام جداول hash وتُرجع مجموعة تحتوي العناصر المشتركة ... | def intersection(set1, set2):
return sorted(set1 & set2) | [
{
"input": "\"[{1, 2, 3}, {2, 3, 4}]\"",
"expected": "[2, 3]"
},
{
"input": "\"[{1, 2}, {3, 4}]\"",
"expected": "[]"
},
{
"input": "\"[set(), {1, 2}]\"",
"expected": "[]"
}
] |
846 | اكتب دالة تحدد ما إذا كان الرسم البياني يحتوي على دورة باستخدام خوارزمية DFS. | رسوم بيانية | اكتشاف الدورات | صعب | كتابة دالة | نحتاج לتتبع 'الأب' لمنع الرجوع التلقائي واعتباره دورة בالرسم הبياني الغير موجه. | def has_cycle_dfs(graph):
visited = set()
def dfs(node, parent):
visited.add(node)
for neighbor in graph.get(node, []):
if neighbor not in visited:
if dfs(neighbor, node):
return True
elif neighbor != parent:
return... | [] |
783 | لديك قائمة من_tuples تمثل اسم الطالب ودرجته. رتب القائمة أولاً حسب الدرجة تصاعدياً، ثم حسب الاسم أبجدياً إن تساوت الدرجات. | ترتيب | معايير متعددة | سهل | كتابة دالة | نستخدم دالة الفرز `sorted()` مع معامل `key` يُرجع `tuple` يحتوي على الدرجة أولاً `x[1]`، ثم الاسم ثانياً `x[0]`. سيهتم المحرك الداخلي לבايثون بترتيبهما بالشكل الصحيح. | def sort_students(students):
# ترتيب حسب x[1] (الدرجة) ثم x[0] (الاسم)
return sorted(students, key=lambda x: (x[1], x[0])) | [] |
208 | اكتب دالة `find_longest_word(sentence)` تعيد أطول كلمة في الجملة. | سلاسل نصية | أطول كلمة | متوسط | كتابة دالة | المشكلة تطلب إيجاد أطول كلمة في جملة نصية. الكلمات مفصولة بمسافات.
الفكرة الأساسية: نُقسّم الجملة بـ split ثم نستخدم max مع key=len للحصول على الكلمة الأطول مباشرة. هذا يعمل في O(n).
حالة خاصة: جملة فارغة تُرجع سلسلة فارغة. split على سلسلة فارغة يُرجع قائمة فارغة، فنتحقق منها ونُرجع '' مباشرة.
تطبيق على مثال: 'Hello... | def find_longest_word(sentence):
words = sentence.split()
if not words:
return ''
return max(words, key=len) | [
{
"input": "\"البرمجة ممتعة وشيق\"",
"expected": "\"البرمجة\""
},
{
"input": "\"Hello world python\"",
"expected": "\"python\""
},
{
"input": "\"\"",
"expected": "\"\""
}
] |
449 | يُطلب منك العثور على القيم المشتركة بين قائمتين من القواميس. ولكن يوجد خطأ في الكود التالي:
```python
def common_values(dict1, dict2):
return [v for v in dict1.values() if v in dict2.values()]
``` | قواميس | القيم المشتركة | سهل | فهم الكود | الكود المعطى يقوم باستخراج القيم المشتركة بين قاموسين بشكل صحيح من الناحية المنطقية، ولكنه يعاني من مشكلة كفاءة خفية. باستخدام `if v in dict2.values()` داخل حلقة الاستيعاب، يتم استدعاء وتحويل قيم القاموس الثاني إلى قائمة في كل دورة من دورات قيم القاموس الأول، مما يؤدي إلى تعقيد زمني غير فعال يصل إلى O(N * M). علاوة على... | def common_values(dict1, dict2):
return list(set(dict1.values()) & set(dict2.values())) | [
{
"input": "{\"dict1\":{\"a\":1,\"c\":3},\"dict2\":{\"b\":1,\"d\":4}}",
"expected": "[1]"
},
{
"input": "{\"dict1\":{\"x\":10},\"dict2\":{\"y\":20}}",
"expected": "[]"
},
{
"input": "{\"dict1\":{\"p\":5,\"m\":5},\"dict2\":{\"q\":5}}",
"expected": "[5]"
}
] |
784 | لديك لوحة NxN، ضع N ملكات بحيث لا تهاجم إحداهن الأخرى. اكتب دالة تعيد عدد الطرق الممكنة لوضع الملكات. | استدعاء ذاتي | N-Queens | صعب | كتابة دالة | بشكل مشابه للحل السابق لـ N-Queens، التراجع مع تتبع الأعمدة والأقطار في مجموعات (Sets) يمنع الهجمات المتبادلة ويوفر كفاءة O(N!). | def count_n_queens_solutions(n):
cols, diag1, diag2 = set(), set(), set()
def backtrack(row):
if row == n:
return 1
count = 0
for col in range(n):
if col in cols or (row - col) in diag1 or (row + col) in diag2:
continue
cols.add(co... | [] |
67 | اكتب دالة `first_occurrence` تستلم سلسلة نصية وحرف، وتعيد أول موقع يظهر فيه الحرف في السلسلة. إذا لم يوجد، أعد -1. | بحث | أول ظهور | سهل | كتابة دالة | المطلوب كتابة دالة تقوم بحساب أو معالجة البيانات وفق الوصف المطلوب. نحدد أولا المعطيات والنتيجة المرجوة، ثم نختار الخوارزمية المناسبة لحل المسألة مع مراعاة الحالات الحدية مثل القيم الفارغة أو الأعداد السالبة أو الفهارس خارج النطاق. | def first_occurrence(s, ch):
for i, c in enumerate(s):
if c == ch: return i
return -1 | [
{
"input": "[\"hello\",\"l\"]",
"expected": "2"
},
{
"input": "[\"world\",\"z\"]",
"expected": "-1"
},
{
"input": "[\"test\",\"t\"]",
"expected": "0"
},
{
"input": "[\"\",\"a\"]",
"expected": "-1"
}
] |
828 | اكتب دالة ترتب قائمة من القواميس حسب أكثر من معيار. على سبيل المثال، ارتب حسب العمر أولًا، ثم حسب الاسم ثانيًا. | ترتيب | معايير متعددة | متوسط | كتابة دالة | يتم تطبيق الترتيب متعدد المعايير بتمرير `Tuple` لبرامتر `key`. ترتيب الـ Tuple يمثل أولوية الفرز. | def multi_criteria_sort(dict_list):
# ترتيب القواميس حسب 'age' ثم 'name'
return sorted(dict_list, key=lambda x: (x.get('age', 0), x.get('name', ''))) | [] |
808 | اكتب دالة تعيد عناصر التقاطع بين قائمتين مرتبطتين (LinkedLists) كقائمة جديدة. | قوائم | قوائم مرتبطة | متوسط | كتابة دالة | التعليمات لم تقدم تمثيل القائمة المرتبطة، سنفترض عقدة `ListNode`. لإيجاد التقاطع المنطقي للقوائم المرتبطة، يمكننا المرور على الأولى وإضافة قيمها في مجموعة (Set)، ثم المرور على الثانية وبناء قائمة مرتبطة جديدة بالقيم الموجودة في المجموعة. | class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
def intersect_linked_lists(head1, head2):
values = set()
curr = head1
while curr:
values.add(curr.val)
curr = curr.next
dummy = ListNode()
tail = dummy
curr = head2... | [] |
1521 | اكتب دالة تأخذ عددين n و m وتعيد عدد الأعداد التي هي مضاعفات لكليهما ضمن النطاق من 1 إلى L. | رياضيات | مضاعفات | سهل | كتابة دالة | الأعداد التي هي مضاعفات لـ `a` و `b` معاً يجب أن تكون مضاعفات للمضاعف المشترك الأصغر (LCM) لهما. عدد هذه المضاعفات من 1 إلى `n` يُحسب ببساطة بقسمة `n // LCM(a, b)`. | import math
def count_common_multiples(a, b, n):
if a == 0 or b == 0:
return 0
lcm = abs(a * b) // math.gcd(a, b)
return n // lcm | [] |
1338 | اكتب دالة تأخذ مصفوفة من الأعداد وتعيد جميع التباديل الممكنة لها. | استدعاء ذاتي | المجموعات الفرعية | متوسط | كتابة دالة | توليد التباديل يمكن باستخدام الاستدعاء الذاتي والتراجع (Backtracking)، أو بكل بساطة وسرعة باستخدام أداة بايثون القياسية `itertools.permutations` التي تُنفّذ العملية بكفاءة عالية (مبنية بلغة C). | def subsets(nums):
res = [[]]
for num in nums:
res += [curr + [num] for curr in res]
return res | [] |
670 | اكتب دالة تعيد عناصر التقاطع بين قائمتين. | قوائم | تقاطع | سهل | كتابة دالة | أسرع طريقة لإيجاد التقاطع (إذا لم يكن التكرار مهماً) هي تحويل القوائم إلى مجموعات (Sets) وإيجاد العناصر المشتركة بعلامة `&`. إذا كان التكرار مهماً يفضل استخدام قائمة التكرارات (Counter). | def intersection(list1, list2):
# استخدام المجموعات يوفر سرعة استعلام O(1) ونتيجة نهائية O(N+M)
return list(set(list1) & set(list2)) | [] |
1123 | اكتب دالة `coin_change_min` تأخذ مصفوفة من قيم العملات ومبلغ مالي، وتعيد أقل عدد من العملات اللازمة لتكوين هذا المبلغ. | برمجة ديناميكية | Coin Change | متوسط | كتابة دالة | تبدأ عملية الحل بتحديد طبيعة المتطلب، وهو العثور على عنصر معين، أو فرز عناصر بناءً على معيار مبسط، أو استخراج بيانات من القائمة. بما أن المشكلة لا تتطلب تعقيدات خوارزمية مركبة، فإن الفكرة الأساسية تكمن في استخدام حلقة تكرارية خطية للمرور على العناصر ومقارنتها بالشرط المطلوب. لماذا يعتبر هذا المرور البسيط كافياً؟ لأن ال... | def coin_change_min(coins, amount):
dp = [float('inf')] * (amount + 1)
dp[0] = 0
for coin in coins:
for i in range(coin, amount + 1):
dp[i] = min(dp[i], dp[i - coin] + 1)
return dp[amount] if dp[amount] != float('inf') else -1 | [] |
471 | اكتب دالة `min_operations_to_equal(arr)` تأخذ مصفوفة من الأعداد الصحيحة وتعيد الحد الأدنى لعدد العمليات اللازمة لجعل جميع العناصر متساوية، حيث يمكن إضافة أو طرح 1 من أي عنصر في كل عملية. | جشع | Minimum Operations | متوسط | كتابة دالة | الهدف من هذه المسألة هو جعل جميع عناصر المصفوفة متساوية بأقل عدد ممكن من عمليات الزيادة أو النقصان بمقدار 1. هذه المسألة الكلاسيكية تُحل بفعالية عالية باستخدام المبدأ الرياضي القائل بأن "الوسيط" (Median) يقلل دائماً من مجموع الفروق المطلقة. بدلاً من حساب المتوسط الحسابي، نقوم بفرز المصفوفة لاستخراج العنصر الوسيط الذي ي... | def min_operations_to_equal(arr):
if not arr:
return 0
arr.sort()
median = arr[len(arr) // 2]
return sum(abs(x - median) for x in arr) | [
{
"input": "[1,2,3]",
"expected": "2"
},
{
"input": "[4,4,4]",
"expected": "0"
},
{
"input": "[1,10]",
"expected": "9"
},
{
"input": "[5]",
"expected": "0"
}
] |
897 | اكتب دالة `find_pair_with_sum(lst, target)` تعيد أول زوج من العناصر يساوي مجموعها الهدف. | مجموعات | Pair Sum | سهل | كتابة دالة | نستخدم مجموعة (`set`) لتعقب الأرقام التي رأيناها للتو. لكل رقم، نقوم بحساب المتمم (الهدف - الرقم الحالي). إذا كان المتمم موجوداً مسبقاً في المجموعة، نعيد الرقمين فوراً كأول زوج مكتشف. | def find_pair_with_sum(lst, target):
seen = set()
for num in lst:
complement = target - num
if complement in seen:
return (complement, num)
seen.add(num)
return None | [] |
241 | الوظيفة التالية تحسب اتحاد مجموعتين، لكنها تحتوي على خطأ. عيّن الخطأ وصوّبه.
```python
def set_union(set1, set2):
result = set1
for item in set2:
if item not in result:
result.add(item)
return result
```
الوظيفة الحالية تُحسب الاتحاد، لكنها قد تؤثر على المجموعة الأصلية. | مجموعات | اتحاد | متوسط | إيجاد الخطأ | المطلوب حساب اتحاد مجموعتين دون التأثير على المجموعة الأصلية. الخطأ في الدالة واضح: السطر result = set1 لا ينسخ المجموعة بل يجعل result مرجعاً للمجموعة الأصلية ذاتها. بالتالي عند إضافة عناصر set2 إلى result فإن set1 الأصلية تتعدل أيضاً وهذا التأثير الجانبي غير مقبول. الحل هو نسخ set1 قبل التعديل عبر result = set(set1) ... | def set_union(set1, set2):
result = set(set1)
for item in set2:
if item not in result:
result.add(item)
return result | [
{
"input": "\"[{1, 2}, {2, 3}]\"",
"expected": "\"{1, 2, 3}\""
},
{
"input": "\"[{1, 2}, {3, 4}]\"",
"expected": "\"{1, 2, 3, 4}\""
},
{
"input": "\"[set(), {1, 2}]\"",
"expected": "\"{1, 2}\""
},
{
"input": "\"[{1, 2}, set()]\"",
"expected": "\"{1, 2}\""
}
] |
322 | فيما يلي كود لتنظيف سلسلة نصية من الأحرف غير المطلوبة، لكنه يحتوي على خطأ. عيّن الخطأ وصحيحه.
```python
def clean_text(text, chars_to_remove):
for char in chars_to_remove:
text.replace(char, '')
return text
```
| سلاسل نصية | تنظيف النص | صعب | إيجاد الخطأ | المطلوب حذف مجموعة من الأحرف المحددة من سلسلة نصية. الفكرة هي المرور على كل حرف من chars_to_remove واستبداله بالسلسلة الفارغة في النص.
الخطأ في الكود يتعلق بطبيعة السلاسل النصية في Python: السلاسل النصية غير قابلة للتعديل في مكانها. الدالة str.replace لا تُعدّل السلسلة الأصلية بل تُعيد سلسلة جديدة بعد إجراء الاستبدال.... | def clean_text(text, chars_to_remove):
for char in chars_to_remove:
text = text.replace(char, '')
return text | [
{
"input": "\"('hello world!', 'lo')\"",
"expected": "\"he wrd!\""
},
{
"input": "\"('abc123def', '123')\"",
"expected": "\"abcdef\""
}
] |
431 | نريد حساب العامل (factorial) لعدد معين. إليك الكود الخاطئ:
```python
def factorial(n):
if n == 0 or n == 1:
return 1
return n * factorial(n - 1)
```
ما هو الخطأ في هذا الكود؟ | استدعاء ذاتي | Factorial | سهل | فهم الكود | الكود المعطى لحساب العامل (المضروب) لعدد `n` باستخدام الاستدعاء الذاتي (Recursion) سليم من الناحية المنطقية والبرمجية. الدالة تتضمن شرط الإيقاف (Base Case) بشكل واضح، وهو عندما تصل القيمة إلى 0 أو 1، حيث تُرجع 1 فوراً لإيقاف سلسلة الاستدعاءات ومنع الدوران اللانهائي. وفي حال كانت القيمة أكبر من 1، تضرب الدالة الرقم `n` ... | def factorial(n):
if n == 0 or n == 1:
return 1
return n * factorial(n - 1) | [
{
"input": "5",
"expected": "120"
},
{
"input": "0",
"expected": "1"
}
] |
215 | اكتب دالة `max_non_overlapping_intervals(intervals)` تُرجع الحد الأقصى لعدد الفترات غير المتداخلة التي يمكن اختيارها. | جشع | Interval Scheduling | متوسط | كتابة دالة | المطلوب اختيار أكبر عدد ممكن من الفترات الزمنية بحيث لا تتداخل أي فترتين مختارتين.
الفكرة الجشعة الكلاسيكية لهذه المسألة هي الترتيب حسب نهاية الفترة تصاعدياً، ثم اختيار الفترة ذات النهاية الأبكر دائماً، لأن ذلك يترك أكبر مساحة زمنية للفترات اللاحقة. هذا النهج يضمن الحل الأمثل بما أن اختيار الفترة التي تنتهي أبكر لا يُ... | def max_non_overlapping_intervals(intervals):
if not intervals:
return 0
intervals.sort(key=lambda x: x[1])
count = 1
end = intervals[0][1]
for i in range(1, len(intervals)):
if intervals[i][0] >= end:
count += 1
end = intervals[i][1]
return count | [
{
"input": "[[1, 3], [2, 4], [3, 5]]",
"expected": "2"
},
{
"input": "[[1, 2], [2, 3], [3, 4]]",
"expected": "3"
},
{
"input": "[[1, 4], [2, 3], [4, 6]]",
"expected": "2"
},
{
"input": "[]",
"expected": "0"
}
] |
273 | الدالة التالية تُستخدم لتدوير قائمة بمقدار k خطوات إلى اليمين. ولكن يوجد خطأ في الكود. عيّن الخطأ وصوّبه.
```python
def rotate_list(lst, k):
if not lst:
return lst
k = k % len(lst)
return lst[-k:] + lst[:-k]
```
| قوائم | تدوير قائمة | متوسط | إيجاد الخطأ | المطلوب تدوير القائمة k خطوات إلى اليمين، بمعنى أن العناصر الأخيرة k تنتقل إلى بداية القائمة. الفكرة الجوهرية هي أن تدوير k خطوة إلى اليمين يعادل أخذ آخر k عناصر lst[-k:] ووضعها في المقدمة، ثم إضافة الباقي lst[:-k] خلفها. قبل ذلك نُطبّع k باستخدام k % len(lst) لأن التدوير بمقدار len(lst) يُعيد القائمة إلى أصلها، إذن k ... | def rotate_list(lst, k):
if not lst:
return lst
k = k % len(lst)
return lst[-k:] + lst[:-k] | [
{
"input": "{\"lst\":[1,2,3,4,5],\"k\":2}",
"expected": "[4,5,1,2,3]"
},
{
"input": "{\"lst\":[1,2,3],\"k\":4}",
"expected": "[3,1,2]"
}
] |
71 | اكتب دالة extract_patterns(s) تستخرج جميع الأزواج المكونة من حرفين متتاليين متطابقين من السلسلة النصية s. | سلاسل نصية | استخراج الأنماط | سهل | كتابة دالة | المطلوب التحقق من تطابق نمط مع سلسلة نصية حيث * تطابق أي عدد من الحروف و ? تطابق حرفا واحدا. نستخدم البرمجة الديناميكية: نعرف dp[i][j] بأنه هل يطابق أول i أحرف من النص أول j أحرف من النمط. نبدأ بـ dp[0][0] = True. إذا كان النمط يحوي *، يمكن أن يطابق صفرا أو أكثر من الأحرف. نملأ الجدول تصاعديا ثم نعيد dp[m][n]. | def extract_patterns(s):
res = []
for i in range(len(s) - 1):
if s[i] == s[i+1]:
res.append(s[i] + s[i+1])
return res | [
{
"input": "\"aabbcc\"",
"expected": "[\"aa\",\"bb\",\"cc\"]"
},
{
"input": "\"abccba\"",
"expected": "[\"cc\"]"
},
{
"input": "\"abcdef\"",
"expected": "[]"
},
{
"input": "\"aaa\"",
"expected": "[\"aa\",\"aa\"]"
},
{
"input": "\"\"",
"expected": "[]"
}
] |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 16