# برمجة Python: حل المسائل عبر الإنترنت

Home PDF English 中文 日本語 Español हिंदी Français Deutsch العربية 繁體中文

---

هنا نستخدم نظام التقييم عبر الإنترنت لحل المسائل. إذا كنت تجيد اللغة الإنجليزية، يمكنك استخدام Codeforces و LeetCode. أما إذا كنت تفضل اللغة الصينية، فيمكنك استخدام “计蒜客” و “力扣”. هنا نستخدم LeetCode. لقد قمت بحل 10 مسائل. وفي المسألة الأخيرة، استخدمت عدة طرق لتحسين كفاءة البرنامج من التغلب على 10% من الإجابات إلى التغلب على 99%.

1480. مجموع تشغيل مصفوفة أحادية البعد

لدينا مصفوفة nums. نعرف المجموع التراكمي للمصفوفة على أنه runningSum[i] = sum(nums[0]…nums[i]).

قم بإرجاع المجموع التراكمي لـ nums.

class Solution:
    def runningSum(self, nums: [int]) -> [int]:         
      running = []
      s = 0
      for num in nums:
        s += num
        running.append(s)
      
      return running

تمت ترجمة الكود أعلاه إلى اللغة العربية مع الحفاظ على نفس البنية والوظيفة. الكود يقوم بحساب المجموع التراكمي لقائمة من الأرقام وإرجاع قائمة جديدة تحتوي على هذه المجاميع.

#print(Solution().runningSum([1,2,3,4]))

تم تعليق الكود أعلاه باستخدام #، مما يعني أنه لن يتم تنفيذه عند تشغيل البرنامج. إذا أردت إزالة التعليق لجعل الكود قابلًا للتنفيذ، يمكنك إزالة # ليصبح الكود كالتالي:

print(Solution().runningSum([1,2,3,4]))

هذا الكود يستدعي دالة runningSum من الكلاس Solution ويمرر لها قائمة [1,2,3,4] كوسيطة. الدالة runningSum من المفترض أن تقوم بحساب المجموع التراكمي للعناصر في القائمة.

تم اجتياز السؤال الأول بنجاح.

1108. إزالة النقاط من عنوان IP

الوصف

بالنظر إلى عنوان IP صالح (IPv4)، قم بإرجاع نسخة معدلة من عنوان IP حيث يتم استبدال كل نقطة "." بـ "[.]".

مثال 1:

الإدخال: address = "1.1.1.1"
الإخراج: "1[.]1[.]1[.]1"

مثال 2:

الإدخال: address = "255.100.50.0"
الإخراج: "255[.]100[.]50[.]0"

القيود:

• address هو عنوان IPv4 صالح.

الحل

لحل هذه المشكلة، يمكننا ببساطة استبدال كل نقطة في عنوان IP بـ "[.]". يمكن تحقيق ذلك باستخدام دالة الاستبدال المتوفرة في معظم لغات البرمجة.

كود Python

def defangIPaddr(address: str) -> str:
    return address.replace('.', '[.]')

شرح الكود

1. نستخدم الدالة replace لاستبدال كل نقطة "." بـ "[.]".
2. نعيد النتيجة المعدلة.

تعقيد الوقت

• الوقت: (O(n))، حيث (n) هو طول عنوان IP. نحتاج إلى المرور على كل حرف في العنوان مرة واحدة.
• المساحة: (O(n))، حيث ننشئ سلسلة جديدة تحتوي على العنوان المعدل.

خاتمة

هذه المشكلة بسيطة وتوضح كيفية استخدام الدوال الأساسية في اللغة لتحقيق النتيجة المطلوبة. يمكن تطبيق نفس الفكرة في لغات برمجة أخرى باستخدام الدوال المماثلة.

بالنظر إلى عنوان IP صالح (IPv4) address، قم بإرجاع نسخة مُعدَّلة من هذا العنوان.

العنوان المُعدَّل يستبدل كل نقطة "." بـ "[.]".

مثال:

def defangIPaddr(address: str) -> str:
    return address.replace('.', '[.]')

استخدام الدالة:

address = "192.168.1.1"
print(defangIPaddr(address))  # الإخراج: "192[.]168[.]1[.]1"

في هذا المثال، يتم استبدال كل نقطة في العنوان 192.168.1.1 بـ [.]، مما يعطي النتيجة 192[.]168[.]1[.]1.

class Solution:
    def defangIPaddr(self, address: str) -> str:
        return address.replace('.', '[.]')

ترجمة الكود إلى العربية:

class Solution:
    def defangIPaddr(self, address: str) -> str:
        return address.replace('.', '[.]')

شرح الكود:

• class Solution: يتم تعريف فئة باسم Solution.
• def defangIPaddr(self, address: str) -> str: يتم تعريف دالة داخل الفئة باسم defangIPaddr تأخذ مُدخلًا من نوع str (سلسلة نصية) وتُرجع مُخرجًا من نوع str.
• return address.replace('.', '[.]'): يتم استبدال كل نقطة . في العنوان بـ [.] باستخدام الدالة replace.

مثال:

إذا كان العنوان المدخل هو "192.168.1.1"، فإن المخرجات ستكون "192[.]168[.]1[.]1".

print(Solution().defangIPaddr(‘1.1.1.1’))

## 1431. الأطفال الذين لديهم أكبر عدد من الحلوى

هناك `n` أطفال لديهم بعض الحلوى. يتم إعطاؤك مصفوفة عدد صحيح `candies` حيث يمثل كل عنصر `candies[i]` عدد الحلوى التي يمتلكها الطفل `i`. يتم أيضًا إعطاؤك عدد صحيح `extraCandies`، حيث يمثل عدد الحلوى الإضافية التي لديك.

قم بإرجاع قائمة منطقية `result` بطول `n`، حيث تكون `result[i]` `true` إذا كان بإمكان الطفل `i` الحصول على أكبر عدد من الحلوى بين جميع الأطفال بعد تلقي جميع الحلوى الإضافية `extraCandies`، أو `false` بخلاف ذلك.

لاحظ أنه يمكن أن يكون هناك أكثر من طفل لديه أكبر عدد من الحلوى.

**مثال 1:**

Input: candies = [2,3,5,1,3], extraCandies = 3 Output: [true,true,true,false,true] Explanation:

• الطفل 1 لديه 2 حلوى وإذا حصل على جميع الحلوى الإضافية 3، سيكون لديه 5 حلوى - وهو أكبر عدد من الحلوى بين جميع الأطفال.
• الطفل 2 لديه 3 حلوى وإذا حصل على جميع الحلوى الإضافية 3، سيكون لديه 6 حلوى - وهو أكبر عدد من الحلوى بين جميع الأطفال.
• الطفل 3 لديه 5 حلوى وإذا حصل على جميع الحلوى الإضافية 3، سيكون لديه 8 حلوى - وهو أكبر عدد من الحلوى بين جميع الأطفال.
• الطفل 4 لديه 1 حلوى وإذا حصل على جميع الحلوى الإضافية 3، سيكون لديه 4 حلوى - وهو ليس أكبر عدد من الحلوى بين جميع الأطفال.
• الطفل 5 لديه 3 حلوى وإذا حصل على جميع الحلوى الإضافية 3، سيكون لديه 6 حلوى - وهو أكبر عدد من الحلوى بين جميع الأطفال. ```

مثال 2:

Input: candies = [4,2,1,1,2], extraCandies = 1
Output: [true,false,false,false,false]
Explanation: هناك طفل واحد فقط لديه أكبر عدد من الحلوى.

مثال 3:

Input: candies = [12,1,12], extraCandies = 10
Output: [true,false,true]

القيود:

• n == candies.length
• 2 <= n <= 100
• 1 <= candies[i] <= 100
• 1 <= extraCandies <= 50

الحل

def kidsWithCandies(candies, extraCandies):
    max_candies = max(candies)
    result = []
    for candy in candies:
        if candy + extraCandies >= max_candies:
            result.append(True)
        else:
            result.append(False)
    return result

شرح الحل:

1. إيجاد الحد الأقصى للحلوى: أولاً، نجد الحد الأقصى لعدد الحلوى التي يمتلكها أي طفل في المصفوفة candies.
2. تقييم كل طفل: لكل طفل، نتحقق مما إذا كان عدد الحلوى لديه مضافًا إليه الحلوى الإضافية extraCandies سيكون أكبر من أو يساوي الحد الأقصى للحلوى.
3. تحديد النتيجة: إذا كان الشرط صحيحًا، نضيف true إلى النتيجة، وإلا نضيف false.
4. إرجاع النتيجة: أخيرًا، نعيد القائمة result التي تحتوي على النتائج لكل طفل.

هذا الحل بسيط وفعال، حيث يعمل في وقت O(n) حيث n هو عدد الأطفال.

لدينا مصفوفة candies وعدد صحيح extraCandies، حيث يمثل candies[i] عدد الحلوى التي يمتلكها الطفل *ith*.

لكل طفل، تحقق مما إذا كان هناك طريقة لتوزيع extraCandies بين الأطفال بحيث يمكنه الحصول على أكبر عدد من الحلوى بينهم. لاحظ أنه يمكن أن يكون لدى عدة أطفال أكبر عدد من الحلوى.

class Solution:
    def kidsWithCandies(self, candies: [int], extraCandies: int) -> [bool]:
        max = 0
        for candy in candies:
          if candy > max:
            max = candy
        greatests = []
        for candy in candies:
          if candy + extraCandies >= max:
            greatests.append(True)
          else:
            greatests.append(False)
        return greatests

print(Solution().kidsWithCandies([2,3,5,1,3], 3))

## 1672. أغنى ثروة للعميل

> لديك مصفوفة أعداد صحيحة `accounts` بحجم `m x n` حيث يمثل `accounts[i][j]` مقدار المال الذي يمتلكه العميل `i` في البنك `j`. المطلوب هو إرجاع *ال**ثروة** التي يمتلكها العميل الأغنى.*
>
> **الثروة** الخاصة بالعميل هي مجموع الأموال التي يمتلكها في جميع حساباتهم البنكية. العميل الأغنى هو العميل الذي لديه أكبر **ثروة**.

```python
class Solution:
    def maximumWealth(self, accounts: [[int]]) -> int:
        max = 0      
        for account in accounts:
          s = sum(account) 
          if max < s:
            max = s
        return max

ترجمة الكود إلى العربية:

class Solution:
    def maximumWealth(self, accounts: [[int]]) -> int:
        max = 0      
        for account in accounts:
          s = sum(account) 
          if max < s:
            max = s
        return max

شرح الكود:

• الكلاس Solution يحتوي على دالة maximumWealth التي تأخذ معاملًا واحدًا هو accounts، وهو قائمة من القوائم التي تحتوي على أعداد صحيحة ([[int]]).
• المتغير max يتم تهيئته بقيمة 0، وسيتم استخدامه لتخزين أكبر قيمة للثروة.
• يتم التكرار خلال كل حساب في accounts، ويتم حساب مجموع القيم في كل حساب باستخدام الدالة sum.
• إذا كان المجموع s أكبر من القيمة الحالية لـ max، يتم تحديث max ليكون مساويًا لـ s.
• في النهاية، يتم إرجاع القيمة max، وهي أكبر قيمة للثروة تم العثور عليها.

#print(Solution().maximumWealth([[1,2,3],[3,2,1]]))          

1470. خلط المصفوفة

لدينا المصفوفة nums التي تتكون من 2n عنصر بالشكل [x1,x2,...,xn,y1,y2,...,yn].

قم بإعادة المصفوفة بالشكل [x1,y1,x2,y2,...,xn,yn].

class Solution:
  def shuffle(self, nums: [int], n: int) -> [int]:
    ns1 = nums[:n]
    ns2 = nums[n:]
    ns = []
    for i in range(n):
      ns.append(ns1[i])
      ns.append(ns2[i])
    return ns

ترجمة الكود إلى العربية:

class Solution:
  def shuffle(self, nums: [int], n: int) -> [int]:
    # تقسيم القائمة إلى قسمين
    ns1 = nums[:n]  # القسم الأول من القائمة
    ns2 = nums[n:]  # القسم الثاني من القائمة
    ns = []  # قائمة جديدة لتخزين النتيجة
    for i in range(n):
      # إضافة عنصر من القسم الأول ثم القسم الثاني بالتناوب
      ns.append(ns1[i])
      ns.append(ns2[i])
    return ns  # إرجاع القائمة المخلوطة

شرح الكود:

• الكود يقوم بخلط قائمة من الأعداد الصحيحة nums عن طريق تقسيمها إلى قسمين متساويين في الطول (حيث n هو نصف طول القائمة).
• ثم يتم إنشاء قائمة جديدة ns عن طريق إضافة عناصر من القسم الأول ثم القسم الثاني بالتناوب.
• في النهاية، يتم إرجاع القائمة المخلوطة.

print(Solution().shuffle([2,5,1,3,4,7], 3))

## 1512. عدد الأزواج الجيدة

**الوصف:**

بالنظر إلى مصفوفة من الأعداد الصحيحة `nums`، يُرجى إيجاد عدد الأزواج الجيدة `(i, j)` حيث `i < j` و `nums[i] == nums[j]`.

**مثال 1:**

الإدخال: nums = [1,2,3,1,1,3] الإخراج: 4 التفسير: هناك 4 أزواج جيدة: (0,3), (0,4), (3,4), (2,5).

**مثال 2:**

الإدخال: nums = [1,1,1,1] الإخراج: 6 التفسير: كل زوج من العناصر يشكل زوجًا جيدًا.

**مثال 3:**

الإدخال: nums = [1,2,3] الإخراج: 0 التفسير: لا توجد أزواج جيدة.

**القيود:**

- `1 <= nums.length <= 100`
- `1 <= nums[i] <= 100`

**الحل:**

لحل هذه المشكلة، يمكننا استخدام خريطة لتتبع عدد المرات التي يظهر فيها كل عنصر في المصفوفة. ثم، لكل عنصر، نحسب عدد الأزواج الجيدة التي يمكن تشكيلها باستخدام هذا العنصر.

```python
def numIdenticalPairs(nums):
    count = 0
    freq = {}
    for num in nums:
        if num in freq:
            count += freq[num]
            freq[num] += 1
        else:
            freq[num] = 1
    return count

شرح الحل:

1. نقوم بتهيئة متغير count ليحتفظ بعدد الأزواج الجيدة.
2. نستخدم خريطة freq لتتبع عدد المرات التي يظهر فيها كل عنصر في المصفوفة.
3. نمر عبر كل عنصر في المصفوفة:
   • إذا كان العنصر موجودًا بالفعل في الخريطة، فإننا نضيف عدد المرات التي ظهر فيها هذا العنصر إلى count، ثم نزيد عدد مرات ظهوره في الخريطة بمقدار 1.
   • إذا لم يكن العنصر موجودًا في الخريطة، فإننا نضيفه إلى الخريطة مع قيمة 1.
4. في النهاية، نعيد قيمة count التي تمثل عدد الأزواج الجيدة.

تعقيد الوقت:

تعقيد الوقت لهذا الحل هو O(n) حيث n هو طول المصفوفة nums. وذلك لأننا نمر عبر المصفوفة مرة واحدة فقط.

تعقيد المساحة:

تعقيد المساحة هو O(n) أيضًا، حيث قد نحتاج إلى تخزين جميع العناصر الفريدة في الخريطة في أسوأ الحالات.

هذا الحل فعال ويعمل بشكل جيد مع القيود المحددة.

لدينا مصفوفة من الأعداد الصحيحة nums.

يُطلق على الزوج (i,j) اسم جيد إذا كان nums[i] يساوي nums[j] وكان i أصغر من j.

المطلوب هو إرجاع عدد الأزواج الجيدة.

لحل هذه المسألة، يمكننا استخدام خوارزمية بسيطة تعتمد على عد تكرارات كل عنصر في المصفوفة. إليك الخطوات:

1. إنشاء قاموس (Dictionary): نستخدم قاموسًا لتخزين عدد المرات التي يظهر فيها كل عنصر في المصفوفة.
2. حساب الأزواج الجيدة: لكل عنصر في المصفوفة، إذا كان قد ظهر من قبل، فإن عدد الأزواج الجيدة التي يمكن تشكيلها مع هذا العنصر يساوي عدد المرات التي ظهر فيها هذا العنصر سابقًا.
3. تحديث القاموس: بعد حساب الأزواج الجيدة، نقوم بتحديث القاموس لزيادة عدد مرات ظهور العنصر الحالي.

إليك الكود الذي يقوم بتنفيذ هذه الخطوات:

def numIdenticalPairs(nums):
    count = {}
    good_pairs = 0
    
    for num in nums:
        if num in count:
            good_pairs += count[num]
            count[num] += 1
        else:
            count[num] = 1
    
    return good_pairs

شرح الكود:

• count هو القاموس الذي نستخدمه لتخزين عدد المرات التي يظهر فيها كل عنصر.
• good_pairs هو المتغير الذي نستخدمه لتخزين عدد الأزواج الجيدة.
• نمر على كل عنصر في المصفوفة nums:
  • إذا كان العنصر موجودًا بالفعل في القاموس، فإننا نضيف عدد مرات ظهوره السابقة إلى good_pairs، ثم نزيد عدد مرات ظهوره في القاموس بمقدار 1.
  • إذا لم يكن العنصر موجودًا في القاموس، فإننا نضيفه إلى القاموس مع تعيين عدد مرات ظهوره إلى 1.
• في النهاية، نعيد قيمة good_pairs التي تمثل عدد الأزواج الجيدة.

مثال:

إذا كانت المصفوفة nums = [1, 2, 3, 1, 1, 3]، فإن الأزواج الجيدة هي:

• (0, 3) لأن nums[0] == nums[3] == 1
• (0, 4) لأن nums[0] == nums[4] == 1
• (3, 4) لأن nums[3] == nums[4] == 1
• (2, 5) لأن nums[2] == nums[5] == 3

إذن، عدد الأزواج الجيدة هو 4.

التعقيد الزمني:

• التعقيد الزمني لهذا الحل هو O(n) حيث n هو عدد العناصر في المصفوفة، لأننا نمر على كل عنصر مرة واحدة فقط.
• التعقيد المكاني هو O(n) أيضًا، لأننا قد نحتاج إلى تخزين جميع العناصر في القاموس في أسوأ الحالات.

هذا الحل فعال ويعمل بشكل جيد حتى مع المصفوفات الكبيرة.

class Solution:
    def numIdenticalPairs(self, nums: [int]) -> int:
        j = 1
        n = len(nums)
        p = 0
        while j < n:
          for i in range(j):
            if nums[i] == nums[j]:
              p += 1
          j+=1
        return p

ترجمة الكود إلى العربية:

class Solution:
    def numIdenticalPairs(self, nums: [int]) -> int:
        j = 1
        n = len(nums)
        p = 0
        while j < n:
          for i in range(j):
            if nums[i] == nums[j]:
              p += 1
          j+=1
        return p

شرح الكود:

• j = 1: يتم تهيئة المتغير j بالقيمة 1، والذي سيستخدم كفهرس للعنصر الثاني في المقارنة.
• n = len(nums): يتم تخزين طول القائمة nums في المتغير n.
• p = 0: يتم تهيئة المتغير p بالقيمة 0، والذي سيستخدم لحساب عدد الأزواج المتطابقة.
• while j < n:: يتم تنفيذ الحلقة طالما أن j أقل من طول القائمة n.
  • for i in range(j): يتم تنفيذ حلقة داخلية للوصول إلى العناصر التي تسبق العنصر الحالي j.
    • if nums[i] == nums[j]: إذا كان العنصر الحالي nums[j] يساوي العنصر nums[i]، يتم زيادة العداد p بواحد.
  • j += 1: يتم زيادة الفهرس j بواحد للانتقال إلى العنصر التالي في القائمة.
• return p: يتم إرجاع العدد الإجمالي للأزواج المتطابقة p.

هذا الكود يحسب عدد الأزواج المتطابقة في قائمة الأعداد nums، حيث يعتبر الزوج متطابقًا إذا كان العنصران في الموضعين i و j متساويين و i < j.

print(Solution().numIdenticalPairs([1,2,3,1,1,3]))

## 771. الأحجار الكريمة والأحجار

**الوصف:**

أنت تحصل على سلسلة `jewels` تمثل أنواع الأحجار الكريمة التي لديك، وسلسلة `stones` تمثل الأحجار التي لديك. كل حرف في `stones` هو نوع من الحجر الذي لديك. تريد معرفة عدد الأحجار التي لديك والتي تعتبر أيضًا أحجارًا كريمة.

الحروف حساسة لحالة الأحرف، لذا فإن `"a"` تعتبر نوعًا مختلفًا من الحجر عن `"A"`.

**مثال 1:**

Input: jewels = “aA”, stones = “aAAbbbb” Output: 3

**مثال 2:**

Input: jewels = “z”, stones = “ZZ” Output: 0

**القيود:**

- `1 <= jewels.length, stones.length <= 50`
- `jewels` و `stones` تتكونان من أحرف إنجليزية فقط.
- جميع أحجار `jewels` فريدة من نوعها.

**الحل:**

```python
def numJewelsInStones(jewels, stones):
    jewel_set = set(jewels)
    count = 0
    for stone in stones:
        if stone in jewel_set:
            count += 1
    return count

شرح الحل:

1. نقوم بتحويل سلسلة jewels إلى مجموعة (set) لتسهيل عملية البحث.
2. نقوم بتهيئة عداد (count) لتتبع عدد الأحجار الكريمة الموجودة في stones.
3. نقوم بتمرير كل حجر في stones والتحقق مما إذا كان موجودًا في مجموعة jewels. إذا كان موجودًا، نزيد العداد بمقدار 1.
4. في النهاية، نعيد قيمة العداد الذي يمثل عدد الأحجار الكريمة الموجودة في stones.

تعقيد الوقت:

• الوقت: (O(n + m))، حيث (n) هو طول jewels و (m) هو طول stones.
• المساحة: (O(n))، حيث (n) هو طول jewels (لإنشاء المجموعة).

لديك سلسلتان من الأحرف: jewels تمثل أنواع الأحجار الكريمة، وstones تمثل الأحجار التي تمتلكها. كل حرف في stones يمثل نوعًا من الأحجار التي تمتلكها. تريد معرفة عدد الأحجار التي تمتلكها والتي تعتبر أيضًا أحجارًا كريمة.

الأحرف حساسة لحالة الأحرف (case sensitive)، لذا يعتبر الحرف "a" نوعًا مختلفًا من الحجر عن الحرف "A".

class Solution:
    def numJewelsInStones(self, jewels: str, stones: str) -> int:
        n = 0
        for i in range(len(jewels)):
          js = jewels[i:i+1]
          n += stones.count(js)
        return n

ترجمة الكود إلى العربية:

class Solution:
    def numJewelsInStones(self, jewels: str, stones: str) -> int:
        n = 0
        for i in range(len(jewels)):
          js = jewels[i:i+1]
          n += stones.count(js)
        return n

شرح الكود:

• الكلاس Solution يحتوي على دالة numJewelsInStones التي تأخذ مُدخلين: jewels (الجواهر) و stones (الحجارة).
• المتغير n يُستخدم لحساب عدد الجواهر الموجودة في الحجارة.
• يتم استخدام حلقة for للتكرار عبر كل حرف في jewels.
• في كل تكرار، يتم أخذ حرف واحد من jewels باستخدام jewels[i:i+1] وتخزينه في المتغير js.
• يتم استخدام الدالة stones.count(js) لحساب عدد مرات ظهور الحرف js في stones وإضافته إلى n.
• في النهاية، يتم إرجاع القيمة n التي تمثل عدد الجواهر الموجودة في الحجارة.

print(Solution().numJewelsInStones(“aA”, “aAAbbbb”))

## 1603. تصميم نظام مواقف السيارات

**الوصف:**

قم بتصميم نظام مواقف سيارات يحتوي على ثلاثة أنواع من أماكن الوقوف: كبيرة، ومتوسطة، وصغيرة. يحتوي كل نوع على عدد محدد من الأماكن المتاحة.

يجب أن يدعم النظام الوظائف التالية:

- `ParkingSystem(int big, int medium, int small)`: يقوم بتهيئة النظام بعدد الأماكن المتاحة لكل نوع من أنواع المواقف.
- `bool addCar(int carType)`: يحاول إضافة سيارة من النوع المحدد إلى الموقف. إذا كان هناك مكان متاح، يتم إضافة السيارة ويعود النظام بقيمة `true`. إذا لم يكن هناك مكان متاح، يعود النظام بقيمة `false`.

**أنواع السيارات:**

- `1`: سيارة كبيرة
- `2`: سيارة متوسطة
- `3`: سيارة صغيرة

**مثال:**

```python
parkingSystem = ParkingSystem(1, 1, 0)
parkingSystem.addCar(1) # يعود بـ true
parkingSystem.addCar(2) # يعود بـ true
parkingSystem.addCar(3) # يعود بـ false
parkingSystem.addCar(1) # يعود بـ false

التفسير:

• يتم تهيئة النظام بموقف واحد كبير، وموقف واحد متوسط، ولا يوجد مواقف صغيرة.
• يتم إضافة سيارة كبيرة بنجاح.
• يتم إضافة سيارة متوسطة بنجاح.
• لا يمكن إضافة سيارة صغيرة لأن لا يوجد مواقف صغيرة متاحة.
• لا يمكن إضافة سيارة كبيرة أخرى لأن الموقف الكبير الوحيد مشغول.

القيود:

• 0 <= big, medium, small <= 1000
• 1 <= carType <= 3
• يتم استدعاء الدالة addCar على الأكثر 1000 مرة.

الحل:

class ParkingSystem:

    def __init__(self, big: int, medium: int, small: int):
        self.spaces = [big, medium, small]

    def addCar(self, carType: int) -> bool:
        if self.spaces[carType - 1] > 0:
            self.spaces[carType - 1] -= 1
            return True
        return False

التفسير:

• يتم تخزين عدد الأماكن المتاحة لكل نوع من أنواع المواقف في قائمة spaces.
• عند محاولة إضافة سيارة، يتم التحقق من وجود مكان متاح للنوع المحدد.
• إذا كان هناك مكان متاح، يتم تقليل عدد الأماكن المتاحة ويعود النظام بقيمة true.
• إذا لم يكن هناك مكان متاح، يعود النظام بقيمة false.

صمم نظام مواقف لموقف سيارات. يحتوي الموقف على ثلاثة أنواع من أماكن الوقوف: كبيرة، متوسطة، وصغيرة، مع عدد ثابت من الأماكن لكل حجم.

قم بتنفيذ فئة ParkingSystem:

• ParkingSystem(int big, int medium, int small) يقوم بتهيئة كائن من فئة ParkingSystem. يتم تحديد عدد الأماكن لكل حجم من أحجام الوقوف كجزء من المُنشئ.
• bool addCar(int carType) يتحقق مما إذا كان هناك مكان وقوف متاح من نوع carType للسيارة التي تريد الدخول إلى الموقف. يمكن أن يكون carType من ثلاثة أنواع: كبيرة، متوسطة، أو صغيرة، والتي يتم تمثيلها بالأرقام 1، 2، و3 على التوالي. يمكن للسيارة أن تقف فقط في مكان وقوف من نفس نوعها carType. إذا لم يكن هناك مكان متاح، يتم إرجاع false، وإلا يتم وقوف السيارة في المكان المناسب ويتم إرجاع true.

class ParkingSystem:
    slots = [0, 0, 0]

def __init__(self, big: int, medium: int, small: int):
  self.slots[0] = big
  self.slots[1] = medium
  self.slots[2] = small

def addCar(self, carType: int) -> bool:
  if self.slots[carType - 1] > 0:
    self.slots[carType - 1] -=1
    return True
  else:
    return False

تمت ترجمة الكود أعلاه إلى العربية كما يلي:

def addCar(self, carType: int) -> bool:
  if self.slots[carType - 1] > 0:
    self.slots[carType - 1] -=1
    return True
  else:
    return False

ملاحظة: الكود مكتوب بلغة Python ولا يحتاج إلى ترجمة، حيث أن الأكواد البرمجية تبقى كما هي بغض النظر عن اللغة المستخدمة في التوثيق أو الشرح.

# parkingSystem = ParkingSystem(1, 1, 0)
# print(parkingSystem.addCar(1))
# print(parkingSystem.addCar(2))
# print(parkingSystem.addCar(3))
# print(parkingSystem.addCar(1))

1773. عد العناصر المطابقة للقاعدة

لديك مصفوفة items، حيث كل عنصر items[i] = [typei, colori, namei] يصف النوع، اللون، والاسم للعنصر i. كما لديك قاعدة ممثلة بسلسلتين نصيتين، ruleKey و ruleValue.

يُقال أن العنصر i يطابق القاعدة إذا كان واحد مما يلي صحيحًا:

• ruleKey == "type" و ruleValue == typei.
• ruleKey == "color" و ruleValue == colori.
• ruleKey == "name" و ruleValue == namei.

قم بإرجاع عدد العناصر التي تطابق القاعدة المعطاة.

class Solution:
    def countMatches(self, items: [[str]], ruleKey: str, ruleValue: str) -> int:
      i = 0
      if ruleKey == "type":
        i = 0
      elif ruleKey == "color":
        i = 1
      else:
        i = 2
      n = 0
      for item in items:
        if item[i] == ruleValue:
          n +=1
      return n

تمت ترجمة الكود أعلاه إلى العربية مع الحفاظ على الأسماء الإنجليزية كما هي.

print(Solution().countMatches([[“phone”,”blue”,”pixel”],[“computer”,”silver”,”lenovo”],[“phone”,”gold”,”iphone”]], “color”, “silver”))

## 1365. كم عدد الأرقام الأصغر من الرقم الحالي

> بالنظر إلى المصفوفة `nums`، لكل عنصر `nums[i]`، ابحث عن عدد الأرقام في المصفوفة التي تكون أصغر منه. أي، لكل `nums[i]` يجب عليك حساب عدد العناصر `j` التي تحقق الشرط `j != i` **و** `nums[j] < nums[i]`.
>
> قم بإرجاع النتيجة في مصفوفة.

> ```
> الإدخال: nums = [8,1,2,2,3]
> الإخراج: [4,0,1,1,3]
> الشرح:
> بالنسبة لـ nums[0]=8 يوجد أربعة أرقام أصغر منه (1, 2, 2 و 3).
> بالنسبة لـ nums[1]=1 لا يوجد أي رقم أصغر منه.
> بالنسبة لـ nums[2]=2 يوجد رقم واحد أصغر منه (1).
> بالنسبة لـ nums[3]=2 يوجد رقم واحد أصغر منه (1).
> بالنسبة لـ nums[4]=3 يوجد ثلاثة أرقام أصغر منه (1, 2 و 2).
> ```

```python
class Solution:
    def smallerNumbersThanCurrent(self, nums: [int]) -> [int]:
        ns = []
        l = len(nums)
        for i in range(l):
          n = 0
          for j in range(l):
            if i != j:
              if nums[j] < nums[i]:
                n += 1
          ns.append(n)
        return ns

ترجمة الكود إلى اللغة العربية:

class Solution:
    def smallerNumbersThanCurrent(self, nums: [int]) -> [int]:
        ns = []  # قائمة لتخزين النتائج
        l = len(nums)  # طول القائمة nums
        for i in range(l):  # تكرار عبر كل عنصر في القائمة
          n = 0  # عداد لعدد العناصر الأصغر من العنصر الحالي
          for j in range(l):  # تكرار عبر كل عنصر في القائمة مرة أخرى
            if i != j:  # تجنب مقارنة العنصر مع نفسه
              if nums[j] < nums[i]:  # إذا كان العنصر الحالي أكبر من العنصر الآخر
                n += 1  # زيادة العداد
          ns.append(n)  # إضافة العدد إلى القائمة النهائية
        return ns  # إرجاع القائمة النهائية

شرح الكود:

• الكود يقوم بحساب عدد العناصر الأصغر من كل عنصر في القائمة nums.
• لكل عنصر في القائمة، يتم مقارنته مع جميع العناصر الأخرى في القائمة.
• إذا كان العنصر الآخر أصغر من العنصر الحالي، يتم زيادة العداد n.
• في النهاية، يتم إضافة العدد n إلى القائمة ns التي تحتوي على النتائج.
• يتم إرجاع القائمة ns التي تحتوي على عدد العناصر الأصغر من كل عنصر في القائمة الأصلية.

print(Solution().smallerNumbersThanCurrent([8,1,2,2,3]))

تم تنفيذ الكود في 528 مللي ثانية، متفوقًا على 11.81% من البرامج. دعنا نحسن الأداء.

```python
class Solution:
    def smallerNumbersThanCurrent(self, nums: [int]) -> [int]:
        l = len(nums)

ترجمة الكود أعلاه إلى العربية:

class Solution:
    def smallerNumbersThanCurrent(self, nums: [int]) -> [int]:
        l = len(nums)

في الكود أعلاه، يتم تعريف دالة smallerNumbersThanCurrent داخل الكلاس Solution. هذه الدالة تأخذ قائمة من الأعداد الصحيحة (nums) وتُرجع قائمة أخرى من الأعداد الصحيحة. المتغير l يتم تعيينه لطول القائمة nums.

sort_nums = nums.copy()

ins = list(range(l))
for i in range(l):          
    for j in range(i+1, l):
        if sort_nums[i] > sort_nums[j]:
            a = sort_nums[i]
            sort_nums[i] = sort_nums[j]
            sort_nums[j] = a
              
            a = ins[i]
            ins[i] = ins[j]
            ins[j] = a
        
smalls = [0]
for i in range(1, l):
    if sort_nums[i-1] == sort_nums[i]:
        smalls.append(smalls[i-1])
    else:
        smalls.append(i)

ترجمة الكود إلى العربية:

# إنشاء قائمة تحتوي على الأرقام من 0 إلى l-1
ins = list(range(l))

# تنفيذ عملية الفرز (Bubble Sort) على القائمة sort_nums
for i in range(l):          
    for j in range(i+1, l):
        if sort_nums[i] > sort_nums[j]:
            # تبديل العناصر في القائمة sort_nums
            a = sort_nums[i]
            sort_nums[i] = sort_nums[j]
            sort_nums[j] = a
              
            # تبديل العناصر في القائمة ins بنفس الترتيب
            a = ins[i]
            ins[i] = ins[j]
            ins[j] = a
        
# إنشاء قائمة smalls لتخزين عدد العناصر الأصغر من كل عنصر
smalls = [0]
for i in range(1, l):
    if sort_nums[i-1] == sort_nums[i]:
        # إذا كان العنصر الحالي مساويًا للعنصر السابق، يتم استخدام نفس القيمة
        smalls.append(smalls[i-1])
    else:
        # إذا كان العنصر الحالي مختلفًا، يتم استخدام الفهرس الحالي
        smalls.append(i)

شرح الكود:

1. إنشاء قائمة ins: يتم إنشاء قائمة تحتوي على الأرقام من 0 إلى l-1، حيث l هو طول القائمة sort_nums.

2. عملية الفرز (Bubble Sort): يتم تنفيذ عملية فرز على القائمة sort_nums باستخدام خوارزمية Bubble Sort. أثناء عملية الفرز، يتم أيضًا تبديل العناصر في القائمة ins بنفس الترتيب للحفاظ على العلاقة بين العناصر في القائمتين.

3. إنشاء قائمة smalls: يتم إنشاء قائمة smalls لتخزين عدد العناصر الأصغر من كل عنصر في القائمة sort_nums بعد الفرز. إذا كان العنصر الحالي مساويًا للعنصر السابق، يتم استخدام نفس القيمة المخزنة في smalls للعنصر السابق. إذا كان العنصر الحالي مختلفًا، يتم استخدام الفهرس الحالي كقيمة جديدة في smalls.

    # print(sort_nums)
    # print(smalls)
   

r_is = list(range(l))
for i in ins:
    r_is[ins[i]] = i

ns = []
for i in range(l):          
    ns.append(smalls[r_is[i]])
return ns

تم تحويل الكود إلى لغة Python مع الحفاظ على الهيكل الأصلي. إذا كنت بحاجة إلى شرح أو ترجمة للكود، فالرجاء توضيح ذلك.

print(Solution().smallerNumbersThanCurrent([8,1,2,2,3]))

هذا الاختبار استغرق `284ms`، وهو أقل من الوقت السابق الذي استغرق `528ms`.

استخدم دوال النظام المختصرة للكتابة.

```python
class Solution:
    def smallerNumbersThanCurrent(self, nums: [int]) -> [int]:
        # نسخة من القائمة الأصلية لفرزها
        sort_nums = nums.copy()
        sort_nums.sort()
        
        # قائمة لتخزين النتائج
        ns = []
        for num in nums:
          # إيجاد عدد العناصر الأصغر من العنصر الحالي
          ns.append(sort_nums.index(num))
        return ns

print(Solution().smallerNumbersThanCurrent([8,1,2,2,3]))

هذا سيستغرق فقط `64ms`، متفوقًا على `71%` من الإرسالات.

```python
class Solution:
    def smallerNumbersThanCurrent(self, nums: [int]) -> [int]:
        l = len(nums)
        ns = [0] * l
        for i in range(l):
          for j in range(i+1, l):
            if nums[i] > nums[j]:
              ns[i] +=1
            elif nums[i] < nums[j]:
              ns[j] +=1
            else:
              pass
        return ns

print(Solution().smallerNumbersThanCurrent([8,1,2,2,3]))

لقد توصلت إلى حل آخر. استغرق الأمر `400ms`.

```python
class Solution:
    def smallerNumbersThanCurrent(self, nums: [int]) -> [int]:        
        ss = sorted((e,i) for i,e in enumerate(nums))

l = len(nums)
smalls = [0]
for i in range(1, l):
    (e0, j0) = ss[i-1]
    (e1, j1) = ss[i]
    if e0 == e1:
        smalls.append(smalls[i-1])
    else:
        smalls.append(i)

ns = [0]*l
for i in range(l):
    (e, j) = ss[i]
    ns[j] = smalls[i]
return ns

تمت ترجمة الكود إلى:

ns = [0]*l
for i in range(l):
    (e, j) = ss[i]
    ns[j] = smalls[i]
return ns

ملاحظة: الكود يبقى كما هو لأنه مكتوب بلغة برمجة (Python) ولا يتم ترجمته.

print(Solution().smallerNumbersThanCurrent([8,1,2,2,3]))

> وقت التشغيل: 52 مللي ثانية، أسرع من 91.45% من الإرسالات عبر الإنترنت لـ Python3 لمسألة "كم عدد الأرقام الأصغر من الرقم الحالي".
>
> استخدام الذاكرة: 14.6 ميجابايت، أقل من 15.18% من الإرسالات عبر الإنترنت لـ Python3 لمسألة "كم عدد الأرقام الأصغر من الرقم الحالي".

أخيرًا نجحت! هذه الطريقة أسرع مرة أخرى، وهزمت `91.45%` من الإرسالات.

استمر في التبسيط.

```python
class Solution:
    def smallerNumbersThanCurrent(self, nums: [int]) -> [int]:
        ss = sorted((e,i) for i,e in enumerate(nums))

l = len(nums)
smalls = [0]
ns = [0]*l
for i in range(1, l):
    (e0, j0) = ss[i-1]
    (e1, j1) = ss[i]
    if e0 == e1:
        smalls.append(smalls[i-1])
    else:
        smalls.append(i)

تمت ترجمة الكود إلى:

l = len(nums)
smalls = [0]
ns = [0]*l
for i in range(1, l):
    (e0, j0) = ss[i-1]
    (e1, j1) = ss[i]
    if e0 == e1:
        smalls.append(smalls[i-1])
    else:
        smalls.append(i)

ملاحظة: الكود بقي كما هو لأنه يحتوي على أسماء متغيرات ودوال بالإنجليزية، ولم يتم تغييرها.

ns[j1] = smalls[i]
return ns

print(Solution().smallerNumbersThanCurrent([8,1,2,2,3]))

استمر.

```python
class Solution:
    def smallerNumbersThanCurrent(self, nums: [int]) -> [int]:
        ss = sorted((e,i) for i,e in enumerate(nums))

l = len(nums)
last = 0
ns = [0]*l
for i in range(1, l):
    (e0, j0) = ss[i-1]
    (e1, j1) = ss[i]
    if e0 == e1:
        pass
    else:
        last = i

ns[j1] = last
return ns

print(Solution().smallerNumbersThanCurrent([8,1,2,2,3]))

في هذه المرحلة، وصلنا إلى `40ms`، متفوقين على `99.81%` من البرامج.

> وقت التشغيل: 40 مللي ثانية، أسرع من 99.81% من الإرسالات على Python3 عبر الإنترنت لمسألة "كم عدد الأرقام الأصغر من الرقم الحالي".
>
> استخدام الذاكرة: 14.4 ميجابايت، أقل من 15.18% من الإرسالات على Python3 عبر الإنترنت لمسألة "كم عدد الأرقام الأصغر من الرقم الحالي".

إليك حلًا آخر.

```python
class Solution:
    def smallerNumbersThanCurrent(self, nums: [int]) -> [int]:
      l = len(nums)
      n = [0] * 101
      max_num = 0
      for num in nums:
        n[num] += 1
        if num > max_num:
          max_num = num

هذا الكود يعرض جزءًا من دالة في لغة Python تُسمى smallerNumbersThanCurrent والتي تأخذ قائمة من الأعداد الصحيحة nums وتُرجع قائمة جديدة تحتوي على عدد الأعداد الأصغر من كل عنصر في القائمة الأصلية.

في هذا الجزء من الكود:

• يتم تحديد طول القائمة nums وحفظه في المتغير l.
• يتم إنشاء قائمة n تحتوي على 101 عنصرًا، كلها قيمتها الأولية صفر.
• يتم استخدام حلقة for للتكرار عبر كل عنصر في القائمة nums:
  • يتم زيادة القيمة في القائمة n عند الفهرس المطابق للعدد الحالي num.
  • يتم تحديث المتغير max_num إذا كان العدد الحالي num أكبر من القيمة الحالية لـ max_num.

هذا الجزء من الكود يُعد جزءًا من خوارزمية لحساب عدد الأعداد الأصغر من كل عنصر في القائمة.

sm = [0] * (max_num + 1)
sum = 0
for i in range(max_num + 1):
    sm[i] = sum
    sum += n[i]

ns = [0] * l
for i in range(l):
    ns[i] = sm[nums[i]]

  إرجاع ns

print(Solution().smallerNumbersThanCurrent([8,1,2,2,3]))

لنأخذ مثالًا أكثر تعقيدًا.

```python
class Solution:
    def smallerNumbersThanCurrent(self, nums: [int]) -> [int]:
      l = len(nums)
      n = [0] * 101
      max_num = 0
      for num in nums:
        n[num] += 1
        if num > max_num:
          max_num = num

في الكود أعلاه، يتم تعريف دالة smallerNumbersThanCurrent داخل فئة Solution. هذه الدالة تأخذ قائمة من الأعداد الصحيحة nums وتعيد قائمة أخرى تحتوي على عدد الأعداد الأصغر من كل عنصر في القائمة الأصلية.

شرح الكود:

1. تهيئة المتغيرات:
   • l يتم تعيينه لطول القائمة nums.
   • n يتم تهيئته كقائمة تحتوي على 101 عنصرًا، كلها تساوي 0. هذا سيتم استخدامه لحساب عدد المرات التي يظهر فيها كل رقم في القائمة.
   • max_num يتم تهيئته إلى 0، وسيتم استخدامه لتتبع أكبر رقم في القائمة.
2. حساب التكرارات:
   • يتم تكرار القائمة nums، وفي كل تكرار:
     • يتم زيادة قيمة n[num] بمقدار 1، حيث num هو العنصر الحالي في القائمة.
     • إذا كان num أكبر من max_num، يتم تحديث max_num ليكون num.

سيتم استكمال الكود لاحقًا لحساب عدد الأعداد الأصغر من كل عنصر في القائمة الأصلية.

short_n = []
short_num = [] * l
zn = [0] * 101
j = 0
for i in range(max_num+1):
    if n[i] > 0:
        zn[i] = j          
        short_n.append(n[i])          
        short_num.append(num)
        j+=1

sm = [0] * j
sum = 0
for i in range(j):
    sm[i] = sum
    sum += short_n[i]

ns = [0] * l
for i in range(l):
    ns[i] = sm[zn[nums[i]]]
return ns

print(Solution().smallerNumbersThanCurrent([8,1,2,2,3]))

```python
class Solution:    

    def smallerNumbersThanCurrent(self, nums: [int]) -> [int]:
      max_num = max(nums)

ترجمة الكود أعلاه إلى العربية:

class Solution:    

    def smallerNumbersThanCurrent(self, nums: [int]) -> [int]:
      max_num = max(nums)  # العثور على القيمة القصوى في القائمة

في هذا الكود، يتم تعريف دالة smallerNumbersThanCurrent داخل الكلاس Solution. هذه الدالة تأخذ قائمة من الأعداد الصحيحة nums كمدخل وتقوم بإرجاع قائمة جديدة تحتوي على عدد الأعداد الأصغر من كل عنصر في القائمة الأصلية. في السطر الأول داخل الدالة، يتم العثور على القيمة القصوى في القائمة nums باستخدام الدالة max().

n = [0] * (max_num + 1)
for num in nums:
    n[num] += 1

تمثل الكود أعلاه عملية إنشاء قائمة n بحجم max_num + 1، حيث يتم تهيئة جميع العناصر بالقيمة 0. ثم يتم التكرار عبر قائمة nums، وفي كل تكرار، يتم زيادة قيمة العنصر المقابل في القائمة n بمقدار 1. هذا الكود يستخدم عادةً لحساب تكرار الأرقام في قائمة nums.

sorted_ls = []
for i in range(max_num + 1):
    if n[i] > 0:
        sorted_ls.append(i)

تمت ترجمة الكود إلى:

sorted_ls = []
for i in range(max_num + 1):
    if n[i] > 0:
        sorted_ls.append(i)

ملاحظة: الكود يبقى كما هو لأنه مكتوب بلغة برمجة (Python) ولا يتم ترجمته.

      sm = [0] * (max_num + 1)
      sum = 0
      for i in range(len(sorted_ls)):
        v = sorted_ls[i]
        sm[v] = sum
        sum += n[v]
      
      ns = [] 
      for i in range(len(nums)):
        ns.append(sm[nums[i]])
      return ns
# print(Solution().smallerNumbersThanCurrent([72,48,32,16,10,59,83,38,1,4,68,7,67,16,5,35,99,15,55,11,24,3,63,81,16,95,35,87,24,84,57,49,42,80,34,33,82,81,31,31,7,75,100,75,22,44,54,77,89,71,81,66,7]))

التمرين

• يقوم الطلاب بحل بعض الأسئلة المشابهة لتلك المذكورة أعلاه.

---

Back 2025.01.18 Donate