from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Angalia kama kuna namba mbili zozote kwenye orodha ya namba zilizotolewa ambazo ziko karibu zaidi ya kizingiti kilichowekwa
    >>> 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(nambari: Orodha[float], mpaka: float) -> bool:
    """ Angalia ikiwa katika orodha ya nambari zilizotolewa, kuna nambari mbili karibu zaidi na kila mmoja kuliko kizingiti kilichotolewa.
    >>> 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]:
    """ Kazi hii inapokea kamba yenye vikundi vingi vya mabano yaliyopangwa. Lengo ni kutenganisha vikundi hivi
    kuwa kamba tofauti na kurudisha kama orodha ya kamba hizo.
    Vikundi vilivyotenganishwa vitakuwa na usawa (kila bano la kufungua litafungwa ipasavyo) na havitapangwa.
    Puuza nafasi katika kamba iliyoingizwa.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """


def truncate_number(number: float) -> float:
    """ Kulingana na nambari halisi chanya, inaweza kugawanywa katika sehemu ya nambari kamili
    (nambari kamili kubwa zaidi kwenye nambari fulani) na sehemu ya desimali
    (sehemu iliyobaki ambayo daima ni ndogo kuliko 1)

    Rudisha sehemu ya desimali ya nambari
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """Inapopokea sehemu ya desimali ya nambari chanya, inaweza kugawanywa katika sehemu ya nambari kamili
    (nambari kamili kubwa zaidi ambayo ni ndogo kuliko nambari iliyotolewa) na sehemu ya desimali
    (Sehemu iliyobaki ambayo daima ni ndogo kuliko 0)

    Rudisha sehemu ya desimali ya nambari
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ Inapopokea sehemu ya desimali ya nambari chanya, inaweza kugawanywa katika sehemu ya nambari kamili
    (nambari kamili kubwa zaidi ambayo ni ndogo kuliko nambari iliyotolewa) na sehemu ya desimali
    (sehemu iliyobaki ambayo daima ni ndogo kuliko 0)

    Rudisha sehemu ya desimali ya nambari
    >>> truncate_number(3.5)
    0.5
    """


from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Unapewa orodha ya shughuli za kuweka na kuondoa kwenye akaunti ya benki inayoanza nayo
    sifuri usawa. Kazi yako ni kugundua ikiwa wakati wowote usawa wa akaunti unaanguka chini ya sifuri, na
    wakati huo kazi inapaswa kurudi Kweli. Vinginevyo inapaswa kurudi Uongo.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Kutoa orodha ya amana na uondoaji kwenye akaunti ya benki. Akaunti hii huanza na salio la sifuri.
    Kazi yako ni kuangalia kama salio la akaunti linashuka chini ya sifuri, na katika hatua hiyo kazi inapaswa kurudisha True.
    Ikiwa sivyo, inapaswa kurudisha False.
    >>> 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:
    """ Kwa orodha fulani ya nambari za ingizo, hesabu Wastani wa Mkengeuko Kabisa
    kwenye wastani wa mkusanyiko huu wa data.
    Wastani wa Mkengeuko Kabisa ni wastani wa tofauti kamili kati ya kila moja
    kipengele na kituo (maana katika kesi hii):
    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:
    """ Kuhesabu upotofu wa wastani kabisa kwa kutumia wastani kama kitovu
    kwa orodha ya nambari zilizotolewa
    Upotofu wa wastani kabisa ni wastani wa tofauti kabisa
    kati ya kila kipengele na kitovu (katika kesi hii ni wastani):
    MAD = wastani | 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]:
    """ Weka namba 'delimeter' kati ya vipengele vinavyoendelea katika orodha ya ingizo `numbers`
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(nambari: List[int], delimeter: int) -> List[int]:
    """ Ingiza nambari 'delimeter' kati ya kila vipengele viwili mfululizo vya orodha ya ingizo `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]:
    """ Kazi hii inapokea kamba inayoonyesha vikundi vya mabano yaliyopachikwa
    vingi vilivyotenganishwa na nafasi. Kwa kila kikundi, onyesha kiwango cha
    upachikaji wa mabano kilicho cha ndani zaidi.
    Mfano: (()()) ina upachikaji wa kiwango cha juu cha 2, na ((())) ina kiwango cha 3

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


kutoka typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Chuja orodha ya pembejeo ya kamba kwa zile tu zinazojumuisha nukta kidogo iliyopewa
    >>> 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]:
    """Chuja orodha ya pembejeo ya nyuzi kwa zile tu ambazo zina sehemu ndogo iliyotolewa.
    >>> 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]:
    """ Chuja orodha ya pembejeo ya nyuzi kwa zile tu ambazo zina sehemu ndogo iliyotolewa.
    >>> 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]:
    """ Rudisha tuple inayojumuisha jumla na kuzidisha kwa nambari zote kamili kwenye orodha iliyotolewa
    Jumla ya orodha tupu inapaswa kuwa sawa na 0 na kuzidisha kwa orodha tupu inapaswa kuwa sawa na 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]:
    """ Kwa orodha fulani ya nambari kamili, rudisha nakala inayojumuisha jumla na bidhaa ya nambari zote kamili kwenye orodha.
    Jumla tupu inapaswa kuwa sawa na 0 na bidhaa tupu inapaswa kuwa sawa na 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]:
    """ Tengeneza orodha ya vipengele vya juu zaidi vya kuviringisha vilivyopatikana hadi hatua maalum katika mlolongo kutoka kwenye orodha ya nambari kamili iliyotolewa
    >>> 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]:
    """ Kutoka kwa orodha fulani ya nambari kamili, toa orodha ya vipengee vya juu zaidi vinavyopatikana hadi wakati fulani
    katika mlolongo.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """


def is_palindrome(string: str) -> bool:
    """ Jaribu ikiwa kamba iliyotolewa ni palindrome """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Pata palindrome fupi zaidi ambayo inanza na kamba iliyotolewa.
    Wazo la algorithimu ni kama ifuatavyo:
    - Tafuta sehemu ya mwisho ndefu zaidi ya string ambayo ni palindrome
    - Ongeza hadi mwisho ya mfuatano kinyume cha kiambishi awali kinachokuja kabla ya kiambishi tamati cha palindrome.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ Kujaribu kama string iliyotolewa ni palindrome """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Tafuta palindrome fupi zaidi inayotokana na string iliyotolewa
    Wazo la algorithimu ni kama ifuatavyo:
    - Tafuta sehemu ya mwisho ndefu zaidi ya string ambayo ni palindrome
    - Chukua sehemu ya mwanzo ya string kabla ya sehemu ya mwisho ya palindrome, geuza na ongeza mwishoni mwa string
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


from typing import List

def string_xor(a: str, b: str) -> str:
    """ Ingizo ni mistari miwili a na b ambayo ina 1 na 0 pekee
    Fanya XOR ya nambari ya msingi mbili na ingizo hizi na rudisha matokeo kama mfululizo
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ Ingizo ni mfuatanao mbili a na b zinazojumuisha 1 na 0 pekee.
    Tekeleza tofauti ya binary kwenye ingizo hizi na matokeo ya kurejesha pia kama mfuatano.
    >>> string_xor('010', '110')
    '100'
    """


from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ Kamba ndefu zaidi katika orodha ya kamba itarejeshwa. Ikiwa kuna kamba kadhaa zenye urefu sawa, ya kwanza itarejeshwa.
    Ikiwa orodha ya pembejeo ni tupu, itarejeshwa None.
    >>> longest([])

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ Nje ya orodha ya mifuatano, rudisha ile ndefu zaidi. Rudisha ya kwanza ikiwa ni nyingi
    kamba za urefu sawa. Usirudishe Iwapo orodha ya ingizo haina kitu.
    >>> longest([])

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


def greatest_common_divisor(a: int, b: int) -> int:
    """ Rudisha kigawanyiko kikubwa zaidi cha nambari mbili kamili a na b
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ Rudisha kipimo kikubwa zaidi cha pamoja cha nambari mbili nzima a na b
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """


from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Rudisha orodha ya awali zote kutoka fupi hadi ndefu za kamba ya pembejeo
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Rudisha orodha ya viambishi vyote kutoka kifupi zaidi hadi kirefu zaidi cha kamba iliyoingizwa
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """


def string_sequence(n: int) -> str:
    """ Rudisha kamba iliyotenganishwa na nafasi ambayo ina nambari kutoka 0 hadi n
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ Rudisha mfuatano ulio na nambari zilizotenganishwa na nafasi kuanzia 0 hadi n zikijumlishwa.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """


def count_distinct_characters(string: str) -> int:
    """ Ukipewa kamba, tafuta ni aina ngapi za herufi tofauti zilizopo bila kujali herufi kubwa na ndogo
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ Ukipewa nyuzi, gundua ina herufi ngapi tofauti (bila kujali herufi kubwa au ndogo).
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """


from typing import List

def parse_music(music_string: str) -> List[int]:
    """ Kazi ya kazi hii ni kupokea kamba inayoonyesha noti za muziki katika muundo maalum wa ASCII
    Kazi yako ni kuchanganua kamba hii na kurudisha orodha ya nambari za mzima zinazolingana na idadi ya midundo ambayo kila noti inachukua

    Hadithi ni kama ifuatavyo:
    'o' - noti kamili, inachukua midundo 4
    'o|' - noti nusu, inachukua midundo 2
    '.|' - noti robo, inachukua mdundo 1

    >>> 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]:
    """ Ingizo la chaguo hili la kukokotoa ni mfuatano unaowakilisha noti za muziki katika umbizo maalum la ASCII.
    Kazi yako ni kuchanganua mfuatano huu na kurejesha orodha ya nambari kamili zinazolingana na midundo mingapi kila moja
    sio mwisho.

    Hapa kuna hadithi:
    'o' - noti nzima, hudumu midundo minne
    'o|' - noti nusu, hudumu midundo miwili
    '.|' - noti ya robo, hudumu mpigo mmoja

    >>> 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:
    """ Angalia ni mara ngapi substring iliyotajwa inapatikana katika string ya asili, ikijumuisha matukio yanayorudiwa
    >>> 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:
    """ Pata ni mara ngapi kamba ndogo iliyotolewa inaweza kupatikana katika mfuatano asili. Hesabu kesi zinazoingiliana.
    >>> 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:
    """ Ingizo ni kamba ya namba kutoka 'sufuri' hadi 'tisa' zilizotenganishwa na nafasi
    Chaguo sahihi ni 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'
    Rudisha kamba ya namba zilizopangwa kutoka ndogo hadi kubwa
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ Ingizo ni mfuatano wa nambari uliotenganishwa na nafasi kutoka 'sifuri' hadi 'tisa'.
    Chaguo halali ni 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
    Rudisha mfuatano na nambari zilizopangwa kutoka ndogo hadi kubwa zaidi
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ Ingizo ni kamba ya namba kutoka 'zero' hadi 'nine' zilizotenganishwa na nafasi
    Chaguo sahihi ni 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'
    Rudisha kamba ya namba zilizopangwa kutoka ndogo hadi kubwa
    >>> sort_numbers('three one five')
    'one three five'
    """


from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ Chagua namba mbili ambazo ziko karibu zaidi kutoka kwenye orodha ya namba zilizotolewa (urefu angalau 2 au zaidi)
    na rudisha kwa mpangilio (namba ndogo, namba kubwa)
    >>> 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]:
    """ Kutoka kwa orodha iliyotolewa ya nambari (za urefu angalau mbili) chagua na urudishe mbili ambazo ziko karibu zaidi kwa kila moja
    nyingine na kuzirudisha kwa mpangilio (nambari ndogo, idadi kubwa).
    >>> 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]:
    """ Inapopewa orodha ya namba zenye angalau vipengele 2, tumia mabadiliko ya mstari kwenye orodha hiyo
    ili namba ndogo zaidi iwe 0 na namba kubwa zaidi iwe 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

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Kwa kuzingatia orodha ya nambari (ya angalau vipengele viwili), tumia ubadilishaji wa mstari kwenye orodha hiyo,
    ili nambari ndogo zaidi itakuwa 0 na kubwa itakuwa 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]:
    """ Chuja nambari kamili pekee kutoka kwenye orodha ya thamani yoyote ya Python iliyotolewa
    >>> 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]:
    """ Kichujio kilichopewa orodha ya thamani zozote za chatu kwa nambari kamili pekee
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """


def strlen(string: str) -> int:
    """ Rudisha urefu wa kamba iliyotolewa
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(kamba: str) -> int:
    """ Rudisha urefu wa mfuatano fulani
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


def largest_divisor(n: int) -> int:
    """Kwa nambari fulani n, pata nambari kubwa zaidi inayogawanya n kwa usawa, ndogo kuliko n.
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ Tafuta nambari kubwa zaidi iliyo chini ya n ambayo inaweza kugawanya n bila baki
    >>> largest_divisor(15)
    5
    """


from typing import List

def factorize(n: int) -> List[int]:
    """ Rudisha orodha ya vipengele vya msingi vya nambari kamili iliyotolewa kwa mpangilio kutoka ndogo hadi kubwa
    Kila kipengele lazima kijumuishe kwenye orodha kulingana na idadi ya mara kinavyojitokeza katika mgawanyiko
    Nambari iliyoingizwa lazima iwe sawa na bidhaa ya vipengele vyote
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ Rejesha orodha ya vipengele vikuu vya nambari kamili iliyotolewa kwa mpangilio kutoka ndogo hadi kubwa zaidi.
    Kila moja ya vipengele vinapaswa kuorodheshwa idadi ya nyakati zinazolingana na mara ngapi inatulia katika uainishaji.
    Nambari ya pembejeo inapaswa kuwa sawa na bidhaa ya mambo yote
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """


from typing import List

def ondoa_duplicates(numbers: List[int]) -> List[int]:
    """ Kutoka kwa orodha ya nambari kamili, ondoa vipengele vyote vinavyotokea zaidi ya mara moja.
    Weka mpangilio wa vipengee vilivyoachwa sawa na kwenye ingizo.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Ondoa kila kipengele kinachoonekana zaidi ya mara moja kutoka kwenye orodha ya nambari nzima
    Hifadhi mpangilio wa vipengele vilivyobaki sawa na pembejeo
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """


def flip_case(string: str) -> str:
    """ Badilisha herufi ndogo kuwa herufi kubwa na herufi kubwa kuwa herufi ndogo katika kamba iliyotolewa
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ Kwa mfuatano fulani, pindua herufi ndogo kwa herufi kubwa na herufi kubwa kwa herufi ndogo.
    >>> flip_case('Hello')
    'hELLO'
    """


from typing import List

def concatenate(strings: List[str]) -> str:
    """Unganisha orodha ya nyuzi kuwa nyuzi moja.
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ Unganisha orodha ya mistari kuwa mstari mmoja
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """


from typing import List

def filter_by_prefix (nyuzi: List[str], kiambishi awali: str) -> List[str]:
    """ Chuja orodha ya ingizo ya mifuatano kwa zile zinazoanza na kiambishi awali fulani.
    >>> 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]:
    """ Chuja orodha ya mistari iliyoingizwa ili kubaki na zile tu zinazotangulia na kiambishi awali kilichobainishwa
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """


def get_positive(l: list):
    """Rudisha nambari chanya pekee kwenye orodha
    >>> 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: orodha):
    """Rudisha nambari chanya pekee kwenye orodha.
    >>> 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):
    """Rudisha kweli ikiwa nambari iliyotolewa ni nambari ya kwanza, vinginevyo rudisha si kweli
    >>> 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):
    """Rudisha kweli ikiwa nambari iliyotolewa ni nambari ya pekee, vinginevyo rudisha si kweli
    >>> 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):
    """
    Tambua thamani ya polinomu yenye vigezo xs katika nukta 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 ni vigezo vya polinomu
    find_zero itatafuta thamani ya x inayofanya poly(x) = 0
    find_zero itarudisha nukta moja tu ya sifuri, hata kama kuna majibu mengi
    Zaidi ya hayo, find_zero itakubali tu orodha ya xs yenye idadi ya vigezo kuwa nambari shufwa
    na yenye vigezo visivyo sifuri zaidi
    >>> 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):
    """ Chaguo hili la kukokotoa huchukua orodha l na kurudisha orodha l' hivi
    l' ni sawa na l katika dalili ambazo haziwezi kugawanywa na tatu, wakati maadili yake katika dalili ambazo zinaweza kugawanywa na tatu ni sawa
    kwa maadili ya dalili zinazolingana za l, lakini zimepangwa.
    >>> 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):
    """Kazi hii inapokea orodha l na kurudisha orodha l'
    l' itakuwa sawa na l katika faharasa ambazo haziwezi kugawanywa kwa 3 bila baki, na thamani katika faharasa zinazogawanyika kwa 3 bila baki
    zitakuwa thamani zilizopangwa kutoka kwa faharasa zinazolingana katika 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):
    """Rudisha vipengele vya kipekee vilivyopangwa katika orodha
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """Rudisha orodha iliyopangwa na isiyo na nakala katika orodha
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def ya kipekee(l: list):
    """Rudisha orodha iliyopangwa na isiyo na nakala katika orodha
    >>> ya kipekee([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


def max_element(l: list):
    """Rudisha kipengele kikubwa zaidi katika orodha
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """

def max_element(l: orodha):
    """Rudisha kipengele cha juu zaidi kwenye orodha.
    >>> 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):
    """Rudisha idadi ya mara tarakimu 7 inaonekana katika nambari kamili chini ya n ambazo zinaweza kugawanywa na 11 au 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """Rudisha idadi ya mara ambazo namba 7 inaonekana katika nambari nzima chini ya n ambayo inagawanyika kwa 11 au 13
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """


def sort_even(l: list):
    """Kazi hii inapokea orodha l na kurudisha orodha l'
    l' itakuwa sawa na l kwenye faharasa zisizo za jozi, na thamani kwenye faharasa za jozi zitakuwa sawa na
    thamani kwenye faharasa za jozi za l ambazo zimepangwa
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """ Chaguo hili la kukokotoa huchukua orodha l na kurudisha orodha l' hivi
    l' ni sawa na l katika dalili zisizo za kawaida, wakati maadili yake katika dalili sawa ni sawa
    kwa maadili ya dalili hata za l, lakini zimepangwa.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """


def encode_cyclic(s: str):
    """
    Rudisha ujumbe uliofichwa kwa kuzungusha vikundi vya herufi 3
    """
    # Gawanya ujumbe katika vikundi, kila kikundi kina urefu wa 3
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # Zungusha vipengele katika kila kikundi isipokuwa pale ambapo kikundi kina vipengele chini ya 3
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    Pokea ujumbe uliofichwa na kazi ya encode_cyclic na rudisha ujumbe uliofichuliwa
    """

def encode_cyclic(s: str):
    """
    inarudisha nyuzi iliyosimbwa kwa kuzungusha vikundi vya herufi tatu.
    """
    # gawanya nyuzi kwa vikundi. Kila moja ina urefu wa 3.
    vikundi = [s[(3 * i):min((3 * i + 3), len(s))] kwa i katika safu ((len(s) + 2) // 3)]
    # zungusha vipengele katika kila kundi. Isipokuwa kundi lina vipengele vichache kuliko 3.
    vikundi = [(kundi[1:] + kundi[0]) ikiwa urefu wa kundi ni 3, vinginevyo kundi] kwa vikundi katika vikundi]
    return "".join(vikundi)

def decode_cyclic(s: str):
    """
    inachukua kama pembejeo nyuzi iliyosimbwa na kazi ya encode_cyclic. Inarejesha nyuzi iliyosimbuliwa.
    """


def prime_fib(n: int):
    """
    prime_fib inarudisha nambari ya n-th ambayo ni nambari ya Fibonacci na pia ni nambari kuu.
    >>> 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 itarudisha nambari ya n katika mlolongo wa nambari ambazo ni Fibonacci na pia ni nambari za kwanza
    >>> 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 inapokea orodha ya nambari kamili kama ingizo
    Ikiwa kuna vipengele vitatu tofauti kwenye orodha ambavyo jumla yake ni sifuri, itarudisha True
    Ikiwa sivyo, itarudisha 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: orodha):
    """
    triples_sum_to_zero huchukua orodha ya nambari kamili kama ingizo.
    inarudi Kweli ikiwa kuna vipengele vitatu tofauti kwenye orodha hiyo
    jumla hadi sifuri, na Uongo vinginevyo.

    >>> 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):
    """
    Fikiria barabara kama mstari mrefu usio na mwisho
    Kuna magari n yanayokwenda kutoka kushoto kwenda kulia, wakati huo huo kuna magari mengine n
    yanayokwenda kutoka kulia kwenda kushoto. Seti zote mbili za magari zinaanza kutoka umbali mrefu sana
    Magari yote yanatembea kwa kasi sawa. Wakati gari linalokwenda kutoka kushoto kwenda kulia
    linapogongana na gari linalokwenda kutoka kulia kwenda kushoto, tutasema magari mawili yamegongana
    Hata hivyo, magari yana nguvu na uimara usio na mwisho, kwa hivyo
    yataendelea kusonga kwenye njia zao kana kwamba hakuna mgongano uliofanyika

    Kazi hii itatoa matokeo ya idadi ya migongano hiyo
    """

def car_race_collision(n: int):
    """
    Hebu fikiria barabara ambayo ni mstari mrefu ulionyooka kabisa.
    magari ya N yanaendesha kushoto kwenda kulia; wakati huo huo, seti tofauti ya magari ya n
    wanaendesha gari kulia kwenda kushoto.   Seti mbili za magari huanza kuwa mbali sana
    kila mmoja.  Magari yote yanasonga kwa kasi sawa.  Magari mawili yanasemekana kugongana
    wakati gari linalosogea kushoto kwenda kulia linapogonga gari linalosogea kulia kwenda kushoto.
    Hata hivyo, magari ni imara na yenye nguvu; matokeo yake, wanaendelea kusonga
    katika mwelekeo wao kana kwamba hawakugongana.

    Chaguo hili la kukokotoa hutoa idadi ya migongano kama hii.
    """


def incr_list(l: list):
    """Rudisha orodha ambayo kila kipengele kimeongezwa kwa 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):
    """Orodha ya kurudi nyuma yenye vipengele vilivyoongezwa kwa 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 inapokea orodha ya nambari kamili kama pembejeo
    Ikiwa kuna vipengele viwili tofauti kwenye orodha ambavyo jumla yake ni sifuri, itarudisha True
    Ikiwa sivyo, itarudisha 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 huchukua orodha ya nambari kamili kama ingizo.
    inarudi Kweli ikiwa kuna vipengele viwili tofauti kwenye orodha hiyo
    jumla hadi sifuri, na Uongo vinginevyo.
    >>> 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):
    """Badilisha msingi wa nambari x kuwa msingi base
    Rudisha thamani katika muundo wa kamba baada ya kubadilisha
    Msingi lazima uwe nambari chini ya 10
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """Badilisha msingi wa nambari wa nambari ya ingizo x hadi msingi.
    rudisha uwakilishi wa mfuatano baada ya ubadilishaji.
    nambari za msingi ni chini ya 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """


def triangle_area(a, h):
    """Inapokea urefu wa msingi na urefu, itarudisha eneo la pembetatu
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """Kupewa urefu wa upande na eneo la juu la kurudi kwa pembetatu.
    >>> triangle_area(5, 3)
    7.5
    """


def fib4(n: int):
    """Mfuatano wa Fib4 ni mfuatano unaofanana na mfuatano wa Fibonacci unaoelezwa kama ifuatavyo:
    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).
    Andika kazi ya kuhesabu mshiriki wa n wa mfuatano wa Fib4 kwa ufanisi, bila kutumia kurudiwa
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """Mfuatano wa nambari ya Fib4 ni mfuatano sawa na sequnece ya Fibbonacci ambayo inafafanuliwa kama ifuatavyo:
    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).
    Tafadhali andika chaguo za kukokotoa ili kukokotoa kwa ufanisi kipengele cha n-th cha mfuatano wa nambari ya fib4.  Usitumie kujirudia.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """


def median(l: list):
    """Rejesha wastani wa vipengele kwenye orodha l.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median(l: list):
    """Rudisha thamani ya wastani wa vipengele katika orodha l
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """


def is_palindrome(text: str):
    """
    Angalia kama string iliyotolewa ni palindrome au la
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    Hundi ikiwa kamba iliyotolewa ni palindrome
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """


def modp(n: int, p: int):
    """Inarudi mabaki ya 2^n kugawanywa na p (zingatia nambari).
    >>> 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):
    """Return 2^n modulo p (fahamu nambari).
    >>> 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):
    """
    Rudisha ujumbe uliosimbwa kwa kuhamisha kila herufi katika alfabeti ya Kiingereza nafasi 5
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    Pokea ujumbe uliosimbwa na kazi ya encode_shift kama pembejeo na rudisha ujumbe uliotafsiriwa
    """

def encode_shift(s: str):
    """
    hurejesha mfuatano uliosimbwa kwa kuhamisha kila herufi kwa 5 katika alfabeti.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    inachukua kama mfuatano wa ingizo uliosimbwa kwa chaguo za kukokotoa za kusimba_shift. Hurejesha mfuatano uliosimbuliwa.
    """


def remove_vowels(text):
    """
    remove_vowels ni kazi inayopokea kamba na kurudisha kamba isiyo na irabu
    >>> 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 ni chaguo ambalo huchukua mtandao na kurudisha mtandao bila vokali.
    >>> 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):
    """Rudi Kweli ikiwa nambari zote kwenye orodha l ziko chini ya kizingiti t.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """Rudisha True ikiwa nambari zote kwenye orodha l ni chini ya kikomo t
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


def add(x: int, y: int):
    """Ongeza namba mbili x na y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """

def add(x: int, y: int):
    """Ongeza nambari mbili x na y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


def same_chars(s0: str, s1: str):
    """
    Angalia ikiwa maneno mawili yana herufi sawa.
    >>> 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):
    """
    Angalia kama maneno 2 yana herufi sawa
    >>> 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):
    """Rudisha nambari ya n-th ya Fibonacci
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """

def fib(n: int):
    """Rudia namba ya Fibonacci ya n
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """

def fib(n: int):
    """Return n-th nambari ya Fibonacci.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """ brackets ni kamba ya "<" na ">"
    Rudisha True ikiwa kila mabano ya kufungua yana mabano ya kufunga yanayolingana

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

def correct_bracketing(brackets: str):
    """" mabano ni mfuatano wa "<" na ">".
    rudi Kweli ikiwa kila mabano ya ufunguzi yana mabano ya kufunga yanayolingana.

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


def monotonic(l: list):
    """Rudisha True ikiwa vipengele vya orodha vinaongezeka au kupungua mfululizo
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """Return True ni orodha ya vipengele vinavyoongezeka au kupungua.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """


def common(l1: list, l2: list):
    """Rudisha  vipengele vya kipekee vya kawaida vya orodha mbili katika mpangilio.
    >>> 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):
    """Rudisha vipengele vya kipekee vinavyofanana vya orodha mbili katika mpangilio
    >>> 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):
    """Rudisha kipengele kikubwa zaidi cha n, kwa kudhani n > 1 na si nambari ya kwanza
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """Rudisha kifaktori kuu kuu ya n. Angalia n > 1 na sio kifaktori kuu.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """


def sum_to_n(n: int):
    """sum_to_n ni kazi inayojumuisha nambari kutoka 1 hadi 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 ni chaguo la kukokotoa ambalo hujumlisha nambari kutoka 1 hadi 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 jumla_kwa_n(n: int):
    """jumla_kwa_n ni kazi inayojumuisha nambari kukwaka 1 hadi n
    >>> jumla_kwa_n(30)
    465
    >>> jumla_kwa_n(100)
    5050
    >>> jumla_kwa_n(5)
    15
    >>> jumla_kwa_n(10)
    55
    >>> jumla_kwa_n(1)
    1
    """


def correct_bracketing(brackets: str):
    """ brackets ni kamba ya "(" na ")"
    Rudisha True ikiwa kila mabano ya kufungua yana mabano ya kufunga yanayolingana

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

def correct_bracketing(brackets: str):
    """" mabano ni mfuatano wa "(" na ")".
    rudisha True ikiwa kila mabano ya ufunguzi yana mabano ya kufunga yanayolingana.

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


def derivative(xs: orodha):
    """ xs zinawakilisha coefficients ya polynomial.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     Rudisha derivative ya polynomial hii katika fomu sawa.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derivative(xs: list):
    """ xs inawakilisha vigezo vya polinomu
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
    Rudisha polinomu inayowakilisha turufu ya polinomu katika muundo sawa
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """


def fibfib(n: int):
    """Mfuatano wa nambari ya FibFib ni mfuatano sawa na sequnece ya Fibbonacci ambayo inafafanuliwa kama ifuatavyo:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Tafadhali andika chaguo za kukokotoa ili kukokotoa kwa ufanisi kipengele cha n-th cha mfuatano wa nambari ya fibfib.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """Mlolongo wa FibFib umefafanuliwa sawa na mlolongo wa Fibonacci kama ifuatavyo:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Andika kazi ya kuhesabu mshiriki wa n wa mlolongo wa fibfib kwa ufanisi
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """


FIX = """
Ongeza kesi zaidi za majaribio.
"""

def vowels_count(s):
    """Tengeneza kazi vowels_count inayopokea neno lililoonyeshwa na kamba kama pembejeo
    na kurudisha idadi ya vokali zilizopo kwenye kamba hiyo.
    Katika kesi hii, vokali ni 'a', 'e', 'i', 'o', 'u' ambapo 'y' pia ni
    vokali lakini tu ikiwa iko mwishoni mwa neno lililotolewa.

    Mfano:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
Ongeza kesi zaidi za majaribio
"""

def vowels_count(s):
    """Tengeneza kazi vowels_count inayopokea neno lililoonyeshwa na kamba kama pembejeo
    na kurudisha idadi ya vokali zilizopo kwenye kamba hiyo.
    Katika kesi hii, vokali ni 'a', 'e', 'i', 'o', 'u' ambapo 'y' pia ni
    vokali lakini tu ikiwa iko mwishoni mwa neno lililotolewa.

    Mfano:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

REKEBISHA = """
Ongeza kesi zaidi za mtihani.
"""

def vowels_count(s):
    """Andika chaguo za kukokotoa vokali_hesabu ambayo huchukua mfuatano unaowakilisha
    neno kama ingizo na hurejesha idadi ya vokali kwenye mfuatano.
    Vokali katika kesi hii ni 'a', 'e', 'i', 'o', 'u'. Hapa, 'y' pia ni a
    vokali, lakini tu wakati iko mwishoni mwa neno lililotolewa.

    Mfano:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """


def circular_shift(x, shift):
    """Mzunguko huhamisha tarakimu za nambari kamili x, badilisha tarakimu kulia kwa kuhama
    na urudishe matokeo kama kamba.
    Ikiwa shift > idadi ya tarakimu, rudisha tarakimu kinyume.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """Fanya mzunguko wa tarakimu za nambari kamili x kwa kuzungusha tarakimu kwenda kulia kulingana na idadi ya shift
    na rudisha matokeo kama kamba
    Ikiwa shift > idadi ya tarakimu, rudisha tarakimu zilizogeuzwa
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """


def digitSum(s):
    """Kazi
    Andika kazi inayopokea kamba kama ingizo na kurudisha jumla ya nambari za ASCII za herufi kubwa pekee

    Mfano:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """Kazi
    Andika chaguo za kukokotoa ambazo huchukua mfuatano kama ingizo na kurejesha jumla ya herufi za juu pekee'
    Misimbo ya ASCII.

    Mifano:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """


def fruit_distribution(s,n):
    """
    Katika kazi hii, utapewa kamba inayoonyesha idadi ya maapulo na machungwa yaliyosambazwa kwenye kikapu cha matunda
    Kikapu hiki kinajumuisha maapulo, machungwa, na maembe
    Ukipewa kamba inayoonyesha jumla ya machungwa na maapulo, na nambari kamili inayoonyesha jumla ya matunda kwenye kikapu
    Rudisha idadi ya maembe kwenye kikapu
    Mfano:
    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):
    """
    Katika kazi hii, utapewa kamba ambayo inawakilisha idadi ya apples na machungwa
    hiyo inasambazwa katika kikapu cha matunda kikapu hiki kina
    tufaha, machungwa, na matunda ya embe. Kwa kuzingatia mfuatano unaowakilisha jumla ya idadi ya
    machungwa na tufaha na nambari kamili inayowakilisha jumla ya idadi ya matunda
    katika kikapu rudisha idadi ya matunda ya embe kwenye kikapu.
    kwa mfano:
    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):
    """
    "Kwa kuzingatia safu inayowakilisha tawi la mti ambalo lina nodi kamili zisizo hasi
    kazi yako ni kung'oa moja ya nodi na kuirudisha.
    Nodi iliyokatwa inapaswa kuwa nodi yenye thamani ndogo zaidi.
    Ikiwa nodi nyingi zilizo na thamani ndogo sawa zinapatikana hurudisha nodi ambayo ina faharisi ndogo zaidi.

    Nodi iliyokatwa inapaswa kurejeshwa katika orodha, [smalest_value, index yake ],
    Ikiwa hakuna maadili sawa au safu iliyotolewa ni tupu, rudisha [].

    Mfano 1:
        Ingizo: [4,2,3]
        Pato: [2, 1]
        Ufafanuzi: 2 ina thamani ndogo zaidi, na 2 ina faharasa ndogo zaidi.

    Mfano 2:
        Ingizo: [1,2,3]
        Pato: [2, 1]
        Ufafanuzi: 2 ina thamani ndogo zaidi, na 2 ina faharasa ndogo zaidi.

    Mfano 3:
        Ingizo: []
        Pato: []

    Mfano 4:
        Ingizo: [5, 0, 3, 0, 4, 2]
        Pato: [0, 1]
        Ufafanuzi: 0 ndio thamani ndogo zaidi, lakini kuna sufuri mbili,
                     kwa hivyo tutachagua sifuri ya kwanza, ambayo ina faharisi ndogo zaidi.

    Vikwazo:
          * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    Unapopewa safu inayowakilisha matawi ya mti yenye nodi zenye nambari kamili zisizo hasi
    Kazi yako ni kuchagua nodi moja na kuirudisha
    Nodi inayochaguliwa inapaswa kuwa nodi yenye thamani ndogo zaidi ambayo ni nambari shufwa
    Ikiwa nodi nyingi zinapatikana zenye thamani ndogo sawa ya nambari shufwa, rudisha nodi yenye kiashiria kidogo zaidi

    Nodi inayochaguliwa inapaswa kurudishwa katika muundo wa orodha [thamani ndogo zaidi, kiashiria chake]
    Ikiwa hakuna thamani ya nambari shufwa au safu iliyopokelewa ni tupu, rudisha []

    Mfano wa 1:
        Ingizo: [4,2,3]
        Matokeo: [2, 1]
        Maelezo: 2 ina thamani ndogo zaidi ya nambari shufwa na 2 ina kiashiria kidogo zaidi

    Mfano wa 2:
        Ingizo: [1,2,3]
        Matokeo: [2, 1]
        Maelezo: 2 ina thamani ndogo zaidi ya nambari shufwa na 2 ina kiashiria kidogo zaidi

    Mfano wa 3:
        Ingizo: []
        Matokeo: []

    Mfano wa 4:
        Ingizo: [5, 0, 3, 0, 4, 2]
        Matokeo: [0, 1]
        Maelezo: 0 ni thamani ndogo zaidi lakini kuna sifuri mbili
                     Chagua sifuri ya kwanza yenye kiashiria kidogo zaidi

    Vikwazo:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


def search(lst):
    '''
    Pata orodha isiyo tupu ya nambari kamili chanya. Rudisha nambari kamili kubwa zaidi ambayo ina marudio zaidi ya sifuri na ni kubwa au sawa na thamani ya nambari hiyo yenyewe.
    Marudio ya nambari kamili ni idadi ya mara inavyoonekana kwenye orodha.
    Ikiwa hakuna thamani kama hiyo, rudisha -1.
    Mfano:
        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):
    '''
    Unapewa orodha isiyo tupu ya nambari kamili chanya. Rudisha nambari kamili ambayo ni kubwa kuliko
    sifuri, na ina mzunguko mkubwa kuliko au sawa na thamani ya nambari kamili yenyewe.
    Mzunguko wa nambari kamili ni idadi ya mara inaonekana kwenye orodha.
    Ikiwa hakuna thamani kama hiyo, rudisha -1.
    Mifano:
        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):
    '''
    Inapopokea orodha ya nambari kamili, itarudisha orodha katika mpangilio wa ajabu
    Mpangilio wa ajabu ni kuanzia na thamani ya chini kabisa, kisha thamani ya juu kabisa ya nambari kamili zilizobaki
    Kisha thamani ya chini kabisa, na kuendelea hivyo hivyo

    Mfano:
    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):
    '''
    Kwa kuzingatia orodha ya nambari kamili, orodha ya kurudi kwa mpangilio wa kushangaza.
    Upangaji wa ajabu, ni wakati unapoanza na thamani ya chini,
    kisha upeo wa nambari zilizobaki, kisha kiwango cha chini na kadhalika.

    Mifano:
    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):
    '''
    Kwa kuzingatia urefu wa pande tatu za pembetatu. Rudisha eneo la
    pembetatu ilizunguka hadi pointi 2 za desimali ikiwa pande tatu zinaunda pembetatu halali.
    Vinginevyo kurudi -1
    Pande tatu hufanya pembetatu halali wakati jumla ya pande zote mbili ni kubwa zaidi
    kuliko upande wa tatu.
    Mfano:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    Inapopokea urefu wa pande tatu za pembetatu, ikiwa pande hizo tatu zinaunda pembetatu halali
    itarudisha eneo la pembetatu kwa kukokotoa hadi sehemu mbili za desimali.
    Ikiwa sivyo, itarudisha -1.
    Pande tatu zinaunda pembetatu halali wakati jumla ya pande zozote mbili
    ni kubwa kuliko upande wa tatu.
    Mfano:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''


def will_it_fly(q,w):
    '''
    Tengeneza kazi inayorejesha True ikiwa kitu q kinaweza kuruka, na inarejesha False ikiwa hakiwezi
    Kitu q kitapaa ikiwa kina usawa (ni orodha ambayo ni palindromu) na jumla ya vipengele haizidi uzito wa juu unaowezekana w

    Mfano:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 ni chini ya uzito wa juu unaowezekana, lakini haina usawa

    will_it_fly([3, 2, 3], 1) ➞ False
    # Ina usawa, lakini 3+2+3 inazidi uzito wa juu unaowezekana

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 ni chini ya uzito wa juu unaowezekana na ina usawa

    will_it_fly([3], 5) ➞ True
    # 3 ni chini ya uzito wa juu unaowezekana na ina usawa
    '''


def smallest_change(arr):
    """
    Ukipewa arr ambayo ni safu ya nambari nzima, tafuta idadi ndogo zaidi ya mabadiliko
    yanayohitajika ili kufanya safu hiyo kuwa palindromu. Safu ya palindromu ni safu
    inayosomwa kutoka kushoto kwenda kulia au kutoka kulia kwenda kushoto na inabaki sawa.
    Mabadiliko moja yanaweza kubadilisha kipengele kimoja kuwa kipengele kingine chochote.

    Mfano:
    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):
    """
    Kwa kuzingatia safu ya nambari kamili, pata idadi ya chini ya vipengee ambavyo
    haja ya kubadilishwa ili kufanya safu ya palindromic. Safu ya palindromic ni safu ambayo
    inasomwa sawa nyuma na mbele. Katika mabadiliko moja, unaweza kubadilisha kipengele kimoja kwa kipengele kingine chochote.

    Kwa mfano:
    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):
    '''
    Pokea orodha mbili za mistari na unda kazi inayorejesha orodha yenye jumla ya idadi ya herufi
    katika mistari yote kwenye orodha ni ndogo kuliko orodha nyingine.

    Ikiwa orodha mbili zina idadi sawa ya herufi, rejesha orodha ya kwanza.

    Mfano
    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):
    '''
    Andika chaguo la kukokotoa ambalo linakubali orodha mbili za mifuatano na kurejesha orodha iliyo nayo
    jumla ya idadi ya chari katika mifuatano yote ya orodha chini ya orodha nyingine.

    ikiwa orodha mbili zina idadi sawa ya chars, rudisha orodha ya kwanza.

    Mifano
    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):
    """Andika kazi inayorejesha kweli ikiwa nambari iliyotolewa ni
    bidhaa ya nambari 3 za nambari kuu, na inarejesha uongo ikiwa sio hivyo.
    Inajulikana kuwa (a) ni chini ya 100
    Mfano:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """ Andika chaguo la kukokotoa ambalo linarejesha kweli ikiwa nambari iliyotolewa ni kuzidisha kwa nambari 3 kuu
    na uongo vinginevyo.
    Kujua kwamba (a) ni chini ya 100.
    Mfano:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """Andika kifutanzi inayorejesha true ikiwa nambari iliyopeanwa ni kizidisho cha nambari 3 za msingi
    na false vinginevyo.
    Kujua kwamba (a) ni chini ya 100.
    Mfano:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """


def is_simple_power(x, n):
    """Kazi yako ni kuandika kazi inayorejesha true ikiwa nambari x ni simple power ya n
    na inarejesha false katika hali nyinginezo
    x ni simple power ya n inamaanisha n**int=x
    Mfano:
    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):
    """Kazi yako ni kuandika chaguo za kukokotoa ambazo hurudi kweli ikiwa nambari x ni rahisi
    nguvu ya n na uwongo katika hali zingine.
    x ni nguvu rahisi ya n ikiwa n**int=x
    Kwa mfano:
    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):
    """Kazi yako ni kuandika kazi inayorejesha kweli ikiwa nambari x ni nguvu ya kisa ya n
    na inarejesha uongo katika hali nyinginezo
    x ni nguvu rahisi ya n inamaanisha n anga namba ya kisa ya x
    Mfano:
    is_simple_power(1, 4) => kweli
    is_simple_power(2, 2) => kweli
    is_simple_power(8, 2) => kweli
    is_simple_power(3, 2) => uongo
    is_simple_power(3, 1) => uongo
    is_simple_power(5, 3) => uongo
    """


def iscube(a):
    '''
    Unda kazi inayopokea nambari kamili a na kurudisha True ikiwa nambari hii kamili ni mchemraba wa nambari kamili yoyote
    Kumbuka: Unaweza kudhani kwamba data ya pembejeo ni sahihi kila wakati
    Mfano:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    Andika chaguo la kukokotoa ambalo huchukua nambari kamili na True ikiwa nambari hii kamili ni
    mchemraba wa nambari kamili yoyote
    Kumbuka: unaweza kudhani ingizo ni halali kila wakati.
    Mifano:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''


def hex_key(num):
    """Umepewa jukumu la kuandika kazi inayopokea
    nambari ya heksadesimali kama mfuatano na huhesabu idadi ya heksadesimali
    nambari ambazo ni msingi (nambari kuu, au nambari kuu, ni nambari asilia
    kubwa kuliko 1 ambayo sio bidhaa ya nambari mbili ndogo za asili).
    Nambari za hexadecimal ni 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Nambari kuu ni 2, 3, 5, 7, 11, 13, 17,...
    Kwa hivyo lazima uamue idadi ya nambari zifuatazo: 2, 3, 5, 7,
    B (=decimal 11), D (=decimal 13).
    Kumbuka: unaweza kudhani ingizo ni kamba sahihi au tupu kila wakati,
    na alama A,B,C,D,E,F daima ni herufi kubwa.
    Mifano:
    Kwa num = "AB" matokeo yanapaswa kuwa 1.
    Kwa num = "1077E" matokeo yanapaswa kuwa 2.
    Kwa num = "ABED1A33" matokeo yanapaswa kuwa 4.
    Kwa num = "123456789ABCDEF0" matokeo yanapaswa kuwa 6.
    Kwa num = "2020" matokeo yanapaswa kuwa 2.
    """

def hex_key(num):
    """Uliombwa kuunda kazi inayopokea kamba ya nambari ya hexadecimal na kuhesabu idadi ya tarakimu ambazo ni nambari za kwanza ndani yake.
    Nambari za kwanza (nambari ya kwanza ni nambari asilia ambayo ni kubwa kuliko 1 na si bidhaa ya nambari asilia ndogo kuliko 2)
    Tarakimu za hexadecimal ni 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F
    Nambari za kwanza ni 2, 3, 5, 7, 11, 13, 17,...
    Kwa hivyo, ni muhimu kuchunguza tarakimu zifuatazo: 2, 3, 5, 7, B (=desimali 11), D (=desimali 13)
    Kumbuka: Inaweza kudhaniwa kuwa pembejeo itakuwa sahihi kila wakati au ni kamba tupu, na alama A, B, C, D, E, F zitakuwa herufi kubwa kila wakati.
    Mfano:
    Ikiwa num = "AB" matokeo yanapaswa kuwa 1
    Ikiwa num = "1077E" matokeo yanapaswa kuwa 2
    Ikiwa num = "ABED1A33" matokeo yanapaswa kuwa 4
    Ikiwa num = "123456789ABCDEF0" matokeo yanapaswa kuwa 6
    Ikiwa num = "2020" matokeo yanapaswa kuwa 2
    """


def decimal_to_binary(decimal):
    """Pokea nambari katika mfumo wa desimali na kazi yako ni kuibadilisha kuwa mfumo wa binary
    Kazi inapaswa kurudisha thamani kama kamba, ambapo kila herufi inawakilisha binary
    Kila herufi katika kamba itakuwa '0' au '1'

    Kutakuwa na herufi maalum 'db' mwanzoni na mwishoni mwa kamba
    Herufi hii maalum ni kusaidia katika uundaji wa muundo

    Mfano:
    decimal_to_binary(15)   # Rudisha "db1111db"
    decimal_to_binary(32)   # Rudisha "db100000db"
    """

def decimal_to_binary(decimal):
    """Utapewa nambari katika fomu ya desimali na kazi yako ni kuibadilisha kuwa
    muundo binary. Chaguo za kukokotoa zinapaswa kurudisha mfuatano, huku kila herufi ikiwakilisha jozi
    nambari. Kila herufi kwenye mfuatano itakuwa '0' au '1'.

    Kutakuwa na wahusika kadhaa wa ziada 'db' mwanzoni na mwisho wa mfuatano.
    Herufi za ziada zipo kusaidia na umbizo.

    Mifano:
    decimal_to_binary(15)   # inarudisha "db1111db"
    decimal_to_binary(32)   # inarudisha "db100000db"
    """


def is_happy(s):
    """Unapewa kamba s.
    Kazi yako ni kuangalia ikiwa kamba ina furaha au la.
    Mfuatano una furaha ikiwa urefu wake ni angalau 3 na kila herufi 3 zinazofuatana ni tofauti
    Kwa mfano:
    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):
    """Kutoa mfuatano s
    Kazi yako ni kuangalia kama mfuatano huo una furaha au la
    Mfuatano utakuwa na furaha ikiwa una urefu wa angalau 3 na herufi 3 zinazofuatana zinatofautiana zote
    Mfano:
    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):
    """Katika wiki ya mwisho ya muhula, mwalimu anahitaji kutoa alama kwa wanafunzi
    Mwalimu anatumia njia yake mwenyewe kutoa alama
    Tatizo pekee ni kwamba alipoteza msimbo aliotumia kutoa alama
    Amekupa orodha ya GPA za wanafunzi na unahitaji kuandika kazi
    inayoweza kuonyesha orodha ya alama za herufi kwa kutumia jedwali hapa chini
             GPA       |    Alama za Herufi
              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

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

def nuculic_letter_grade(grades):
    """Ni wiki ya mwisho ya muhula na mwalimu anapaswa kutoa alama
    kwa wanafunzi. Mwalimu amekuwa akitengeneza algorithm yake mwenyewe ya kuweka alama.
    Shida pekee ni kwamba, amepoteza nambari aliyotumia kuweka alama.
    Amekupa orodha ya GPA kwa baadhi ya wanafunzi na unapaswa kuandika
    chaguo za kukokotoa ambazo zinaweza kutoa orodha ya alama za herufi kwa kutumia jedwali lifuatalo:
             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

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


def prime_length(string):
    """Andika kazi inayochukua nyuzi na kurudisha True ikiwa urefu wa nyuzi
    ni nambari ya msingi au False vinginevyo.
    Mifano
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def urefu_kwanza(kamba):
    """Unda kamba inayotolewa kwa kamba na inayorejesha Ukweli ikiwa urefu wa kamba ni nambari ya kwanza au Uongo ikiwa sivyo.
    Mfano
    urefu_kwanza('Hello') == Ukweli
    urefu_kwanza('abcdcba') == Ukweli
    urefu_kwanza('paka') == Ukweli
    urefu_kwanza('chungwa') == Uongo
    """

def prime_length(string):
    """Pokea kamba na unda kazi inayorejesha True
    ikiwa urefu wa kamba hiyo ni nambari ya kwanza
    na rejesha False ikiwa sivyo
    Mfano
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """


def starts_one_ends(n):
    """
    Iwapo umepewa nambari kamili chanya n, rudisha idadi ya nambari kamili chanya zenye n tarakimu ambazo zinaanza na 1 au kumalizika na 1
    """

def starts_one_ends(n):
    """
    Iwapo umepewa positive integer n, rudisha idadi ya nambari kamili chanya zenye n tarakimu ambazo zinaanza na 1 au kumalizika na 1
    """


def solve(N):
    """Ukipewa nambari kamili chanya N, rudisha jumla ya tarakimu katika mfumo wa nambari ya msingi mbili

    Mfano
        N = 1000 Katika kesi hii, jumla ya tarakimu ni 1 na matokeo yanapaswa kuwa "1"
        N = 150 Katika kesi hii, jumla ya tarakimu ni 6 na matokeo yanapaswa kuwa "110"
        N = 147 Katika kesi hii, jumla ya tarakimu ni 12 na matokeo yanapaswa kuwa "1100"

    Vigezo:
        @N Nambari kamili
             Kizuizi: 0 ≤ N ≤ 10000.
    Matokeo:
         Mfuatano wa nambari ya msingi mbili
    """

def solve(N):
    """Kwa kuzingatia nambari kamili N, rudisha jumla ya tarakimu zake katika mfumo wa jozi.

    Mfano
        Kwa N = 1000, jumla ya tarakimu itakuwa 1 pato linapaswa kuwa "1".
        Kwa N = 150, jumla ya tarakimu itakuwa 6 pato linapaswa kuwa "110".
        Kwa N = 147, jumla ya tarakimu itakuwa 12 pato linapaswa kuwa "1100".

    Vigezo:
        @N integer
             Vikwazo: 0 ≤ N ≤ 10000.
    Pato:
         mfuatano wa nambari ya binari
    """


def add(lst):
    """Ukipata orodha isiyo na tupu ya nambari za nzima lst, ongeza vipengele vya nambari shufwa zilizopo kwenye faharisi isiyo shufwa.

    Mfano:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Ukipata orodha isiyo na tupu ya nambari za nzima lst, ongeza vipengele vya nambari shufwa zilizopo kwenye faharisi isiyo shufwa..

    Mifano:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Ukipata orodha isiyo na tupu ya nambari za nzima lst. ongeza vipengele vya nambari shufwa zilizopo kwenye faharisi isiyo shufwa..

    Mifano:
        add([4, 2, 6, 7]) ==> 2
    """


def anti_shuffle(s):
    """
    Pokea kamba na tengeneza kazi inayorejesha toleo lililopangwa la kamba hiyo
    Toleo lililopangwa la kamba linamaanisha kubadilisha maneno yote
    (yanayotenganishwa na nafasi) na maneno mapya ambapo herufi zote zimepangwa
    kulingana na thamani ya ascii kwa mpangilio wa kuongezeka
    Kumbuka: Lazima uhifadhi mpangilio wa maneno na nafasi katika sentensi

    Kwa mfano:
    anti_shuffle('Hi') itarejesha 'Hi'
    anti_shuffle('hello') itarejesha 'ehllo'
    anti_shuffle('Hello World!!!') itarejesha 'Hello !!!Wdlor'
    """


def get_row(lst, x):
    """
    Orodha mbili-dimensionali itatolewa katika mfumo wa orodha zilizopachikwa
    ambayo inafanana na matrix, lakini tofauti na matrix ni kwamba
    kila safu inaweza kuwa na idadi tofauti ya nguzo
    Ukipewa lst na nambari kamili x, tafuta nambari kamili x katika orodha
    na rudisha orodha ya jozi katika mfumo wa [(x1, y1), (x2, y2) ...]
    ambapo kila jozi inaonyesha kuratibu - (safu, nguzo) kuanzia 0
    Kuratibu zitapangwa kulingana na safu kwa mpangilio wa chini kwenda juu
    na kuratibu za safu zitapangwa kulingana na nguzo kwa mpangilio wa juu kwenda chini

    Mfano:
    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):
    """
    Unapewa data ya dimensional 2, kama orodha zilizowekwa,
    ambayo ni sawa na matrix, hata hivyo, tofauti na matrices,
    kila safu inaweza kuwa na idadi tofauti ya safu wima.
    Kwa kuzingatia lst, na nambari kamili x, pata nambari x kwenye orodha,
    na orodha ya kurudi ya nakala, [(x1, y1), (x2, y2) ...] hivyo
    kila nakala ni kuratibu - (safu, safu), kuanzia na 0.
    Panga viwianishi mwanzoni kwa safu mlalo kwa mpangilio wa kupanda.
    Pia, panga viwianishi vya safu mlalo kwa safu wima kwa mpangilio wa kushuka.

    Mifano:
    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):
    """
    Kwa kuzingatia safu ya nambari kamili zisizo hasi, rudisha nakala ya safu uliyopewa baada ya kupanga,
    utapanga safu uliyopewa kwa mpangilio wa kupanda ikiwa jumla (thamani ya faharasa ya kwanza, thamani ya faharasa ya mwisho) ni isiyo ya kawaida,
    au ipange kwa mpangilio wa kushuka ikiwa jumla (thamani ya faharasa ya kwanza, thamani ya faharasa ya mwisho) ni sawa.

    Kumbuka:
    * usibadilishe safu uliyopewa.

    Mifano:
    * 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):
    """
    Unapopewa safu ya nambari kamili zisizo hasi, itarudisha nakala ya safu iliyopangwa
    Ikiwa jumla ya thamani katika nafasi ya kwanza na thamani katika nafasi ya mwisho ni nambari isiyo ya kawaida, itapangwa kwa mpangilio wa chini kwenda juu
    Ikiwa jumla ni nambari ya kawaida, itapangwa kwa mpangilio wa juu kwenda chini

    Kumbuka:
    * Usibadilishe safu iliyopokelewa

    Mfano:
    * 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):
    """Pokea kamba kama hoja na tengeneza kazi ya encrypt
    inayorejesha kamba iliyosimbwa kwa kuzungusha herufi
    Herufi zinapaswa kuzungushwa ili herufi zihamie kwenye nafasi ya pili ya mara mbili
    Mfano:
    encrypt('hi') itarejesha 'lm'
    encrypt('asdfghjkl') itarejesha 'ewhjklnop'
    encrypt('gf') itarejesha 'kj'
    encrypt('et') itarejesha 'ix'
    """

def encrypt(s):
    """Unda usimbaji fiche wa chaguo za kukokotoa ambao huchukua mfuatano kama hoja na
    hurejesha mfuatano uliosimbwa kwa njia fiche huku alfabeti ikizungushwa.
    Alfabeti inapaswa kuzungushwa kwa namna ambayo herufi
    hamisha chini kwa mbili imezidishwa hadi sehemu mbili.
    Kwa mfano:
    usimba ('hi') hurejesha 'lm'
    kwa njia fiche ('asdfghjkl') hurejesha 'ewhjklnop'
    kwa njia fiche ('gf') hurejesha 'kj'
    usimba ('et') hurejesha 'ix'
    """


def next_smallest(lst):
    """
    Ukipewa orodha ya nambari nzima
    Tengeneza kazi next_smallest() inayorejesha nambari ya pili ndogo zaidi kwenye orodha
    Ikiwa hakuna nambari kama hiyo, rejesha 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):
    """
    Unapewa orodha ya nambari kamili.
    Andika chaguo la kukokotoa linalofuata_smallest () ambalo hurejesha kipengele cha 2 kidogo zaidi cha orodha.
    Usirudishe Ikiwa hakuna kipengele kama hicho.

    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):
    """
    Utapewa mfuatano wa maneno, na kazi yako ni kuhesabu nambari
    ya kuchoka. Kuchoshwa ni sentensi inayoanza na neno "I".
    Sentensi zimewekewa mipaka na '.', '?' au '!'.

    Kwa mfano:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Umepewa kamba ya maneno, kazi yako ni kuhesabu idadi ya sentensi zinazotokujali
    kutokujali kunamaanisha sentensi inayotangulia na neno "I"
    Sentensi zinatenganishwa na '.', '?' au '!'

    Mfano:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Umepewa kamba, kazi yako ni kuhesabu idadi ya uchoshi
    Uchoshi inamaanisha sentensi inayotangulia na neno "I"
    Sentensi zinatenganishwa na '.', '?' au '!'

    Mfano:
    >>> 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):
    '''
    Tengeneza kazi inayopokea namba tatu
    Rudisha true ikiwa namba moja ni sawa na jumla ya namba mbili nyingine na namba zote ni nambari kamili
    Katika hali nyingine, rudisha false

    Mfano
    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):
    '''
    Unda chaguo za kukokotoa ambazo huchukua nambari 3.
    Hurejesha kweli ikiwa moja ya nambari ni sawa na jumla ya zingine mbili, na nambari zote ni nambari kamili.
    Hurejesha false katika hali nyingine zozote.

    Mifano
    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):
    """
    Andika chaguo la kukokotoa ambalo huchukua ujumbe, na kusimba katika vile
    njia ambayo inabadilisha kesi ya herufi zote, inachukua nafasi ya vokali zote ndani
    ujumbe wenye herufi inayoonekana sehemu 2 mbele ya hiyo
    vokali katika alfabeti ya Kiingereza.
    Chukulia herufi tu.

    Mifano:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Pokea ujumbe na ubadilishe herufi kubwa na ndogo za herufi zote
    Andika kazi ya kusimba kwa kubadilisha vokali zote kwenye ujumbe
    na herufi inayofuata mbili katika alfabeti ya Kiingereza
    Fikiria ni herufi pekee

    Mfano:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """


def skjkasdkd(lst):
    """Unapewa orodha ya nambari kamili.
    Unahitaji kupata thamani kuu kubwa zaidi na kurudisha jumla ya tarakimu zake.

    Mifano:
    Kwa lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] matokeo yanapaswa kuwa 10
    Kwa lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] matokeo yanapaswa kuwa 25
    Kwa lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] matokeo yanapaswa kuwa 13
    Kwa lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] matokeo yanapaswa kuwa 11
    Kwa lst = [0,81,12,3,1,21] matokeo yanapaswa kuwa 3
    Kwa lst = [0,8,1,2,1,7] matokeo yanapaswa kuwa 7
    """

def skjkasdkd(lst):
    """Unapewa orodha ya nambari nzima
    Inapaswa kutafuta thamani ya nambari kubwa zaidi ya kawaida na kurudisha jumla ya tarakimu za thamani hiyo

    Mfano:
    lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] Matokeo yakutoka itakuwa 10
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] Matokeo yakutoka itakuwa 25
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] Matokeo yakutoka itakuwa 13
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] Matokeo yakutoka itakuwa 11
    lst = [0,81,12,3,1,21] Matokeo yakutoka itakuwa 3
    lst = [0,8,1,2,1,7] Matokeo yakutoka itakuwa 7
    """

def skjkasdkd(lst):
    """Unapewa orodha ya nambari nzima
    Inapaswa kutafuta thamani ya nambari kubwa zaidi ya kawaida na kurudisha jumla ya tarakimu za thamani hiyo

    Mfano:
    lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] Matokeo yakutoa ni 10
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] Matokeo yakutoa ni 25
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] Matokeo yakutoa ni 13
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] Matokeo yakutoa ni 11
    lst = [0,81,12,3,1,21] Matokeo yakutoa ni 3
    lst = [0,8,1,2,1,7] Matokeo yakutoa ni 7
    """


def check_dict_case(dict):
    """
    Iwapo kamusi imetolewa, itarejesha True ikiwa funguo zote ni herufi ndogo au funguo zote ni herufi kubwa.
    Katika hali nyingine, itarejesha False.
    Iwapo kamusi iliyotolewa ni tupu, kazi inapaswa kurejesha False.
    Mfano:
    check_dict_case({"a":"apple", "b":"banana"}) inapaswa kurejesha True
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) inapaswa kurejesha False
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) inapaswa kurejesha False
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) inapaswa kurejesha False
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) inapaswa kurejesha True
    """

def check_dict_case(dict):
    """
    Kwa kuzingatia kamusi, rudisha True ikiwa vitufe vyote ni mifuatano ya chini
    kesi au funguo zote ni mifuatano katika herufi kubwa, vinginevyo rudisha False.
    Chaguo za kukokotoa zinapaswa kurudisha Uongo ni kamusi iliyotolewa haina kitu.
    Mifano:
    check_dict_case({"a":"apple", "b":"banana"}) inapaswa kurudi True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) inapaswa kurudisha False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) inapaswa kurudisha False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) inapaswa kurudisha False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) inapaswa kurudi True.
    """


def count_up_to(n):
    """Tekeleza kazi inayochukua nambari nzima isiyo na hasi na kurudisha safu ya nambari za kwanza n
    ambazo ni nambari za msingi na ndogo kuliko n.
    kwa mfano:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """Pokea nambari kamili isiyo hasi na rudisha safu iliyo na nambari za kwanza za n ambazo ni chini ya n
    Mfano:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """


def multiply(a, b):
    """Pokea namba mbili kamili na tengeneza kazi inayorejesha thamani ya kuzidisha ya tarakimu za mwisho za namba hizo
    Fikiria kwamba data ya ingizo ni sahihi kila wakati
    Mfano:
    multiply(148, 412) inapaswa kurejesha 16
    multiply(19, 28) inapaswa kurejesha 72
    multiply(2020, 1851) inapaswa kurejesha 0
    multiply(14,-15) inapaswa kurejesha 20
    """

def zidisha(a, b):
    """Kamilisha chaguo za kukokotoa ambazo huchukua nambari mbili kamili na kurejesha
    bidhaa ya tarakimu zao za kitengo.
    Chukulia ingizo ni halali kila wakati.
    Mifano:
    multiply(148, 412) inapaswa kurejesha 16
    multiply(19, 28) inapaswa kurejesha 72
    multiply(2020, 1851) inapaswa kurejesha 0
    multiply(14,-15) inapaswa kurejesha 20
    """


def count_upper(s):
    """
    Kwa kuzingatia mfuatano s, hesabu idadi ya vokali za herufi kubwa katika fahirisi hata.

    Kwa mfano:
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """

def count_upper(s):
    """
    Iwapo umepewa kamba s, hesabu idadi ya vokali za herufi kubwa zilizo kwenye faharasa za nambari shufwa

    Mfano:
    count_upper('aBCdEf') itarudisha 1
    count_upper('abcdefg') itarudisha 0
    count_upper('dBBE') itarudisha 0
    """


def closest_integer(value):
    '''
    Pokea thamani (kamba) inayowakilisha nambari na tengeneza kazi inayorejesha nambari kamili iliyo karibu zaidi
    Ikiwa nambari iko mbali sawa na nambari mbili kamili, itazungushwa kuelekea mbali na sifuri

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

    Kumbuka:
    Kuzungusha kuelekea mbali na sifuri inamaanisha ikiwa nambari iliyotolewa iko mbali sawa na nambari mbili kamili,
    itarejesha thamani iliyo mbali zaidi na sifuri. Kwa mfano, closest_integer("14.5") itarejesha 15
    na closest_integer("-14.5") itarejesha -15
    '''

def closest_integer(value):
    '''
    Unda chaguo za kukokotoa ambazo huchukua thamani (kamba) inayowakilisha nambari
    na inarudisha nambari kamili iliyo karibu nayo. Ikiwa nambari ni sawa
    kutoka kwa nambari mbili kamili, izungushe mbali na sifuri.

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

    Kumbuka:
    Kuzungusha mbali na sifuri inamaanisha kuwa ikiwa nambari iliyotolewa ni sawa
    kutoka kwa nambari mbili kamili, moja unapaswa kurudi ni ile ambayo ni
    mbali zaidi na sifuri. Kwa mfano karibu_integer ("14.5") inapaswa
    rudisha 15 na_integer wa karibu zaidi ("-14.5") anapaswa kurudi -15.
    '''


def make_a_pile(n):
    """
    Kwa kuzingatia nambari kamili n, lazima utengeneze rundo la viwango vya n vya mawe.
    Ngazi ya kwanza ina mawe ya n.
    Idadi ya mawe katika ngazi inayofuata ni:
        - nambari inayofuata isiyo ya kawaida ikiwa n ni isiyo ya kawaida.
        - nambari inayofuata ikiwa n ni sawa.
    Rudisha idadi ya mawe katika kila ngazi katika orodha, ambapo kipengele katika index i
    kinawakilisha idadi ya mawe katika kiwango (i+1).

    Mifano:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    Inapopokea nambari kamili chanya n, itaunda rundo la mawe lenye ngazi n
    Ngazi ya kwanza itakuwa na mawe n
    Idadi ya mawe katika ngazi inayofuata ni kama ifuatavyo:
        - Ikiwa n ni nambari isiyo ya kawaida, itakuwa nambari isiyo ya kawaida inayofuata
        - Ikiwa n ni nambari shufwa, itakuwa nambari shufwa inayofuata
    Rudisha idadi ya mawe katika kila ngazi katika muundo wa orodha, kipengele chenye faharasa i
    kinaonyesha idadi ya mawe katika ngazi ya (i+1)

    Mfano:
    >>> make_a_pile(3)
    [3, 5, 7]
    """


def words_string(s):
    """
    Ukipewa kamba yenye maneno yaliyotenganishwa na koma au nafasi, kazi yako ni
    kugawanya kamba hiyo katika maneno na kurudisha safu ya maneno

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

def words_string(s):
    """
    Utapewa mfuatano wa maneno yaliyotenganishwa na koma au nafasi. Kazi yako ni
    ili kugawanya kamba katika maneno na kurudisha safu ya maneno.

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


def choose_num(x, y):
    """ Chaguo hili la kukokotoa huchukua nambari mbili chanya x na y na kurudisha
    nambari kubwa zaidi hata kamili ambayo iko katika safu [x, y] ikijumuisha. Ikiwa
    hakuna nambari kama hiyo, basi kazi inapaswa kurudi -1.

    Kwa mfano:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """Kazi hii inapokea namba mbili kamili chanya x na y na inarudisha namba kamili shufwa kubwa zaidi
    iliyoko katika safu [x, y] ikiwa hakuna namba kama hiyo, kazi inapaswa kurudisha -1

    Mfano:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """


def rounded_avg(n, m):
    """Unapewa nambari mbili chanya n na m, na kazi yako ni kukokotoa
    wastani wa nambari kamili kutoka n hadi m (pamoja na n na m).
    Funga jibu kwa nambari kamili iliyo karibu na ubadilishe kuwa binary.
    Ikiwa n ni kubwa kuliko m, rudisha -1.
    Mfano:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """Inapopokea nambari kamili chanya n na m, hesabu wastani wa nambari kamili kutoka n hadi m
    (ikiwa ni pamoja na n na m) kisha piga wastani huo kuwa nambari kamili iliyo karibu zaidi na ubadilishe kuwa msingi wa mbili.
    Ikiwa n ni kubwa kuliko m, rudisha -1
    Mfano:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def mviringo_avg(n, m):
    """Inapopokea nambari kamili chanya n na m, hesabu wastani wa nambari kamili kutoka n hadi m
    (ikiwa ni pamoja na n na m) kisha piga wastani huo kuwa nambari kamili iliyo karibu zaidi na ubadilishe kuwa msingi wa mbili.
    Ikiwa n ni kubwa kuliko m, rudisha -1
    Mfano:
    mviringo_avg(1, 5) => "0b11"
    mviringo_avg(7, 5) => -1
    mviringo_avg(10, 20) => "0b1111"
    mviringo_avg(20, 33) => "0b11010"
    """


def unique_digits(x):
    """Ukipata orodha ya nambari za nzima chanya x, rudisha orodha iliyo pangwa ya vipengele vyote
    ambavyo havina tarakimu yoyote ya shufwa.

    Kumbuka: Orodha iliyorejeshwa inapaswa kupangwa kwa mpangilio unaoongezeka.

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

def unique_digits(x):
    """Inapopokea orodha ya nambari kamili chanya x, rudisha orodha iliyopangwa
    ya kila kipengele ambacho hakina nambari shufwa

    Kumbuka: Orodha inayorudishwa lazima iwe imepangwa kwa mpangilio kutoka ndogo hadi kubwa

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


def by_length(arr):
    """
    Unapopewa safu ya nambari nzima, panga nambari nzima zilizo kati ya 1 hadi 9
    kisha geuza mpangilio wa safu hiyo na badilisha kila nambari na jina linalolingana
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"

    Mfano:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> panga arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> geuza mpangilio arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      Katika hali ambapo safu ni tupu, rudisha safu tupu:
      arr = []
      return []

      Katika hali ambapo kuna nambari zisizo za kawaida kwenye safu, ziachilie:
      arr = [1, -1 , 55]
            -> panga arr -> [-1, 1, 55]
            -> geuza mpangilio arr -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    Kwa kuzingatia safu ya nambari kamili, panga nambari kamili ambazo zinajumuisha kati ya 1 na 9, pamoja
    badilisha safu inayotokana, na kisha ubadilishe kila tarakimu kwa jina linalolingana kutoka
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Kwa mfano:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      Ikiwa safu ni tupu, rudisha safu tupu:
      arr = []
      return []

      Ikiwa safu ina nambari yoyote ya kushangaza ipuuze:
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """


def f(n):
    """ Kazi ya f inayopokea parameter n na
    inarudisha orodha yenye ukubwa wa n ambapo thamani ya kila kipengele katika nafasi i ni
    factorial ya i ikiwa i ni nambari shufwa
    Vinginevyo ni jumla ya nambari kutoka 1 hadi i
    i inaanza na 1
    Factorial ya i ni kuzidisha nambari kutoka 1 hadi i (1 * 2 * ... * i)
    Mfano:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ Tekeleza chaguo la kukokotoa f ambalo huchukua n kama kigezo,
    na hurejesha orodha ya saizi n, hivi kwamba thamani ya kipengele kwenye faharasa i ndio msingi wa i ikiwa ni sawa
    au jumla ya nambari kutoka 1 hadi i vinginevyo.
    ninaanza kutoka 1.
    kipengele cha i ni kuzidisha nambari kutoka 1 hadi i (1 * 2 * ... * i).
    Mfano:
    f(5) == [1, 2, 6, 24, 15]
    """


def even_odd_palindrome(n):
    """
    Inapopewa nambari kamili chanya n, rudisha jozi yenye idadi ya palindromu za nambari kamili za jozi na witiri zilizo katika safu (1, n)

    Mfano wa 1:

        Ingizo: 3
        Tokeo: (1, 2)
        Maelezo:
        Palindromu za nambari kamili ni 1, 2, 3 ambapo 1 ni nambari ya jozi na 2 ni nambari za witiri

    Mfano wa 2:

        Ingizo: 12
        Tokeo: (4, 6)
        Maelezo:
        Palindromu za nambari kamili ni 1, 2, 3, 4, 5, 6, 7, 8, 9, 11 ambapo 4 ni nambari za jozi na 6 ni nambari za witiri

    Kumbuka:
        1. 1 <= n <= 10^3
        2. Jozi inayorudishwa itakuwa na idadi ya palindromu za nambari kamili za jozi na witiri mtawalia
    """

def even_odd_palindrome(n):
    """
    Kwa kuzingatia nambari kamili n, rudisha nakala ambayo ina idadi ya sawa na isiyo ya kawaida
    palindromes kamili ambazo ziko ndani ya safu (1, n), zikijumlishwa.

    Mfano 1:

        Ingizo: 3
        Pato: (1, 2)
        Maelezo:
        Palindrome kamili ni 1, 2, 3. moja yao ni sawa, na mbili kati yao ni isiyo ya kawaida.

    Mfano 2:

        Ingizo: 12
        Pato: (4, 6)
        Maelezo:
        Palindrome kamili ni 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. nne kati yao ni sawa, na 6 kati yao ni isiyo ya kawaida.

    Kumbuka:
        1. 1 <= n <= 10^3
        2. nakala iliyorejeshwa ina idadi ya palindromes kamili na isiyo ya kawaida mtawalia.
    """


def count_nums(arr):
    """
    Pokea safu ya nambari nzima na unda kazi count_nums inayorejesha idadi ya vipengele ambavyo jumla ya tarakimu ni zaidi ya 0.
    Ikiwa nambari ni hasi, tarakimu ya kwanza yenye alama itakuwa hasi:
    Mfano: -123 ina tarakimu zenye alama -1, 2, 3
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    Andika fungo count_nums ambayo huchukua safu ya namba kamili na kurejesha
    idadi ya vipengele ambavyo vina jumla ya tarakimu> 0.
    Ikiwa namba ni hasi saini la kwanza litakuwa hasi:
    kwa mfano -123 imetia saini tarakimu -1, 2, na 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """


def move_one_ball(arr):
    """Array 'arr' ina idadi ya nambari za N arr[1], arr[2], ..., arr[N]
    Nambari katika array zimepangwa kwa mpangilio wa nasibu. Kazi yako ni kuamua kama
    inawezekana kufanya array iwe katika mpangilio usiopungua kwa kufanya operesheni ifuatayo:
        Inaruhusiwa kufanya mzunguko wa kulia kadri inavyohitajika

    Mzunguko mmoja wa kulia unamaanisha kusogeza kila kipengele katika array kwenda kulia kwa nafasi moja
    Kipengele cha mwisho cha array kitahamia kwenye nafasi ya mwanzo ya array, yaani, index 0

    Ikiwa inawezekana kufanya array iwe katika mpangilio kwa kufanya operesheni iliyo hapo juu, rudisha True
    Ikiwa haiwezekani, rudisha False
    Ikiwa array iliyotolewa ni tupu, rudisha True

    Kumbuka: Inahakikishwa kuwa array iliyotolewa ina vipengele visivyojirudia

    Mfano:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Maelezo: Inawezekana kufanya mzunguko wa kulia mara 2 ili kufanya array iliyotolewa iwe katika mpangilio usiopungua
    move_one_ball([3, 5, 4, 1, 2])==>False
    Maelezo: Haiwezekani kufanya array iliyotolewa iwe katika mpangilio usiopungua bila kujali ni mzunguko wa kulia ngapi unafanywa

    """

def move_one_ball(arr):
    """Tuna safu 'arr' ya nambari kamili za N arr[1], arr[2], ..., arr[N].Ya
    nambari katika safu zitaagizwa kwa nasibu. Kazi yako ni kuamua ikiwa
    inawezekana kupata safu iliyopangwa kwa mpangilio usiopungua kwa kutekeleza
    operesheni ifuatayo kwenye safu iliyotolewa:
        Unaruhusiwa kufanya operesheni ya zamu sahihi mara kadhaa.

    Operesheni moja ya kuhama kulia inamaanisha kuhamisha vipengele vyote vya safu kwa moja
    nafasi katika mwelekeo sahihi. Kipengele cha mwisho cha safu kitahamishwa hadi
    nafasi ya kuanzia katika safu ie 0th index.

    Ikiwa inawezekana kupata safu iliyopangwa kwa kufanya operesheni hapo juu
    kisha rudi Kweli tena rudisha False.
    Ikiwa safu iliyotolewa ni tupu basi rudisha True.

    Kumbuka: Orodha iliyotolewa imehakikishiwa kuwa na vipengele vya kipekee.

    Kwa Mfano:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Ufafanuzi: Kwa kutekeleza shughuli 2 za zamu ya kulia, mpangilio usiopungua unaweza
                 ipatikane kwa safu iliyotolewa.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Ufafanuzi: Haiwezekani kupata agizo lisilopungua kwa iliyotolewa
                panga kwa kutekeleza idadi yoyote ya shughuli za zamu ya kulia.

    """


def exchange(lst1, lst2):
    """Katika tatizo hili, utatekeleza kazi ambayo inachukua orodha mbili za nambari,
    na huamua ikiwa inawezekana kufanya ubadilishanaji wa vipengele
    kati yao kufanya lst1 orodha ya nambari sawa tu.
    Hakuna kikomo kwa idadi ya vipengele vilivyobadilishwa kati ya lst1 na lst2.
    Ikiwa inawezekana kubadilishana vipengele kati ya lst1 na lst2 kufanya
    vipengele vyote vya lst1 kuwa sawa, rudisha "NDIYO".
    Vinginevyo, rudisha "HAPANA".
    Kwa mfano:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Inachukuliwa kuwa orodha za ingizo hazitakuwa tupu.
    """

def exchange(lst1, lst2):
    """Katika tatizo hili, tutapokea orodha mbili za namba
    na tunahitaji kuchunguza kama inawezekana kubadilisha vipengele
    ili lst1 iwe orodha yenye namba shufwa pekee au la.
    Hakuna kikomo katika idadi ya vipengele vinavyoweza kubadilishwa kati ya lst1 na lst2.
    Ikiwa inawezekana kubadilisha vipengele kati ya lst1 na lst2 ili lst1 iwe na namba shufwa pekee, rudisha "YES".
    Ikiwa haiwezekani, rudisha "NO".
    Mfano:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Tunasadiki kwamba orodha zinazopokelewa si tupu.
    """


def histogram(test):
    """Pokea mfuatano wa herufi ndogo zilizotenganishwa na nafasi na rudisha kamusi yenye herufi zinazojirudia zaidi na idadi inayolingana
    Ikiwa kuna herufi kadhaa zenye idadi sawa ya kujitokeza, rudisha zote

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

    """

def histogram(mtihani):
    """Kwa kuzingatia mfuatano unaowakilisha nafasi iliyotenganishwa herufi ndogo, rudisha kamusi
    ya barua yenye marudio mengi na yenye hesabu inayolingana.
    Ikiwa herufi kadhaa zina tukio sawa, zirudishe zote.

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

    """


def reverse_delete(s,c):
    """Kazi
    Unapopewa mistari miwili s na c, ondoa herufi zote katika s zinazolingana na herufi yoyote katika c
    na angalia kama mstari uliopatikana ni palindromu au la.
    Mstari unaosomwa kutoka kushoto kwenda kulia au kulia kwenda kushoto na kuwa sawa unaitwa palindromu.
    Inapaswa kurudisha tuple inayojumuisha mstari uliopatikana na matokeo ya ukaguzi (True/False).
    Mfano
    Ikiwa s = "abcde", c = "ae" matokeo yanapaswa kuwa ('bcd',False)
    Ikiwa s = "abcdef", c = "b" matokeo yanapaswa kuwa ('acdef',False)
    Ikiwa s = "abcdedcba", c = "ab" matokeo yanapaswa kuwa ('cdedc',True)
    """

def reverse_delete(s,c):
    """Kazi
    Tumepewa mifuatano miwili s na c, lazima ufute herufi zote katika s ambazo ni sawa na herufi yoyote katika c
    kisha angalia ikiwa kamba ya matokeo ni palindrome.
    Kamba inaitwa palindrome ikiwa inasoma nyuma sawa na mbele.
    Unapaswa kurudisha nakala iliyo na mfuatano wa matokeo na Kweli/Uongo kwa hundi.
    Mfano
    Kwa s = "abcde", c = "ae", matokeo yanapaswa kuwa ('bcd',False)
    Kwa s = "abcdef", c = "b" matokeo yanapaswa kuwa ('acdef',False)
    Kwa s = "abcdedcba", c = "ab", matokeo yanapaswa kuwa ('cdedc',True)
    """


def odd_count(lst):
    """Kwa kuzingatia orodha ya mifuatano, ambapo kila mfuatano una tarakimu pekee, rudisha orodha.
    Kila kipengele i cha pato kinapaswa kuwa "idadi ya vipengele visivyo vya kawaida katika
    kamba i ya ingizo." ambapo i zote zinapaswa kubadilishwa na nambari
    ya tarakimu zisizo za kawaida katika mfuatano wa i'th wa ingizo.

    >>> odd_count(['1234567'])
    ["idadi ya vipengele visivyo vya kawaida 4n str4ng 4 ya 4nput."]
    >>> odd_count(['3',"1111111111"])
    ["idadi ya vipengele visivyo vya kawaida 1n str1ng 1 ya 1nput.",
     "idadi ya vipengele visivyo vya kawaida 8n str8ng 8 ya 8nput."]
    """

def odd_count(lst):
    """Unapopewa orodha ya mistari, dhania kwamba kila mstari una nambari pekee na rudisha orodha
    Kila kipengele i cha matokeo kinapaswa kuwa "idadi ya vipengele visivyo vya kawaida vya mstari i wa ingizo"
    Hapa, kila i itabadilishwa na idadi ya tarakimu zisizo za kawaida za mstari i wa ingizo

    >>> odd_count(['1234567'])
    ["idadi ya vipengele visivyo vya kawaida 4 katika mstari 4 wa ingizo."]
    >>> odd_count(['3',"11111111"])
    ["idadi ya vipengele visivyo vya kawaida 1 katika mstari 1 wa ingizo.",
     "idadi ya vipengele visivyo vya kawaida 8 katika mstari 8 wa ingizo."]
    """


def minSubArraySum(namu):
    """
    Kwa kuzingatia safu ya nambari kamili, pata jumla ya chini ya safu ndogo isiyo tupu
    ya nums.
    Mfano
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    "Ukipata safu ya nambari za nzima nums, pata jumla ndogo zaidi ya safu ndogo yoyote isiyo na tupu ya nums.
    Mfano:
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    Ukipewa orodha ya nambari nzima nums, Pata Jumla Ndogo Zaidi ya kujumlia SAFU Ndogo yoyote ya nums ambayo si Tupu
    Mfano
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """