from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ قم بالتحقق مما إذا كان أي رقمين في القائمة الممنوحة أقرب إلى بعضهما بعضا من
    الحد المعطى.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ تحقق مما إذا كانت هناك أي أرقام في القائمة المعطاة أقرب إلى بعضها البعض من
    العتبة المعطاة.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ تحقق مما إذا كانت هناك في القائمة المعطاة أرقام قريبة من بعضها البعض أكثر من
    الحد المعطى.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """


from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ المدخل لهذه الدالة هو سلسلة تحتوي على مجموعات متعددة من الأقواس المتداخلة. هدفك هو
    فصل تلك المجموعات إلى سلاسل منفصلة وإرجاع قائمة بها.
    المجموعات المنفصلة متوازنة (كل قوس مفتوح مغلق بشكل صحيح) وليست متداخلة داخل بعضها البعض
    تجاهل أي مسافات في سلسلة المدخلات.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    ”"“ مدخلات هذه الدالة هي سلسلة تحتوي على مجموعات متعددة من الأقواس المتداخلة. هدفك هو
    فصل تلك المجموعات إلى سلاسل منفصلة وإرجاع قائمة بها.
    تكون المجموعات المنفصلة متوازنة (كل قوس مفتوح يكون مغلقًا بشكل صحيح) وغير متداخلة داخل بعضها البعض
    تجاهل أي مسافات في سلسلة الإدخال.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    "" المدخل إلى هذه الدالة عبارة عن سلسلة تحتوي على مجموعات متعددة من الأقواس المتداخلة. هدفك هو
    فصل هذه المجموعة إلى سلاسل منفصلة وإرجاع قائمة بها.
    المجموعات المنفصلة متوازنة (كل قوس مفتوح مغلق بشكل صحيح) وليست متداخلة داخل بعضها البعض
    تجاهل أي مسافات في السلسلة المدخلة.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """


def truncate_number(number: float) -> float:
    """ بالنظر إلى عدد عشري موجب، يمكن تقسيمه إلى جزء صحيح
    (أكبر عدد صحيح أصغر من العدد المعطى) وأجزاء عشرية
    (الجزء المتبقي دائماً أصغر من 1).

    يعيد الجزء العشري من العدد.
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ بالنظر إلى عدد عشري موجب، يمكن تقسيمه إلى جزء صحيح
    (أكبر عدد صحيح أصغر من العدد المعطى) وأجزاء عشرية
    (الجزء المتبقي دائماً أصغر من 1).

    أعد الجزء العشري من العدد.
    >>> truncate_number(3.5)
    0.5
    """

:def truncate_number(number: float) -> float
    """ لدينا عدد عشري موجب، يمكن تقسيمه إلى جزء صحيح
    (أكبر عدد صحيح أصغر من العدد المعطى) وأجزاء عشرية
    (الجزء المتبقي دائماً أصغر من 1).

    نقوم بإعادة الجزء العشري من العدد.
    >>> truncate_number(3.5)
    0.5
    """


from typing import List

def below_zero(operations: List[int]) -> bool:
    """ لديك قائمة بعمليات الإيداع والسحب على حساب بنكي يبدأ برصيد صفر.
    مهمتك هي اكتشاف ما إذا كان في أي نقطة ينخفض رصيد الحساب إلى ما دون الصفر،
    وفي هذه الحالة يجب أن تعيد الدالة True. خلاف ذلك، يجب أن تعيد False.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ لديك قائمة بعمليات الإيداع والسحب على حساب بنكي يبدأـ
    برصيد صفر. مهمتك هي اكتشاف ما إذا كان رصيد الحساب في أي وقت يتدنى عن الصفر، و
    عند هذه النقطة يجب أن تُرجع الدالة True. وإلا يجب أن تُرجع False.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ لديك قائمة بعمليات الإيداع والسحب على حساب بنكي يبدأ بـ
    برصيد صفر. مهمتك هي اكتشاف ما إذا كان رصيد الحساب في أي وقت يقل عن الصفر، و
    عند هذه النقطة يجب أن تُرجع الدالة صواب. وإلا يجب أن تُرجع خطأ.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """


from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ لقائمة معينة من الأرقام المدخلة، احسب الانحراف المطلق المتوسط
    حول متوسط هذه المجموعة من البيانات.
    الانحراف المطلق المتوسط هو متوسط الفرق المطلق بين كل
    عنصر ونقطة مركزية (المتوسط في هذه الحالة):
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
    """ لمجموعة معينة من الأرقام التي يتم ادخالها، قم بحساب الانحراف المطلق المتوسط
    حول متوسط هذه المجموعة من البيانات.
    الانحراف المطلق المتوسط يعرف على أنه متوسط الفرق المطلق بين كل
    عنصر والنقطة مركزية (يكون هو المتوسط هنا ):
    MAD = متوسط | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ لقائمة معينة من الأرقام المدخلة، احسب Mean Absolute Deviation
    حول متوسط هذه المجموعة من البيانات.
    Mean Absolute Deviation هو متوسط الفرق المطلق بين كل
    عنصر ونقطة مركزية (المتوسط في هذه الحالة):
    MAD = متوسط | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """


from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ إدراج رقم 'delimeter' بين كل عنصرين متتاليين من قائمة الإدخال `numbers`
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    "" أدخل رقمًا 'delimiter' بين كل عنصرين متتاليين من قائمة الإدخال 'numbers'
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ أدرج رقماً ' delimeter' بين كل عنصرين متتاليين من قائمة المدخلات ' Numbers'
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """


from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ الإدخال لهذه الدالة هو سلسلة نصية تحتوي على عدة مجموعات من الأقواس المتداخلة مفصولة بمسافات.
    لكل مجموعة، يتم إرجاع أعمق مستوى من التداخل للأقواس.
    على سبيل المثال، (()()) يحتوي على مستويين كحد أقصى من التداخل، بينما ((())) يحتوي على ثلاثة مستويات.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ مدخل هذه الدالة عبارة عن سلسلة تمثل فئات عدة من أقواس متداخلة منفصلة بمسافات.
    لكل فئة، يتم إخراج أعمق مستوى من التداخل للأقواس.
    كمثال،لدى  (()())  مستويان من التداخل كحد أقصى  في حين ((())) تملك ثلاثا.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    "" المدخل إلى هذه الدالة هو سلسلة تمثل مجموعات متعددة من الأقواس المتداخلة المفصولة بمسافات.
    لكل مجموعة، قم بإخراج أعمق مستوى من تداخل الأقواس.
    على سبيل المثال، (()()) تحتوي على أقصى مستويين من التداخل بينما ((())) لديها ثلاثة مستويات.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """


from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ قم بتصفية قائمة المدخلات من السلاسل النصية فقط لتلك التي تحتوي على سلسلة جزئية معينة
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ تصفية قائمة مدخلات السلاسل التي تحتوي على سلسلة فرعية معينة فقط
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ قم بتصفية قائمة إدخال من السلاسل فقط للسلاسل التي تحتوي على سلسلة فرعية معينة
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """


from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ بالنظر إلى قائمة من الأعداد الصحيحة، أرجع زوجًا مكونًا من مجموع  وحاصل ضرب جميع الأعداد الصحيحة في القائمة.
    يجب أن يكون المجموع الفارغ مساويًا لـ 0 ويجب أن يكون حاصل الضرب الفارغ مساويًا لـ 1.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """
    بالنسبة لقائمة معينة من الأعداد الصحيحة، قم بإرجاع مجموعة تتكون من مجموع وحاصل ضرب جميع الأعداد الصحيحة في القائمة.
    يجب أن يكون المجموع الفارغ مساويًا لـ 0 ويجب أن يكون الحاصل الفارغ مساويًا لـ 1.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ بالنسبة لقائمة معطاة من الأعداد الصحيحة، أرجع مجموعة تتكون من مجموع وحاصل ضرب جميع الأعداد الصحيحة في القائمة.
    المجموع الفارغ يجب أن يساوي 0 وحاصل الضرب الفارغ يجب أن يساوي 1.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """


from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ من قائمة من الأعداد الصحيحة المعطاة، أنشئ قائمة تحتوي على أكبر عنصر متحرك تم العثور عليه حتى اللحظة المعطاة في التسلسل.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
    """
    من قائمة معينة من الأعداد الصحيحة، قم بإنشاء قائمة بالعناصر القصوى المتجددة التي تم العثور عليها حتى اللحظة المحددة في التسلسل.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ من قائمة الأعداد الصحيحة المعطاة، قم بإنشاء قائمة بأقصى عنصر متداول تم العثور عليه حتى اللحظة المعطاة
    في التسلسل.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """


def is_palindrome(string: str) -> bool:
    """ التحقق مما إذا كانت السلسلة النصية المعطاة تقرأ بنفس الطريقة من الجهتين """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ إيجاد أقصر سلسلة نصية تقرأ بنفس الطريقة من الجهتين (متناظرة) تبدأ بالسلسلة النصية المعطاة.
    الفكرة الأساسية للخوارزمية:
    - تحديد أطول جزء في نهاية السلسلة النصية يكون متناظرًا.
    - إضافة عكس الجزء المتبقي من السلسلة (الذي يسبق الجزء المتناظر) إلى نهايتها.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

:def is_palindrome(string: str) -> bool
    """ اختبر ما إذا كانت السلسلة النصية المعطاة هي كلمة متقابلة """
    return string == string[::-1]

:def make_palindrome(string: str) -> str
    """ قم بإيجاد أقصر كلمة متقابلة تبدأ بسلسلة نصية متوفرة.
    فكرة الخوارزمية بسيطة:
    - قم بإيجاد أطول لاحقة من السلسلة المتوفرة وتكون كلمة متطابقة.
    - قم بإضافة العكس إلى نهاية السلسلة النصية التي تأتي قبل اللاحقة المتطابقة المتطابقة.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ اختبر ما إذا كانت السلسلةالمعطاة عبارة عن كلمة متماثلة """
    return string == string[::-1]
def make_palindrome(string: str) -> str:
    """ قم بإيجاد أقصر كلمة متماثلة تبدأ بالسلسلة المعطاة.
    فكرة هذه الخوارزمية بسيطة:
    -جد أطول لاحقة في السلسلة المقدمة بحيث تكون كلمة متماثلة.
    - ثم نضيف عكس بادئة السلسلة التي تأتي قبل اللاحقة المتماثلة لخاتمة السلسلة.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


from typing import List

def string_xor(a: str, b: str) -> str:
    """ المدخلات هي سلسلتان a و b تتكونان فقط من 1s و 0s.
    قم بإجراء عملية XOR الثنائية على هذه المدخلات وأعد النتيجة أيضًا كسلسلة.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ المدخلات هي سلسلتان a و b تتكونان فقط من أصفار وواحدات .
    أجر عملية XOR الثنائية على هذه المدخلات وأرجع النتيجة أيضًا كسلسلة.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str، b: str) -> str:
    ”"“ المدخلات عبارة عن سلسلتين أ و ب تتكونان من أحاد و أصفار فقط.
    قم بأجراء XOR ثنائي على هذه المدخلات وأعد النتيجة أيضًا كسلسلة.
    >>> string_xor('010'، '110')
    '100'
    ”"“


from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ من قائمة السلاسل النصية، قم بإرجاع الأطول منها. قم بإرجاع أول واحدة في حالة وجود عدة
    سلاسل بنفس الطول. قم بإرجاع None إذا كانت القائمة المدخلة فارغة.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ ضمن قائمة من السلاسل النصية، أرجع أطولها. أعد  الأول في حال تواجد سلاسل عديدة لها الطول نفسه
    أعد None في حال كانت القائمة المدخلة شاغرة.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ من قائمة السلاسل النصية، قم بإرجاع الأطول. قم بإرجاع الأول في حالة وجود سلاسل متعددة بنفس الطول.
    قم بإرجاع None في حالة كانت القائمة المدخلة فارغة.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """


def greatest_common_divisor(a: int, b: int) -> int:
    """ إرجع القاسم المشترك الأكبر لعددين صحيحين a و b
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int، b: int) -> int:
    ”"“ قم بإرجاع أكبر قاسِم مشترك بين عددين صحيحين (a) و(b)
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5

def greatest_common_divisor(a: int, b: int) -> int:
    """ أعد القاسم المشترك الأكبر لعددين صحيحين a و b
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """


from typing import List

def all_prefixes(string: str) -> List[str]:
    """ إرجاع قائمة تحتوي على جميع البادئات الخاصة بالسلسلة النصية المدخلة،
    بدءًا من الأقصر إلى الأطول.
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ قم بإرجاع قائمة بجميع البادئات من الأقصر إلى الأطول, من السلسلة النصية المدخلة ,
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ قم بإرجاع قائمة بجميع البادئات من الأقصر إلى الأطول من سلسلة الإدخال
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """


def string_sequence(n: int) -> str:
    """ أرجع سلسلة تحتوي على أرقام مفصولة بمسافات بدءًا من 0 حتى n شاملة.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    "" قم بإرجاع سلسلة تحتوي على أرقام منفصلة بمسافة تبدأ من 0 حتى n شاملة.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

:def string_sequence(n: int) -> str
    """ أعد سلسلة تضم أرقاما مفصولة بمسافات تبدأ من 0 حتى n ًمتضمنا.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """


def count_distinct_characters(string: str) -> int:
    """ معطى سلسلة نصوص، اكتشف عدد الأحرف الفريدة (مهما كانت حالتها) التي تتكون منها
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ تم إعطاؤك سلسلة نصية، احسب عدد الأحرف المميزة (بغض النظر عن الحالة) التي تتكون منها
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ بالنظر إلى سلسلة نصية، قم بأيجاد عدد الأحرف الغير مكررة (بغض النظر عن حالة الحروف إن كانت صغيرة أم كبيرة) التي تتكون السلسلة منها
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """


from typing import List

def parse_music(music_string: str) -> List[int]:
    """ المدخل لهذه الدالة هو سلسلة نصية تمثل النوتات الموسيقية في صيغة ASCII خاصة.
    مهمتك هي تحليل هذه السلسلة وإرجاع قائمة من الأعداد الصحيحة التي تمثل عدد النبضات التي تستمر فيها كل
    نوتة.

    هنا هو المفتاح:
    'o' - نوتة كاملة، تستمر لأربع نبضات
    'o|' - نوتة نصفية، تستمر لنبضتين
    '.|' - نوتة ربع، تستمر لنبضة واحدة

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

from typing import List
def parse_music(music_string: str) -> List[int]:
    """ المدخل إلى هذه الوظيفة هو سلسلة تمثل النوتات الموسيقية بتنسيق ASCII خاص.

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

    فيما يلي شرح:
    'o' - النوتة الكاملة، تدوم أربع نبضات
    'o|' - نصف النوتة، تدوم نبضتين
    '.|' - النوتة الرباعية، تدوم نبضة واحدة

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ المدخل لهذه الدالة هو سلسلة نصية تمثل النوتات الموسيقية في صيغة ASCII خاصة.
    مهمتك هي تحليل هذه السلسلة وإرجاع قائمة من الأعداد الصحيحة التي تمثل عدد النبضات التي تستمر فيها كل
    نوتة.

    هنا هو المفتاح:
    'o' - نوتة كاملة، تستمر لأربع نبضات
    'o|' - نوتة نصفية، تستمر لنبضتين
    '.|' - نوتة ربعاعية، تستمر لنبضة واحدة

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """


def how_many_times(string: str, substring: str) -> int:
    """ابحث عن عدد المرات التي يمكن فيها العثور على السلسلة الفرعية المعطاة في السلسلة الأصلية. احسب الحالات المتداخلة.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ ابحث عن عدد المرات التي يمكن فيها العثور على سلسلة فرعية معينة في السلسلة الأصلية. احسب الحالات المتداخلة.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ ابحث عن عدد المرات التي يمكن العثور فيها على سلسلة فرعية معينة في السلسلة الأصلية. قم بإحصاء الحالات المتداخلة مع بعضها البعض.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """


from typing import List

def sort_numbers(numbers: str) -> str:
    "" الإدخال عبارة عن سلسلة من الأرقام مفصولة بمسافة من "صفر" إلى "تسعة".

    الخيارات الصالحة هي "صفر"، "واحد"، "اثنان"، "ثلاثة"، "أربعة"، "خمسة"، "ستة"، "سبعة"، "ثمانية" و"تسعة".

    قم بإرجاع السلسلة التي تحتوي على أرقام مرتبة من الأصغر إلى الأكبر
    >>> sort_numbers('ثلاثة واحد خمسة')
    'واحد ثلاثة خمسة'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ الإدخال هو سلسلة نصية تحتوي على أرقام مفصولة بمسافات من 'zero' إلى 'nine'.
    الخيارات الصالحة هي 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' و 'nine'.
    تعيد السلسلة مع الأرقام مرتبة من الأصغر إلى الأكبر
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers( numbers: str) -> str:
    """ الإدخال عبارة عن سلسلة نصية تحتوي على أرقام مفصولة بمسافات من ”zero“ إلى ”nine“.
    الخيارات الصالحة هي 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
    أعد السلسلة التي تحتوي على الأرقام مرتبة من الأصغر إلى الأكبر
    >>> sort_numbers('three one five')
    'one three five'
    """


from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ من قائمة الأرقام المقدمة (بطول لا يقل عن اثنين) اختر وأعد رقمين هما الأقرب لبعضهما البعض وأعدهما بالترتيب (الرقم الأصغر، الرقم الأكبر).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

import typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ من قائمة الأرقام المقدمة (بطول لا يقل عن اثنين) اختر وأعد رقمين هما الأقرب لبعضهما البعض وأعدهما بالترتيب
    (الرقم الأصغر، الرقم الأكبر).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ من قائمة أرقام مُقدمة (بطول اثنين على الأقل) حدد وأرجع اثنين من الأرقام الأقرب إلى بعضهما البعض وأرجعهما بالترتيب (رقم أصغر، رقم أكبر).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """


from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """
    بالنظر إلى قائمة من الأرقام (تحتوي على عنصرين على الأقل)، يتم تطبيق تحويل خطي على القائمة
    بحيث يصبح أصغر رقم في القائمة يساوي 0، وأكبر رقم يساوي 1.

    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """
    min_num = min(numbers)
    max_num = max(numbers)
    return [(x - min_num) / (max_num - min_num) for x in numbers]

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ بالنظر إلى قائمة من الأرقام (تحتوي على عنصرين على الأقل)، قم بتطبيق تحويل خطي على هذه القائمة،
    بحيث يصبح أصغر رقم فيها صفر وأكبر رقم يصبح واحدًا.
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ بالنظر إلى قائمة من الأرقام (تحتوي على عنصرين على الأقل)، قم بتطبيق تحويل خطي على تلك القائمة،
    بحيث يصبح أصغر رقم 0 وأكبر رقم يصبح 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """


from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ قم بتصفية قائمة معطاة من أي قيم بايثون فقط للأعداد الصحيحة
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ تصفية قائمة القيم المعطاة من أي قيم بايثون فقط للأعداد الصحيحة
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """


def strlen(string: str) -> int:
    """ قم بإرجاع طول السلسلة النصية المعطاة
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

:def strlen(string: str) -> int
    """ قم بإرجاع طول السلسلة النصية المعطاة
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(string: str) -> int:
    """ أرجع طول السلسلة المعطاة.
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


def largest_divisor(n: int) -> int:
    """ لأجل عدد معين n، أوجد أكبر عدد يقسم n قسمة بدون باقية، ويكون أصغر من n
    >>> largest_divisor(15)
    5
    """

:def largest_divisor(n: int) -> int
    """ لديك عدد معين يدعى n، قم بإيجاد أكبر عدد يقسم العدد n بشكل متساوي، ويكون أصغر من n
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ بالنسبة للعدد المعطى n، ابحث عن أكبر عدد يقسم n بالتساوي وأصغر من n.
    >>> largest_divisor(15)
    5
    """


from typing import List

def factorize(n: int) -> List[int]:
    """ أرجع قائمة من العوامل الأولية للعدد الصحيح المعطى مترتبة من الأصغر إلى الأكبر.
    يجب أن يظهر كل عامل عدد مرات يساوي عدد مرات ظهوره في التحليل.
    يجب أن يكون العدد المدخل مساوياً لحاصل ضرب جميع العوامل
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ إرجاع قائمة بالعوامل الأولية للعدد الصحيح المدخل بترتيب من الأصغر إلى الأكبر.
    يجب أن يتم إدراج كل عامل في القائمة بعدد مرات ظهوره في عملية التحليل إلى عوامل.
    يجب أن يكون العدد المدخل مساويًا لحاصل ضرب جميع العوامل في القائمة.
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ قم بإرجاع قائمة بالعوامل الأولية لعدد صحيح معين بالترتيب من الأصغر إلى الأكبر.
    يجب أن يتم إدراج كل عامل من العوامل بعدد من المرات يتناسب مع عدد المرات التي يظهر فيها في التحليل.
    يجب أن يكون عدد المدخلات مساويًا لحاصل ضرب جميع العوامل
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """


from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ من قائمة الأعداد الصحيحة، قم بإزالة جميع العناصر التي تتكرر أكثر من مرة.
    احتفظ بترتيب العناصر المتبقية كما هو في المدخلات.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ من مجموعة من الأعداد الصحيحة،قم بإزالة جميع العناصر التي يتم تكرارها أكثر من مرة.
    احفظ ترتيب العناصر المتبقية كما في المدخلات.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    ""

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ "" أزل كل العناصر التي تتكرر أكثر من مرة من قائمة العناصر الصحيحة.
    حافظ على ترتيب العناصر المتبقية كما هو في المدخل الأصلي.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """


def flip_case(string: str) -> str:
    """ للسلسلة المعطاة، قم بتحويل الحروف الصغيرة إلى حروف كبيرة والحروف الكبيرة إلى حروف صغيرة.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    ”"“ في سلسلة معطاة، اقلب الأحرف الصغيرة إلى أحرف كبيرة والكبيرة إلى أحرف صغيرة.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ لعكس حالة الأحرف في سلسلة معينة، تحويل الأحرف الصغيرة إلى كبيرة والكبيرة إلى صغيرة.
    >>> flip_case('Hello')
    'hELLO'
    """


from typing import List

def concatenate(strings: List[str]) -> str:
    """ تقوم بدمج قائمة من السلاسل النصية إلى سلسلة نصية واحدة.
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ دمج قائمة من السلاسل إلى سلسلة واحدة.
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ ادمج قائمة من السلاسل في سلسلة واحدة
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """


from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ فلتر قائمة الإدخال من السلاسل النصية لتحتوي فقط على تلك التي تبدأ بالبادئة المعطاة.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ تصفية قائمة مدخلات من السلاسل النصية فقط لتلك التي تبدأ بمقدمة معينة.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """"قم بتصفية  قائمة مدخلات من السلاسل النصية فقط تلك التي تستهل بمقدمة محددة.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """


def get_positive(l: list):
    """إرجع الأرقام الموجبة فقط في القائمة.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """

def get_positive(l: list):
    """قم فقط بإرجاع الأرقام الموجبة في القائمة.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """

def get_positive(l: list):
    """أرجع الأرقام الموجبة فقط في القائمة.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """


def is_prime(n):
    """إرجاع True إذا كان العدد المعطى عددًا أوليًا، و False إذا لم يكن كذلك.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """أرجع القيمة true إذا كان الرقم المعطى أوليًا، والقيمة false بخلاف ذلك..
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

:def is_prime(n)
    """قم بإرجاع true إذا كان الرقم المعطى أوليًا، وfalse خلاف ذلك.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """


import math

def poly(xs: list, x: float):
    """
    تقييم متعدد الحدود مع المعاملات xs عند النقطة x.
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs هي معاملات متعدد الحدود.
    find_zero يجد x بحيث يكون poly(x) = 0.
    find_zero يعيد نقطة صفر واحدة فقط، حتى لو كان هناك العديد.
    علاوة على ذلك، find_zero يقبل فقط القائمة xs التي تحتوي على عدد زوجي من المعاملات
    وأكبر معامل غير صفري حيث يضمن
    حلاً.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    قيم متعدد الحدود مع المعاملات xs عند النقطة x.
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs هي معاملات متعدد الحدود.
    find_zero جِد x بحيث يكون poly(x) = 0.
    find_zero أرجع نقطة صفر واحدة فقط، حتى إذا وُجد العديد.
    من ناحية أخرى ، find_zero يقبل فقط القائمة xs التي تضم  عددا زوجيا من المعاملات
    وأكبر معامل غير صفري بحيث يتضمن
    حلاً.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    تقييم متعددة الحدود ذات المعاملات xs عند النقطة x.
    الناتج هو xs[0] + xs[1] * x + xs[2] * x^2 + .... + xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs هي معاملات متعددة الحدود.
    find_zero يجد قيمة x حيث تكون poly(x) = 0.
    تقوم find_zero بإرجاع نقطة جذر واحدة فقط، حتى إذا كانت هناك العديد من الجذور.
    علاوة على ذلك، تعمل find_zero فقط على القوائم xs التي تحتوي على عدد زوجي
    من المعاملات وأكبر معامل غير صفري، حيث يضمن ذلك وجود حل.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """


def sort_third(l: list):
    """تأخذ هذه الدالة قائمة l وتعيد قائمة l' بحيث تكون
    l' مطابقة لـ l في المؤشرات غير القابلة للقسمة على ثلاثة، بينما تكون قيمها في المؤشرات التي تقبل القسمة على ثلاثة مساوية
    للقيم الموجودة في المؤشرات المقابلة في l، ولكن مرتبة.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """تأخذ هذه الدالة قائمة l وتعيد قائمة l' بحيث تكون
    l' مطابقة لـ l في الفهارس التي لا تقبل القسمة على ثلاثة، بينما تكون قيمها في الفهارس التي تقبل القسمة على ثلاثة مساوية
    لقيم الفهارس المقابلة في l، ولكن مرتبة.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """


def unique(l: list):
    """أعد العناصر الفريدة المرتبة في القائمة.
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """إرجاع العناصر الفريدة المرتبة في قائمة
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """أعد العناصر المميزة مرتبة في القائمة
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


def max_element(l: list):
    """إرجاع العنصر الأقصى في القائمة.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """

def max_element(l: list):
    """أعد العنصر الأعلى في القائمة.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """

:def max_element(l: list)
    """قم بإرجاع العنصر الأكبر في القائمة.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """


def fizz_buzz(n: int):
    """أعد عدد المرات التي يظهر فيها الرقم 7 في الأعداد الصحيحة الأقل من n والتي تقبل القسمة على 11 أو 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """إرجاع عدد المرات التي يظهر فيها الرقم 7 في الأعداد التي تقل عن n والتي هي قابلة للقسمة على 11 أو 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """إعاده عدد المرات التي يظهر فيها الرقم 7 في الأعداد الصحيحة الأقل من n والتي يمكن قسمتها على 11 أو 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """


def sort_even(l: list):
    """تأخذ هذه الدالة قائمة l وتعيد قائمة l' بحيث تكون
    l' مطابقة لـ l في الفهارس الفردية، بينما تكون قيمها في الفهارس الزوجية مساوية
    لقيم الفهارس الزوجية لـ l، ولكن مرتبة.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """تأخذ هذه الدالة قائمة l وتعيد قائمة l' بحيث تكون
    l' مطابقة لـ l في المؤشرات الفردية، بينما تكون قيمها في المؤشرات الزوجية مساوية
    لقيم المؤشرات الزوجية لـ l، ولكن مرتبة.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """
    تأخذ هذه الدالة قائمة l وتعيد قائمة l' بحيث تكون l' مطابقة لـ l في المؤشرات الفردية، بينما تكون قيمها في المؤشرات الزوجية مساوية لقيم المؤشرات الزوجية لـ l، ولكن مرتبة.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """


def encode_cyclic(s: str):
    """
    يعيد سلسلة مشفرة عن طريق تدوير مجموعات من ثلاثة أحرف.
    """
    # تقسيم السلسلة إلى مجموعات. كل منها بطول 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # تدوير العناصر في كل مجموعة. ما لم تكن المجموعة تحتوي على عناصر أقل من 3.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    يأخذ كسلسلة مدخلة مشفرة باستخدام دالة encode_cyclic. يعيد السلسلة المفككة.
    """

def encode_cyclic(s: str):
    """
    يعيد السلسلة المشفرة عن طريق تدوير مجموعات مكونة من ثلاثة حروف
    """
    # تقسيم السلسلة إلى مجموعات. كل منها بطول 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # تدوير العناصر في كل مجموعة. ما لم يكن لدى المجموعة عناصر أقل من 3.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    يأخذ سلسلة نصية مشفرة باستخدام دالة encode_cyclic كمدخل. يعيد السلسلة المشفرة.
    """


def prime_fib(n: int):
    """
    prime_fib تُرجع العدد n الذي هو عدد فيبوناتشي وهو أيضًا عدد أولي.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    prime_fib تعيد العدد n الذي يعد عدد فيبوناتشي وأيضًا عددا أوليا.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """


def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero تأخذ قائمة من الأعداد الصحيحة كمدخل.
    تعيد True إذا كانت هناك ثلاثة عناصر مميزة في القائمة
    مجموعها يساوي صفر، و False خلاف ذلك.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero تأخذ قائمة من الأعداد الصحيحة كمدخل.
    فإنها تُرجع True إذا كان هناك ثلاثة عناصر مختلفة في القائمة التي مجموعها
    مجموعها يساوي صفر، و”False“ إذا لم يكن كذلك.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero يأخذ قائمة من الأعداد الصحيحة كمدخل.
    تعيد True إذا كانت هناك ثلاثة عناصر مميزة في القائمة
    مجموعها يساوي صفر، و False خلاف ذلك.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """


def car_race_collision(n: int):
    """
    تخيل طريقًا مستقيمًا تمامًا ويمتد إلى ما لا نهاية.
    n من السيارات تسير من اليسار إلى اليمين؛ في نفس الوقت، مجموعة مختلفة من n من السيارات
    تسير من اليمين إلى اليسار. تبدأ المجموعتان من السيارات بعيدتين جدًا عن
    بعضهما البعض. جميع السيارات تتحرك بنفس السرعة. يقال إن سيارتين تصطدمان
    عندما تصطدم سيارة تسير من اليسار إلى اليمين بسيارة تسير من اليمين إلى اليسار.
    ومع ذلك، فإن السيارات قوية ومتينة إلى ما لا نهاية؛ ونتيجة لذلك، تستمر في التحرك
    في مسارها كما لو لم تصطدم.

    تقوم هذه الدالة بإخراج عدد هذه الاصطدامات.
    """

def car_race_collision(n: int):
    """
    تصور طريقًا مستقيما بالضبط و ممتدا بلا حدود.
    n سيارة تتجه من اليسار إلى اليمين؛ وفي ذات الوقت، مجموعة مختلفة من n سيارة
    تسير من اليمين إلى اليسار.مجموعتا السيارات تبدأآن بعيدتين جدًا عن
    بعضهما البعض. السيارات كلها تتحرك بالسرعة ذاتها. يحكى أن سيارتين تصطدمان
    عندما تصطدم سيارة تسير من اليسار إلى اليمين بأخرى تسير من اليمين إلى اليسار.
    ومع ذلك، فإن السيارات قوية ومتينة لحد لا نهاية له؛ مما يترتب عليه أن تستمر في التحرك
    في خط سيرها كأنها لم ترتطم.

    هذه الدالة تقوم بإنتاج عدد الاصطدامات هذه
    """

def car_race_collision(n: int):
    """
    تخيل طريقًا مستقيمًا تمامًا ويمتد إلى ما لا نهاية.
    n سيارة تسير من اليسار إلى اليمين؛ في نفس الوقت، مجموعة مختلفة من n سيارة
    تسير من اليمين إلى اليسار. تبدأ المجموعتان من السيارات بعيدتين جدًا عن
    بعضهما البعض. جميع السيارات تتحرك بنفس السرعة. يقال إن سيارتين تصطدمان
    عندما تصطدم سيارة تسير من اليسار إلى اليمين بسيارة تسير من اليمين إلى اليسار.
    ومع ذلك، فإن السيارات قوية ومتينة إلى ما لا نهاية؛ ونتيجة لذلك، تستمر في التحرك
    في مسارها كما لو لم تصطدم.

    تقوم هذه الدالة بإخراج عدد هذه الاصطدامات.
    """


def incr_list(l: list):
    """قم بإرجاع قائمة مع زيادة العناصر بمقدار 1.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """ إرجاع القائمة التي تحتوي على عناصر تم زيادة عدد عناصرها بمقدار 1.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """أرجع قائمة بالعناصر التي تم زيادتها بمقدار 1.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """


def pairs_sum_to_zero(l):
    """
    تقوم pairs_sum_to_zero بأخذ قائمة من الأعداد الصحيحة كمدخل.
    تُرجع True إذا كان هناك عنصران مميزان في القائمة مجموعهما يساوي صفرًا،
    وتُرجع False في الحالات الأخرى.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero يأخذ قائمة من الأعداد الصحيحة كمدخل.
    تُعيد True إذا كان هناك عنصران مختلفان في القائمة
    مجموعهما يساوي صفر، و”False “ إذا لم يكن كذلك.    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero تأخذ قائمة من الأعداد الصحيحة كمدخل.
    تعيد True إذا كان هناك عنصران متميزان في القائمة
    مجموعهما يساوي صفر، و False خلاف ذلك.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """


def change_base(x: int, base: int):
    """تغيير الأساس العددي للعدد المدخل x إلى الأساس المحدد.
    إرجاع تمثيل نصي بعد التحويل.
    الأرقام الأساسية أقل من 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """ تقوم بتغيير القاعدة العددية للرقم المدخل x إلى القاعدة المطلوبة.
    إرجاع التمثيل النصي بعد التحويل
    الأرقام الأساسية أقل من 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """تغيير الأساس الرقمي للعدد المدخل x إلى الأساس المحدد.
    قم بإرجاعه في شكله النصي بعد التحويل.
    الأرقام الأساسية أقل من 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """


def triangle_area(a, h):
    """معطى طول الضلع والارتفاع، ترجع الدالة مساحة المثلث.
    >>> triangle_area(5, 3)
    7.5
    """

:def triangle_area(a, h)
    """معطى طول الضلع والارتفاع، أعِد مساحة المثلث.
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    ”“”“بمعلومية طول الضلع والارتفاع قم بإرجاع مساحة المثلث.
    >>> triangle_area(5, 3)
    7.5
    """


def fib4(n: int):
    """تسلسل الأرقام Fib4 هو تسلسل مشابه لتسلسل فيبوناتشي يُعرّف كما يلي:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    يرجى كتابة دالة لحساب العنصر n من تسلسل الأرقام Fib4 بكفاءة. لا تستخدم العودية.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

:def fib4(n: int)
    """متتابعة الأرقام Fib4 هي متتابعة مشابة لمتتابعة فيبوناتشي وتُعرّف كما يلي:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    يرجى منك كتابة دالة لحساب العنصر n من متتابعة الأرقام Fib4 بكفاءة. لا تستخدم التكرارية (recursion).
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """تسلسل الأرقام Fib4 عبارة عن تسلسل مماثل لتسلسل فيبوناتشي يتم تعريفه كالتالي:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    أرجو أن تكتب دالة تحسب العنصر n من تسلسل الأرقام Fib4 بكفاءة. لا تستخدم العودية.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """


def median(l: list):
    """إرجاع الوسيط للعناصر في القائمة l.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median(l: list):
    """أعد الوسيط للعناصر في القائمة l.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median(l: list):
    """أرجع الوسيط للعناصر في القائمة l.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """


def is_palindrome(text: str):
    """
    تحقق مما إذا كانت السلسلة المعطاة عبارة عن سلسلة متناظرة
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    ”"“
    تحقق مما إذا كان النص المعطى متماثلاً عند عكسه
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    يتحقق مما إذا كانت السلسلة المعطاة هي كلمة متطابقة عند عكسها
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """


:def modp(n: int, p: int)
    """ٌقم بإرجاع 2^n modulo p (كن حذرا في التعامل مع الأرقام).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """إرجاع 2^n بالModulo p (يرجى الحذر بشأن الأرقام).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """إرجاع 2^n modulo p (احذر الأرقام).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """


def encode_shift(s: str):
    """
    أرجع السلسلة المشفرة عن طريق إزاحة كل حرف بمقدار 5 في الأبجدية.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    يأخذ كإدخال سلسلة مشفرة باستخدام دالة encode_shift. يرجع السلسلة المفككة.
    """

:def encode_shift(s: str)
    """
    تُعيد سلسلة حروف مشفرة عن طريق تحريك كل حرف بمقدار 5 أماكن في الأبجدية.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    تأخذ سلسلة حروف مشفرة باستخدام دالة encode_shift. وتعيد السلسلة بدون تشفير
    """

def encode_shift(s: str):
    """
    تُخرج سلسلة مرمزة وذلك بإزاحة  كل حرف بمقدار 5 في الأبجدية.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    تأخذ كسلسلة مدخلة مرمزة باستعمال دالة encode_shift. تُخرج السلسلة المفككة.
    """


def remove_vowels(text):
    """
    remove_vowels هي دالة تأخذ سلسلة نصية وتعيد السلسلة بدون الحروف المتحركة.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

def remove_vowels(text):
    """
    remove_vowels هي دالة تأخذ سلسلة نصية وتعيد نفس السلسلة بعد إزالة الأحرف المتحركة منها.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

:def remove_vowels(text)
    """
    remove_vowels هي دالة تأخذ سلسلة نصية وتعيد سلسلة بدون الحروف المتحركة.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """


:def below_threshold(l: list, t: int)
    """قم بإرجاع True إذا كانت جميع الأرقام في القائمة l أقل من الحد t.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    ""أعد True في حال كانت جميع الأرقام في القائمة l أصغر من العتبة  t.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """إرجاع True إذا كانت جميع الأرقام في القائمة l أقل من الحد الذي لا يمكن تجاوزه t.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


def add(x: int, y: int):
    """اجمع عددين x و y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """

def add(x: int, y: int):
    """قم بجمع رقمين x و y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """

:def add(x: int, y: int)
    """قم بجمع رقمين x و y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


def same_chars(s0: str, s1: str):
    """
    تحقق مما إذا كانت الكلمتان تحتويان على نفس الأحرف.
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """

def same_chars(s0: str, s1: str):
    """
    افحص ما إذا كانت كلمتان تضمان الأحرف نفسها.
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """


def fib(n: int):
    """أرجع العدد النوني في سلسلة فيبوناتشي.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """

def fib(n: int):
    """قم بإرجاع العدد النوني في سلسلة فيبوناتشي.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """

def fib(n: int):
    """إرجاع رقم فيبوناتشي رقم n.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """ الأقواس هي سلسلة من "<" و ">".
    ارجع True إذا كان لكل قوس مفتوح قوس مغلق مطابق.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """

def correct_bracketing(brackets: str):
    """ الأقواس هي سلسلة من "<" و ">".
    إرجاع True إذا كان لكل قوس افتتاحي قوس إغلاق مقابل.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """

def correct_bracketing(brackets: str):
    """ الأقواس هي سلسلة من "<" و ">".
    إرجاع True إذا كان لكل قوس مفتوح قوس مغلق مطابق.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """


def monotonic(l: list):
    """إرجاع True إذا كانت عناصر القائمة تزيد أو تنقص بشكل أحادي.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """أعد True في حال كانت عناصر القائمة تتزايد أو تتناقص برتابة.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """إرجاع True إذا كانت عناصر القائمة تزداد أو تتناقص بشكل رتيب.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """


def common(l1: list, l2: list):
    """إرجاع العناصر المشتركة الفريدة والمرتبة لقائمتين.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """أعد العناصر المشتركة الفريدة المرتبة لقائمتين.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """إرجاع عناصر مشتركة فريدة مرتبة لقائمتين..
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """


def largest_prime_factor(n: int):
    """إعاده أكبر عامل أولي لـ n. افترض أن n > 1 وليس عددًا أوليًا.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

:def largest_prime_factor(n: int)
    """قم بإرجاع أكبر عامل أولي لـ n. افترض أن n > 1 وليست عددًا أوليًا.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """قم بإرجاع أكبر عامل أولي لـ n. افترض أن n > 1 وليست عدد أولي.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """


def sum_to_n(n: int):
    """sum_to_n هي دالة تجمع الأعداد من 1 إلى n.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """sum_to_n هي دالة تجمع الأرقام من 1 إلى n.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """sum_to_n إنها دالة تقوم بجمع الأرقام من 1 إلى n.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """


def correct_bracketing(brackets: str):
    """ brackets هي سلسلة تحتوي على "(" و ")".
    قم بإرجاع True إذا كان كل قوس مفتوح له قوس مغلق مطابق.

    >>> correct_bracketing("(")
    False
    >>> correct_bracketing("()")
    True
    >>> correct_bracketing("(()())")
    True
    >>> correct_bracketing(")(()")
    False
    """

def correct_bracketing(brackets: str):
    """ الأقواس هي سلسلة من "(" و ")".
    أرجع True إذا كان كل قوس مفتوح له قوس مغلق مطابق.

    >>> correct_bracketing("(")
    False
    >>> correct_bracketing("()")
    True
    >>> correct_bracketing("(()())")
    True
    >>> correct_bracketing(")(()")
    False
    """

def correct_bracketing(brackets: str):
    """ القوس عبارة عن سلسلة من "(" و ")".
    أعد True عندما يكون لكل قوس مفتوح قوس مقفل مطابق.

    >>> correct_bracketing("(")
    False
    >>> correct_bracketing("()")
    True
    >>> correct_bracketing("(()())")
    True
    >>> correct_bracketing(")(()")
    False
    """


def derivative(xs: list):
    """ تمثل xs معاملات متعددة الحدود.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     أعد مشتقة الدالة متعددة الحدود هذه بنفس الهيئة.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derivative(xs: list):
    """ تمثل xs معاملات متعددة الحدود.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     أرجع مشتقة هذه الدالة متعددة الحدود بنفس الشكل.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

:def derivative(xs: list)
    """ تمثل xs معاملات متعددة الحدود.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     قم بإرجاع مشتقة هذه الدالة متعددة الحدود بنفس الشكل.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """


def fibfib(n: int):
    """تسلسل أرقام FibFib هو تسلسل مشابه لتسلسل فيبوناتشي يُعرّف كما يلي:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    يرجى كتابة دالة لحساب العنصر n من تسلسل أرقام fibfib بكفاءة.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def Fibfib(n: int):
    ”“”“متسلسلة الأرقام FibFib هي متسلسلة مشابهة لمتسلسلة فيبوناتشي التي تُعرَّف على النحو التالي:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).

    يُرجى كتابة دالة لحساب العنصر n من متسلسلة أرقام fibfib بكفاءة.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

:def fibfib(n: int)
    """متتابعة أرقام FibFib هي تسلسل مشابه لمتتابعة فيبوناتشي يُعرّف كما يلي:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    يرجى كتابة دالة لحساب العنصر n من متتابعة أرقام fibfib بكفاءة.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """


FIX = """
أضف المزيد من حالات الاختبار.
"""

def vowels_count(s):
    """اكتب دالة vowels_count التي تأخذ سلسلة تمثل
    كلمة كمدخل وتعيد عدد الحروف المتحركة في السلسلة.
    الحروف المتحركة في هذه الحالة هي 'a'، 'e'، 'i'، 'o'، 'u'. هنا، 'y'
    تعتبر أيضًا حرفًا متحركًا، ولكن فقط عندما تكون في نهاية الكلمة المعطاة.

    مثال:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
أضف المزيد من حالات الاختبار.
"""

def vowels_count(s):
    """اكتب دالة vowels_count التي تأخذ سلسلة تمثل
    كلمة كمدخل وتعيد عدد الحروف المتحركة في السلسلة.
    الحروف المتحركة في هذه الحالة هي 'a'، 'e'، 'i'، 'o'، 'u'. هنا، 'y'
    تُعد أيضًا حرفًا متحركًا، فقط  في حال كانت في نهاية الكلمة المعطاة .

    مثال:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
أدرج مزيدا من حالات الاختبار.
"""

def vowels_count(s):
    """اكتب دالة vowels_count  تقوم بأخذ سلسلة تمثل
    كلمة كمدخل وتقوم بإرجاع عدد الحروف المتحركة في السلسلة.
    في هذه الحالة الحروف المتحركة هي 'a'، 'e'، 'i'، 'o'، 'u'. هنا، 'y'
    يُعد حرفًا متحركًا أيضا ، لكن فقط في حال وجودها في نهاية الكلمة المعطاة.

    مثال:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """


def circular_shift(x, shift):
    """إزاحة دائرية لأرقام العدد الصحيح x، إزاحة الأرقام إلى اليمين بمقدار shift
    وإرجاع النتيجة كسلسلة نصية.
    إذا كانت shift > عدد الأرقام، يتم إرجاع الأرقام معكوسة.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """قم بإزاحة أرقام العدد الصحيح x بشكل دائري، ثم قم بإزاحة الأرقام إلى اليمين باستخدام shift
    وأرجع النتيجة كسلسلة نصية.
    إذا كان shift > عدد الأرقام، فقم بإرجاع الأرقام معكوسة.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """إزاحة دائرية لأرقام العدد الصحيح x، إزاحة الأرقام إلى اليمين بمقدار shift
    وإرجاع النتيجة كسلسلة نصية.
    إذا كانت shift > عدد الأرقام، أعد الأرقام معكوسة.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """


def digitSum(s):
    """المهمة
    اكتب دالة تأخذ سلسلة نصية كمدخل وتعيد مجموع أكواد ASCII للأحرف الكبيرة فقط.

    أمثلة:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """المهمة
    اكتب دالة تأخذ سلسلة نصية وتقوم بإرجاع مجموع أكواد ASCII للأحرف الكبيرة فقط.

    أمثلة:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """المهمة
    اكتب دالة تأخذ سلسلة نصية كإدخال وتعيد مجموع رموز ASCII للحروف الكبيرة فقط.

    أمثلة:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """


def fruit_distribution(s, n):
    """
    في هذه المهمة، سيتم إعطاؤك سلسلة تمثل عدد من التفاح والبرتقال
    التي تم توزيعها في سلة فواكه تحتوي على التفاح والبرتقال والمانجو.
    بناءً على السلسلة التي تمثل إجمالي عدد البرتقال والتفاح وعدد صحيح يمثل
    إجمالي عدد الفواكه في السلة، قم بإرجاع عدد فواكه المانجو في السلة.
    على سبيل المثال:
    fruit_distribution("5 apples and 6 oranges", 19) -> 19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges", 3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges", 120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    في هذه المهمة، سيتم إعطاؤك سلسلة تمثل عدد التفاح والبرتقال
    الموزعة في سلة فاكهة تحتوي على
    التفاح والبرتقال والمانجو. بالنظر إلى السلسلة التي تمثل العدد الإجمالي
    للبرتقال والتفاح وعدد صحيح يمثل العدد الإجمالي للفاكهة
    الموجودة في السلة، قم بإرجاع عدد فاكهة المانجو الموجودة في السلة.
    على سبيل المثال:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    في هذه المهمة، سيتم إعطاؤك سلسلة تمثل عدد التفاح والبرتقال
    التي يتم توزيعها في سلة فواكه تحتوي على
    التفاح والبرتقال وفاكهة المانجو. بالنظر إلى السلسلة التي تمثل العدد الإجمالي
    للبرتقال والتفاح وعدد صحيح يمثل العدد الإجمالي للفواكه
    في السلة، أعد عدد فاكهة المانجو في السلة.
    على سبيل المثال:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """


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

    يجب إرجاع العقدة المقتطعة في قائمة، [أصغر_قيمة، فهرسها]،
    إذا لم تكن هناك قيم زوجية أو كانت المصفوفة المعطاة فارغة، فقم بإرجاع [].

    المثال 1:
        المدخل: [4,2,3]
        المخرج: [2, 1]
        التوضيح: 2 لديها أصغر قيمة زوجية، و2 لديها أصغر فهرس.

    المثال 2:
        المدخل: [1,2,3]
        المخرج: [2, 1]
        التوضيح: 2 لديها أصغر قيمة زوجية، و2 لديها أصغر فهرس.

    المثال 3:
        المدخل: []
        المخرج: []

    المثال 4:
        المدخل: [5, 0, 3, 0, 4, 2]
        المخرج: [0, 1]
        التوضيح: 0 هي أصغر قيمة، ولكن هناك صفران،
                     لذلك سنختار الصفر الأول، الذي لديه أصغر فهرس.

    القيود:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

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

    يجب ان تعاد العقدة المقتطعة في قائمة، [أصغر_قيمة، فهرسها]،
    إذا لم توجد قيم زوجية أو كانت المصفوفة المعطاة شاغرة، فأعد
    []
    المثال 1:
        المدخل: [4,2,3]
        المخرج: [2, 1]
        التوضيح: 2 لديها أصغر قيمة زوجية، و2 لها أصغر فهرس.

    المثال 2:
        المدخل: [1,2,3]
        المخرج: [2, 1]
        التوضيح: 2 تملك أصغر قيمة زوجية، و2 لديها أصغر فهرس.

    المثال 3:
        المدخل: []
        المخرج: []

    المثال 4:
        المدخل: [5, 0, 3, 0, 4, 2]
        المخرج: [0, 1]
        التفسير: 0 هي أصغر قيمة، ولكن هناك صفران،
                     لذا سوف نختار الصفر الأول، الذي عنده أصغر فهرس.

    القيود:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

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

    يجب إرجاع العقدة المقتطعة في قائمة، [أصغر_قيمة، فهرسها]،
    إذا لم تكن هناك قيم زوجية أو كانت المصفوفة المعطاة فارغة، أعد [].

    المثال 1:
        Input: [4,2,3]
        Output: [2, 1]
        ملاحظة : 2 حتى قيمة الحد الأدنى ، 2 قيمة المؤشر هو الحد الأدنى .

    المثال 2:
        Input: [1,2,3]
        Output: [2, 1]
        ملاحظة : 2 حتى قيمة الحد الأدنى ، 2 قيمة المؤشر هو الحد الأدنى .

    المثال 3:
        Input: []
        Output: []

    المثال 4:
        Input: [5, 0, 3, 0, 4, 2]
        Output: [0, 1]
        التوضيح: 0  أصغر قيمة، ولكن هناك صفران،
                     لذا سنختار الصفر الأول، الذي له أصغر فهرس.

    القيود:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


def search(lst):
    '''
    تم إعطاؤك قائمة غير فارغة من الأعداد الصحيحة الموجبة. قم بإرجاع أكبر عدد أكبر من
    الصفر، وله تكرار أكبر من أو يساوي قيمة العدد نفسه.
    التكرار للعدد هو عدد مرات ظهوره في القائمة.
    إذا لم يوجد أي عدد يحقق ذلك، قم بإرجاع -1.
    الأمثلة:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

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

    تردد العدد الصحيح هو عدد المرات التي يظهر فيها في القائمة.
    إذا لم يوجد مثل هذه القيمة، أعد -1.
    أمثلة:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    لديك قائمة غير فارغة من الأعداد الصحيحة الموجبة. أعد العدد الصحيح الأكبر الذي يكون أكبر من
    الصفر، ويكون تكراره أكبر من أو يساوي قيمة العدد نفسه.
    تكرار العدد الصحيح هو عدد المرات التي يظهر فيها في القائمة.
    إذا لم يوجد مثل هذه القيمة، أعد -1.
    أمثلة:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''


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

    أمثلة:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''معطى قائمة من الأعداد الصحيحة، رتب القائمة ترتيبا غريبا
    الترتيب الغريب هو  عندما تبدأ بالقيمة الأصغر ،
    ثم القيمة الأكبر من الأعداد الصحيحة الباقية، ثم الأدنى وهكذا دواليك.

    أمثلة:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''


def triangle_area(a, b, c):
    '''
    بالنظر إلى أطوال الأضلاع الثلاثة لمثلث. إرجاع مساحة
    المثلث مقربة إلى نقطتين عشريتين إذا كانت الأضلاع الثلاثة تشكل مثلثًا صالحًا.
    خلاف ذلك، إرجاع -1
    تشكل الأضلاع الثلاثة مثلثًا صالحًا عندما يكون مجموع أي ضلعين أكبر
    من الضلع الثالث.
    مثال:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

:def triangle_area(a, b, c)
    '''
    بالنظر إلى أطوال الأضلاع الثلاثة لمثلث. قم بإرجاع مساحة
    المثلث مقربة إلى خانتين عشريتين إذا كانت الأضلاع الثلاثة يمكنها تشكيل مثلث.
    خلاف ذلك، قم بإرجاع-1
    ثلاثة أضلاع يمكنها تشكيل مثلث بحيث يكون مجموع أطوال أي ضلعين أكبر من طول الضلع الثالث.
    مثال:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

    """

def triangle_area(a, b, c):
    '''
    بالنظر إلى أطوال الأضلاع الثلاثة لمثلث ترجع المساحه
    مقربة إلى نقطتين عشريتين إذا كانت الأضلاع الثلاثة تشكل مثلثًا صالحًا
    خلاف ذلك، إرجع -1
    تشكل الأضلاع الثلاثة مثلثًا صحيحاً عندما يكون مجموع أي ضلعين أكبر
    من الضلع الثالث.
    مثال:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''


def will_it_fly(q,w):
    '''
    قم بكتابة دالة ترجع  True إذا كان الجسم q سوف يطير، و False  غير هذا .
    فسيطير الجسم q إذا كان متوازنا (قائمة متناظرة) وحاصل جمع عناصره أقل أو مساو للوزن الأقصى الممكن w.

    مثال:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 أقل من الوزن الأقصى الممكن، لكنه غير متوازن.

    will_it_fly([3, 2, 3], 1) ➞ False
    # هذا متوازن، لكن 3+2+3 أكثر من الوزن الأقصى الممكن.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 أقل من الوزن الأقصى الممكن، و متوازن.

    will_it_fly([3], 5) ➞ True
    # 3 أقل من الوزن الأقصى الممكن، وهو متوازن.
    '''

def will_it_fly(q,w):
    '''
    اكتب دالة تعيد True إذا كان الجسم q سيطير، و False خلاف ذلك.
    سيطير الجسم q إذا كان متوازنًا (قائمة متناظرة) ومجموع عناصره أقل من أو يساوي الوزن الأقصى الممكن w.

    مثال:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 أقل من الوزن الأقصى الممكن، لكنه غير متوازن.

    will_it_fly([3, 2, 3], 1) ➞ False
    # إنه متوازن، لكن 3+2+3 أكثر من الوزن الأقصى الممكن.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 أقل من الوزن الأقصى الممكن، وهو متوازن.

    will_it_fly([3], 5) ➞ True
    # 3 أقل من الوزن الأقصى الممكن، وهو متوازن.
    '''

def will_it_fly(q,w):
    '''
    اكتب دالة تعيد True إذا كان الجسم q سيطير، و False غير ذلك.
    سيطير الجسم q إذا كان متوازنًا (قائمة متناظرة) ومجموع عناصره أقل من أو مسايا الوزن الأقصى الممكن w.

    مثال:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 أقل من الوزن الأقصى الممكن، لكنه غير متوازن.

    will_it_fly([3, 2, 3], 1) ➞ False
    # متوازن، لكن 3+2+3 أكثر من الوزن الأقصى الممكن.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 أقل من الوزن الأقصى الممكن، ومتوازن.

    will_it_fly([3], 5) ➞ True
    # 3 أقل من الوزن الأقصى الممكن، ومتوازن.
    '''


def smallest_change(arr):
    """
    بالنظر إلى مصفوفة arr من الأعداد الصحيحة، ابحث عن الحد الأدنى لعدد العناصر
    التي تحتاج إلى تغيير لجعل المصفوفة متناظرة. المصفوفة المتناظرة هي المصفوفة التي
    تقرأ بنفس الطريقة من الأمام والخلف. في تغيير واحد، يمكنك تغيير عنصر واحد إلى أي عنصر آخر.

    على سبيل المثال:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    تم إعطاؤك مصفوفة arr من الأعداد الصحيحة، ابحث عن الحد الأدنى لعدد العناصر التي
    التي تحتاج إلى تغيير لجعل المصفوفة متناظرة. المصفوفة المتناظرة هي المصفوفة التي
    تقرأ بنفس الطريقة من الأمام والخلف. في تغيير واحد، يمكنك تغيير عنصر واحد إلى أي عنصر آخر.

    على سبيل المثال:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

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

    على سبيل المثال:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """


def total_match(lst1, lst2):
    '''
    اكتب دالة تقبل قائمتين من السلاسل النصية وتعيد القائمة التي تحتوي على
    العدد الإجمالي للأحرف في جميع السلاسل النصية في القائمة أقل من القائمة الأخرى.

    إذا كانت القائمتان تحتويان على نفس عدد الأحرف، أعد القائمة الأولى.

    أمثلة
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''

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

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

    أمثلة
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''


def is_multiply_prime(a):
    """اكتب دالة تعيد القيمة true إذا كان العدد المعطى هو حاصل ضرب 3 أعداد أولية، وfalse إذا كان غير ذلك.
    مثال:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """اكتب دالة تُرجِع صواب إذا كان العدد المُعطى هو حاصل ضرب 3 أعداد أولية
    وخلاف ذلك خطأ.
    مع العلم أن (a) أقل من 100.
    مثال:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """اكتب دالة ترجع القيمة true إذا كان الرقم المعطى هو حاصل ضرب 3 أعداد أولية
    والقيمة false بخلاف ذلك.
    مع العلم أن (a) أقل من 100.
    مثال:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """


def is_simple_power(x, n):
    """مهمتك هي كتابة دالة تعيد true إذا كان الرقم x هو أس بسيط لـ n
    و false في الحالات الأخرى.
    x هو أس بسيط لـ n إذا كان n**int=x
    على سبيل المثال:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """

def is_simple_power(x, n):
    """مهمتك هي كتابة دالة تعيد true إذا كان الرقم x هو قوة بسيطة لـ n
    و false في الحالات الأخرى.
    x هو قوة بسيطة لـ n إذا كان n**int=x
    على سبيل المثال:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """


def iscube(a):
    '''
    اكتب دالة تأخذ عددًا صحيحًا a وتعيد True
    إذا كان هذا العدد هو مكعب لعدد صحيح ما.
    ملاحظة: يمكنك افتراض أن المدخلات دائمًا صالحة.
    أمثلة:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

:def iscube(a)
    '''
    اكتب دالة تأخذ عددًا صحيحًا a وتعيد True
    إذا كان هذا العدد هو مكعب لعدد صحيح ما.
    ملاحظة: يمكنك افتراض أن المدخلات دائمًا مضبوطة.
    أمثلة:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    اكتب دالة تأخذ عددًا صحيحًا أ وتعيد صوابًا
    إذا كان هذا العدد الصحيح مكعبًا لعدد صحيح ما.
    ملاحظة: يمكنك افتراض أن المدخلات صحيحة دائماً.
    أمثلة:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''


def hex_key(num):
    """لقد تم تكليفك بكتابة دالة تستقبل
    رقمًا سداسي عشريًا كسلسلة نصية وتعد عدد الأرقام
    السداسية العشرية التي هي أعداد أولية (العدد الأولي، أو الأولي،
    هو عدد طبيعي أكبر من 1 وليس ناتج ضرب عددين طبيعيين أصغر).
    الأرقام السداسية العشرية هي 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    الأعداد الأولية هي 2, 3, 5, 7, 11, 13, 17,...
    لذا عليك تحديد عدد الأرقام التالية: 2, 3, 5, 7,
    B (=decimal 11), D (=decimal 13).
    ملاحظة: يمكنك افتراض أن المدخلات صحيحة دائمًا أو سلسلة فارغة،
    وأن الرموز A,B,C,D,E,F دائمًا بأحرف كبيرة.
    أمثلة:
    بالنسبة لـ num = "AB" يجب أن يكون الناتج 1.
    بالنسبة لـ num = "1077E" يجب أن يكون الناتج 2.
    بالنسبة لـ num = "ABED1A33" يجب أن يكون الناتج 4.
    بالنسبة لـ num = "123456789ABCDEF0" يجب أن يكون الناتج 6.
    بالنسبة لـ num = "2020" يجب أن يكون الناتج 2.
    """

def hex_key(num):
    """لقد تم تكليفك بكتابة دالة تستقبل
    رقمًا سداسيًا عشريًا كسلسلة وتحسب عدد الأرقام السداسية العشرية
    التي هي أعداد أولية (العدد الأولي، أو العدد الأولي، هو عدد طبيعي
    أكبر من 1 وليس حاصل ضرب عددين طبيعيين أصغر منه).

    الأرقام السداسية العشرية هي 0، 1، 2، 3، 4، 5، 6، 7، 8، 9، A، B، C، D، E، F.

    الأعداد الأولية هي 2، 3، 5، 7، 11، 13، 17،...
    لذا عليك تحديد عدد الأرقام التالية: 2، 3، 5، 7،
    B (=عشري 11)، D (=عشري 13).
    ملاحظة: قد تفترض أن الإدخال دائمًا صحيح أو سلسلة فارغة،
    والرموز A,B,C,D,E,F تكون دائمًا بأحرف كبيرة.
    أمثلة:

    بالنسبة لـ num = "AB" يجب أن يكون الناتج 1.
    بالنسبة لـ num = "1077E" يجب أن يكون الناتج 2.
    بالنسبة لـ num = "ABED1A33" يجب أن يكون الناتج 4.
    بالنسبة لـ num = "123456789ABCDEF0" يجب أن يكون الناتج 6.
    بالنسبة لـ num = "2020" يجب أن يكون الناتج 2.
    """


def decimal_to_binary(decimal):
    """سيتم إعطاؤك رقمًا في الشكل العشري ومهمتك هي تحويله إلى
    صيغة ثنائية. يجب أن تعيد الدالة سلسلة، مع كل حرف يمثل رقمًا ثنائيًا.
    كل حرف في السلسلة سيكون '0' أو '1'.

    سيكون هناك زوج إضافي من الأحرف 'db' في بداية ونهاية السلسلة.
    الأحرف الإضافية موجودة للمساعدة في التنسيق.

    أمثلة:
    decimal_to_binary(15)   # يعيد "db1111db"
    decimal_to_binary(32)   # يعيد "db100000db"
    """

def decimal_to_binary(decimal):
    """معطى رقمًا في الحالة العشرية ومهمتك ان تحوله إلى
    صيغة ثنائية. يعليك أن ترجع الدالة سلسلة، مع كل حرف يمثل رقمًا ثنائيًا.
    كل حرف في السلسلة سوف يكون '0' أو '1'.

    سوف يكون هناك زوج إضافي من الأحرف 'db' في بداية ونهاية السلسلة.
    الأحرف الزائدة موجودة لتساعد في التنسيق.

    أمثلة:
    decimal_to_binary(15)   # ترجع "db1111db"
    decimal_to_binary(32)   # ترجع "db100000db"
    """


def is_happy(s):
    """أنت مُعطى سلسلة نصية s.
    مهمتك هي التحقق مما إذا كانت السلسلة النصية سعيدة أم لا.
    السلسلة النصية تُعتبر سعيدة إذا كان طولها على الأقل 3 وكل 3 حروف متتالية فيها مختلفة
    على سبيل المثال:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """تم إعطاؤك سلسلة نصية s.
    مهمتك هي التحقق مما إذا كانت السلسلة النصية سعيدة أم لا.
    السلسلة النصية تُعتبر سعيدة إذا كان طولها على الأقل 3 وكل 3 حروف متتالية فيها مختلفة
    على سبيل المثال:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """بافتراض أنه تم إعطاؤك سلسلة من النصوص s.
    مهمتك هي أن تتأكد إذا كانت متسلسلة النصوص مبتهجة أم لا.
    السلسلة النصية تعد مبتهجة إذا كان طولها على الأقل 3 وكل ثلاثة حروف متتالية فيها مغايرة
    على سبيل المثال:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """


def numerical_letter_grade(grades):
    """إنه الأسبوع الأخير من الفصل الدراسي ويتعين على المعلمة إعطاء الدرجات
    للطلاب. كانت المعلمة تقوم بإنشاء خوارزمية خاصة بها للتقييم.
    المشكلة الوحيدة هي أنها فقدت الكود الذي استخدمته للتقييم.
    لقد أعطتك قائمة بمعدلات النقاط التراكمية لبعض الطلاب وعليك كتابة دالة يمكنها إخراج قائمة بالدرجات بالحروف باستخدام الجدول التالي:
    GPA | درجة بالحروف
    4.0 A+
    > 3.7 A
    > 3.3 A-
    > 3.0 B+
    > 2.7 B
    > 2.3 B-
    > 2.0 C+
    > 1.7 C
    > 1.3 C-
    > 1.0 D+
    > 0.7 D
    > 0.0 D-
    0.0 E

    مثال:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """إنه الأسبوع الأخير من الفصل الدراسي والمعلم يجب أن يعطي الدرجات
    للطلاب. لقد كانت المعلمة تصنع خوارزميتها الخاصة للتقييم.
    المشكلة الوحيدة هي أنها فقدت الكود الذي استخدمته للتقييم.
    لقد أعطتك قائمة من المعدلات التراكمية لبعض الطلاب وعليك كتابة
    دالة يمكنها إخراج قائمة من الدرجات الحرفية باستخدام الجدول التالي:
             GPA       |    Letter grade
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    Example:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """إنه الأسبوع الأخير من الفصل الدراسي والمعلم يجب أن يعطي الدرجات
    للطلاب. لقد كانت المعلمة تصنع خوارزميتها الخاصة للتقييم.
    المشكلة الوحيدة هي أنها فقدت الكود الذي استخدمته للتقييم.
    لقد أعطتك قائمة من المعدلات التراكمية لبعض الطلاب وعليك كتابة
    دالة يمكنها إخراج قائمة من الدرجات الحرفية باستخدام الجدول التالي:
             المعدل التراكمي |    الدرجة الحرفية
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    مثال:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """


def prime_length(string):
    """تأخذ هذه الدالة سلسلة نصية وتتحقق مما إذا كان طول السلسلة
    عددًا أوليًا. إذا كان العدد أوليًا، تعيد True، وإذا لم يكن كذلك، تعيد False.
    أمثلة:
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """اكتب دالة تأخذ سلسلة وتعيد القيمة True إذا كان طول السلسلة عددًا أوليًا أو False إذا كان غير ذلك .
    أمثلة
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """اكتب دالة تأخذ سلسلة نصية وتعيد True إذا كان طول السلسلة عددًا أوليًا أو False خلاف ذلك
    أمثلة
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """


def starts_one_ends(n):
    """
    بالنظر إلى عدد صحيح موجب n، أعد عدد الأعداد الصحيحة الموجبة ذات n أرقام
    التي تبدأ أو تنتهي بالرقم 1.
    """

def starts_one_ends(n):
    """
    معطى عددا صحيحا موجبا n، قم بإعادة عدد الأعداد الصحيحة الموجبة لها n أرقام
    التي تبدأ أو تنتهي بالرقم 1.
    """

:def starts_one_ends(n)
    """
    بالنظر إلى العدد الصحيح الموجب n، أعد عدد الأعداد الصحيحة الموجبة ذات n خانات
    التي تبدأ أو تنتهي بالرقم 1.
    """


def solve(N):
    """معطى عددا صحيحا موجبا N، أرجع مجموع أرقامه في النظام الثنائي.

    مثال
        لـ N = 1000، مجموع الأرقام سيكون 1، على الناتج أن يكون "1".
        لـ N = 150، مجموع الأرقام سيكون 6، على الناتج أن يكون "110".
        لـ N = 147، مجموع الأرقام سيكون 12، على الناتج أن يكون "1100".

    المتغيرات:
        @N عدد صحيح
             القيود: 0 ≤ N ≤ 10000.
    المخرجات:
         سلسلة نصية لعدد ثنائي
    """

def solve(N):
    """بإعطائك عددا صحيحا موجبا N، أرجع حاصل جمع أرقامه في نظام ثنائي.

    مثال
        لـ N = 1000، مجموع الأرقام سوف يكون 1،  الناتج يجب أن يكون  "1".
        لـ N = 150، مجموع الأرقام سوف يكون 6،  الناتج يجب أن يكون  "110".
        لـ N = 147، مجموع الأرقام سوف يكون 12،  الناتج يجب أن يكون "1100".

    المتغيرات:
        @N عدد صحيح
             القيود: 0 ≤ N ≤ 10000.
    المخرجات:
         متسلسلة نصية لعدد ثنائي
    """

def solve(N):
    """معطى عدد صحيح موجب N، أعد مجموع أرقامه في النظام الثنائي.

    مثال
        For N = 1000، مجموع الأرقام سيكون 1، يجب أن يكون الناتج "1".
        For N = 150، مجموع الأرقام سيكون 6، يجب أن يكون الناتج "110".
        For N = 147، مجموع الأرقام سيكون 12، يجب أن يكون الناتج "1100".

    المتغيرات:
        @N عدد صحيح
             القيود: 0 ≤ N ≤ 10000.
    المخرجات:
         سلسلة نصية لعدد ثنائي
    """


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

    أمثلة:
        add([4, 2, 6, 7]) ==> 2
    """

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

    أمثلة:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """بناءً على قائمة غير فارغة من الأعداد الصحيحة lst، قم بإضافة العناصر الزوجية التي تقع في الفهارس الفردية..

    أمثلة:
        add([4, 2, 6, 7]) ==> 2
    """


def anti_shuffle(s):
    """
    اكتب دالة تأخذ سلسلة نصية وتُرجع نسخة مرتبة منها.
    النسخة المرتبة من السلسلة هي سلسلة يتم فيها استبدال كل الكلمات (المفصولة بمسافة)
    بكلمة جديدة حيث يتم ترتيب جميع الحروف فيها بترتيب تصاعدي استنادًا إلى قيمتها في ASCII.
    ملاحظة: يجب الحفاظ على ترتيب الكلمات والمسافات الفارغة في الجملة.

    على سبيل المثال:
    anti_shuffle('Hi') تُرجع 'Hi'
    anti_shuffle('hello') تُرجع 'ehllo'
    anti_shuffle('Hello World!!!') تُرجع 'Hello !!!Wdlor'
    """

:def anti_shuffle(s)
    """
    اكتب دالة تأخذ سلسلة نصية وتعيد نسخة مرتبة منها.
    النسخة المرتبة من السلسلة النصية، هي سلسلة نصية حيث يتم استبدال جميع الكلمات (المفصولة بمسافة)
     بكلمة جديدة بحيث يتم ترتيب جميع الأحرف بترتيب تصاعدي
  بناءً على قيمتها تبعًا لشفرة  ascii.
    ملاحظة: يجب عليك الحفاظ على ترتيب الكلمات والمسافات الفارغة في الجملة.

    على سبيل المثال:
    anti_shuffle('Hi') تعيد 'Hi'
    anti_shuffle('hello') تعيد 'ehllo'
    anti_shuffle('Hello World!!!') تعيد 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    قم بكتابة دالة تقوم بأخذ سلسلة من النصوص وترجع نسخة مرتبة منها.

    النسخة المرتبة في متسلسلة نصية، هي سلسلة يتم فيها استبدال جميع الكلمات
    (المفصولة بمسافة) بكلمة جديدة حيث يتم ترتيب جميع الأحرف بترتيب ترتيب جميع الأحرف تصاعديا
    بناءً على قيمة ascii.
    ملاحظة: يتوجب عليكأن تحافظ على ترتيب الكلمات والمسافات الفارغة في الجملة.

    على سبيل المثال:
    anti_shuffle('Hi') تعيد 'Hi'
    anti_shuffle('hello') تعيد 'ehllo'
    anti_shuffle('Hello World!!!') تعيد 'Hello !!!Wdlor'
    """


def get_row(lst, x):
    """
    لديك بيانات ثنائية الأبعاد على شكل قوائم متداخلة،
    وهي تشبه المصفوفة، ولكن على عكس المصفوفات، قد تحتوي كل صف
    على عدد مختلف من الأعمدة.
    بالنظر إلى lst وعدد صحيح x، قم بالبحث عن العدد x داخل القائمة،
    وأعد قائمة من الأزواج [(x1, y1), (x2, y2) ...] بحيث يمثل كل زوج
    إحداثيات - (الصف، العمود)، بدءًا من 0.
    قم بفرز الإحداثيات حسب الصفوف بترتيب تصاعدي أولاً،
    ثم قم بفرز الإحداثيات في الصف الواحد حسب الأعمدة بترتيب تنازلي.

    أمثلة:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    لديك بيانات ثنائية الأبعاد، كقوائم متداخلة،
    والتي تشبه المصفوفة، ومع ذلك، على عكس المصفوفات،
    قد يحتوي كل صف على عدد مختلف من الأعمدة.
    بالنظر إلى lst، والعدد الصحيح x، ابحث عن الأعداد الصحيحة x في القائمة،
    وأعد قائمة من الأزواج، [(x1, y1), (x2, y2) ...] بحيث
    كل زوج هو إحداثيات - (صف، أعمدة)، بدءًا من 0.
    قم بترتيب الإحداثيات في البداية حسب الصفوف بترتيب تصاعدي.
    و أيضًا، قم بترتيب إحداثيات الصف حسب الأعمدة بترتيب تنازلي.

    أمثلة:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    لديك بيانات ثنائية الأبعاد، كقوائم متداخلة،
    والتي تشبه المصفوفة، ومع ذلك، على عكس المصفوفات،
    قد تحتوي كل صف على عدد مختلف من الأعمدة.
    بالنظر إلى lst، والعدد الصحيح x، ابحث عن الأعداد الصحيحة x في القائمة،
    وأعد قائمة من الأزواج، [(x1, y1), (x2, y2) ...] بحيث
    كل زوج هو إحداثي - (صف، أعمدة)، بدءًا من 0.
    قم بترتيب الإحداثيات في البداية حسب الصفوف بترتيب تصاعدي.
    أيضًا، قم بترتيب إحداثيات الصف حسب الأعمدة بترتيب تنازلي.

    أمثلة:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """


def sort_array(array):
    """
    تم إعطاؤك مصفوفة من الأعداد الصحيحة غير السالبة، أرجع نسخة من المصفوفة المعطاة بعد الفرز.
    ستقوم بفرز المصفوفة المعطاة بترتيب تصاعدي إذا كان مجموع (قيمة الفهرس الأول، قيمة الفهرس الأخير) فرديًا،
    أو قم بفرزها بترتيب تنازلي إذا كان مجموع (قيمة الفهرس الأول، قيمة الفهرس الأخير) زوجيًا.

    ملاحظة:
    * لا تقم بتغيير المصفوفة المعطاة.

    أمثلة:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    بالنظر إلى مصفوفة من الأعداد الصحيحة غير السالبة، تُرجع نسخة من المصفوفة بعد الفرز.
    ستقوم بفرز المصفوفة بترتيب تصاعدي إذا كان مجموع (قيمة العنصر الأول، قيمة العنصر الأخير) فرديًا،
    أو بترتيب تنازلي إذا كان المجموع زوجيًا.

    ملاحظة:
    * لا تقم بتغيير المصفوفة المُعطاة.

    أمثلة:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

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

    ملاحظة:
    * لا تغير المصفوفة المعطاة.

    أمثلة:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """


def encrypt(s):
    """قم بإنشاء دالة تسمى encrypt تأخذ سلسلة نصية كمعامل
    وتعيد سلسلة مشفرة حيث يتم تدوير الأحرف في الأبجدية.
    يتم تدوير الأحرف بطريقة تتحرك فيها الحروف بمقدار يساوي ضعف
    اثنين من المواقع في الأبجدية.
    على سبيل المثال:
    encrypt('hi') تعيد 'lm'
    encrypt('asdfghjkl') تعيد 'ewhjklnop'
    encrypt('gf') تعيد 'kj'
    encrypt('et') تعيد 'ix'
    """

def encrypt(s):
    """قم بإنشاء دالة تشفير تأخذ سلسلة نصية كعامل وتعيد سلسلة نصية مشفرة مع تدوير الأبجدية.

    يجب أن تقوم بتدوير الأبجدية بطريقة تجعل الحروف
    تتحرك للأسفل بمقدار أربعة مرات.
    على سبيل المثال:
    encrypt('hi') تعيد 'lm'
    encrypt('asdfghjkl') تعيد 'ewhjklnop'
    encrypt('gf') تعيد 'kj'
    encrypt('et') تعيد 'ix'
    """

def encrypt(s):
    """قم بإنشاء دالة تشفير تأخذ سلسلة كوسيطة
    تُرجع سلسلة مشفرة بالأبجدية التي يتم تدويرها.
    يجب تدوير الحروف الأبجدية بطريقة تجعل الحروف
    إلى أسفل بمقدار اثنين في اثنين.
    على سبيل المثال
    encrypt('hi') returns 'lm'
    encrypt('asdfghjkl') returns 'ewhjklnop'
    encrypt('gf') returns 'kj'
    encrypt('et') returns 'ix'
    """


def next_smallest(lst):
    """
    معطى قائمة من الأعداد الصحيحة.
    قم بكتابة دالة next_smallest() تعيد ثاني أصغر عنصر في القائمة.
    وتعيد None إذا لم يوجد مثل هذا العنصر.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """

def next_smallest(lst):
    """
    لديك قائمة من الأعداد الصحيحة.
    اكتب دالة next_smallest() تُرجع ثاني أصغر عنصر في القائمة.
    إذا لم يوجد هذا العنصر، تُرجع None.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """

def next_smallest(lst)
    """
    لديك قائمة من الأعداد الصحيحة.
    اكتب دالة تدعى next_smallest() تقوم بإعادة العنصر الثاني الأصغر في القائمة.
    أرجع None إذا لم يكن هناك مثل هذا العنصر.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None


def is_bored(S):
    """
    سيتم إعطاؤك سلسلة من الكلمات، ومهمتك هي حساب عدد الملل.
    الملل هو جملة تبدأ بالكلمة "I".
    يتم تحديد الجمل بواسطة '.', '?' أو '!'.

    على سبيل المثال:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    ”"“
    سيتم إعطاؤك سلسلة من الكلمات، ومهمتك هي حساب عدد
    الجمل المملة، الجملة المملة هي جملة تبدأ بكلمة ”أنا“،
    يتم تحديد الجمل بـ ”.“ أو ”؟“ أو ”!“.

    على سبيل المثال
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """


def any_int(x, y, z):
    '''
    أنشئ دالة تأخذ 3 أرقام.
    تُرجع True إذا كان أحد الأرقام يساوي مجموع الرقمين الآخرين، وجميع الأرقام هي أعداد صحيحة.
    تُرجع False في أي حالة أخرى.

    أمثلة
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False
    '''

:def any_int(x, y, z)
    '''
    قم بإنشاء دالة تأخذ 3 أرقام.
    تقوم بإرجاع true إذا كان أحد الأرقام يساوي مجموع الرقمين الآخرين، وجميع الأرقام أعداد صحيحة.
    تقوم بإرجاع false في أي حالة أخرى.

    أمثلة
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False
    '''

def any_int(x, y, z):
    '''

    قم بإنشاء دالة تأخذ 3 أرقام.

    ترجع القيمة true إذا كان أحد الأرقام يساوي مجموع الرقمين الآخرين، وكانت جميع الأرقام أعدادًا صحيحة.

    ترجع القيمة false في أي حالات مختلفه.

    الأمثلة
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''


def encode(message):
    """اكتب دالة تأخذ رسالة، وتقوم بترميزها بطريقة
    تقوم بتبديل حالة جميع الحروف، واستبدال جميع الحروف المتحركة في
    الرسالة بالحرف الذي يظهر بعد حرفين من الحرف المتحرك في الأبجدية الإنجليزية.
    افترض أنه لا يوجد سوى الحروف.

    الأمثلة:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    اكتب دالة تأخذ رسالة، وتقوم بتشفيرها بطريقة
    تقوم بتبديل حالة جميع الأحرف، وتستبدل جميع الحروف المتحركة في
    الرسالة بالحرف الذي يظهر بعد حرفين من ذلك
    الحرف المتحرك في الأبجدية الإنجليزية.
    افترض وجود أحرف فقط.

    أمثلة:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    قم بكتابة دالة تأخذ رسالة، ثم تشفرها بحيث
     تبدل حالة جميع الحروف، وتستعيض عن كل الحروف الصوتية في
    الرسالة بالحرف الذي يأتي بعد حرفين من
    الحرف الصوتي في الأبجدية الإنجليزية.
     افترض أن الرسالة تحتوي على أحرف فقط.

    أمثلة:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """


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

    أمثلة:
    للقائمة lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] يجب أن يكون الناتج 10
    للقائمة lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] يجب أن يكون الناتج 25
    للقائمة lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] يجب أن يكون الناتج 13
    للقائمة lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] يجب أن يكون الناتج 11
    للقائمة lst = [0,81,12,3,1,21] يجب أن يكون الناتج 3
    للقائمة lst = [0,8,1,2,1,7] يجب أن يكون الناتج 7
    """

def skjkasdkd(lst):
    """لقد تم إعطاؤك قائمة من الأعداد الصحيحة.

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

    الأمثلة:
    بالنسبة لـ lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] يجب أن يكون الناتج 10
    بالنسبة لـ lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] يجب أن يكون الناتج 25
    بالنسبة لـ lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] يجب أن يكون الناتج 13
    بالنسبة لـ lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] يجب أن يكون الناتج 11
    بالنسبة لـ lst = [0,81,12,3,1,21] يجب أن يكون الناتج 3
    بالنسبة لـ lst = [0,8,1,2,1,7] يجب أن يكون الناتج 7
    """

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

    أمثلة:
    للقائمة lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] يجب أن يكون الناتج 10
    للقائمة lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] يجب أن يكون الناتج 25
    للقائمة lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] يجب أن يكون الناتج 13
    للقائمة lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] يجب أن يكون الناتج 11
    للقائمة lst = [0,81,12,3,1,21] يجب أن يكون الناتج 3
    للقائمة lst = [0,8,1,2,1,7] يجب أن يكون الناتج 7
    """


def check_dict_case(dict):
    """
    معطى قاموسا، أعد True في حال كانت جميع المفاتيح عبارة عن سلاسل
    بحروف صغيرة أو جميع المفاتيح سلاسلا ذات أحرف كبيرة، وإلا أعد False.
    يجب علي الدالة أن تعيد False إذا كان القاموس المعطى فارغًا.
    أمثلة:
    check_dict_case({"a":"apple", "b":"banana"}) يجب أن تعيد True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) يجب أن تعيد False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) يجب أن تعيد False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) يجب أن تعيد False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) يجب أن تعيد True.
    """

def check_dict_case(dict):
    """
    بإعطائك قاموسا، أرجع True في حال كانت كل المفاتيح عبارة عن سلاسل
    بأحرف صغيرة أو كل المفاتيح سلاسل بأحرف كبيرة، غير ذلك أرجع False.
    على الدالة أن ترجع False إذا كان القاموس المعطى شاغرا.
    أمثلة:
    check_dict_case({"a":"apple", "b":"banana"}) يجب أن تعيد True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) يجب أن تعيد False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) يجب أن تعيد False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) يجب أن تعيد False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) يجب أن تعيد True.
    """

:def check_dict_case(dict)
    """
    بالنظر إلى أحد القواميس، قم بإرجاع True إذا كانت جميع المُعرّفات (keys) عبارة عن سلاسل نصية
    بحروف صغيرة أو إذا كانت جميع المٌعرّفات عبارة عن سلاسل نصية بحروف كبيرة، وإلا قم بإرجاع False.
    إذا كان القاموس المعطى فارغًا, يجب أن تعيد الدالة False
    أمثلة:
    check_dict_case({"a":"apple", "b":"banana"}) يجب أن تعيد True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) يجب أن تعيد False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) يجب أن تعيد False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) يجب أن تعيد False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) يجب أن تعيد True.
    """