import math

def max_fill(grid, capacity):
    """
    Umepewa gridi ya mstatili ya visima vya maji. Kila mstari unawakilisha kisima kimoja.
    Kila 1 katika mstari unawakilisha kitengo cha maji.
    Kila kisima kina ndoo inayoweza kutumika kutoa maji.
    Ndoo zote zina uwezo sawa.
    Kazi yako ni kutumia ndoo ili kufanya visima kuwa tupu.
    Onyesha idadi ya mara ambazo ndoo inapaswa kushushwa.

    Mfano wa 1:
        Ingizo:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Matokeo: 6

    Mfano wa 2:
        Ingizo:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Matokeo: 5

    Mfano wa 3:
        Ingizo:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Matokeo: 0

    Vikwazo:
        * Visima vyote vina urefu sawa
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    Unapewa gridi ya mstatili ya visima. Kila safu inawakilisha kisima kimoja,
    na kila 1 kwa safu inawakilisha kitengo kimoja cha maji.
    Kila kisima kina ndoo inayolingana ambayo inaweza kutumika kutoa maji kutoka kwake,
    na ndoo zote zina uwezo sawa.
    Kazi yako ni kutumia ndoo kumwaga visima.
    Pato idadi ya mara unahitaji kupunguza ndoo.

    Mfano 1:
        Ingizo:
             grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Pato: 6

    Mfano 2:
        Ingizo:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Pato: 5

    Mfano 3:
        Ingizo:
           grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Pato: 0

    Vikwazo:
        * visima vyote vina urefu sawa
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """


def sort_array(arr):
    """
    Katika Kata hii, unahitaji kupanga safu ya nambari zisizo hasi kulingana na idadi ya 1 katika uwakilishi wa binary.
    Ikiwa idadi ya 1 ni sawa, panga kulingana na thamani ya desimali.

    Unahitaji kufanya usanidi kama ifuatavyo:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    """
    Katika Kata hii, lazima upange safu ya nambari kamili zisizo hasi kulingana na
    idadi ya zile katika uwakilishi wao wa binary kwa mpangilio wa kupanda.
    Kwa idadi sawa ya hizo, panga kulingana na thamani ya desimali.

    Ni lazima kutekelezwa kama hii:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """


def select_words(s, n):
    """Unapopewa kamba s na nambari kamili chanya n, andika kazi inayorejesha orodha ya maneno
    ambayo yana idadi ya konsonanti sawa na n kutoka kwenye kamba s.
    Maneno haya yatatolewa kulingana na mpangilio yanavyoonekana kwenye kamba s.
    Ikiwa kamba s ni tupu, kazi inapaswa kurudisha orodha tupu.
    Kumbuka: Unaweza kudhani kwamba kamba iliyoingizwa ina herufi na nafasi tu.
    Mfano:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """Kwa kuzingatia kamba s na nambari asilia n, umepewa jukumu la kutekeleza
    chaguo za kukokotoa ambazo hurejesha orodha ya maneno yote kutoka kwa mfuatano wa s ambayo yana haswa
    konsonanti N, kwa mpangilio maneno haya yanaonekana katika mfuatano s.
    Ikiwa kamba s ni tupu basi kazi inapaswa kurudisha orodha tupu.
    Kumbuka: unaweza kudhani kamba ya ingizo ina herufi na nafasi pekee.
    Mifano:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """


def get_closest_vowel(word):
    """Pata neno, una jukumu la kutafuta irabu iliyo karibu zaidi kati ya konsonanti mbili kutoka upande wa kulia wa neno
    (tofautisha herufi kubwa na ndogo)

    Usijumuishe irabu zilizo mwanzoni na mwishoni mwa neno. Ikiwa hakuna irabu inayokidhi masharti hapo juu,
    rudisha kamba tupu

    Dhania kwamba herufi zilizotolewa zinajumuisha herufi za Kiingereza pekee

    Mfano:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """Unapewa neno. Kazi yako ni kupata vokali ya karibu zaidi ambayo inasimama kati
    konsonanti mbili kutoka upande wa kulia wa neno (kesi nyeti).

    Vokali mwanzoni na mwisho hazihesabiki. Rudisha kamba tupu ikiwa hukufanya hivyo
    pata vokali yoyote iliyokidhi hali iliyo hapo juu.

    Unaweza kudhani kuwa kamba iliyotolewa ina herufi ya Kiingereza pekee.

    Mfano:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """


def match_parens(lst):
    '''
    Umepewa orodha ya mistari miwili ya herufi, kila mstari una mabano ya kufungua '(' au mabano ya kufunga ')' pekee.
    Kazi yako ni kuunganisha mistari hiyo miwili kwa mpangilio wowote ili kuangalia kama mstari wa matokeo ni mstari mzuri.
    Mstari S utachukuliwa kuwa mzuri ikiwa tu mabano yote katika S yamebalansiwa. Kwa mfano, mstari '(())()' unachukuliwa kuwa mzuri, lakini mstari '())' si mzuri.
    Ikiwa kuna njia ya kuunda mstari mzuri, rudisha 'Yes', la sivyo rudisha 'No'.

    Mfano:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    "Umepewa orodha ya nyuzi mbili, nyuzi zote mbili zinafanana na mabano ya kufungua '(' au kufunga ')'.
    Kazi yako ni kuangalia kama inawezekana kuunganisha nyuzi hizo mbili kwa mpangilio fulani, kwamba nyuzi inayosababishwa itakuwa nzuri.
    Nyuzi S inachukuliwa kuwa nzuri ikiwa na tu ikiwa mabano yote katika S yamepangwa vizuri. Kwa mfano: nyuzi '(())()' ni nzuri, wakati nyuzi '())' si nzuri.
    Rudisha 'Ndiyo' ikiwa kuna njia ya kutengeneza nyuzi nzuri, na rudisha 'Hapana' vinginevyo.

    Mifano:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''


def upeo (arr, k):
    """
    Kwa kuzingatia safu ya nambari kamili na nambari kamili k, rudisha orodha iliyopangwa
    ya urefu k na nambari za juu zaidi za k katika arr.

    Mfano 1:

        Ingizo: arr = [-3, -4, 5], k = 3
        Pato: [-4, -3, 5]

    Mfano 2:

        Ingizo: arr = [4, -4, 4], k = 2
        Pato: [4, 4]

    Mfano 3:

        Ingizo: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Pato: [2]

    Kumbuka:
        1. Urefu wa safu utakuwa katika safu ya [1, 1000].
        2. Vipengele katika safu vitakuwa katika anuwai ya [-1000, 1000].
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    Ukipewa arr ambayo ni safu ya nambari nzima na k ambayo ni nambari nzima chanya
    rudisha orodha iliyopangwa ya urefu k yenye nambari k kubwa zaidi katika arr

    Mfano wa 1:

        Ingizo: arr = [-3, -4, 5], k = 3
        Matokeo: [-4, -3, 5]

    Mfano wa 2:

        Ingizo: arr = [4, -4, 4], k = 2
        Matokeo: [4, 4]

    Mfano wa 3:

        Ingizo: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Matokeo: [2]

    Kumbuka:
        1. Urefu wa safu utakuwa kati ya [1, 1000]
        2. Vipengele vya safu vitakuwa kati ya [-1000, 1000]
        3. 0 <= k <= len(arr)
    """


def solution(lst):
    """Inapopokea orodha isiyo tupu ya nambari nzima, rudisha jumla ya vipengele visivyo vya kawaida vilivyopo katika nafasi za kawaida.

    Mfano
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """Ukipata orodha isiyo na tupu ya nambari za nzima, rudisha jumla ya vipengele vyote visivyo shufwa vilivyopo kwenye nafasi shufwa.

    Mifano:
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """Ukipata orodha isiyo na tupu ya nambari za nzima, rudisha jumla ya vipengele vyote visivyo shufwa vilivyopo kwenye nafasi shufwa.

    Mifano
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """


def add_elements(arr, k):
    """
    Kwa arr ambayo ni safu ya nambari kamili isiyo tupu, na nambari kamili k
    Rudisha jumla ya vipengele ambavyo vina si zaidi ya tarakimu 2 kutoka kwa vipengele k vya kwanza vya arr

    Mfano:

        Ingizo: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Tokeo: 24 # Jumla ya 21 + 3

    Vikwazo:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    Kwa kuzingatia safu isiyo tupu ya nambari kamili arr na nambari kamili k, rudi
    jumla ya vipengele vilivyo na angalau tarakimu mbili kutoka kwa vipengele vya k vya kwanza vya arr.

    Mfano:

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

    Vikwazo:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """


def get_odd_collatz(n):
    """
    Kwa kuzingatia nambari kamili n, rudisha orodha iliyopangwa ambayo ina nambari zisizo za kawaida katika mlolongo wa collatz.

    Dhana ya Collatz ni dhana katika hisabati ambayo inahusu mfuatano uliofafanuliwa
    kama ifuatavyo: anza na nambari yoyote chanya n. Kisha kila neno linapatikana kutoka kwa
    muda uliopita kama ifuatavyo: ikiwa muhula uliopita ni sawa, muhula unaofuata ni nusu ya
    muda uliopita. Ikiwa neno la awali ni la ajabu, neno linalofuata ni mara 3 ya awali
    muda pamoja na 1. Dhana ni kwamba haijalishi ni thamani gani ya n, mlolongo utafikia 1 kila wakati.

    Kumbuka:
        1. Collatz(1) ni [1].
        2. orodha iliyorejeshwa imepangwa kwa mpangilio unaoongezeka.

    Kwa mfano:
    get_odd_collatz(5) hurejesha [1, 5] # Mfuatano wa collatz kwa 5 ni [5, 16, 8, 4, 2, 1], kwa hivyo nambari zisizo za kawaida ni 1, na 5 pekee.
    """

def get_odd_collatz(n):
    """
    Inapopokea nambari kamili chanya n na kurudisha orodha iliyopangwa ambayo ina nambari zisizo za jozi katika mlolongo wa Collatz

    Dhana ya Collatz ni dhana ya kihisabati kuhusu mlolongo unaofafanuliwa kama ifuatavyo
    Anza na nambari kamili chanya n yoyote, kisha kila neno linapatikana kutoka kwa neno lililotangulia kwa njia ifuatayo
    Ikiwa neno lililotangulia ni nambari ya jozi, neno linalofuata litakuwa nusu ya neno lililotangulia
    Ikiwa neno lililotangulia ni nambari isiyo ya jozi, neno linalofuata litakuwa mara tatu ya neno lililotangulia kisha kuongeza moja
    Dhana hii inasema kwamba mlolongo utakuwa 1 kila wakati bila kujali thamani ya n

    Kumbuka:
        1. Collatz(1) ni [1]
        2. Orodha inayorudishwa itapangwa kwa mpangilio wa kuongezeka

    Mfano:
    get_odd_collatz(5) inarudisha [1, 5] # Mlolongo wa Collatz wa 5 ni [5, 16, 8, 4, 2, 1] na nambari zisizo za jozi ni 1 na 5 pekee
    """


def valid_date(tarehe):
    """Lazima uandike chaguo la kukokotoa ambalo huthibitisha mfuatano wa tarehe na
    hurejesha True ikiwa tarehe ni halali vinginevyo ni False.
    Tarehe ni halali ikiwa sheria zote zifuatazo zimeridhika:
    1. Mfuatano wa tarehe sio tupu.
    2. Idadi ya siku si chini ya 1 au zaidi ya siku 31 kwa miezi 1,3,5,7,8,10,12. Na idadi ya siku sio chini ya 1 au zaidi ya siku 30 kwa miezi 4,6,9,11. Na, idadi ya siku sio chini ya 1 au zaidi ya 29 kwa mwezi wa 2.
    3. Miezi haipaswi kuwa chini ya 1 au zaidi ya 12.
    4. Tarehe inapaswa kuwa katika muundo: mm-dd-yyyy

    kwa mfano:
    valid_date('03-11-2000') => True

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

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

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

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

def valid_date(date):
    """Unda kazi ya kuangalia uzi wa tarehe na kurudisha True ikiwa tarehe ni sahihi, vinginevyo rudisha False
    Ili tarehe iwe sahihi, lazima ifuate sheria zote zifuatazo:
    1. Uzi wa tarehe haupaswi kuwa tupu
    2. Idadi ya siku haipaswi kuwa chini ya siku 1 au zaidi ya siku 31 katika miezi 1,3,5,7,8,10,12, haipaswi kuzidi siku 30 katika miezi 4,6,9,11, na haipaswi kuzidi siku 29 katika mwezi wa 2
    3. Mwezi haupaswi kuwa chini ya 1 au zaidi ya 12
    4. Tarehe inapaswa kuwa katika muundo: mm-dd-yyyy

    Mfano:
    valid_date('03-11-2000') => True

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

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

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

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


def split_words(txt):
    '''
    Iwapo kuna kamba ya maneno, rudisha orodha ya maneno yaliyogawanywa kwa nafasi. Ikiwa hakuna nafasi kwenye maandishi,
    inahitajika kugawanya kwa alama ya comma ','. Ikiwa hakuna alama ya comma, inahitajika kurudisha idadi ya herufi ndogo zenye nambari isiyo ya kawaida.
    ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Mfano
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    Kwa kuzingatia mfuatano wa maneno, rudisha orodha ya maneno yaliyogawanywa kwenye nafasi nyeupe, ikiwa hakuna nafasi nyeupe katika maandishi yako
    inapaswa kugawanywa kwa koma ',' ikiwa hakuna koma unapaswa kurudisha idadi ya herufi ndogo zenye mpangilio usio wa kawaida
    alfabeti, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Mifano
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''


def is_sorted(lst):
    '''
    Ukipewa orodha ya nambari, rudisha ikiwa nambari hizo zimepangwa kutoka ndogo hadi kubwa
    Ikiwa kuna nambari sawa zaidi ya moja, rudisha False
    Dhania hakuna nambari hasi na kuna nambari kamili pekee

    Mfano
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''

def is_sorted(lst):
    '''
    Kwa kuzingatia orodha ya nambari, rudisha ikiwa zimepangwa au la
    kwa utaratibu wa kupanda. Ikiwa orodha ina zaidi ya nakala 1 ya sawa
    nambari, rudisha Uongo. Chukulia hakuna nambari hasi na nambari kamili pekee.

    Mifano
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''


def intersection(interval1, interval2):
    """Unapewa vipindi viwili,
    ambapo kila muda ni jozi ya nambari kamili. Kwa mfano, muda = (anza, mwisho) = (1, 2).
    Vipindi vilivyotolewa vimefungwa ambayo ina maana kwamba muda (anza, mwisho)
    inajumuisha kuanza na mwisho.
    Kwa kila muda uliotolewa, inachukuliwa kuwa mwanzo wake ni chini au sawa na mwisho wake.
    Kazi yako ni kuamua ikiwa urefu wa makutano ya hizi mbili
    vipindi ni nambari kuu.
    Mfano, makutano ya vipindi (1, 3), (2, 4) ni (2, 3)
    ambayo urefu wake ni 1, ambayo sio nambari kuu.
    Ikiwa urefu wa makutano ni nambari kuu, rudisha "YES",
    vinginevyo, rudisha "NO".
    Ikiwa vipindi viwili haviingiliani, rudisha "NO".

    [ingizo/pato] sampuli:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """Kutoa vipindi viwili
    Kila kipindi ni jozi ya nambari nzima, kwa mfano, kipindi = (kuanza, kumaliza) = (1, 2)
    Vipindi vilivyotolewa ni vipindi vilivyofungwa na kipindi (kuanza, kumaliza) kinajumuisha mwanzo na mwisho
    Kwa kila kipindi, dhana ni kwamba mwanzo ni mdogo au sawa na mwisho
    Kazi yako ni kuamua kama urefu wa makutano ya vipindi viwili ni nambari ya kwanza au la
    Kwa mfano, makutano ya vipindi (1, 3), (2, 4) ni (2, 3)
    Urefu wake ni 1 ambayo si nambari ya kwanza
    Ikiwa urefu wa makutano ni nambari ya kwanza, rudisha "YES"
    Ikiwa sivyo, rudisha "NO"
    Ikiwa vipindi viwili havikutani, rudisha "NO"

    [Mfano] Ingizo/Toleo:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """


def prod_signs(arr):
    """
    Unapewa safu ya nambari kamili na unahitaji kurudi
    jumla ya ukubwa wa nambari kamili unaozidishwa na bidhaa ya ishara zote
    ya kila nambari katika safu, inayowakilishwa na 1, -1 au 0.
    Kumbuka: Usirudishe kwa safu tupu.

    Mfano:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    Kwa arr ambayo ni safu ya nambari nzima, na tunahitaji kurudisha matokeo ya kuzidisha alama za kila nambari
    (inayoonyeshwa na 1, -1 au 0) na jumla ya thamani kamili ya nambari nzima.
    Kumbuka: Katika kesi ya safu tupu, rudisha None

    Mfano:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """


def minPath(grid, k):
    """
    Kutoa gridi yenye mistari N na safu N (N >= 2) na nambari kamili chanya k
    Kila seli katika gridi ina thamani iliyojumuishwa. Nambari zote kamili katika safu [1, N * N]
    zinaonekana katika seli ya gridi mara moja tu.

    Inahitajika kupata njia yenye urefu k ndogo zaidi katika gridi. Inaweza kuanza kutoka seli yoyote
    na katika kila hatua inaweza kuhamia kwenye seli iliyo karibu. Hii ni kusema, inaweza kuhamia kwenye seli
    inayoshiriki mpaka na seli ya sasa.
    Njia yenye urefu k inamaanisha kutembelea seli k kwa usahihi (sio lazima ziwe tofauti)
    Haiwezi kutoka nje ya gridi.
    Njia A yenye urefu k itachukuliwa kuwa ndogo kuliko njia B ikiwa baada ya kuunda orodha ya mlolongo wa thamani ambazo
    njia A na B zinapita (ziite kama lst_A na lst_B)
    lst_A ina mlolongo wa kamusi ndogo kuliko lst_B, yaani kuna kiashiria cha nambari kamili i (1 <= i <= k)
    ambapo lst_A[i] < lst_B[i] na kwa j yoyote (1 <= j < i)
    lst_A[j] = lst_B[j]
    Inahakikishwa kuwa jibu ni la kipekee
    Rudisha orodha ya mlolongo wa thamani ambazo njia ndogo zaidi inapita

    Mfano:

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

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

def minPath(grid, k):
    """
    Imepewa gridi yenye safu mlalo za N na safu wima N (N >= 2) na nambari kamili k,
    kila seli ya gridi ya taifa ina thamani. Kila nambari kamili katika safu [1, N * N]
    umoja huonekana mara moja kwenye seli za gridi ya taifa.

    Lazima utafute njia ya chini ya urefu k kwenye gridi ya taifa. Unaweza kuanza
    kutoka kwa seli yoyote, na katika kila hatua unaweza kuhamia seli yoyote ya jirani,
    kwa maneno mengine, unaweza kwenda kwenye seli zinazoshiriki makali na wewe mkondo
    kiini.
    Tafadhali kumbuka kuwa njia ya urefu k inamaanisha kutembelea seli za k haswa (sio
    lazima tofauti).
    HUWEZI kwenda nje ya gridi ya taifa.
    Njia A (ya urefu k) inachukuliwa kuwa chini ya njia B (ya urefu k) ikiwa
    baada ya kutengeneza orodha zilizoagizwa za thamani kwenye seli ambazo A na B huenda
    kupitia (wacha tuwaite lst_A na lst_B), lst_A haina leksikografia kidogo
    kuliko lst_B, kwa maneno mengine, kuna faharasa kamili i (1 <= i <= k)
    hivi kwamba lst_A[i] < lst_B[i] na kwa j yoyote (1 <= j < i) tunayo
    lst_A[j] = lst_B[j].
    Imehakikishiwa kuwa jibu ni la kipekee.
    Rudisha orodha iliyoagizwa ya thamani kwenye seli ambazo njia ya chini hupitia.

    Mifano:

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

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


def tri(n):
    """Kila mtu anajua mlolongo wa Fibonacci, ulisomwa kwa kina na wanahisabati katika
    karne kadhaa zilizopita. Walakini, kile ambacho watu hawajui ni mlolongo wa Tribonacci.
    Mlolongo wa Tribonacci hufafanuliwa na kurudia:
    tri(1) = 3
    tri(n) = 1 + n / 2, ikiwa n ni sawa.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), ikiwa n ni isiyo ya kawaida.
    Kwa mfano:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Unapewa nambari kamili isiyo hasi n, lazima urejeshe orodha ya
    nambari za kwanza za n + 1 za mlolongo wa Tribonacci.
    Mifano:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """Kila mtu anajua mfuatano wa Fibonacci, ambao umesomwa kwa kina na wanahisabati kwa karne nyingi
    Lakini kile ambacho watu hawajui ni mfuatano wa Tribonacci
    Mfuatano wa Tribonacci unafafanuliwa na urejeleaji kama ifuatavyo:
    tri(1) = 3
    tri(n) = 1 + n / 2, wakati n ni nambari shufwa
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), wakati n ni nambari witiri
    Kwa mfano:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Unapopewa nambari kamili isiyo hasi n, inapaswa kurudisha mfuatano wa Tribonacci kabla ya n + 1 katika muundo wa orodha
    Mfano:
    tri(3) = [1, 3, 2, 8]
    """


def digits(n):
    """Ukipata nambari nzima chanya n, rudisha tunda la tarakimu zisizo shufwa.
    Rudisha 0 ikiwa tarakimu zote ni shufwa.
    Kwa mfano:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """


def is_nested(string):
    '''
    Unda kazi inayopokea kamba inayojumuisha mabano ya mraba pekee kama ingizo
    Kazi inapaswa kurudisha True ikiwa tu kuna jozi angalau 1 ya mabano yaliyopachikwa katika sehemu yoyote ya kamba

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

def is_nested(string):
    '''
    Unda chaguo za kukokotoa ambazo huchukua mfuatano kama ingizo ambalo lina mabano ya mraba pekee.
    Chaguo za kukokotoa zinapaswa kurudi Kweli ikiwa na tu ikiwa kuna mfuatano halali wa mabano
    ambapo angalau mabano moja kwenye kifuatacho yamewekwa.

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


def sum_squares(lst):
    """Unapewa orodha ya nambari.
    Unahitaji kurudisha jumla ya nambari za mraba kwenye orodha uliyopewa,
    zungusha kila kipengele kwenye orodha hadi int ya juu (Ceiling) kwanza.
    Mifano:
    Kwa lst = [1,2,3] matokeo yanapaswa kuwa 14
    Kwa lst = [1,4,9] matokeo yanapaswa kuwa 98
    Kwa lst = [1,3,5,7] matokeo yanapaswa kuwa 84
    Kwa lst = [1.4,4.2,0] matokeo yanapaswa kuwa 29
    Kwa lst = [-2.4,1,1] matokeo yanapaswa kuwa 6

    """

def sum_squares(lst):
    """Kutoa orodha ya nambari
    Inahitajika kurudisha jumla ya nambari katika orodha iliyotolewa baada ya kuzikuza mara mbili
    Kwanza, piga kila kipengele katika orodha hadi nambari kamili kubwa zaidi (dari)
    Mfano:
    lst = [1,2,3] matokeo yanapaswa kuwa 14
    lst = [1,4,9] matokeo yanapaswa kuwa 98
    lst = [1,3,5,7] matokeo yanapaswa kuwa 84
    lst = [1.4,4.2,0] matokeo yanapaswa kuwa 29
    lst = [-2.4,1,1] matokeo yanapaswa kuwa 6
    """


def check_if_last_char_is_a_letter(txt):
    '''
    Unda kazi inayorejesha True ikiwa herufi ya mwisho ya kamba iliyotolewa ni herufi
    na si sehemu ya neno. Vinginevyo, rejesha False.
    Kumbuka: "Neno" ni kundi la herufi zinazotenganishwa na nafasi.

    Mfano:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    Unda chaguo za kukokotoa zinazorejesha Kweli ikiwa herufi ya mwisho
    ya mfuatano fulani ni herufi ya alfabeti na sivyo
    sehemu ya neno, na Uongo vinginevyo.
    Kumbuka: "neno" ni kundi la wahusika waliotenganishwa na nafasi.

    Mifano:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''


def can_arrange(arr):
    """Tengeneza kazi inayorejesha kiashiria cha juu zaidi ambapo kipengele si kikubwa kuliko kipengele kilichotangulia
    Ikiwa hakuna kipengele kama hicho, rejesha -1. Mlolongo uliotolewa hautakuwa na thamani zinazojirudia.

    Mfano:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """Unda chaguo za kukokotoa ambazo hurejesha faharasa kubwa zaidi ya kipengele ambacho
    si kubwa kuliko au sawa na kipengele kinachotangulia mara moja. Ikiwa
    hakuna kipengele kama hicho basi rudi -1. Safu iliyotolewa haitakuwa na
    thamani rudufu.

    Mifano:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """


def largest_smallest_integers(lst):
    '''
    Unda kazi inayorejesha tuple (a, b) ambapo 'a' ni nambari hasi kubwa zaidi kwenye orodha
    na 'b' ni nambari chanya ndogo zaidi kwenye orodha.
    Ikiwa hakuna nambari hasi au chanya, rejesha None

    Mfano:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''

def largest_smallest_integers(lst):
    '''
    Unda chaguo za kukokotoa zinazorejesha nakala (a, b), ambapo 'a' iko
    nambari kubwa zaidi ya nambari hasi, na 'b' ndio ndogo zaidi
    ya nambari kamili chanya kwenye orodha.
    Ikiwa hakuna nambari kamili hasi au chanya, zirudishe kama Hakuna.

    Mifano:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''


def compare_one(a, b):
    """
    Pokea thamani kama nambari kamili, nambari ya desimali, au kamba inayowakilisha nambari halisi
    Tengeneza kazi inayorejesha kigezo chenye thamani kubwa zaidi katika aina ya kigezo kilichotolewa
    Ikiwa thamani ni sawa, rejesha None
    Kumbuka: Ikiwa nambari halisi imewakilishwa kama kamba, nukta ya desimali inaweza kuwa . au ,

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

def linganisha_moja(a, b):
    """
    Pokea thamani kama nambari kamili, nambari ya desimali, au kamba inayowakilisha nambari halisi
    Tengeneza kazi inayorejesha kigezo chenye thamani kubwa zaidi katika aina ya kigezo kilichotolewa
    Ikiwa thamani ni sawa, rejesha Bila
    Kumbuka: Ikiwa nambari halisi imewakilishwa kama kamba, nukta ya desimali inaweza kuwa . au ,

    linganisha_moja(1, 2.5) ➞ 2.5
    linganisha_moja(1, "2,3") ➞ "2,3"
    linganisha_moja("5,1", "6") ➞ "6"
    linganisha_moja("1", 1) ➞ Bila
    """

def kulinganisha_one(a, b):
    """
    Unda chaguo za kukokotoa ambazo huchukua nambari kamili, kuelea, au mifuatano inayowakilisha
    nambari halisi, na hurejesha kigezo kikubwa zaidi katika aina yake ya kutofautisha.
    Usirudishe Ikiwa thamani ni sawa.
    Kumbuka: Ikiwa nambari halisi inawakilishwa kama mfuatano, sehemu inayoelea inaweza kuwa . au ,

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


def is_equal_to_sum_even(n):
    """Tathmini ikiwa nambari iliyotolewa n inaweza kuandikwa kama jumla ya nambari 4 chanya sawa
    Mfano
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """Inatathmini kama namba iliyotolewa n inaweza kuwakilishwa kama jumla ya namba 4 shufwa chanya
    Mfano
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """


def special_factorial(n):
    """Faktoria maalum inafafanuliwa kama ifuatavyo:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    ambapo n > 0

    Mfano:
    >>> special_factorial(4)
    288

    Kazi hii inapaswa kupokea nambari kamili kama ingizo na kurudisha faktoria maalum ya nambari hii kamili
    """

def special_factorial(n):
    """Kipengele cha Kibrazili kinafafanuliwa kama:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    ambapo n > 0

    Kwa mfano:
    >>> special_factorial(4)
    288

    Chaguo za kukokotoa zitapokea nambari kamili kama ingizo na inapaswa kurudisha maalum
    kipengele cha nambari hii kamili.
    """


def fix_spaces(text):
    """
    Kwa kuzingatia maandishi ya kamba, badilisha nafasi zote ndani yake na alama za chini,
    na ikiwa kamba ina nafasi zaidi ya 2 mfululizo,
    kisha badilisha nafasi zote zinazofuatana na -

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

def fix_spaces(text):
    """
    Inapopokea kamba ya maandishi text, badilisha nafasi zote na alama ya chini
    Ikiwa kuna nafasi mbili au zaidi mfululizo kwenye kamba
    badilisha nafasi zote mfululizo na -

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


def file_name_check(file_name):
    """Pokea jina la faili linalowakilishwa na kamba na tengeneza kazi inayorejesha 'Yes'
    ikiwa jina la faili hilo ni sahihi, na rejesha 'No' ikiwa sivyo.
    Jina la faili litachukuliwa kuwa sahihi ikiwa masharti yote yafuatayo ni kweli:
    - Nambari ('0'-'9') zilizopo kwenye jina la faili hazipaswi kuzidi 3
    - Jina la faili lazima liwe na nukta '.' moja tu
    - Sehemu kabla ya nukta haipaswi kuwa tupu na lazima ianze na herufi ya Kilatini ('a'-'z' na 'A'-'Z')
    - Sehemu baada ya nukta lazima iwe moja ya yafuatayo: ['txt', 'exe', 'dll']
    Mfano:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (jina linapaswa kuanza na herufi ya Kilatini)
    """

def file_name_check(file_name):
    """Unda chaguo za kukokotoa ambazo huchukua mfuatano unaowakilisha jina la faili, na kurejesha
    'Ndiyo' ikiwa jina la faili ni halali, na hurejesha 'Hapana' vinginevyo.
    Jina la faili linachukuliwa kuwa halali ikiwa na tu ikiwa masharti yote yafuatayo
    imefikiwa:
    - Haipaswi kuwa na zaidi ya tarakimu tatu ('0'-'9') katika jina la faili.
    - Jina la faili lina nukta moja haswa '.'
    - Substring kabla ya dot haipaswi kuwa tupu, na huanza na barua kutoka
    alfabeti ya Kilatini ('a'-'z' na 'A'-'Z').
    - Sehemu ndogo baada ya nukta inapaswa kuwa mojawapo ya hizi: ['txt', 'exe', 'dll']
    Mifano:
    file_name_check("mfano.txt") # => 'Yes'
    file_name_check("1mfano.dll") # => 'No' (jina linapaswa kuanza na herufi ya alfabeti ya Kilatini)
    """


def sum_squares(lst):
    """
    Kazi hii inapokea orodha ya nambari kamili. Kwa kila kipengele katika orodha, ikiwa faharasa ni kizio cha 3, itapandisha kipengele hicho kwa mraba.
    Ikiwa faharasa ni kizio cha 4 lakini si kizio cha 3, itapandisha kipengele hicho kwa cubi. Vipengele ambavyo si vizio vya 3 au 4 havitabadilika.
    Kisha itarudisha jumla ya vipengele vyote.

    Mfano:
    Ikiwa lst = [1,2,3] matokeo yatakuwa 6
    Ikiwa lst = [] matokeo yatakuwa 0
    Ikiwa lst = [-1,-5,2,-1,-5] matokeo yatakuwa -126
    """

def sum_squares(lst):
    """"
    Chaguo hili la kukokotoa litachukua orodha ya nambari kamili. Kwa maingizo yote kwenye orodha, chaguo za kukokotoa zitasawazisha ingizo kamili ikiwa faharasa yake ni a
    nyingi kati ya 3 na itaweka mchemraba wa ingizo kamili ikiwa faharasa yake ni kizidishio cha 4 na si kizidishio cha 3. Chaguo za kukokotoa hazitafanya kazi
    badilisha maingizo katika orodha ambayo faharasa zake si kizidishio cha 3 au 4. Chaguo za kukokotoa zitarejesha jumla ya maingizo yote.

    Mifano:
    Kwa lst = [1,2,3] matokeo yanapaswa kuwa 6
    Kwa lst = [] matokeo yanapaswa kuwa 0
    Kwa lst = [-1,-5,2,-1,-5]  matokeo yanapaswa kuwa -126
    """


def words_in_sentence(sentence):
    """
    Unapewa kamba inayowakilisha sentensi,
    sentensi ina baadhi ya maneno yaliyotenganishwa na nafasi,
    na lazima urudishe kamba ambayo ina maneno kutoka kwa sentensi asili,
    ambao urefu wao ni nambari kuu,
    mpangilio wa maneno katika mfuatano mpya unapaswa kuwa sawa na ule wa asili.

    Mfano 1:
        Ingizo: sentence = "This is a test"
        Pato: "is"

    Mfano 2:
        Ingizo: sentence = "lets go for swimming"
        Pato: "go for"

    Vikwazo:
         * 1 <= len(sentence) <= 100
         * sentence contains only letters
    """

def words_in_sentence(sentence):
    """
    Ukipewa sentensi iliyo katika muundo wa kamba
    Sentensi ina maneno yaliyotenganishwa na nafasi
    Inahitajika kurudisha kamba yenye maneno ambayo urefu wake ni nambari ya kwanza kutoka kwenye sentensi ya awali
    Mpangilio wa maneno katika kamba mpya unapaswa kuwa sawa na asili

    Mfano wa 1:
        Ingizo: sentence = "This is a test"
        Matokeo: "is"

    Mfano wa 2:
        Ingizo: sentence = "lets go for swimming"
        Matokeo: "go for"

    Vikwazo:
        * 1 <= len(sentence) <= 100
        * sentensi ina herufi pekee
    """


def simplify(x, n):
    """Kazi yako ni kuunda kazi inayorahisisha mlingano x * n
    Kazi itarudisha True ikiwa x * n inakadiria kuwa nambari kamili na itarudisha False ikiwa sivyo
    x na n ni uwakilishi wa sehemu katika muundo wa kamba, na zina muundo kama huu
    <sehemu ya juu>/<sehemu ya chini> ambapo sehemu ya juu na sehemu ya chini ni nambari kamili chanya zote mbili

    Unaweza kudhani kuwa x na n ni sehemu sahihi na sehemu ya chini si sifuri

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

def kurahisisha (x, n):
    """Kazi yako ni kutekeleza kazi ambayo itarahisisha usemi
    x * n. Chaguo za kukokotoa hurejesha Kweli ikiwa x * n itatathmini kwa nambari nzima na Si kweli
    vinginevyo. X na n, zote mbili ni uwakilishi wa mfuatano wa sehemu, na zina umbizo lifuatalo,
    <numerator>/<denominator> ambapo nambari na denominator zote ni nambari kamili chanya.

    Unaweza kudhani kuwa x, na n ni sehemu halali, na hazina sifuri kama denominator.

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


def order_by_points(nums):
    """
    Andika kazi inayopanga orodha ya nambari kamili zilizotolewa kutoka ndogo hadi kubwa kulingana na jumla ya tarakimu
    Kumbuka: Ikiwa kuna orodha nyingi zenye jumla ya tarakimu sawa, zipange kulingana na faharasa katika orodha ya awali

    Mfano:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    Andika chaguo za kukokotoa ambazo hupanga orodha iliyotolewa ya nambari kamili
    kwa mpangilio wa kupanda kulingana na jumla ya nambari zao.
    Kumbuka: ikiwa kuna vitu kadhaa vilivyo na jumla sawa ya nambari zao,
    waagize kulingana na faharisi yao katika orodha asili.

    Kwa mfano:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """


def specialFilter(nums):
    """Pokea nambari kwenye safu kama ingizo, na unda kazi inayorejesha idadi ya vipengele ambavyo ni zaidi ya 10
    na tarakimu ya kwanza na ya mwisho ya nambari ni isiyo ya kawaida (1, 3, 5, 7, 9)
    Mfano:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """Andika chaguo ambazo huchukua ripango ya nambari kama ingizo na urejeshaji
    idadi ya vipengele katika safu ambayo ni kubwa kuliko 10 na zote mbili
    nambari za kwanza na za mwisho za nambari ni zisizo za kawaida (1, 3, 5, 7, 9).
    Kwa mfano:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """


def get_max_triples(n):
    """
    Unapewa nambari kamili n. Lazima uunde safu kamili a ya urefu n.
        Kwa kila i (1 ≤ i ≤ n), thamani ya a[i] = i * i - i + 1.
        Rudisha idadi ya mara tatu (a[i], a[j], a[k]) ya ambapo i < j < k,
    na a[i] + a[j] + a[k] ni kizidishio cha 3.

    Mfano :
        Ingizo: n = 5
        Pato: 1
        Maelezo:
        a = [1, 3, 7, 13, 21]
        Tatu halali pekee ni (1, 7, 13).
    """

def get_max_triples(n):
    """
    Ukipewa n kama nambari kamili chanya, unahitaji kuunda safu ya nambari kamili a yenye urefu n
        Kwa kila i (1 ≤ i ≤ n) thamani ya a[i] ni i * i - i + 1
        Wakati i < j < k idadi ya seti tatu (a[i], a[j], a[k]) katika a
    ambapo a[i] + a[j] + a[k] ni kigezo cha 3

    Mfano:
        Ingizo: n = 5
        Matokeo: 1
        Maelezo:
        a = [1, 3, 7, 13, 21]
        Seti tatu sahihi pekee ni (1, 7, 13)
    """


def bf(planet1, planet2):
    '''
    Katika mfumo wa jua kuna sayari 8: Mercury iko karibu zaidi na jua,
    ikifuatiwa na Venus, Dunia, Mars, Jupiter, Saturn, Uranus, Neptune
    Tengeneza kazi inayopokea majina ya sayari 2 kama kamba planet1 na planet2
    Kazi inapaswa kurudisha tuple inayojumuisha sayari zote zilizo kati ya mizunguko ya planet1 na planet2,
    zikiwa zimepangwa kulingana na ukaribu na jua
    Ikiwa planet1 au planet2 si jina sahihi la sayari, kazi inapaswa kurudisha tuple tupu
    Mfano
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    Katika mfumo wa jua kuna sayari 8: Mercury iko karibu zaidi na jua,
    ikifuatiwa na Venus, Dunia, Mars, Jupiter, Saturn, Uranus, Neptune.
    Tengeneza kazi inayopokea majina ya sayari 2 kama kamba planet1 na planet2
    Kazi inapaswa kurudisha nakala iliyo na sayari zote ambazo mizunguko yake ni
    iko kati ya obiti ya planet1 na obiti ya planet2, iliyopangwa na
    ukaribu na jua.
    Chaguo za kukokotoa zinapaswa kurudisha nakala tupu ikiwa sayari1 au sayari2
    sio majina sahihi ya sayari.
    Mifano
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''


def sorted_list_sum(lst):
    """Pokea orodha ya maneno kama parameter
    Ondoa maneno yenye urefu wa maneno si ya kawaida
    Andika kazi inayorejesha orodha iliyopangwa
    Orodha itakuwa daima orodha ya maneno, si safu ya nambari
    Inaweza kuwa na marudio
    Mpangilio wa orodha lazima upangwe kulingana na urefu wa kila neno kutoka fupi hadi ndefu
    Na lazima urejeshe orodha iliyopangwa kulingana na sheria hiyo
    Ikiwa kuna maneno mawili yenye urefu sawa, panga orodha kwa mpangilio wa alfabeti
    Kazi lazima irejeshe orodha ya maneno iliyopangwa
    Unaweza kudhani kwamba kila neno lina urefu sawa
    Mfano:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Andika chaguo za kukokotoa zinazokubali orodha ya mifuatano kama kigezo,
    hufuta masharti ambayo yana urefu usio wa kawaida kutoka kwake,
    na hurejesha orodha iliyotokana na mpangilio uliopangwa,
    Orodha daima ni orodha ya mifuatano na kamwe sio safu ya nambari,
    na inaweza kuwa na nakala.
    Mpangilio wa orodha unapaswa kupanda kwa urefu wa kila neno, na wewe
    inapaswa kurudisha orodha iliyopangwa na sheria hiyo.
    Ikiwa maneno mawili yana urefu sawa, panga orodha kwa alfabeti.
    Chaguo za kukokotoa zinapaswa kurudisha orodha ya mifuatano kwa mpangilio uliopangwa.
    Unaweza kudhani kuwa maneno yote yatakuwa na urefu sawa.
    Kwa mfano:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Pokea orodha ya maneno kama parameter
    Ondoa maneno yenye urefu ya nambari isiyo ya kawaida
    Andika kazi inayorejesha orodha iliyopangwa
    Orodha itakuwa daima orodha ya maneno, si safu ya nambari
    Inaweza kuwa na marudio
    Mpangilio wa orodha lazima upangwe kulingana na urefu wa kila neno kutoka fupi hadi ndefu
    Na lazima urejeshe orodha iliyopangwa kulingana na sheria hiyo
    Ikiwa kuna maneno mawili yenye urefu sawa, panga orodha kwa mpangilio wa alfabeti
    Rejesha orodha iliyopangwa
    Unaweza kudhani kwamba kila neno lina urefu sawa
    Mfano:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """Mpango rahisi ambao unapaswa kurudisha thamani ya x ikiwa n ni
    nambari pekee na inapaswa kurudisha thamani ya y.

    Mifano:
    kwa x_or_y(7, 34, 12) == 34
    kwa x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """Ikiwa n ni nambari ya kwanza, rudisha thamani ya x, vinginevyo rudisha thamani ya y
    Programu rahisi.

    Mfano:
    kwa x_or_y(7, 34, 12) == 34
    kwa x_or_y(15, 8, 5) == 5

    """


def double_the_difference(lst):
    '''
    Kwa kuzingatia orodha ya nambari, rudisha jumla ya miraba ya nambari
    katika orodha ambayo ni isiyo ya kawaida. Puuza nambari ambazo ni hasi au sio nambari kamili.

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

    Ikiwa orodha ya ingizo ni tupu, rudisha 0.
    '''

def double_the_difference(lst):
    '''
    Ukipewa orodha ya nambari, rudisha jumla ya mraba wa nambari zisizo shufwa kwenye orodha
    Puuza nambari hasi au nambari ambazo si nambari kamili

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

    Ikiwa orodha iliyoingizwa ni tupu, rudisha 0
    '''


def compare(game,guess):
    """Kila mtu anaweza kukumbuka hisia wakati matokeo ya tukio lililosubiriwa kwa muda mrefu hatimaye yanapofichuliwa
    Hisia na mawazo katika wakati huo ni ya thamani ya kurekodi na kulinganisha
    Kazi yako ni kuamua kama mtu alitabiri matokeo ya mechi kwa usahihi au la
    Utapewa safu mbili za urefu sawa zinazoonyesha alama na utabiri. Kila faharasa inaonyesha mechi
    Rudisha safu ya urefu sawa inayoonyesha upotofu wa kila utabiri. Ikiwa utabiri ni sahihi, thamani ni 0
    Ikiwa sivyo, thamani ni tofauti kamili kati ya utabiri na alama

    Mfano:

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

def compare(game,guess):
    """Nadhani sote tunakumbuka hisia hiyo wakati matokeo ya wengine waliosubiriwa kwa muda mrefu
    tukio hatimaye linajulikana. Hisia na mawazo uliyo nayo wakati huo ni
    hakika inafaa kuzingatia na kulinganisha.
    Kazi yako ni kuamua ikiwa mtu alikisia kwa usahihi matokeo ya idadi ya mechi.
    Unapewa safu mbili za alama na makadirio ya urefu sawa, ambapo kila faharasa inaonyesha mechi.
    Rudisha safu ya urefu sawa inayoashiria umbali ambao kila nadhani ulikuwa. Ikiwa wamekisia kwa usahihi,
    thamani ni 0, na ikiwa sivyo, thamani ni tofauti kabisa kati ya nadhani na alama.

    mfano:

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


def Strongest_Extension(class_name, extensions):
    """Kutoa jina la darasa (kamba) na orodha ya viendelezi
    Viendelezi hutumika kupakia madarasa ya ziada kwenye darasa
    Nguvu ya kiendelezi inafafanuliwa kama ifuatavyo: CAP ni idadi ya herufi
    kubwa zilizopo kwenye jina la kiendelezi, SM ni idadi ya herufi ndogo
    Nguvu inaonyeshwa kama sehemu ya CAP - SM
    Inahitajika kupata kiendelezi chenye nguvu zaidi na kurudisha kamba katika muundo ufuatao:
    ClassName.StrongestExtensionName
    Ikiwa kuna viendelezi vilivyo na nguvu sawa zaidi ya viwili, chagua
    kile kinachoonekana kwanza kwenye orodha
    Kwa mfano, ikiwa darasa linaitwa "Slices" na orodha ya viendelezi ni
    ['SErviNGSliCes', 'Cheese', 'StuFfed'] katika kesi hii
    'SErviNGSliCes' ni kiendelezi chenye nguvu zaidi (nguvu ni -1)
    Kwa hivyo inahitajika kurudisha 'Slices.SErviNGSliCes'
    Mfano:
    Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension (class_name, viendelezi):
    """Utapewa jina la darasa (kamba) na orodha ya viendelezi.
    Viendelezi vinapaswa kutumika kupakia madarasa ya ziada kwa darasa. Ya
    nguvu ya ugani ni kama ifuatavyo: Acha CAP iwe nambari ya herufi kubwa
    herufi katika jina la kiendelezi, na acha SM iwe idadi ya herufi ndogo
    katika jina la ugani, nguvu hutolewa na sehemu ya CAP - SM.
    Unapaswa kupata kiendelezi chenye nguvu zaidi na urudishe mfuatano katika hili
    umbizo: ClassName.StrongestExtensionName.
    Ikiwa kuna upanuzi mbili au zaidi na nguvu sawa, unapaswa
    chagua ile inayokuja kwanza kwenye orodha.
    Kwa mfano, ikiwa umepewa "Vipande" kama darasa na orodha ya
    viendelezi: ['SErviNGSliCes', 'Cheese', 'StuFfed'] basi unapaswa
    rudisha 'Vipande.SErviNGSliCes' kwa kuwa 'SErviNGSliCes' ndicho kiendelezi chenye nguvu zaidi
    (nguvu zake ni -1).
    Mfano:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """


def cycpattern_check(a , b):
    """Unapewa maneno 2. Unahitaji kurudi Kweli ikiwa neno la pili au mzunguko wake wowote ni kamba ndogo katika neno la kwanza
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """Kwa maneno mawili, ikiwa neno la pili au mzunguko wowote wa neno la pili ni sehemu ya neno la kwanza, rudisha True
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """


def even_odd_count(num):
    """Pokea nambari nzima na rudisha jozi yenye idadi ya tarakimu za nambari shufwa na witiri mtawalia

     Mfano:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """Ukipata nambari nzima, rudisha jozi iliyo na idadi ya tarakimu shufwa na zisizo shufwa mtawalia.

     Mfano:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """Ikiwa unapewa nambari kamili, rudisha jozi inayoonyesha idadi ya tarakimu shufwa na zisizo shufwa mtawalia.

     Mfano:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """


def int_to_mini_roman(number):
    """
    Kwa kuzingatia nambari kamili chanya, pata nambari yake ya Kirumi sawa na mfuatano,
    na uirudishe kwa herufi ndogo.
    Vizuizi: 1 <= num <= 1000

    Mifano:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    Inapopewa nambari kamili chanya, rudisha thamani inayolingana ya nambari ya Kirumi kama kamba
    na irudishe kwa herufi ndogo
    Kizuizi: 1 <= num <= 1000

    Mfano:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """


def right_angle_triangle(a, b, c):
    '''
    Iwapo urefu wa pande tatu za pembetatu umetolewa
    Ikiwa pande hizo tatu zinaunda pembetatu ya pembe ya kulia, itarudisha True
    Ikiwa sivyo, itarudisha False
    Pembetatu ya pembe ya kulia ni pembetatu yenye pembe moja ya digrii 90
    Mfano:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    Kwa kuzingatia urefu wa pande tatu za pembetatu. Rudi Kweli ikiwa hizo tatu
    pande huunda pembetatu yenye pembe ya kulia, Uongo vinginevyo.
    Pembetatu ya pembe ya kulia ni pembetatu ambayo pembe moja ni pembe ya kulia au
    90 shahada.
    Mfano:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''


def find_max(words):
    """Tengeneza kazi inayopokea orodha ya mistari
    Orodha inajumuisha maneno tofauti. Rudisha neno lenye idadi kubwa zaidi ya herufi zisizorudiwa.
    Ikiwa kuna mistari kadhaa yenye idadi kubwa zaidi ya herufi zisizorudiwa, rudisha ile inayokuja kwanza kwa mpangilio wa kamusi.

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

def find_max(words):
    """Andika fungo linalowakubalisha orodha ya maneno.
    Orodha ina maneno tofauti. Rudisha neno lenye idadi kubwa zaidi
    ya herufi za kipekee. Ikiwa nyuzi nyingi zina idadi kubwa zaidi ya herufi za kipekee,
    rudisha ile inayokuja kwanza kwa mpangilio wa leksikografia.

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


def eat(number, need, remaining):
    """
    Wewe ni sungura mwenye njaa, na tayari umekula idadi fulani ya karoti,
    lakini sasa unahitaji kula karoti zaidi ili kukamilisha milo ya siku.
    unapaswa kurudisha safu ya [jumla ya idadi ya karoti zilizoliwa baada ya milo yako,
                                    idadi ya karoti iliyobaki baada ya milo yako ]
    ikiwa hakuna karoti zilizobaki za kutosha, utakula karoti zote zilizobaki, lakini bado utakuwa na njaa.

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

    Vigezo:
    @nambari: nambari kamili
        idadi ya karoti ambazo umekula.
    @need : nambari kamili
        idadi ya karoti ambazo unahitaji kula.
    @kusalia: nambari kamili
        idadi ya karoti zilizobaki zipo kwenye hisa

    Kizuizi:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Furahia:)
    """

def eat(number, need, remaining):
    """
    Wewe ni sungura mwenye njaa na tayari umekula karoti kadhaa
    Leo unahitaji kula karoti zaidi ili kumaliza chakula yako
    Unapaswa kurudisha jumla ya karoti zote ulizokula baada ya mlo
    Na idadi ya karoti zilizobaki baada ya mlo katika muundo wa orodha
    Ikiwa karoti zilizobaki hazitoshi, utakula karoti zote zilizobaki lakini bado utakuwa na njaa

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

    Vigezo:
    @number : nambari
        Idadi ya karoti ulizokula tayari
    @need : nambari
        Idadi ya karoti unazohitaji kula
    @remaining : nambari
        Idadi ya karoti zilizobaki kwenye kijani

    Vikwazo:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Furahia :)
    """

def eat(number, need, remaining):
    """
    Wewe ni sungura mwenye njaa, na tayari umekula idadi fulani ya karoti,
    lakini sasa unahitaji kula karoti zaidi ili kukamilisha chakula chaa siku.
    unapaswa kurudisha safu ya [ idadi jumla ya karoti zilizoliwa baada ya chakula chako,
                                 idadi ya karoti zilizobaki baada ya chakula chako ]
    ikiwa hakuna karoti za kutosha zilizobaki, utakula karoti zote zilizobaki, lakini bado utakuwa na njaa.

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

    Vigezo:
    @number : nambari ya nzima
        idadi ya karoti ambazo umekula.
    @need : nambari ya nzima
        idadi ya karoti unayohitaji kula.
    @remaining : nambari ya nzima
        idadi ya karoti zilizobaki ambazo ziko kwenye hisa

    Kizuizi:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining<= 1000

    Furahia :)
    """


def do_algebra(operator, operand):
    """
    Kuna orodha mbili zilizotolewa, operator na operand. Orodha ya kwanza ina operesheni za kimsingi za aljebra
    na orodha ya pili ni orodha ya nambari kamili. Tumia orodha hizi mbili zilizotolewa kuunda usemi wa aljebra
    na rudisha thamani ya tathmini ya usemi huu.

    Operesheni za kimsingi za aljebra:
    Kuongeza ( + )
    Kutoa ( - )
    Kuzidisha ( * )
    Kugawanya na kukokotoa chini ( // )
    Kuweka nguvu ( ** )

    Mfano:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Kumbuka:
        Urefu wa orodha ya operator ni sawa na urefu wa orodha ya operand ukiondoa 1
        operand ni orodha ya nambari kamili zisizo hasi
        Orodha ya operator ina angalau opereta 1 na orodha ya operand ina angalau operandi 2

    """

def do_algebra(operator, operand):
    """
    Imepewa orodha mbili za waendeshaji, na uendeshaji. Orodha ya kwanza ina shughuli za msingi za algebra, na
    orodha ya pili ni orodha ya nambari kamili. Tumia orodha mbili zilizotolewa kuunda aljebra
    kujieleza na kurudisha tathmini ya usemi huu.

    Shughuli za msingi za algebra:
    Nyongeza ( + )
    Utoaji ( - )
    Kuzidisha ( * )
    Mgawanyiko wa sakafu ( // )
    Ufafanuzi ( ** )

    Mfano:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Kumbuka:
        Urefu wa orodha ya waendeshaji ni sawa na urefu wa orodha ya uendeshaji ukiondoa moja.
        Operand ni orodha ya nambari kamili zisizo hasi.
        Orodha ya waendeshaji ina angalau opereta mmoja, na orodha ya uendeshaji ina angalau operesheni mbili.

    """


def solve(s):
    """Unapewa kamba s.
    ikiwa s[i] ni herufi, badilisha kesi yake kutoka chini hadi juu au kinyume chake,
    vinginevyo ihifadhi kama ilivyo.
    Ikiwa kamba haina herufi, badilisha kamba.
    Chaguo za kukokotoa zinapaswa kurudisha kamba iliyosababisha.
    Mifano
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """Kwa string s
    Ikiwa s[i] ni herufi, badilisha herufi kubwa kuwa ndogo na kinyume chake (kutoka ndogo kuwa kubwa au kinyume chake)
    Ikiwa siyo, acha kama ilivyo
    Ikiwa hakuna herufi katika string, geuza string
    Kazi inapaswa kurudisha string iliyopatikana
    Mfano
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """


def string_to_md5(text):
    """
    Inapopewa kamba 'text' itarudisha kamba inayolingana na hash ya md5 yake
    Ikiwa 'text' ni kamba tupu, itarudisha None

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

def string_to_md5(text):
    """
    Kupitia mfuatano wa 'text', rudisha heshi ya md5 yake
    Ikiwa 'text' ni mfuatano tupu, rudisha None

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


def generate_integers(a, b):
    """
    Ukipewa nambari mbili kamili chanya a na b, rudisha nambari za jozi kati ya a na b katika mpangilio wa kutoka chini kwenda juu

    Mfano:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

def tengeneza_nambari(a, b):
    """
    Ukipewa nambari mbili nzuri a na b, rudisha tarakimu za jozi kati ya
    a na b, kwa mpangilio unaopanda.

    Kwa mfano:
     generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """