def count_up_to(n):
    """قم بتنفيذ دالة تأخذ عددًا صحيحًا غير سالب وتعيد مصفوفة تحتوي على أول n أعداد صحيحة
    التي هي أعداد أولية وأقل من n.
    على سبيل المثال:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """تنفيذ دالة تأخذ عددًا صحيحًا غير سالب وتعيد مصفوفة من الأعداد الصحيحة الأولى التي هي أعداد أولية وأقل من n.
    على سبيل المثال:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
     """قم بتنفيذ دالة تأخذ عددًا صحيحًا غير سالب وتعيد مصفوفة من أول n
    الأعداد الأولية الأقل من n.
    :على سبيل المثال
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """


def multiply(a, b):
    """أكمل الدالة التي تأخذ عددين صحيحين وتُرجع حاصل ضرب رقمي الأحاد في كل منهم.
    افترض أن المدخلات صحيحة دائماً.
    أمثلة:
    multiply(148, 412) يجب أن ترجع 16.
    multiply(19, 28) يجب أن ترجع 72.
    multiply(2020, 1851) يجب أن ترجع 0.
    multiply(14,-15) يجب أن ترجع 20.
    """

def multiply(a, b):
    """أكمل الدالة التي تأخذ عددين صحيحين وتعيد
    ناتج ضرب الأرقام الأحادية لهما.
    افترض أن المدخلات دائماً صحيحة.
    أمثلة:
    multiply(148, 412) يجب أن تعيد 16.
    multiply(19, 28) يجب أن تعيد 72.
    multiply(2020, 1851) يجب أن تعيد 0.
    multiply(14,-15) يجب أن تعيد 20.
    """

def multiply(a, b):
    """
    أكمل الدالة التي تأخذ عددين صحيحين وتعيد حاصل ضرب أرقامهما الآحادية.
    افترض أن المدخلات صحيحة دائمًا.
    أمثلة:
    multiply(148, 412) يجب أن تعيد 16.
    multiply(19, 28) يجب أن تعيد 72.
    multiply(2020, 1851) يجب أن تعيد 0.
    multiply(14,-15) يجب أن تعيد 20.
    """


def count_upper(s):
    """
    بالنظر إلى سلسلة نصية s، قم بحساب عدد الحروف المتحركة الكبيرة الموجودة في الفهارس الزوجية.

    على سبيل المثال:
    count_upper('aBCdEf') تُرجع 1
    count_upper('abcdefg') تُرجع 0
    count_upper('dBBE') تُرجع 0
    """

def count_upper(s):
    """
    بمعلومية السلسلة s، احسب عدد أحرف العلة الكبيرة في المؤشرات الزوجية.

    على سبيل المثال
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """

def count_upper(s):
    """
    بالنظر إلى سلسلة نصية s، قم بعدّ عدد الحروف المتحركة الكبيرة في الفهارس الزوجية.

    على سبيل المثال:
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """


:def closest_integer(value)
    '''
    قم بإنشاء دالة تأخذ قيمة (سلسلة نصية) تمثل رقمًا
    وتعيد أقرب عدد صحيح لها. إذا كان الرقم متساوي البعد
    عن عددين صحيحين، قم بتقريبه للعدد الأبعد عن الصفر.

    أمثلة
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    ملاحظة:
    التقريب بعيدًا عن الصفر يعني أنه إذا كان الرقم المعطى متساوي البعد
    عن عددين صحيحين، فإن العدد الذي يجب أن تعيده هو الذي يكون
    الأبعد عن الصفر. على سبيل المثال closest_integer("14.5") يجب أن
    تعيد 15 و closest_integer("-14.5") يجب أن تعيد -15.
    '''

def closest_integer(value):
    '''
    قم بإنشاء دالة تأخذ قيمة (سلسلة) تمثل رقمًا
    وتُرجع أقرب عدد صحيح لها. إذا كان الرقم على مسافة متساوية
    من عددين صحيحين، قرّبه بعيداً عن الصفر.

    أمثلة

    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    ملاحظة:
    التقريب من الصفر يعني أنّه إذا كان الرقم المُعطى متساوي المسافة
    من عددين صحيحين، فالعدد الذي يجب أن تعيده هو العدد الذي يكون
    الأبعد عن الصفر. على سبيل المثال closest_integer("14.5") يجب أن يُعيد
    15 و closest_integer("-14.5")  يجب أن يُعيد -15.
    '''

def closest_integer(value):
    '''
    قم بإنشاء دالة تأخذ قيمة (نص) تمثل رقمًا
    وترجع أقرب عدد صحيح إليه. إذا كان الرقم على مسافة متساوية من
    عددين صحيحين، فقم بتقريبه بعيدًا عن الصفر.

    الأمثلة
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    ملاحظة:
    التقريب بعيدًا عن الصفر يعني أنه إذا كان الرقم المعطى على مسافة متساوية من
    عددين صحيحين، فإن الرقم الذي يجب إرجاعه هو الرقم الأبعد عن الصفر. على سبيل المثال، يجب أن
    يرجع closest_integer("14.5") 15 ويجب أن
    يرجع closest_integer("-14.5") -15.
    '''


def make_a_pile(n):
    """
    بالنظر إلى عدد صحيح موجب n، يجب عليك إنشاء كومة من n مستويات من الحجارة.
    يحتوي المستوى الأول على n حجارة.
    عدد الحجارة في المستوى التالي هو:
        - العدد الفردي التالي إذا كان n فرديًا.
        - العدد الزوجي التالي إذا كان n زوجيًا.
    أعد عدد الحجارة في كل مستوى في قائمة، حيث يمثل العنصر في الفهرس
    i عدد الحجارة في المستوى (i+1).

    أمثلة:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    معطى عددا صحيحا موجب n، يتوجب أن تنشئ كومة من n مستويات من الأحجارا.
    يشتمل  المستوى الأول على n حجارة.
    عدد الحجارة في المستوى التالي هو:
        - العدد الفردي التالي إذا كان n فرديًا.
        - العدد الزوجي التالي إذا كان n زوجيًا.
    أرجع عدد الأحجار في كل مستوى في قائمة، بحيث يمثل العنصر في الفهرس
    i عدد الحجارة في المستوى (i+1).

    أمثلة:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

:def make_a_pile(n)
    """
    لدينا عدد صحيح موجب يدعى n،  يجب عليك إنشاء كومة من عدد n مستويات من الحجارة.
    يحتوي المستوى الأول على n حجارة.
    عدد الحجارة في المستوى التالي هو:
        - العدد الفردي التالي إذا كان n فرديًا.
        - العدد الزوجي التالي إذا كان n زوجيًا.
    أعد عدد الحجارة في كل مستوى في قائمة، حيث يمثل العنصر في المكان
    i عدد الحجارة في المستوى (i+1).

    أمثلة:
    >>> make_a_pile(3)
    [3, 5, 7]
    """


:def words_string(s)
    """
    سيتم إعطاؤك سلسلة نصية من الكلمات مفصولة بفواصل أو مسافات. مهمتك هي
    تقسيم السلسلة إلى كلمات وإرجاع مصفوفة مكونة من الكلمات.

    على سبيل المثال:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    ستعطى مجموعة من الكلمات مفصولة بفواصل أو مسافات. هدفك هو
    أن تقسم السلسلة إلى كلمات وإعادة مصفوفة الكلمات.

    خذ هذا كمثال:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    سيتم إعطاؤك سلسلة من الكلمات مفصولة بفواصل أو مسافات. مهمتك هي
    تقسيم السلسلة إلى كلمات وإرجاع مصفوفة من الكلمات.

    For example:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """


def choose_num(x, y):

    """هذه الدالة تأخذ عددين صحيحين موجبين x و y،
    وترجع أكبر عدد زوجي صحيح ضمن المدى [x, y]، بما في ذلك x و y.
    إذا لم يوجد مثل هذا العدد، فإن الدالة ترجع -1.

    على سبيل المثال:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """تأخذ هذه الدالة رقمين موجبين x و y وتعيد
    أكبر عدد صحيح زوجي يكون في النطاق [x, y] شامل. إذا
    لم يكن هناك مثل هذا الرقم، فيجب أن تعيد الدالة -1.

    على سبيل المثال:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

:def choose_num(x, y)
    """تأخذ هذه الدالة رقمين موجبين x و y وتعيد أكبر عدد صحيح زوجي
    يكون في نطاق الأعداد  [x, y] . إذا لم يوجد رقم بهذا الوصف،
    فيجب أن تقوم الدالة بإرجاع -1.

    على سبيل المثال:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """


def rounded_avg(n, m):
    """لديك عددين صحيحين موجبين n و m، ومهمتك هي حساب
    متوسط الأعداد الصحيحة من n إلى m (بما في ذلك n و m).
    قرِّب الإجابة إلى أقرب عدد صحيح وحوِّلها إلى عدد ثنائي.
    إذا كان n أكبر من m، فأرجع -1.
    مثال:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """أنت لديك عددين صحيحين موجبين n و m، ومهمتك هي حساب متوسط
    الأعداد الصحيحة من n إلى m (بما في ذلك n و m).
    قم بتقريب الإجابة إلى أقرب عدد صحيح وحولها إلى النظام الثنائي.
    إذا كان n أكبر من m، أعد -1.
    مثال:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """أمامك عددان صحيحان موجبان  .n و m، وهدفك هو ان تحسب متوسط
    الأعداد الصحيحة من n إلى m (بما في ذلك n و m).
    عليك بتقريب الإجابة لأقرب عدد صحيح ومن ثم تحويلها إلى النظام الثنائي.
    عندما تكون n أكبر من m، أعد -1.
    إليك مثالا:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """


def unique_digits(x):
    """تم إعطاؤك قائمة من الأعداد الصحيحة الموجبة x. أرجع قائمة مرتبة لجميع العناصر التي لا تحتوي على أي رقم زوجي.

    ملاحظة: يجب أن تكون القائمة المرتجعة مرتبة بترتيب تصاعدي.

    على سبيل المثال:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """بمعلومية قائمة من الأعداد الصحيحة الموجبة x. قم بإرجاع قائمة مرتبة من جميع
    العناصر التي لا تحتوي على أي رقم زوجي.

    ملاحظة: يجب أن تكون القائمة المرتجعة مرتبة ترتيبًا تصاعديًا.

    For example:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """تم إعطاء قائمة من الأعداد الصحيحة الموجبة x. قم بإرجاع قائمة مرتبة من جميع
    العناصر التي لا تحتوي على أي رقم زوجي.

    ملاحظة: يجب أن تكون القائمة المرجعة مرتبة بترتيب تصاعدي.

    على سبيل المثال:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """


def by_length(arr):
    """
    بالنظر إلى مصفوفة من الأعداد الصحيحة، قم بترتيب الأعداد الصحيحة التي تكون بين 1 و 9 شاملة،
    ثم قم بعكس ترتيب المصفوفة الناتجة، ثم استبدل كل رقم باسمه المقابل من
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    على سبيل المثال:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> ترتيب المصفوفة -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> عكس ترتيب المصفوفة -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      إذا كانت المصفوفة فارغة، قم بإرجاع مصفوفة فارغة:
      arr = []
      return []

      إذا كانت المصفوفة تحتوي على أي رقم غريب تجاهله:
      arr = [1, -1 , 55]
            -> ترتيب المصفوفة -> [-1, 1, 55]
            -> عكس ترتيب المصفوفة -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    بمعرفة مصفوفة من الأعداد الصحيحة، قم بفرز الأعداد الصحيحة التي تقع بين 1 و 9 ضمنيًا,
    ثم اعكس المصفوفة الناتجة، ثم استبدل كل رقم باسمه المقابل من
        "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    على سبيل المثال:
    arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

    إذا كانت المصفوفة فارغة، أرجع مصفوفة فارغة:
    arr = []
      return []

      إذا كانت المصفوفة تحتوي على أي رقم خارج النطاق تجاهله:
    arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """


def f(n):
    """ تنفيذ الدالة f التي تأخذ n كمعامل،
    وتعيد قائمة بحجم n، بحيث تكون قيمة العنصر عند الفهرس i هي مضروب i إذا كان i زوجياً
    أو مجموع الأرقام من 1 إلى i خلاف ذلك.
    يبدأ i من 1.
    مضروب i هو حاصل ضرب الأرقام من 1 إلى i (1 * 2 * ... * i).
    مثال:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ نفذ دالة f التي تأخذ n كمعامل،
    وترجع قائمة بحجم n، بحيث تكون قيمة العنصر عند الفهرس i هي مضروب i إذا كان i زوجياً
    أو مجموع الأرقام من 1 إلى i  .
    يستهل i من 1.
    مضروب i هو حاصل ضرب الأرقام من 1 إلى i (1 * 2 * ... * i).
    فمثلا:
    f(5) == [1, 2, 6, 24, 15]
    """

:def f(n)
    """ قم بتنفيذ دالة f التي تأخذ n كمعامل،
    وتعيد قائمة بحجم n، بحيث تكون قيمة العنصر في المكان i هي مضروب i إذا كان i زوجياً
    أو مجموع الأرقام من 1 إلى i خلاف ذلك.
    يبدأ i من 1.
    مضروب i هو حاصل ضرب الأرقام من 1 إلى i (1 * 2 * ... * i).
    مثال:
    f(5) == [1, 2, 6, 24, 15]
    """


def even_odd_palindrome(n):
    """
    هذه الدالة تأخذ عددًا صحيحًا موجبًا n،
    وترجع زوجًا مرتبًا يحتوي على عدد الأعداد الصحيحة الفردية والزوجية
    في المدى (1, n)، بما في ذلك 1 و n.

    المثال 1:

        المدخل: 3
        المخرج: (1, 2)
        التوضيح:
        الأعداد الصحيحة المتناظرة هي 1، 2، 3. واحد منها زوجي، واثنان منها فرديان.

    المثال 2:

        المدخل: 12
        المخرج: (4, 6)
        التوضيح:
        الأعداد الصحيحة المتناظرة هي 1، 2، 3، 4، 5، 6، 7، 8، 9، 11. أربعة منها زوجية، و6 منها فردية.

    ملاحظة:
        1. 1 <= n <= 10^3
        2. الزوج المرتب المرجوع يحتوي على عدد الأعداد الصحيحة الفردية والزوجية على التوالي.
    """

def even_odd_palindrome(n):
    """
    معطى عددا صحيحا موجبا n، أعد زوجا يضم عدد الأعداد الصحيحة المتناظرة الزوجية والفردية
    التي تقع ضمن النطاق (1, n)، بما في ذلك.

    المثال 1:

        input: 3
        output: (1, 2)
        التوضيح:
        الأعداد الصحيحة المتناظرة هي 1، 2، 3. واحد منها زوجي، واثنان منها فرديان.

    المثال 2:

        input: 12
        output: (4, 6)
        التوضيح:
        الأعداد الصحيحة المتناظرة هي 1، 2، 3، 4، 5، 6، 7، 8، 9، 11. أربعة منها زوجية، و6 منها فردية.

    ملاحظة:
        1. 1 <= n <= 10^3
        2. الزوج المعاد يحتوي على عدد الأعداد الصحيحة المتناظرة الزوجية والفردية على التوالي.
    """

def even_odd_palindrome(n):
    """
    معطى عددا صحيحا موجبا n، أعد ثنائيا يحتوي على عدد الأعداد الصحيحة المتناظرة الزوجية والفردية
    التي تقع ضمن النطاق (1, n)،.

    المثال 1:

        Input: 3
        Output: (1, 2)
        التوضيح:
        الأعداد المتناظرة. هي 1، 2، 3. واحد منها ثنائيي، واثنان منها فرديان

    المثال 2:
        input: 12
        Output: (4, 6)
        التوضيح:
        الأعداد الصحيحة المتناظرة هي 1، 2، 3، 4، 5، 6، 7، 8، 9، 11. أربعة منها ثنائيية، و6 منها فردية.

    ملاحظة:
        1. 1 <= n <= 10^3
        2. الثنائي المعاد يضم عددا من الأعداد الصحيحة متنازرة الزوجية والفردية على بالترتيب..
    """


def count_nums(arr):
    """
    اكتب دالة count_nums التي تأخذ مصفوفة من الأعداد الصحيحة وتعيد
    عدد العناصر التي يكون مجموع أرقامها > 0.
    إذا كان الرقم سالبًا، فإن أول رقم موقع سيكون سالبًا:
    على سبيل المثال -123 يحتوي على الأرقام الموقعة -1، 2، و3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    قم بكتابة دالة count_nums
    تقوم بأخذ نسق من الأعداد الصحيحة وتقوم بإعادة
    عدد العناصر التي مجموع أرقامها > 0.
    إذا كان الرقم سالبًا، فأول رقم موقع سوف يكون سالبًا:
    مثال: -123 يحتوي على الأرقام الموقعة -1، 2، و3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

:def count_nums(arr)
    """
    اكتب دالة count_nums التي تأخذ مصفوفة من الأعداد الصحيحة وتعيد
    عدد العناصر التي يكون مجموع أرقامها > 0.
    إذا كان الرقم سالبًا، فإن الرقم الموجود في أول خانة موقعة سيكون سالبًا:
    على سبيل المثال -123 يحتوي على الأرقام الموقعة -1، 2، و3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """


def move_one_ball(arr):
    """لدينا مصفوفة 'arr' تحتوي على N عدد صحيح arr[1], arr[2], ..., arr[N].
    الأرقام في المصفوفة ستكون مرتبة بشكل عشوائي. مهمتك هي تحديد ما إذا كان
    من الممكن الحصول على مصفوفة مرتبة بترتيب غير تنازلي عن طريق تنفيذ
    العملية التالية على المصفوفة المعطاة:
        يُسمح لك بتنفيذ عملية الإزاحة إلى اليمين أي عدد من المرات.

    تعني عملية الإزاحة إلى اليمين نقل جميع عناصر المصفوفة بمقدار موضع واحد
    في الاتجاه الأيمن. سيتم نقل العنصر الأخير من المصفوفة إلى الموضع
    الابتدائي في المصفوفة أي الفهرس 0.

    إذا كان من الممكن الحصول على المصفوفة المرتبة عن طريق تنفيذ العملية
    المذكورة أعلاه، فارجع True وإلا فارجع False.
    إذا كانت المصفوفة المعطاة فارغة، فارجع True.

    ملاحظة: القائمة المعطاة مضمونة أن تحتوي على عناصر فريدة.

    على سبيل المثال:

    move_one_ball([3, 4, 5, 1, 2])==>True
    التوضيح: عن طريق تنفيذ عمليتي إزاحة إلى اليمين، يمكن تحقيق ترتيب غير
             تنازلي للمصفوفة المعطاة.
    move_one_ball([3, 5, 4, 1, 2])==>False
    التوضيح: لا يمكن الحصول على ترتيب غير تنازلي للمصفوفة المعطاة عن طريق
             تنفيذ أي عدد من عمليات الإزاحة إلى اليمين.

    """

def move_one_ball(arr):
    """لدينا مصفوفة 'arr' من N عدد صحيح arr[1]، arr[2]، ...، arr[N]. سيتم ترتيب
    الأرقام في المصفوفة عشوائيًا. مهمتك هي تحديد ما إذا كان من الممكن الحصول على مصفوفة مرتبة بترتيب غير تنازلي من خلال إجراء
    العملية التالية على المصفوفة المعطاة:

    يُسمح لك بإجراء عملية إزاحة يمينية أي عدد من المرات.

    تعني عملية إزاحة يمينية واحدة إزاحة جميع عناصر المصفوفة بمقدار موضع واحد في الاتجاه الصحيح. سيتم نقل العنصر الأخير في المصفوفة إلى
    موضع البداية في المصفوفة أي الفهرس 0.

    إذا كان من الممكن الحصول على المصفوفة المرتبة من خلال إجراء العملية أعلاه
    ، فارجع True وإلا فارجع False.
    إذا كانت المصفوفة المعطاة فارغة، فارجع True.

    ملاحظة: من المؤكد أن القائمة المعطاة تحتوي على عناصر فريدة.

    على سبيل المثال:

    move_one_ball([3, 4, 5, 1, 2])==>صحيح
    التفسير: من خلال إجراء عمليتي تحويل لليمين، يمكن تحقيق ترتيب غير تناقصي للمصفوفة المعطاة.
    move_one_ball([3, 5, 4, 1, 2])==>خطأ
    التفسير: من غير الممكن الحصول على ترتيب غير تناقصي للمصفوفة المعطاة من خلال إجراء أي عدد من عمليات التحويل لليمين.

    """


def exchange(lst1, lst2):
    """في هذه المسألة، ستنفذ دالة تأخذ قائمتين من الأعداد,
    وتحدد ما إذا كان من الممكن إجراء تبادل للعناصر
    بينهما لجعل lst1 قائمة بأعداد زوجية فقط.
    لا يوجد حد لعدد العناصر المتبادلة بين lst1 و lst2.
    إذا كان من الممكن تبادل العناصر بين lst1 و lst2 لجعل
    جميع عناصر lst1 زوجية، فأرجع ”نعم“.
    خلاف ذلك، أرجع ”لا“.
    على سبيل المثال:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    من المفترض أن تكون قوائم المدخلات غير فارغة.
    """

def exchange(lst1, lst2):
    """في هذه المعضلة، سوف تنشئ دالة تقوم بأخذ اثنين من قوائم الأرقام،
    ومن ثم تقوم بتحديد إذا كان ممكنا أن نجري تبادلا للعناصر بينهما
    لجعل lst1 قائمة تضم فقط  أرقاما زوجية.
    لا يوجد حد لعدد العناصر المتبادلة بين lst1 و lst2.
    إذا كان بالإمكان تبادل العناصر بين lst1 و lst2 لجعل
    جميع عناصر lst1 زوجية، نقم بإعادة "YES".
    بخلاف هذا، قم بإدراج "NO".
    خذ كمثال:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    من المفترض أن القوائم التي يتم إدخالها ليست شاغرة.
    """

:def exchange(lst1, lst2)
    """في هذه المسألة، ستقوم بتنفيذ دالة تأخذ قائمتين من الأرقام،
    وتحدد ما إذا كان من الممكن إجراء تبادل للعناصر بينهما
    لجعل lst1 قائمة تحتوي فقط على أرقام زوجية.
    لا يوجد حد لعدد العناصر المتبادلة بين lst1 و lst2.
    إذا كان من الممكن تبادل العناصر بين lst1 و lst2 لجعل
    جميع عناصر lst1 زوجية، قم بإرجاع "YES".
    خلاف ذلك، قم بإرجاع "NO".
    على سبيل المثال:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    يُفترض أن القوائم التي سيتم
إدخالها لن تكون فارغة.
    """


def histogram(test):
    """إذا كان هناك سلسلة تمثل أحرفًا صغيرة منفصلة بمسافة، فارجع قاموسًا
    للحرف الذي يحتوي على أكبر عدد من التكرارات ويحتوي على العدد المقابل.

    إذا كان هناك عدة أحرف لها نفس الظهور، فارجعها جميعًا.

    مثال:

    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """بالنظر إلى سلسلة تمثل حروف صغيرة مفصولة بمسافات، أعد قاموسًا يتضمن الحرف الأكثر تكرارًا مع عدد مرات للتكرار.
    إذا كان هناك عدة حروف لها نفس التكرار، ضع جميعها.

    مثال:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    ””“"بمعلومية سلسلة تمثل حروفًا صغيرة مفصولة بمسافات، قم بإرجاع قاموس
    للحرف الأكثر تكرارًا ويحتوي على العدد المقابل.
    إذا كان هناك عدة أحرف لها نفس التكرار، قم بإرجاعها جميعًا.

    مثال:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """


def reverse_delete(s,c):
    """المهمة
    لدينا سلسلتان نصيتان s و c، يجب عليك حذف جميع الأحرف في s التي تساوي أي حرف في c
    ثم تحقق مما إذا كانت السلسلة الناتجة هي متناظرة.
    تُسمى السلسلة متناظرة إذا كانت تقرأ بنفس الطريقة من الخلف كما من الأمام.
    يجب أن تعيد دالة تحتوي على السلسلة الناتجة و True/False للتحقق.
    مثال
    بالنسبة لـ s = "abcde"، c = "ae"، يجب أن تكون النتيجة ('bcd',False)
    بالنسبة لـ s = "abcdef"، c = "b" يجب أن تكون النتيجة ('acdef',False)
    بالنسبة لـ s = "abcdedcba"، c = "ab"، يجب أن تكون النتيجة ('cdedc',True)
    """

def reverse_delete(s,c):
    """لدينا  سلسلتان نصيتان s وc، يجب عليك حذف جميع الأحرف في s التي تساوي أي حرف في c
    ثم التحقق مما إذا كانت السلسلة النصيه الناتجة عبارة عن سلسلة نصيه  متناظرة.
    تسمى السلسلة النصيه متناظرة إذا كانت تقرأ بنفس الطريقة للخلف وللأمام.
    يجب عليك إرجاع مجموعة تحتوي على سلسلة النتيجة وTrue/False للتحقق.
    مثال
    بالنسبة لـ s = "abcde"، c = "ae"، يجب أن تكون النتيجة ('bcd',False)
    بالنسبة لـ s = "abcdef"، c = "b" يجب أن تكون النتيجة ('acdef',False)
    بالنسبة لـ s = "abcdedcba"، c = "ab"، يجب أن تكون النتيجة ('cdedc',True)
    """


def odd_count(lst):
    """معطى قائمة من السلاسل النصية، حيث كل سلسلة تتكون فقط من أرقام، إرجاع قائمة.
    يجب أن يكون كل عنصر i من المخرجات "عدد العناصر الفردية في
    السلسلة i من المدخلات." حيث يجب استبدال جميع i بعدد
    الأرقام الفردية في السلسلة i من المدخلات.

    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
     "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """

def odd_count(lst):
    ””“"بمعلومية قائمة من السلاسل، حيث تتكون كل سلسلة من أرقام فقط، قم بإرجاع قائمة.
    يجب أن يكون كل عنصر i من المخرجات هو ”عدد العناصر الفردية في
    السلسلة i من المدخلات.“ حيث يجب استبدال جميع العناصر i بعدد
    الأرقام الفردية في السلسلة i من المدخلات.
    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
     "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """

def odd_count(lst):
    """بمعطى قائمة من السلاسل، حيث تتكون كل سلسلة من أرقام فقط، قم بإرجاع قائمة.
    يجب أن يكون كل عنصر i من المخرجات هو ”عدد العناصر الفردية في
    i في السلسلة رقم i من المدخلات.“ حيث يجب استبدال كل i بعدد
    من الأرقام الفردية في السلسلة i من المدخلات.

    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
     "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """


def minSubArraySum(nums):
    """
    تم إعطاؤك مصفوفة من الأعداد الصحيحة nums، ابحث عن الحد الأدنى لمجموع أي مصفوفة فرعية غير فارغة من nums.
    مثال
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    بالنظر إلى مصفوفة من الأعداد الصحيحة nums، ابحث عن الحد الأدنى لمجموع أي جزء غير فارغ
    من nums.
    مثال
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    معطى مصفوفة أعداد صحيحة nums، أوجد  الحد الأدنى لمجموع أي جزء غير شاغر
    من nums.
    مثال
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """


import math

def max_fill(grid, capacity):
    """
    لديك شبكة مستطيلة من الآبار. كل صف يمثل بئرًا واحدًا،
    وكل 1 في الصف يمثل وحدة واحدة من الماء.
    كل بئر لديه دلو مطابق يمكن استخدامه لاستخراج الماء منه،
    وجميع الدلاء لها نفس السعة.
    مهمتك هي استخدام الدلاء لتفريغ الآبار.
    الناتج هو عدد المرات التي تحتاج فيها إلى خفض الدلاء.

    المثال 1:
        Input:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Output: 6

    المثال 2:
        Input:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Output: 5

    المثال 3:
        Input:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Output: 0

    القيود:
        * جميع الآبار لها نفس الطول
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    لديك شبكة مستطيلة من الآبار. كل صف يمثل بئرًا واحدًا،
    وكل 1 في الصف يمثل وحدة واحدة من الماء.
    كل بئر لديه دلو مطابق يمكن استخدامه لاستخراج الماء منه،
    وجميع الدلاء لها نفس السعة.
    مهمتك هي استخدام الدلاء لتفريغ الآبار.
    قم بإخراج عدد المرات التي تحتاج فيها إلى خفض الدلاء.

    المثال 1:
        المدخلات:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        الناتج: 6

    المثال 2:
        المدخلات:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        الناتج: 5

    المثال 3:
        المدخلات:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        الناتج: 0

    القيود:
        * جميع الآبار لها نفس الطول
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """لقد حصلت على شبكة مستطيلة من الآبار. يمثل كل صف بئرًا واحدًا،
    ويمثل كل رقم 1 في الصف وحدة واحدة من الماء.

    يوجد لكل بئر دلو مطابق يمكن استخدامه لاستخراج الماء منه،
    وكل الدلاء لها نفس السعة.

    مهمتك هي استخدام الدلاء لتفريغ الآبار.

    قم بإخراج عدد المرات التي تحتاج فيها إلى خفض الدلاء

    المثال 1:
        المدخلات:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        الناتج: 6

    المثال 2:
        المدخلات:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        الناتج: 5

    المثال 3:
        المدخلات:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        الناتج: 0

    القيود:
        * جميع الآبار لها نفس الطول
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """


def sort_array(arr):
    """
    في هذه المهمة، يجب عليك فرز مصفوفة من الأعداد الصحيحة غير السالبة وفقًا
    لعدد الآحاد في تمثيلها الثنائي بترتيب تصاعدي.
    بالنسبة للأعداد التي تحتوي على نفس العدد من الآحاد، يجب فرزها بناءً على قيمتها العشرية.

    يجب تنفيذها بهذا الشكل:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) == [0, 1, 2, 3, 4]

    """

def sort_array(arr):
    """
    في هذا التحدي، يجب أن ترتب مصفوفة من أعداد صحيحة غير سالبة تبعا
    لعدد الآحاد في تمثيلها الثنائي تصاعديا.
    بالنسبة للأعداد التي تشمل عددا متماثلا من الآحاد، قم بالترتيب بناءً على القيمة العشرية.

    يجب أن تُننفذ بهذه الطريقة:
    >>> sort_array ([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array ([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array ([1, 0, 2, 3, 4]) == [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    ”"“
    في هذا المقطع، عليك فرز مصفوفة من الأعداد الصحيحة غير السالبة وفقًا ل
    عدد الآحاد في تمثيلها الثنائي بترتيب تصاعدي.
    للحصول على عدد مماثل من الآحاد، قم بالفرز بناءً على القيمة العشرية.

    يجب تنفيذ ذلك على النحو التالي:
     >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """


def select_words(s, n):
    """باعتبار السلسلة النصية s وعددًا طبيعيًا n، الهدف هو كتابة
    دالة تُرجع قائمة تحتوي على جميع الكلمات في السلسلة النصية s
    التي تحتوي على عدد الحروف الساكنة يساوي n، مع ترتيب الكلمات
    كما تظهر في النص.
    إذا كانت السلسلة النصية s فارغة، تعيد الدالة قائمة فارغة.
    ملاحظة: يمكن افتراض أن النص يحتوي فقط على أحرف ومسافات.
    أمثلة:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """بالنظر إلى سلسلة نصية s ورقم طبيعي n، تم تكليفك بتنفيذ
    دالة تعيد قائمة بجميع الكلمات من السلسلة النصية s التي تحتوي على
    بالضبط n من الحروف الساكنة، بترتيب ظهور هذه الكلمات في السلسلة النصية s.
    إذا كانت السلسلة النصية s فارغة، فيجب أن تعيد الدالة قائمة فارغة.
    ملاحظة: يمكنك افتراض أن السلسلة النصية المدخلة تحتوي فقط على حروف ومسافات.
    أمثلة:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """معطى  سلسلة نصوص s ورقم طبيعي n، طلب منك إنشاء دالة
    دالة ترجع قائمة بكافة كلمات السلسلة النصية s التي تحتوي على
    بالضبط n من الحروف الساكنة، بترتيب ظهور هذه الكلمات في السلسلة النصية s.
    في حال كانت السلسلة النصية s شاغرة، فعليك إعادة الدالة قائمة شاغرة.
    حاشية: لتفترض أن السلسلة النصية المدخلة تضم فقط على حروفا ومسافات.
    أمثلة:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """


def get_closest_vowel(word):
    """تم إعطاؤك كلمة. مهمتك هي العثور على أقرب حرف متحرك يقع بين.
    حرفين ساكنين من الجانب الأيمن للكلمة (حساس لحالة الأحرف).

    لا تُحسب حروف العلة في البداية والنهاية. أعد سلسلة فارغة إذا لم تجد
    أي حرف علة يفي بالشرط المذكور أعلاه.

    يمكنك افتراض أن السلسلة المُعطاة تحتوي على حروف إنجليزية فقط.

    مثال:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

:def get_closest_vowel(word)
    """لديك كلمة. مهمتك هي إيجاد أقرب حرف متحرك موجود بين
    حرفين ساكنين من الجانب الأيمن للكلمة (حالتي الحروف الصغيرة والكبيرة لا تعد حالة واحدة في الدالة).

    لا تُحسب الحروف المتحركة في البداية والنهاية. قم بإرجاع سلسلة نصية فارغة إذا لم تجد
    أي حرف متحرك يفي بالشرط المذكور أعلاه.

    يمكنك افتراض أن السلسلة النصية المُعطاة تحتوي على حروف إنجليزية فقط.

    مثال:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """بافتراض اعطائك كلمة، مهمتك أن تجد أقرب حرف متحرك يقع بين اثنين من الأحرف الساكنة عن يمين الكلمة ( حالة الحروف حساسه )

    لا يتم احتساب الحروف المتحركة في البداية والنهاية.
    قم بإرجاع سلسلة فارغة في حال لم تجد
     حرفا متحركا يستوفي الشروط التي ذكرت بالأعلى
    بإمكانك أن تفترض أن النصوص المُعطاة تضم أحرفا إنجليزية فقط.

    مثال:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """


def match_parens(lst):
    '''
    لديك قائمة تحتوي على سلسلتين نصيتين، كلتا السلسلتين تتكونان من
    أقواس مفتوحة '(' أو أقواس مغلقة ')' فقط.
    مهمتك هي التحقق مما إذا كان من الممكن دمج السلسلتين في ترتيب ما،
    بحيث تكون السلسلة الناتجة جيدة.
    تعتبر السلسلة S جيدة إذا وفقط إذا كانت جميع الأقواس في S متوازنة.
    على سبيل المثال: السلسلة '(())()' جيدة، بينما السلسلة '())' ليست كذلك.
    أعد 'Yes' إذا كان هناك طريقة لجعل السلسلة جيدة، وأعد 'No' خلاف ذلك.

    أمثلة:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    لقد حصلت على قائمة من سلسلتين، تتكون كل منهما من أقواس مفتوحة '(' أو أقواس مغلقة ')' فقط.
    مهمتك هي التحقق مما إذا كان من الممكن ربط السلسلتين ببعضهما البعض
    ، وأن السلسلة الناتجة ستكون جيدة.
    تُعتبر السلسلة S جيدة إذا وفقط إذا كانت جميع الأقواس في S
    متوازنة. على سبيل المثال: السلسلة '(())()' جيدة، بينما السلسلة '())' ليست كذلك.
    أرجع 'Yes' إذا كانت هناك طريقة لإنشاء سلسلة جيدة، وأرجع 'No' بخلاف ذلك.

    الأمثلة:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    معطى قائمة تحتوي على سلسلتين نصيتين، يتكون كل منهما من أقواس مفتوحة '(' أو أقواس مغلقة ')' فقط.

     مهمتك أن تتحقق مما إذا كان بالإمكان ربط السلسلتين النصيتين ببعضهما البعض
    ،  بترتيب ما بحيث تكون السلسة النصية الناتجة جيدة.

    تُعتبر النصS جيدة فقط في حال كانت جميع الأقواس في S
    متوازنة. فمثلا: النصوص'(())()' جيدة، بينما النصوص'())' ليست كذلك.

    قم بإرجاع 'Yes' إذا كان هناك طريقة لجعل السلسة النصية جيدة، وإلا قم بإرجاع 'No.

    أمثلة:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''


def maximum(arr, k):
    """
    إذا كانت لدينا مصفوفة arr تحتوي على أعداد صحيحة وعدد صحيح موجب k،
    يجب إرجاع قائمة مرتبة تحتوي على أكبر k أعداد من المصفوفة arr.

    المثال 1:
    الإدخال: arr = [-3, -4, 5], k = 3
    الإخراج: [-4, -3, 5]

    المثال 2:
    الإدخال: arr = [4, -4, 4], k = 2
    الإخراج: [4, 4]

    المثال 3:
    الإدخال: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
    الإخراج: [2]

    ملاحظات:
    1. سيكون طول المصفوفة في نطاق [1, 1000].
    2. العناصر في المصفوفة ستكون في نطاق [-1000, 1000].
    3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    بالنظر إلى مصفوفة arr من الأعداد الصحيحة وعدد صحيح موجب k، قم بإرجاع قائمة مرتبة بطول k تحتوي على أكبر k أرقام في arr.

    المثال 1:

        Input: arr = [-3, -4, 5], k = 3
        Output: [-4, -3, 5]

    المثال 2:

        Input: arr = [4, -4, 4], k = 2
        Output: [4, 4]

    المثال 3:

        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Output: [2]

    ملاحظة:
        1. طول المصفوفة سيكون في النطاق [1, 1000].
        2. العناصر في المصفوفة ستكون في النطاق [-1000, 1000].
        3. 0 <= k <= len(arr)
    """


def solution(lst):
    """بالنظر إلى قائمة غير فارغة من الأعداد الصحيحة، قم بإرجاع مجموع جميع العناصر الفردية التي تكون في مواقع زوجية.

    أمثلة
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """بالنظر إلى قائمة غير فارغة من الأعداد الصحيحة، قم بإرجاع مجموع جميع العناصر الفردية التي توجد في المواقع الزوجية.

    أمثلة
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

:def solution(lst)
    """بالنظر إلى قائمة غير فارغة من الأعداد الصحيحة، أعِد مجموع جميع العناصر الفردية الموجودة في أماكن زوجية.

    أمثلة
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """


def add_elements(arr, k):
    """
    معطى مصفوفة غير فارغة من الأعداد الصحيحة arr ورقم صحيح k
    أعد مجموع العناصر التي تحتوي على رقمين على الأكثر من أول k عناصر من المصفوفة.

    مثال:

        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Output: 24 # sum of 21 + 3

    القيود:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    لديك مصفوفة غير فارغة من الأعداد الصحيحة arr وعدد صحيح k، أعد
    مجموع العناصر التي تحتوي على خانتين على الأكثر من أول عنصر k في arr.

    مثال:

        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Output: 24 # مجموع 21 + 3

    القيود:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    إذا كان لدينا مجموعه غير فارغة من الأعداد الصحيحة arr وعدد صحيح k، فقم بإرجاع
    مجموع العناصر التي تحتوي على رقمين على الأكثر من أول k عنصر من arr.

    مثال:

    Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
    Output: 24 # مجموع 21 + 3

    القيود:
    1. 1 <= len(arr) <= 100
    2. 1 <= k <= len(arr)
    """


def get_odd_collatz(n):
    """
    بمعلومية عدد صحيح موجب n، أرجع قائمة مرتبة تحتوي على الأعداد الفردية في متتابعة كولاتز.

    تخمين كولاتز هو تخمين في الرياضيات يتعلق بمتتابعة مُعرَّفة
    على النحو التالي: ابدأ بأي عدد صحيح موجب n. ثم يتم الحصول على كل حد من
    الحد السابق على النحو التالي: إذا كان الحد السابق زوجيًّا، فإن الحد التالي هو نصف
    الحد السابق. إذا كان الحد السابق فرديًّا، فإن الحد التالي يساوي 3 في الحد السابق
    زائد 1. التخمين هو أنه بغض النظر عن قيمة n، ستصل المتتابعة دائمًا إلى 1.

    لاحظ ذلك:
        1. كولاتز(1) هو [1].
        2. القائمة المرتجعة مرتبة ترتيبًا تصاعديًا.

    على سبيل المثال:
    get_odd_collatz(5) returns [1, 5] # متتابعة كولاتز للعدد 5 هي [5، 16، 16، 8، 4، 2، 1],
    لذا الأعداد الفردية هي 1 و 5 فقط.
    """

def get_odd_collatz(n):
    """
    تم إعطاؤك عددًا صحيحًا موجبًا n، أرجع قائمة مرتبة تحتوي على الأعداد الفردية في تسلسل كولاتز.

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

    ملاحظة:
        1. Collatz(1) is [1].
        2. returned list sorted in increasing order.

    على سبيل المثال:
    get_odd_collatz(5) returns [1, 5] # The collatz sequence for 5 is [5, 16, 8, 4, 2, 1], so the odd numbers are only 1, and 5.
    """

def get_odd_collatz(n):
    """
    إذا كان هناك عدد صحيح موجب n، فقم بإرجاع قائمة مرتبة تحتوي على الأرقام الفردية في تسلسل collatz.

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

    ملاحظة:
    1. Collatz(1) هو [1].
    2. تم إرجاع قائمة مرتبة بترتيب تصاعدي.

    على سبيل المثال:
    get_odd_collatz(5) يعيد [1, 5] # تسلسل collatz لـ 5 هو [5, 16, 8, 4, 2, 1]، لذا فإن الأرقام الفردية هي فقط 1 و 5.
    """


def valid_date(date):
    """يجب عليك كتابة دالة تتحقق من صحة سلسلة تاريخ معينة
    وتعيد True إذا كان التاريخ صحيحًا وإلا False.
    يكون التاريخ صحيحًا إذا تم استيفاء جميع القواعد التالية:
    1. سلسلة التاريخ ليست فارغة.
    2. عدد الأيام ليس أقل من 1 أو أكثر من 31 يومًا للأشهر 1,3,5,7,8,10,12. وعدد الأيام ليس أقل من 1 أو أكثر من 30 يومًا للأشهر 4,6,9,11. وعدد الأيام ليس أقل من 1 أو أكثر من 29 للشهر 2.
    3. يجب ألا تكون الأشهر أقل من 1 أو أكثر من 12.
    4. يجب أن يكون التاريخ بالتنسيق: mm-dd-yyyy

    على سبيل المثال:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """

def valid_date(date):
    ””“يجب عليك كتابة دالة تتحقق من صحة سلسلة تاريخ معيّن و
    وتُرجع True إذا كان التاريخ صحيحًا وإلا فهو False.
    يكون التاريخ صالحًا إذا تحققت جميع القواعد التالية:
    1. سلسلة التاريخ ليست فارغة.
    2. عدد الأيام ليس أقل من 1 أو أعلى من 31 يومًا للأشهر 1،3،5،7،8،10،12. وعدد الأيام ليس أقل من 1 أو أعلى من 30 يومًا للأشهر 4،6،9،11. وعدد الأيام لا يقل عن 1 أو أعلى من 29 يومًا للشهر 2.
    3. ويجب ألا يقل عدد الأشهر عن 1 أو أعلى من 12.
    4. يجب أن يكون التاريخ بالصيغة: mm-dd-yyyy

    على سبيل المثال
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """


def split_words(txt):
    '''
    بالنظر إلى سلسلة من الكلمات، قم بإرجاع قائمة من الكلمات مقسمة على المسافات البيضاء، إذا لم توجد مسافات بيضاء في النص
    يجب أن تقسم على الفواصل ',' إذا لم توجد فواصل يجب أن تعيد عدد الأحرف الصغيرة ذات الترتيب الفردي في
    الأبجدية، ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    أمثلة
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''بمعلومية سلسلة من الكلمات، قم بإرجاع قائمة بالكلمات المقسّمة على المسافات البيضاء، إذا لم توجد مسافات بيضاء في النص
    يجب أن تقسم على الفواصل ''،'' إذا لم توجد فواصل يجب عليك إرجاع عدد الأحرف الصغيرة ذات الترتيب الفردي في
    الأبجدية، ord('a') = 0، ord('b') = 1، ... ord('z') = 25
    أمثلة
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''


def is_sorted(lst):
    '''
    بالنظر إلى قائمة من الأرقام، قم بإرجاع ما إذا كانت مرتبة
    بترتيب تصاعدي أم لا. إذا كانت القائمة تحتوي على أكثر من تكرار واحد لنفس
    الرقم، قم بإرجاع False. افترض عدم وجود أرقام سلبية وأنها أعداد صحيحة فقط.

    أمثلة
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''

def is_sorted(lst):
    '''
    بمعلومية قائمة من الأرقام، قم بإرجاع ما إذا كانت مرتبة ترتيبًا تصاعديًا أم لا
    بترتيب تصاعدي. إذا كانت القائمة تحتوي على أكثر من تكرار واحد لنفس الرقم
    نفسها، فأرجع خطأ. بافتراض عدم وجود أرقام سلبية وأن الأرقام هي أعداد صحيحة فقط.

    أمثلة
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''


def intersection(interval1, interval2):
    """تم إعطاؤك فترتين،
    حيث كل فترة هي عبارة عن زوج من الأعداد الصحيحة. على سبيل المثال، الفترة = (البداية، النهاية) = (1، 2).
    الفترات المعطاة هي فترات مغلقة مما يعني أن الفترة (البداية، النهاية)
    تشمل كل من البداية والنهاية.
    بالنسبة لكل فترة معطاة، يُفترض أن تكون بدايتها أقل أو تساوي نهايتها.
    مهمتك هي تحديد ما إذا كان طول التقاطع بين هاتين الفترتين هو عدد أولي.
    على سبيل المثال، تقاطع الفترتين (1، 3)، (2، 4) هو (2، 3)
    وطوله هو 1، وهو ليس عددًا أوليًا.
    إذا كان طول التقاطع عددًا أوليًا، قم بإرجاع "نعم"،
    وإلا، قم بإرجاع "لا".
    إذا لم تتقاطع الفترتين، قم بإرجاع "لا".

    [أمثلة الإدخال/الإخراج]:
    intersection((1, 2), (2, 3)) ==> "لا"
    intersection((-1, 1), (0, 4)) ==> "لا"
    intersection((-3, -1), (-5, 5)) ==> "نعم"
    """

def intersection(interval1, interval2):
    """أنت مُعطى فترتين،
    حيث كل فترة هي زوج من الأعداد الصحيحة. على سبيل المثال، الفترة = (البداية، النهاية) = (1، 2).
    الفترات المعطاة مغلقة مما يعني أن الفترة (البداية، النهاية)
    تشمل كل من البداية والنهاية.
    لكل فترة معطاة، يُفترض أن بدايتها أقل أو تساوي نهايتها.
    مهمتك هي تحديد ما إذا كان طول تقاطع هاتين الفترتين
    هو عدد أولي.
    على سبيل المثال، تقاطع الفترتين (1، 3)، (2، 4) هو (2، 3)
    والذي طوله 1، وهو ليس عددًا أوليًا.
    إذا كان طول التقاطع عددًا أوليًا، أعد "YES"،
    وإلا، أعد "NO".
    إذا لم تتقاطع الفترتين، أعد "NO".

    [أمثلة الإدخال/الإخراج]:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """def intersection(interval1, interval2):
    """أنت مُعطى فترتين،
    حيث كل فترة هي زوج من الأعداد الصحيحة. على سبيل المثال، الفترة = (البداية، النهاية) = (1، 2).
    الفترات المعطاة مغلقة مما يعني أن الفترة (البداية، النهاية)
    تشمل كل من البداية والنهاية.
    لكل فترة معطاة، يُفترض أن بدايتها أقل أو تساوي نهايتها.
    مهمتك هي تحديد ما إذا كان طول تقاطع هاتين الفترتين
    هو عدد أولي.
    على سبيل المثال، تقاطع الفترتين (1، 3)، (2، 4) هو (2، 3)
    والذي طوله 1، وهو ليس عددًا أوليًا.
    إذا كان طول التقاطع عددًا أوليًا، أعد "YES"،
    وإلا، أعد "NO".
    إذا لم تتقاطع الفترتين، أعد "NO".

    [input/output] عينات:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """ مُعطى فترتين،
    حيث كل فترة عبارة عن زوج من أعداد صحيحة. فمثلا، الفترة = (البداية، النهاية) = (1، 2).
    الفترات المعطاة مغلقة مما يعني أن الفترة (البداية، النهاية)
    تتضمن البداية والنهاية كليهما.
    لكل فترة معطاة، من المفترض أن تكون بدايتها أقل أو مساوية نهايتها.
    مهمتك أن تحدد ما إذا كان طول تقاطع هاتين الفترتين عددا أوليا
    على سبيل المثال، تقاطع الفترتين (1، 3)، (2، 4) هو (2، 3)
    الذي طوله 1، وهو ليس عددًا أوليًا.
    إذا كان طول التقاطع عددًا أوليًا، أعد "YES"،
    من ناحية أخرى، ارجع  "No"
    إذا لم تتقاطع الفترتين، أرجع "NO".

    [أمثلة الإدخال/الإخراج]:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """


def prod_signs(arr):
    """
    لديك مصفوفة arr من الأعداد الصحيحة وتحتاج إلى إرجاع
    مجموع مقادير الأعداد مضروبًا في حاصل ضرب جميع إشارات
    كل رقم في المصفوفة، ممثلة بـ 1، -1 أو 0.
    ملاحظة: ارجع None للمصفوفة الفارغة.

    مثال:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """

    لقد حصلت على مصفوفة arr من الأعداد الصحيحة وتحتاج إلى إرجاع
    مجموع مقادير الأعداد الصحيحة مضروبًا في حاصل ضرب جميع العلامات
    لكل رقم في المصفوفة، والممثل بـ 1 أو -1 أو 0.

    ملاحظة: قم بإرجاع None للمصفوفة الفارغة.

    مثال:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """


def minPath(grid, k):
    """
    معطى شبكة تحتوي على N صفوف و N أعمدة (N >= 2) وعدد صحيح موجب k،
    تحتوي كل خلية في الشبكة على قيمة. يظهر كل عدد صحيح في النطاق [1, N * N]
    مرة واحدة بالضبط في خلايا الشبكة.

    يجب عليك إيجاد المسار الأدنى بطول k في الشبكة. يمكنك البدء
    من أي خلية، وفي كل خطوة يمكنك الانتقال إلى أي من الخلايا المجاورة،
    بمعنى آخر، يمكنك الذهاب إلى الخلايا التي تشترك في حافة مع الخلية الحالية.
    يرجى ملاحظة أن المسار بطول k يعني زيارة k خلايا بالضبط (ليس بالضرورة متميزة).
    لا يمكنك الخروج من الشبكة.
    يعتبر المسار A (بطول k) أقل من المسار B (بطول k) إذا
    بعد إنشاء قوائم مرتبة للقيم على الخلايا التي يمر بها A و B (دعونا نسميها lst_A و lst_B)،
    تكون lst_A أقل ترتيبًا لغويًا من lst_B، بمعنى آخر، يوجد فهرس عدد صحيح i (1 <= i <= k)
    بحيث lst_A[i] < lst_B[i] ولأي j (1 <= j < i) لدينا
    lst_A[j] = lst_B[j].
    يضمن أن الإجابة فريدة.
    أعد قائمة مرتبة للقيم على الخلايا التي يمر بها المسار الأدنى.

    أمثلة:

        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Output: [1, 2, 1]

        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Output: [1]
    """

def minPath(grid, k):
    """
    إذا كانت الشبكة تحتوي على N صفوف و N أعمدة (حيث N >= 2) وعدد صحيح موجب k،
    فإن كل خلية في الشبكة تحتوي على قيمة معينة. وتظهر جميع الأعداد الصحيحة ضمن
    النطاق [1، N * N] مرة واحدة فقط في خلايا الشبكة.

    الهدف هو إيجاد المسار الأدنى الذي يمتد بطول k داخل الشبكة. يمكنك البدء من أي خلية
    وفي كل خطوة، يمكن الانتقال إلى إحدى الخلايا المجاورة، أي الخلايا التي تشترك في
    حافة مع الخلية الحالية.

    يجب أن تلاحظ أن المسار بطول k يعني زيارة k خلايا بالضبط (قد تتكرر الخلايا).

    لا يُسمح بالخروج من حدود الشبكة.

    يُعتبر المسار A (الذي طوله k) أقل من المسار B (الذي طوله k) إذا كان بعد ترتيب
    القيم في الخلايا التي يمر بها المساران A و B (التي نسميها lst_A و lst_B)، فإن
    lst_A سيكون أقل معجمياً من lst_B. بمعنى آخر، هناك فهرس صحيح i (حيث 1 <= i <= k)
    بحيث أن lst_A[i] < lst_B[i] ولأي فهرس j (حيث 1 <= j < i) تكون القيم
    lst_A[j] = lst_B[j].

    من المضمون أن الإجابة ستكون فريدة.

    يجب أن ترجع قائمة مرتبة للقيم التي توجد في الخلايا التي يمر بها المسار الأدنى.

    أمثلة:
    Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
    Output: [1, 2, 1]

    Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
    Output: [1]
    """

def minPath(grid, k):
    """
    بالنظر إلى شبكة تحتوي على N صفوف و N أعمدة (N >= 2) وعدد صحيح موجب k،
    يحتوي كل خلية في الشبكة على قيمة. يظهر كل عدد في النطاق [1، N * N]
    شاملاً مرة واحدة فقط في خلايا الشبكة.

    عليك إيجاد المسار الأدنى بطول k في الشبكة. يمكنك البدء
    من أي خلية، وفي كل خطوة يمكنك التحرك إلى أي من الخلايا المجاورة،
    بمعنى آخر، يمكنك الانتقال إلى الخلايا التي تشارك حافة مع الخلية الحالية.
    يرجى ملاحظة أن المسار بطول k يعني زيارة بالضبط k خلايا (ليس بالضرورة مميزة).
    لا يمكنك الخروج من الشبكة.
    يعتبر المسار A (الذي طوله k) أقل من المسار B (الذي طوله k) إذا
    بعد ترتيب القوائم المرتبة للقيم في الخلايا التي يمر بها A و B
    (لنسمها lst_A و lst_B)، تكون lst_A أقل ترتيبًا من lst_B،
    بمعنى آخر، يوجد فهرس صحيح i (1 <= i <= k)
    بحيث lst_A[i] < lst_B[i] ولأي j (1 <= j < i) لدينا
    lst_A[j] = lst_B[j].
    يتم ضمان أن الإجابة فريدة.
    قم بإرجاع قائمة مرتبة للقيم في الخلايا التي يمر بها المسار الأدنى.

    الأمثلة:

        الإدخال: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        الإخراج: [1, 2, 1]

        الإدخال: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        الإخراج: [1]
    """


def tri(n):
    """يعرف الجميع متوالية فيبوناتشي، وقد درسها علماء الرياضيات بعمق في
    القرنين الماضيين. ومع ذلك، فإن ما لا يعرفه الناس هو متوالية تريبوناتشي.

    متوالية تريبوناتشي محددة بالتكرار:
    tri(1) = 3
    tri(n) = 1 + n / 2، إذا كان n زوجيًا.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1)، إذا كان n فرديًا.
    على سبيل المثال:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
    = 2 + 3 + 3 = 8

    لقد حصلت على عدد صحيح غير سالب n، وعليك إرجاع قائمة بأول n + 1 من أرقام متوالية تريبوناتشي.
    الأمثلة:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """الجميع يعرف متتالية فيبوناتشي، وقد درسها الرياضيون بعمق في
    القرون الأخيرة. ومع ذلك، ما لا يعرفه الناس هو متتالية تريبوناتشي.
    متتالية تريبوناتشي تعرف بالتكرار:
    tri(1) = 3
    tri(n) = 1 + n / 2، إذا كان n عددًا زوجيًا.
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1)، إذا كان n عددًا فرديًا.
    على سبيل المثال:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    تم إعطاؤك عدد صحيح غير سالب n، يجب عليك إرجاع قائمة تحتوي على أول n + 1 أرقام من متتالية تريبوناتشي.
    الأمثلة:
    tri(3) = [1, 3, 2, 8]
    """

:def tri(n)
    """الجميع يعرف متتابعة فيبوناتشي، فقد تمت دراستها بعمق من قبل علماء الرياضيات في
    القرون القليلة الماضية. ومع ذلك، ما لا يعرفه الناس هو متتابعة تريبوناتشي.
    يتم تعريف متتابعة تريبوناتشي بالعلاقة التكرارية:
    tri(1) = 3
    tri(n) = 1 + n / 2, إذا كان العدد n زوجياً.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), إذا كان العدد n فردياً.
    على سبيل المثال:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    يتم إعطاؤك عددًا صحيحًا غير سالب n، عليك إرجاع قائمة تحتوي على
    أول n + 1 من أرقام متتالية تريبوناتشي.
    أمثلة:
    tri(3) = [1, 3, 2, 8]
    """


def digits(n):
    """بالنظر إلى عدد صحيح موجب n، تُرجع ناتج ضرب الأرقام الفردية.
    تُرجع 0 إذا كانت جميع الأرقام زوجية.
    على سبيل المثال:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """إذا كان العدد الصحيح الموجب n، فارجع حاصل ضرب الأرقام الفردية.

    ارجع 0 إذا كانت جميع الأرقام زوجية.
    على سبيل المثال:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """بمعلومية عدد صحيح موجب n، أرجع حاصل ضرب الأرقام الفردية.
    أرجع 0 إذا كانت جميع الأرقام زوجية.
    على سبيل المثال:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """


def is_nested(string):
    '''
    أنشئ دالة تأخذ سلسلة نصية كمدخل تحتوي فقط على الأقواس المربعة. يجب أن تُرجع الدالة True إذا وفقط إذا كان هناك تسلسل فرعي صالح من الأقواس حيث يكون هناك قوس واحد على الأقل في التسلسل الفرعي مُتداخل.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''

def is_nested(string):
    '''قم بإنشاء دالة تأخذ سلسلة كمدخل تحتوي فقط على أقواس مربعة.
    يجب أن تعيد الدالة القيمة True إذا وفقط إذا كان هناك تسلسل فرعي صالح من الأقواس
    حيث يوجد قوس واحد على الأقل في التسلسل الفرعي متداخل.
    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''

def is_nested(string):
    '''
     قم بإنشاء دالة تتلقى سلسلة كمدخل والتي تحتوي فقط على أقواس مربعة.
    على الدالة ان تعيد True في حال فقط كان هناك سلسلة فرعية صحيحة من الأقواس
    حيث يوجد قوس واحد على الأقل متداخل.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''


def sum_squares(lst):
    """أنت مُعطى قائمة من الأرقام.
    تحتاج إلى إرجاع مجموع الأرقام المربعة في القائمة المعطاة،
    قم بتقريب كل عنصر في القائمة إلى العدد الصحيح الأعلى (السقف) أولاً.
    أمثلة:
    بالنسبة للقائمة lst = [1,2,3] يجب أن يكون الناتج 14
    بالنسبة للقائمة lst = [1,4,9] يجب أن يكون الناتج 98
    بالنسبة للقائمة lst = [1,3,5,7] يجب أن يكون الناتج 84
    بالنسبة للقائمة lst = [1.4,4.2,0] يجب أن يكون الناتج 29
    بالنسبة للقائمة lst = [-2.4,1,1] يجب أن يكون الناتج 6
    """


def check_if_last_char_is_a_letter(txt):
    '''
    إنشاء دالة تعيد True إذا كان الحرف الأخير
    من سلسلة معينة هو حرف أبجدي وليس جزءًا
    من كلمة، و False خلاف ذلك.
    ملاحظة: "الكلمة" هي مجموعة من الأحرف مفصولة بمسافة.

    أمثلة:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    كون  دالة تقوم بإعادة True في حال كون الحرف الأخير
    من سلسلة محددة هو حرف أبجدي وليس جزءًا
    من كلمة، و False  غير ذلك.
    حاشية: "الكلمة" عبارة مجموعة حروف مفصولة بمسافة.

    أمثلة:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    إنشئ دالة تعيد True إذا كان الحرف الأخير
    من سلسلة حروف معينة هو حرف أبجدي وليس جزءًا
    من كلمة، وتعيد False خلاف ذلك.
    ملاحظة: "الكلمة" هي مجموعة من الأحرف مفصولة بمسافة.

    أمثلة:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''


def can_arrange(arr):
    """أنشئ دالة تُعيد أكبر فهرس لعنصر غير أكبر من أو مساوٍ للعنصر الذي يسبقه مباشرةً.
    إذا لم يوجد مثل هذا العنصر، فإرجع -1. المصفوفة المعطاة لن تحتوي على قيم مكررة.

    أمثلة:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

:def can_arrange(arr)
    """قم بإنشاء دالة تعيد أكبر مكان (index) لعنصر لا يكون أكبر من أو يساوي العنصر الذي يسبقه مباشرة.
    إذا لم يوجد هذا العنصر، فقم بإرجاع -1. لن تحتوي المصفوفة المعطاة على قيم مكررة.

    أمثلة:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """أنشئ دالة ترجع الفهرس  الأكبر لعنصر لا يكون أكبر من أو مساويا للعنصر السابق له مباشرة.
    في حال لم يوجد مثل هذا العنصر، فقم بإعادة -1.  المصفوفة المعطاة لن تحوي قيما متكررة.

    أمثلة:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """


def largest_smallest_integers(lst):
    '''
    إنشاء دالة تُرجع زوج (a, b)، حيث أن 'a' هو
    الأكبر بين الأعداد الصحيحة السالبة، و 'b' هو الأصغر
    بين الأعداد الصحيحة الموجبة في القائمة.
    إذا لم يكن هناك أعداد صحيحة سالبة أو موجبة، قم بإرجاعها كـ None.

    أمثلة:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''

def largest_smallest_integers(lst):
    '''
    قم بإنشاء دالة تعيد مجموعة (a, b)، حيث 'a' هو
    أكبر عدد صحيح سالب، و'b' هو
    أصغر عدد صحيح موجب في القائمة.
    إذا لم يكن هناك أعداد صحيحة سالبة أو موجبة، فقم بإرجاعها على أنها None.

    أمثلة:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''

:def largest_smallest_integers(lst)
    '''
    قم بإنشاء دالة تُرجع زوج (a, b)، حيث أن 'a' هو
    الأكبر بين الأعداد الصحيحة السالبة، و 'b' هو الأصغر
    بين الأعداد الصحيحة الموجبة في القائمة.
    إذا لم يكن هناك أعداد صحيحة سالبة أو موجبة، قم بإرجاعها كـ None.

    أمثلة:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''


def compare_one(a, b):
    """
    قم بإنشاء دالة تأخذ أعداد صحيحة، أعداد عشرية، أو سلاسل نصية تمثل
    أعداد حقيقية، وتعيد المتغير الأكبر في نوع المتغير المعطى.
    أعد None إذا كانت القيم متساوية.
    ملاحظة: إذا تم تمثيل العدد الحقيقي كسلسلة نصية، قد تكون النقطة العشرية . أو ,

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """

def compare_one(a, b):
    """
    ابتكر دالة تستلم أعدادا صحيحة، أعدادا عشرية، أو سلاسل نصية تمثل
    أعدادا حقيقية، وترجع المتغير الأكبر في نوع المتغير الممنوح.
    أعد None إذا كانت القيم مساوية لبعضها.
    تعليق: إذا ما مثل العدد الحقيقي كسلسلة نصية، قد تكون النقطة العشرية . أو ,

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """


def is_equal_to_sum_even(n):
    """تقييم ما إذا كان العدد n المُعطى يمكن كتابته كمجموع 4 أعداد زوجية موجبة تمامًا
    مثال
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """تقييم ما إذا كان يمكن كتابة العدد المعطى n كمجموع 4 أعداد زوجية موجبة بالضبط
    مثال
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """قيم ما إذا كان بإمكان كتابة العدد المعطى n كحاصل مجموع  4 أعداد زوجية موجبة بالضبط
    مثال
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """


def special_factorial(n):
    """يتم تعريف العامل البرازيلي على النحو التالي:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    حيث n > 0

    على سبيل المثال:
    >>> special_factorial(4)
    288

    ستستقبل الدالة عددًا صحيحًا كمدخل ويجب أن تعيد العامل
    الخاص بهذا العدد الصحيح.
    """

def special_factorial(n):
    """يُعرّف المضروب البرازيلي على النحو التالي:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    حيث n > 0

    على سبيل المثال:
    >>> special_factorial(4)
    288

    ستستقبل الدالة عددًا صحيحًا كمدخل ويجب أن تعيد المضروب
    الخاص بهذا العدد الصحيح.
    """
    """


def fix_spaces(text):
    """
    معطى سلسلة نصية text، استبدل كافة المسافات فيها بشرطات سفلية،
    وإذا كانت السلسلة تضم أكثر من مسافتين متتاليتين،
    فاستبدل كل  المسافات المتتالية بعلامة -

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """

def fix_spaces(text):
    """
    بالنظر إلى سلسلة نصية text، استبدل جميع المسافات فيها بشرطات سفلية،
    وإذا كانت السلسلة تحتوي على أكثر من مسافتين متتاليتين،
    فاستبدل جميع المسافات المتتالية بعلامة -

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """

def fix_spaces(text):
    """
    بالنظر إلى نص نصي، استبدل جميع المسافات فيه بشرطات سفلية،
    وإذا كان النص يحتوي على أكثر من مسافتين متتاليتين،
    استبدل جميع المسافات المتتالية بشرطة (-)

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """


def file_name_check(file_name):
    """قم بإنشاء دالة تأخذ سلسلة نصية تمثل اسم ملف، وتعيد
    'Yes' إذا كان اسم الملف صالحًا، وتعيد 'No' خلاف ذلك.
    يعتبر اسم الملف صالحًا إذا وفقط إذا تم استيفاء جميع الشروط التالية:
    - يجب ألا يكون هناك أكثر من ثلاثة أرقام ('0'-'9') في اسم الملف.
    - يحتوي اسم الملف على نقطة واحدة فقط '.'
    - يجب ألا تكون السلسلة النصية الفرعية قبل النقطة فارغة، ويجب أن تبدأ بحرف من
    الأبجدية اللاتينية ('a'-'z' و 'A'-'Z').
    - يجب أن تكون السلسلة الفرعية بعد النقطة واحدة من هذه: ['txt', 'exe', 'dll']
    أمثلة:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (يجب أن يبدأ الاسم بحرف من الأبجدية اللاتينية)
    """

def file_name_check(file_name):
    """قم بإنشاء دالة تأخذ سلسلة تمثل اسم الملف، وتعيد
    'نعم' إذا كان اسم الملف صالحًا، وتعيد 'لا' بخلاف ذلك.
    يعتبر اسم الملف صالحًا إذا وفقط إذا تم استيفاء جميع الشروط التالية:
    - يجب ألا يزيد عدد الأرقام في اسم الملف عن ثلاثة أرقام ('0'-'9').
    - يحتوي اسم الملف على نقطة واحدة فقط '.'
    - يجب ألا يكون السلسلة الفرعية قبل النقطة فارغة، ويجب أن تبدأ بحرف من الأبجدية اللاتينية ('a'-'z' و'A'-'Z').
    - يجب أن تكون السلسلة الفرعية بعد النقطة واحدة من هذه: ['txt', 'exe', 'dll']
    أمثلة:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (يجب أن يبدأ الاسم بحرف من الأبجدية اللاتينية)
    """

def file_name_check(file_name):
    """إنشاء دالة تأخذ سلسلة تمثل اسم ملف، وتعيد
    'Yes' إذا كان اسم الملف صالحًا، وتعيد 'No' خلاف ذلك.
    يعتبر اسم الملف صالحًا إذا وفقط إذا تم استيفاء جميع الشروط التالية:
    - يجب ألا يكون هناك أكثر من ثلاثة أرقام ('0'-'9') في اسم الملف.
    - يحتوي اسم الملف على نقطة واحدة فقط '.'
    - يجب ألا تكون السلسلة الفرعية قبل النقطة فارغة، ويجب أن تبدأ بحرف من
    الأبجدية اللاتينية ('a'-'z' و 'A'-'Z').
    - يجب أن تكون السلسلة الفرعية بعد النقطة واحدة من هذه: ['txt', 'exe', 'dll']
    أمثلة:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (يجب أن يبدأ الاسم بحرف من الأبجدية اللاتينية)
    """


def sum_squares(lst):
    """"
    هذه الدالة ستأخذ قائمة من الأعداد الصحيحة. لكل عنصر في القائمة، ستقوم الدالة بتربيع العنصر إذا كان فهرسه
    مضاعفًا للعدد 3 وستقوم بتكعيب العنصر إذا كان فهرسه مضاعفًا للعدد 4 وليس مضاعفًا للعدد 3. لن تقوم الدالة
    بتغيير العناصر في القائمة التي ليست فهارسها مضاعفات للعدد 3 أو 4. ثم ستقوم الدالة بإرجاع مجموع كل العناصر.

    أمثلة:
    للقائمة lst = [1,2,3] يجب أن يكون الناتج 6
    للقائمة lst = [] يجب أن يكون الناتج 0
    للقائمة lst = [-1,-5,2,-1,-5] يجب أن يكون الناتج -126
    """

:def sum_squares(lst)
    """"
    هذه الدالة ستأخذ قائمة من الأعداد الصحيحة. لكل عنصر في القائمة، ستقوم الدالة بتربيع العنصر إذا كان رقمه في الترتيب
    مضاعفًا للعدد 3 وستقوم بتكعيب العنصر إذا كان رقمه في الترتيب مضاعفًا للعدد 4 وليس مضاعفًا للعدد 3. لن تقوم الدالة
    بتغيير العناصر في القائمة التي ليست مضاعفًا للعدد 3 أو 4. ثم ستقوم الدالة بإرجاع مجموع كل العناصر.

    أمثلة:
    للقائمة lst = [1,2,3] يجب أن يكون الناتج 6
    للقائمة lst = [] يجب أن يكون الناتج 0
    للقائمة lst = [-1,-5,2,-1,-5] يجب أن يكون الناتج -126
    """

def sum_squares(lst):
    """"
    هذه الدالة ستقوم بأخذ قائمة من أعداد صحيحة. لكل  عناصر القائمة، الدالة ستقوم بتربيع العنصر في حال كون فهرسه
    مضاعفًا للعدد 3 وستقوم بتكعيب العنصر إذا كان فهرسه مضاعفًا للعدد 4 وليس مضاعفًا للعدد 3. الدالة
    لن تقوم بتغيير عناصر القائمة التي ليست مضاعفًا للعدد 3 أو 4. ثم ستعيد الدالة مجموع كل العناصر

    أمثلة:
    للقائمة lst = [1,2,3]  الناتج يجب أن يكون  6
    للقائمة lst = []  الناتج يجب أن يكون  0
    للقائمة lst = [-1,-5,2,-1,-5]  الناتج يجب أن يكون  -126
    """


def words_in_sentence(sentence):
    """
    لديك سلسلة تمثل جملة,
    تحتوي الجملة على بعض الكلمات مفصولة بمسافة,
    وعليك إرجاع سلسلة تحتوي على الكلمات من الجملة الأصلية,
    التي تكون أطوالها أعدادًا أولية,
    يجب أن يكون ترتيب الكلمات في السلسلة الجديدة هو نفسه ترتيب الكلمات في السلسلة الأصلية.

    مثال 1:
        Input: sentence = "This is a test"
        Output: "is"

    مثال 2:
        Input: sentence = "lets go for swimming"
        Output: "go for"

    القيود:
        * 1 <= len(sentence) <= 100
        * تحتوي الجملة على حروف فقط    """

def words_in_sentence(sentence):
    """
    أعطيت سلسلة تمثل جملة،
    تضم الجملة بعضا من الكلمات متباعدة بمسافة،
    وعليك إعادة سلسلة تشمل الكلمات من الجملة الأساسية،
    والتي  أطوالها أعداد أولية
    على ترتيب الكلمات في السلسلة الجديدة أن يكون كما الأصل.

    المثال 1:
        Input: sentence = "This is a test"
        Output: "is"

    المثال 2:
        Input: sentence = "lets go for swimming"
        Output: "go for"

    القيود:
        * 1 <= len(sentence) <= 100
        * تحتوي الجملة على حروف فقط
    """

def words_in_sentence(sentence):
    """
    لديك سلسلة تمثل جملة،
    تحتوي الجملة على بعض الكلمات مفصولة بمسافة،
    وعليك إرجاع سلسلة تحتوي على الكلمات من الجملة الأصلية،
    التي تكون أطوالها أعداد أولية،
    يجب أن يكون ترتيب الكلمات في السلسلة الجديدة كما هو في الأصل.

    المثال 1:
        Input: sentence = "This is a test"
        Output: "is"

    المثال 2:
        Input: sentence = "lets go for swimming"
        Output: "go for"

    القيود:
        * 1 <= len(sentence) <= 100
        * تحتوي الجملة على حروف فقط
    """


def simplify(x, n):
    """مهمتك هي تنفيذ دالة تقوم بتبسيط التعبير x * n. تقوم الدالة بإرجاع True إذا كانت x * n تقيّم إلى عدد صحيح و False خلاف ذلك.
    كل من x و n هما تمثيل نصي لكسر، ويكون لهما التنسيق التالي،
    <البسط>/<المقام> حيث يكون كل من البسط والمقام أعداد صحيحة موجبة.

    يمكنك افتراض أن x و n هما كسور صالحة، ولا يحتويان على صفر كمقام.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """

def simplify(x, n):
    """مهمتك هي تنفيذ دالة تقوم بتبسيط التعبير
    x * n. تقوم الدالة بإرجاع True إذا كانت x * n تقيّم إلى عدد صحيح و False
    خلاف ذلك. كل من x و n، هما تمثيل نصي لكسر، ويكون لهما التنسيق التالي،
    <numerator>/<denominator> حيث يكون كل من البسط والمقام أعداد صحيحة موجبة.

    يمكنك افتراض أن x، و n هما كسور صالحة، ولا يحتويان على صفر كمقام.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """

def simplify(x, n):
    """مهمتك هي تنفيذ دالة من شأنها تبسيط التعبير
    x * n. تعيد الدالة القيمة True إذا تم تقييم x * n إلى عدد صحيح وقيمة False
    بخلاف ذلك. يمثل كل من x وn، تمثيلًا نصيًا لكسر، ولهما التنسيق التالي،
    <numerator>/<denominator> حيث يكون كل من البسط والمقام أعدادًا صحيحة موجبة.

    يمكنك افتراض أن x وn عبارة عن كسرين صالحين، ولا يوجد صفر في المقام.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """


def order_by_points(nums):
    """
    اكتب دالة تقوم بترتيب قائمة الأعداد الصحيحة المعطاة
    بترتيب تصاعدي وفقًا لمجموع أرقامها.
    ملاحظة: إذا كان هناك عدة عناصر لها نفس مجموع الأرقام،
    قم بترتيبها بناءً على موقعها في القائمة الأصلية.

    على سبيل المثال:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """

    اكتب دالة تقوم بفرز القائمة المعطاة من الأعداد الصحيحة
    بترتيب تصاعدي وفقًا لمجموع أرقامها.

    ملاحظة: إذا كان هناك عدة عناصر لها مجموع مماثل لأرقامها،
    فرتبها بناءً على مؤشرها في القائمة الأصلية.

    على سبيل المثال:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

:def order_by_points(nums)
    """
    اكتب دالة تقوم بترتيب قائمة الأعداد الصحيحة المعطاة
    بترتيب تصاعدي وفقًا لمجموع الارقام الموجودة في خانات كل رقم.
    ملاحظة: إذا كان هناك عدة عناصر لها نفس مجموع الأرقام،
    قم بترتيبها بناءًا على موقعها في القائمة الأصلية.

    على سبيل المثال:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """


def specialFilter(nums):
    """اكتب دالة تأخذ مصفوفة من الأرقام كمدخل وتعيد عدد العناصر في المصفوفة
    التي تكون أكبر من 10 وكلا الرقمين الأول والأخير للعدد فرديين (1، 3، 5، 7، 9).
    على سبيل المثال:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """قم بكتابة دالة تقوم بأخذ سلسلة أرقام كمدخل وتقوم بإرجاع عدد العناصر في المصفوفة
    الأكبر من 10 والرقمان الأول والأخير للعدد كللهما فردي (1، 3، 5، 7، 9)
    فمثلا:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

:def specialFilter(nums)
    """اكتب دالة تأخذ مصفوفة من الأرقام وتقوم بإرجاع عدد عناصر المصفوفة
    الأكبر من 10 وكلا الخانتين الأولى والأخيرة للعدد فرديتان (1، 3، 5، 7، 9).
    على سبيل المثال:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """


def get_max_triples(n):
    """
    لديك عدد صحيح موجب n. يجب عليك إنشاء مصفوفة أعداد صحيحة a بطول n.
        لكل i (1 ≤ i ≤ n)، قيمة a[i] = i * i - i + 1.
        أعد عدد الثلاثيات (a[i], a[j], a[k]) من a حيث i < j < k،
    و a[i] + a[j] + a[k] هو مضاعف لـ 3.

    مثال:
        Input: n = 5
        Output: 1
        Explanation:
        a = [1, 3, 7, 13, 21]
        The only valid triple is (1, 7, 13).
    """

:def get_max_triples(n)
    """
    لديك عدد صحيح موجب يدعى n. يجب عليك إنشاء مصفوفة أعداد صحيحة تدعى a بطول n.
        لكل قيمة ل i (1 ≤ i ≤ n)، قيمة a[i] = i * i - i + 1.
        قم بإعادة عدد الثلاثيات (a[i], a[j], a[k]) من a حيث i < j < k،
    و a[i] + a[j] + a[k] هو مضاعف لـ 3.

    مثال:
        المدخل: n = 5
        المخرج: 1
        التوضيح:
        a = [1, 3, 7, 13, 21]
        الثلاثية الصالحة الوحيدة هي (1, 7, 13).
    """

def get_max_triples(n):
    """
    يتم إاعطائك عدد صحيح موجب و عليك إنشاء مجموعه أعداد صحيحه طولها n
        لكل i (1 ≤ i ≤ n)، قيمة a[i] = i * i - i + 1.
        أرجع عدد الثلاثيات (a[i], a[j], a[k]) من a حيث i < j < k،
    و a[i] + a[j] + a[k] هو مضاعف لـ 3.

    مثال:
        المدخل: n = 5
        المخرج: 1
        التوضيح:
        a = [1, 3, 7, 13, 21]
        الثلاثية الصالحة الوحيدة هي (1, 7, 13).
    """


def bf(planet1, planet2):
    '''

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

    اكتب دالة تأخذ اسمين لكوكبين كسلاسل planet1 وplanet2.

    يجب أن تعيد الدالة مجموعة تحتوي على جميع الكواكب التي تقع مداراتها بين مدار planet1 ومدار planet2، مرتبة حسب
    القرب من الشمس.

    يجب أن تعيد الدالة مجموعة فارغة إذا لم يكن planet1 أو planet2
    أسماء كواكب صحيحة.
    أمثلة
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

:def bf(planet1, planet2)
    '''
    هناك ثمانية كواكب في نظامنا الشمسي: الأقرب إلى الشمس
    هو عطارد، يليه الزهرة، ثم الأرض، المريخ، المشتري، زحل،
    أورانوس، نبتون.
    اكتب دالة تأخذ اسمين لكوكبين كسلاسل نصية planet1 و planet2.
    يجب أن تعيد الدالة مجموعة (tuple) تحتوي على جميع الكواكب التي تقع مداراتها
    بين مدار planet1 ومدار planet2، مرتبة حسب القرب من الشمس.
    يجب أن تعيد الدالة مجموعة فارغة إذا كان planet1 أو planet2
    ليسا أسماء كواكب صحيحة.
    أمثلة
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    هناك ثمانية كواكب في نظامنا الشمسي: الأقرب إلى الشمس
    هو عطارد، يليه الزهرة، ثم الأرض، المريخ، المشتري، زحل،
    أورانوس، نبتون.
    اكتب دالة تأخذ اسمين لكوكبين كسلاسل نصية planet1 و planet2.
    يجب أن تعيد الدالة مجموعة تحتوي على جميع الكواكب التي تقع مداراتها
    بين مدار planet1 ومدار planet2، مرتبة حسب القرب من الشمس.
    يجب أن تعيد الدالة مجموعة فارغة إذا كان planet1 أو planet2
    ليسا أسماء كواكب صحيحة.
    أمثلة
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''


def sorted_list_sum(lst):
    """اكتب دالة تقبل قائمة من السلاسل النصية كمعامل،
    تحذف السلاسل التي تحتوي على أطوال فردية،
    وتُرجع القائمة الناتجة بترتيب مرتب،
    القائمة دائمًا هي قائمة من السلاسل النصية وليست مصفوفة من الأرقام،
    وقد تحتوي على عناصر مكررة.
    يجب أن يكون ترتيب القائمة تصاعديًا بناءً على طول كل كلمة،
    ويجب أن تُرجع القائمة مرتبة وفقًا لهذه القاعدة.
    إذا كانت هناك كلمتين بنفس الطول، رتب القائمة أبجديًا.
    يجب أن تُرجع الدالة قائمة من السلاسل النصية بالترتيب المرتب.
    يمكنك افتراض أن جميع الكلمات ستكون بنفس الطول.
    على سبيل المثال:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """اكتب دالة تقبل قائمة من السلاسل النصية كمعامل،
    تحذف السلاسل النصية التي لها أطوال فردية منها،
    وتعيد القائمة الناتجة بترتيب مرتب،
    القائمة دائمًا تكون قائمة من السلاسل النصية وليست مصفوفة من الأرقام،
    وقد تحتوي على تكرارات.
    يجب أن يكون ترتيب القائمة تصاعديًا حسب طول كل كلمة، ويجب عليك
    إعادة القائمة مرتبة حسب هذه القاعدة.
    إذا كان لكلمتين نفس الطول، قم بترتيب القائمة أبجديًا.
    يجب أن تعيد الدالة قائمة من السلاسل النصية بترتيب مرتب.
    يمكنك افتراض أن جميع الكلمات سيكون لها نفس الطول.
    على سبيل المثال:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """قم بكتابة دالة تقبل قائمة من سلاسل النصوص كمعامل،
    وتزيل السلاسل النصية التي لها أطوال فردية منها،
    وترجع القائمة الناتجة مرتبة.
    تكون القائمة دائمًا قائمة من سلاسل النصوص وليس مصفوفة من الأرقام
    وقد تضم تكرارات.
    يجب أن تكون القائمة مرتبة تصاعديًا وفقًا لطول كل كلمة، وعليك
    إعادة القائمة مرتبة وفقًا لهذه القاعدة.
    إذا كان لدى كلمتين الطول نفسه ، رتب القائمة أبجديًا.
    على الدالة أن تعيد قائمة من السلاسل النصية مرتبة.
    يمكنك افتراض أن جميع الكلمات ستكون بنفس الطول.
    على سبيل المثال:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """برنامج بسيط يجب أن يعيد قيمة x إذا كان n
    عددًا أوليًا ويجب أن يعيد قيمة y خلاف ذلك.

    أمثلة:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """برنامج بسيط يجب أن يرجع قيمة x إذا كان n عددًا أوليًا ويجب أن يرجع قيمةy إذا كان غير ذلك

    الأمثلة:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """


def double_the_difference(lst):
    '''
    تم إعطاؤك قائمة من الأرقام، أرجع مجموع مربعات الأرقام
    في القائمة التي هي فردية. تجاهل الأرقام التي هي سالبة أو ليست أعداد صحيحة.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    إذا كانت القائمة المدخلة فارغة، قم بإرجاع 0.
    '''

def double_the_difference(lst):
    '''
    بالنظر إلى قائمة من الأرقام، قم بإرجاع مجموع مربعات الأرقام
    في القائمة التي هي فردية. تجاهل الأرقام التي هي سالبة أو ليست أعداد صحيحة.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    إذا كانت القائمة المدخلة فارغة، قم بإرجاع 0.
    '''

def double_the_difference(lst):
    '''
     أنت معطى لائحة أرقام، قم بإستعادة مجموع مربعات الأرقام الفردية
    في القائمة. تجاهل الأرقام  السالبة أو التي ليست أعدادا صحيحة.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    في حال كانت القائمة المدخلة فارغة، أرجع 0.
    '''


def compare(game,guess):
    """أعتقد أننا جميعًا نتذكر ذلك الشعور عندما تُعرف نتيجة حدث طال انتظاره.
    المشاعر والأفكار التي لديك في تلك اللحظة تستحق بالتأكيد التدوين والمقارنة.
    مهمتك هي تحديد ما إذا كان الشخص قد خمن نتائج عدد من المباريات بشكل صحيح.
    يتم إعطاؤك مصفوفتين من الدرجات والتخمينات بنفس الطول، حيث يُظهر كل مؤشر مباراة.
    أعد مصفوفة بنفس الطول تشير إلى مدى بعد كل تخمين. إذا كانوا قد خمنوا بشكل صحيح،
    تكون القيمة 0، وإذا لم يكن كذلك، تكون القيمة هي الفرق المطلق بين التخمين والنتيجة.

    مثال:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """

:def compare(game,guess)
    """أعتقد أننا جميعًا نتذكر ذلك الشعور عندما نعرف أخيرا نتيجة حدث طال انتظاره.
    المشاعر والأفكار التي تتملكك في تلك اللحظة بالتأكيد تستحق التدوين والمقارنة.
    مهمتك هي تحديد ما إذا كان الشخص قد خمن نتائج عدد من المباريات بشكل صحيح.
    يتم إعطاؤك مصفوفتين من النتائج والتخمينات كلاهما بنفس الطول، حيث يُظهر كل مؤشر مباراة.
    أعد مصفوفة بنفس الطول تشير إلى مدى بعد كل تخمين عن النتيجة الصحيحة. إذا كانوا قد خمنوا النتيجة بشكل صحيح،
    تكون القيمة 0، وإذا لم يكن كذلك، تكون القيمة هي الفرق المطلق بين التخمين والنتيجة.

    مثال:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """

def compare( game,guess):
    ””“"أعتقد أننا جميعًا نتذكر ذلك الشعور عندما تُعرف أخيرًا نتيجة حدث طال انتظاره
    أخيرًا. فالمشاعر والأفكار التي تراودك في تلك اللحظة
    بالتأكيد تستحق التدوين والمقارنة.
    مهمتك هي تحديد ما إذا كان الشخص قد خمّن بشكل صحيح نتائج عدد من المباريات.
    لديك مصفوفتان من النتائج والتخمينات متساويتان في الطول، حيث يُمثِّل كل عنصر منهما مباراة.
    قم بإرجاع مصفوفة بنفس الطول تدل على مدى بُعد كل تخمين عن الآخر. إذا كان التخمين صحيحًا
    فالقيمة هي 0، وإن لم يكن كذلك، فالقيمة هي الفرق المطلق بين التخمين والنتيجة.

    مثال
    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]


def Strongest_Extension(class_name, extensions):
    """سيتم إعطاؤك اسم فئة (سلسلة نصية) وقائمة من الامتدادات.
    تُستخدم الامتدادات لتحميل فئات إضافية إلى الفئة. قوة الامتداد هي كما يلي:
    لنفترض أن CAP هو عدد الأحرف الكبيرة في اسم الامتداد، و SM هو عدد الأحرف الصغيرة
    في اسم الامتداد، تُعطى القوة بالكسور CAP - SM.
    يجب عليك العثور على أقوى امتداد وإرجاع سلسلة نصية بهذا
    التنسيق: ClassName.StrongestExtensionName.
    إذا كان هناك امتدادان أو أكثر بنفس القوة، يجب عليك
    اختيار الامتداد الذي يأتي أولاً في القائمة.
    على سبيل المثال، إذا تم إعطاؤك "Slices" كفئة وقائمة من
    الامتدادات: ['SErviNGSliCes', 'Cheese', 'StuFfed'] فيجب عليك
    إرجاع 'Slices.SErviNGSliCes' لأن 'SErviNGSliCes' هو أقوى امتداد
    (قوته هي -1).
    مثال:
    لـ Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """سيتم إعطاؤك اسم فئة (سلسلة نصية) وقائمة من الامتدادات.
    تُستخدم الامتدادات لتحميل فئات إضافية إلى الفئة. قوة الامتداد هي كما يلي:
    لنفترض أن CAP هو عدد الأحرف الكبيرة في اسم الامتداد، و SM هو عدد الأحرف الصغيرة
    في اسم الامتداد، تُعطى القوة بالجزء CAP - SM.
    يجب عليك العثور على أقوى امتداد وإرجاع سلسلة نصية بهذا
    التنسيق: ClassName.StrongestExtensionName.
    إذا كان هناك امتدادان أو أكثر بنفس القوة، يجب عليك
    اختيار الامتداد الذي يأتي أولاً في القائمة.
    على سبيل المثال، إذا تم إعطاؤك "Slices" كفئة وقائمة من
    الامتدادات: ['SErviNGSliCes', 'Cheese', 'StuFfed'] فيجب عليك
    إرجاع 'Slices.SErviNGSliCes' لأن 'SErviNGSliCes' هو أقوى امتداد
    (قوته هي -1).
    مثال:
    لـ Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """سيتم إعطاؤك اسم فئة (سلسلة) وقائمة بالامتدادات.
    ستُستخدم الامتدادات لتحميل فئات إضافية للفئة.
    قوة الامتداد هي كما يلي: دع CAP يكون عدد الأحرف الكبيرة
    في اسم الامتداد، ودع SM يكون عدد الأحرف الصغيرة
    في اسم الامتداد، تُعطى القوة بواسطة الكسر CAP - SM.

    يجب أن تجد أقوى امتداد وتعيد سلسلة بهذا التنسيق: ClassName.StrongestExtensionName.
    إذا كان هناك امتدادان أو أكثر بنفس القوة، فيجب عليك
    اختيار الامتداد الذي يأتي أولاً في القائمة.
    على سبيل المثال، إذا تم إعطاؤك "Slices" كفئة وقائمة بالامتدادات: ['SErviNGSliCes', 'Cheese', 'StuFfed']، فيجب عليك
    إرجاع 'Slices.SErviNGSliCes' لأن 'SErviNGSliCes' هو الامتداد الأقوى
    (قوته -1).
    مثال:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """


def cycpattern_check(a , b):
    """تم إعطاؤك كلمتين. يجب عليك إعادة True إذا كانت الكلمة الثانية أو أي من دوراناتها سلسلة فرعية من الكلمة الأولى
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True
    """

:def cycpattern_check(a , b)
    """يتم إعطاؤك كلمتين. تحتاج إلى إرجاع True إذا كانت الكلمة الثانية أو أي من دوراناتها هي جزء من الكلمة الأولى
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """أنت مُعطى كلمتين. تحتاج إلى إرجاع True إذا كانت الكلمة الثانية أو أي من دوراتها هي جزء من الكلمة الأولى
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """


def even_odd_count(num):
    """معطى عدد صحيح. إرجاع زوج يحتوي على عدد الأرقام الزوجية والفردية على التوالي.

     مثال:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """تم إعطاؤك عددًا صحيحًا. أرجع زوجًا مرتبًا يحتوي على عدد الأرقام الزوجية والفردية على التوالي.

     مثال:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """بالنظر إلى عدد صحيح، أرجع مجموعة تحتوي على عدد الأرقام الزوجية والفردية على التوالي.

     مثال:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """


def int_to_mini_roman(number):
    """
    قم بتحويل عدد صحيح موجب إلى معادلته بالأرقام الرومانية، وأرجعها على شكل سلسلة نصية بأحرف صغيرة.
    القيود: 1 <= num <= 1000

    الأمثلة:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    في حالة وجود عدد صحيح موجب، احصل على ما يعادله من الأرقام الرومانية كسلسلة،
    وأعده بأحرف صغيرة.
    القيود: 1 <= num <= 1000

    الأمثلة:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    بالنظر إلى عدد صحيح موجب، احصل على مكافئه بالأرقام الرومانية كسلسلة نصية،
    وأعدها بحروف صغيرة.
    القيود: 1 <= num <= 1000

    أمثلة:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """


def right_angle_triangle(a, b, c):
    '''
    بالنظر إلى أطوال الأضلاع الثلاثة للمثلث. أرجع True إذا كانت
    أضلاعه الثلاثة تشكل مثلثًا قائم الزاوية، وإلا تكون الإجابة False.
    المثلث القائم الزاوية هو مثلث تكون فيه زاوية واحدة قائمة أو
    90 درجة.
    مثال:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    معطى أطوال الأضلاع الثلاثة لمثلث. أعد True إذا كانت الأضلاع الثلاثة
    تكون مثلثًا قائم الزاوية. False  غير ذلك.
    المثلث القائم الزاوية هو مثلث تكون فيه إحدى الزوايا زاوية قائمة أو
    90 درجة.
    مثال:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

:right_angle_triangle(a, b, c)
    '''
    بالنظر إلى أطوال الأضلاع الثلاثة لمثلث. قم بإرجاع True إذا كانت الأضلاع الثلاثة
    تشكل مثلثًا قائم الزاوية،وقم بإرجاع False خلاف ذلك.
    المثلث القائم الزاوية هو مثلث يكون فيه أحد الزوايا زاوية قائمة أو
    90 درجة.
    مثال:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''


def find_max(words):
    """اكتب دالة تقبل قائمة من السلاسل النصية.
    تحتوي القائمة على كلمات مختلفة. قم بإرجاع الكلمة التي تحتوي على أكبر عدد من الحروف الفريدة.
    إذا كانت هناك كلمات متعددة تحتوي على نفس العدد الأقصى من الحروف الفريدة،
    قم بإرجاع الكلمة التي تأتي أولاً في الترتيب الأبجدي.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == "aaaaaaa"
    """

def find_max(words):
    """اكتب دالة تقبل قائمة من النصوص
    تحتوي القائمة على كلمات مختلفة. أعد الكلمة التي تحتوي على أكبر عدد
    من الأحرف الفريدة. إذا كانت هناك عدة نصوص تحتوي على أكبر عدد من الأحرف الفريدة،
    أعد الكلمة التي تأتي أولاً في الترتيب الأبجدي.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """

def find_max(words):
    """اكتب دالة تقبل قائمة من السلاسل النصية.
    تحتوي القائمة على كلمات مختلفة. أعد الكلمة التي تحتوي على أكبر عدد
    من الأحرف الفريدة. إذا كانت هناك عدة سلاسل تحتوي على أكبر عدد من الأحرف الفريدة،
    أعد الكلمة التي تأتي أولاً في الترتيب الأبجدي.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """


def eat(number, need, remaining):
    """
    أنت أرنب جائع، وقد أكلت بالفعل عددًا معينًا من الجزر،
    ولكن الآن تحتاج إلى أكل المزيد من الجزر لإكمال وجبات اليوم.
    يجب أن تعيد مصفوفة تحتوي على [ إجمالي عدد الجزر المأكول بعد وجباتك،
                                      عدد الجزر المتبقي بعد وجباتك ]
    إذا لم يكن هناك ما يكفي من الجزر المتبقي، ستأكل كل الجزر المتبقي، ولكن ستظل جائعًا.

    مثال:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    المتغيرات:
    @number : عدد صحيح
        عدد الجزر الذي أكلته.
    @need : عدد صحيح
        عدد الجزر الذي تحتاج إلى أكله.
    @remaining : عدد صحيح
        عدد الجزر المتبقي الموجود في المخزون

    القيد:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    استمتع :)
    """

def eat(number, need, remaining):
    """
    أنت أرنب جائع، وقد أكلت بالفعل عددًا معينًا من الجزر،
    ولكنك الآن بحاجة إلى أكل المزيد من الجزر لإكمال وجبات اليوم.
    يجب عليك إرجاع مجموعة من [ العدد الإجمالي للجزر الذي أكلته بعد وجباتك،
    عدد الجزر المتبقي بعد وجباتك ]
    إذا لم يكن هناك ما يكفي من الجزر المتبقي، فسوف تأكل كل الجزر المتبقي، ولكنك ستظل جائعًا.

    مثال:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    المتغيرات:
    @number : عدد صحيح
        عدد الجزر الذي أكلته.
    @need : عدد صحيح
        عدد الجزر الذي تحتاج إلى أكله.
    @remaining : عدد صحيح
        عدد الجزر المتبقي الموجود في المخزن

    القيد:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    استمتع :)
    """


def do_algebra(operator, operand):
    """
    بالنظر إلى قائمتين: operator و operand. القائمة الأولى تحتوي على العمليات الجبرية الأساسية،
    والقائمة الثانية تحتوي على أعداد صحيحة. استخدم القائمتين لبناء التعبير الجبري
    وأعد ناتج تقييم هذا التعبير.

    العمليات الجبرية الأساسية:
    الجمع ( + )
    الطرح ( - )
    الضرب ( * )
    القسمة الصحيحة ( // )
    الأس ( ** )

    مثال:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    ملاحظات:
        طول قائمة operator يساوي طول قائمة operand ناقص واحد.
        قائمة operand تحتوي على أعداد صحيحة غير سالبة.
        تحتوي قائمة operator على عملية واحدة على الأقل، وتحتوي قائمة operand على عنصرين على الأقل.
    """

def do_algebra(operator, operand):
    ”"“
    بمعلومية قائمتين عامل ومعامل. تحتوي القائمة الأولى على عمليات الجبر الأساسية، و
    القائمة الثانية هي قائمة من الأعداد الصحيحة. استخدم القائمتين المُقدّمتين لإنشاء التعبير الجبري
    وأعد قيمة هذا التعبير.

    العمليات الجبرية الأساسية
    الجمع ( + )
    الطرح ( - )
    الضرب ( * )
    القسمة الطابقية ( // )
    الأس ( ** )

    مثال:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

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

    ”"“

def do_algebra(operator, operand):
    """
    بمعلومية قائمتين عامل ومعامل. تحتوي القائمة الأولى على عمليات الجبر الأساسية، و
    القائمة الثانية قائمة من الأعداد الصحيحة. استخدِم القائمتين المُعطاتين لبناء التعبير الجبري
    وإرجاع تقييم هذا التعبير.

    العمليات الجبرية الأساسية
    الجمع ( + )
    الطرح ( - )
    الضرب ( * )
    القسمة الطابقية ( // )
    الأس ( ** )

    مثال:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

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

    """


def solve(s):
    """لديك سلسلة s.
    إذا كانت s[i] حرفًا، فقم بعكس حالتها من حالة الأحرف الصغيرة إلى الكبيرة أو العكس,
    وإلا احتفظ بها كما هي.
    إذا كانت السلسلة لا تحتوي على أحرف، فقم بعكس السلسلة.
    يجب أن تُعيد الدالة السلسلة الناتجة.
    أمثلة
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """أنت مُعطى سلسلة نصية s.
    إذا كان الرمز المؤشَّر عليه حرفًا، قم بعكس حالته من صغير إلى كبير أو العكس، وإلا فاتركه كما هو. إذا كانت السلسلة لا تحتوي على حروف، قم بعكس ترتيب الحروف في السلسلة. يجب أن تُرجع الدالة السلسلة الناتجة.
    أمثلة
    "solve("1234") = "4321"
    "solve("ab") = "AB"
    "solve("#a@C") = "#A@c"
    """

:def solve(s)
    """باعتبار وجود سلسلة نصية s.
    إذا كان s[i] حرفًا، قم بعكس حالته من صغير إلى كبير أو العكس،
    وإلا فاتركه كما هو.
    إذا كانت السلسلة لا تحتوي على حروف، قم بعكس السلسلة.
    يجب أن تُرجع الدالة السلسلة الناتجة.
    أمثلة
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """


def string_to_md5(text):
    """
    بالنظر إلى سلسلة 'text'، أعد سلسلة تجزئة md5 المكافئة لها.
    إذا كانت 'text' سلسلة فارغة، أعد None.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """

تعريف الدالة string_to_md5(text)
    """
    بالنظر إلى  السلسلة 'text'، أعد السلسلة المشفرة md5 المكافئة لها.
    إذا كانت 'text' سلسلة فارغة، قم بإرجاع None.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """

def string_to_md5(text):
    """
    معطى سلسلة 'text'، أرجع سلسلة تجزئة md5 المكافئة لها.
    في حال كانت 'text' سلسلة شاغرة، أعد None.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """


def generate_integers(a, b):
    """
    إذا كان لدينا عددان صحيحان موجبان a وb، فأرجع الأرقام الزوجية بين a
    و b، بترتيب تصاعدي.

    على سبيل المثال:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

def generate_integers(a, b):
    """
    بفرض وجود عددين صحيحين موجبين a و b، عليك بإعادة  الأرقام الزوجية بين a
    و b، مرتبين تصاعديا.

    على سبيل المثال:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

def generate_integers(a, b):
    """
    بالنظر إلى عددين صحيحين موجبين a و b، قم بإرجاع الأرقام الزوجية بين a
    و b، بترتيب تصاعدي.

    على سبيل المثال:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """