def bf(planet1, planet2):
    '''
    మన సౌరమండలంలో ఎనిమిది గ్రహాలు ఉన్నాయి: సూర్యుడికి దగ్గరగా ఉన్నది
    మెర్క్యూరీ, తరువాత వచ్చేది వీనస్, అప్పుడు భూమి, మంగళ గ్రహం, బృహస్పతి, శని,
    యురేనస్, నెప్ట్యూన్.
    planet1 మరియు planet2 అనే రెండు గ్రహాల పేర్లను స్ట్రింగులుగా తీసుకొనే
    ఒక ఫంక్షన్ రాయండి. ఈ ఫంక్షన్ planet1 మరియు planet2 యొక్క కక్ష్యల మధ్య
    ఉన్న అన్ని గ్రహాలను, సూర్యుడికి దగ్గరగా ఉన్న వరుసలో స_sorted_చేసి
    ఒక టపుల్‌గా తిరిగి ఇవ్వాలి.
    ఫంక్షన్ planet1 లేదా planet2 సరైన గ్రహాల పేర్లు కాకపోతే
    ఒక ఖాళీ టపుల్‌ను తిరిగి ఇవ్వాలి.
    ఉదాహరణలు
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    మన సౌరమండలంలో ఎనిమిది గ్రహాలు ఉన్నాయి: సూర్యునికి అత్యంత సమీపంలో ఉన్నది
    బుధం, తదుపరి గ్రహం శుక్ర, ఆపై భూమి, మంగలం, గురు, శనిగ్రహం, యురేనస్, నెప్ట్యూన్.
    రెండు గ్రహాల పేర్లను స్ట్రింగులుగా planet1 మరియు planet2 తీసుకుంటూ ఒక ఫంక్షన్ రాయండి.
    ఈ ఫంక్షన్, planet1 మరియు planet2 యొక్క కక్ష్యాల మధ్యలో ఉన్న అన్ని గ్రహాలు ఉన్న
    టపుల్ ను తిరిగి ఇచ్చి, సూర్యునికి సమీపం ప్రకారం వరుసబెట్టాలి.
    ఫంక్షన్, planet1 లేదా planet2 సరైన గ్రహాల పేర్లు కాకపోతే ఒక ఖాళీ టపుల్
    తిరిగి ఇవ్వాలి.
    ఉదాహరణలు
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    మన సౌరమండలంలో ఎనిమిది గ్రహాలు ఉన్నాయి: సూర్యుడికి అతి సమీపంలో మెర్క్యురీ ఉంది,
    తదుపరి వేదిక వేనస్, ఆ తరువాత ఎర్త్, మార్స్, జూపిటర్, శనిగ్రహం, యూరేనస్, నెప్ట్యూన్.
    planet1 మరియు planet2 అనే రెండు గ్రహాల పేర్లను స్ట్రింగ్‌లుగా తీసుకునే ఫంక్షన్‌ను రాయండి.
    ఈ ఫంక్షన్ planet1 మరియు planet2 మధ్య కక్ష్యలో ఉండే అన్ని గ్రహాలను,
    సూర్యుడి సమీపాన్ని అనుసరించి సSortedగా ట్యుపుల్‌గా తిరిగి ఇవ్వాలి.
    planet1 లేదా planet2 సరైన గ్రహాల పేర్లు కాకపోతే, ఖాళీ ట్యుపుల్‌ను తిరిగి ఇవ్వాలి.
    ఉదాహరణలు
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''


def sorted_list_sum(lst):
    """మీరు ఒక ఫంక్షన్ రాయాలి, ఇది స్ట్రింగ్స్ లిస్ట్ను పరామితిగా స్వీకరిస్తుంది,
    ఒడ్డ సంఖ్యా పొడవు కలిగిన స్ట్రింగ్స్‌ని లిస్టు నుండి తొలగించి,
    ఫలితంగా వచ్చిన లిస్టును సర్దుబాటు చేసిన క్రమంలో తిరిగి ఇస్తుంది.
    ఈ లిస్ట్ ఎప్పుడూ స్ట్రింగ్స్‌తోనే ఉంటుంది, నంబర్ల అర్రే కావడంలేదు,
    మరియు ఇది ప్రతిరూపాలను కలిగి ఉండవచ్చు.
    లిస్టు క్రమం ప్రతి పదం పొడవు ఆధారంగా ఎస్సెండింగ్ క్రమంలో ఉండాలి,
    మరియు మీరు ఆ నియమం ప్రకారం సర్దుబాటు చేసిన లిస్టును తిరిగి ఇవ్వాలి.
    ఒకే పొడవు కలిగిన రెండు పదాలు ఉంటే, లిస్ట్‌ను అల్ఫాబెటిక్‌గా సర్దుబాటు చేయండి.
    ఫంక్షన్ సర్దుబాటు చేసిన క్రమంలో స్ట్రింగ్స్ లిస్టునే తిరిగి ఇవ్వాలి.
    మీరు అన్ని పదాలు ఒకే పొడవు కలిగి ఉంటాయని ఊహించవచ్చు.
    ఉదాహరణకు:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """ఒక ఫంక్షన్‌ను రాయండి ఇది స్ట్రింగుల జాబితాను పరామితిగా స్వీకరిస్తుంది,
    వాటిలో అజ్ఞాత పొడవులున్న స్ట్రింగులను తొలగిస్తుంది,
    మరియు ఫలితంగా వచ్చిన జాబితాను క్రమబద్ధీకరించి తిరిగి ఇస్తుంది,
    జాబితా ఎప్పుడూ స్ట్రింగుల జాబితానే ఉంటుంది మరియు ఎప్పుడూ సంఖ్యల అర్రే కాదు,
    మరియు ఇది డుప్లికేట్లను కలిగి ఉండవచ్చు.
    జాబితా యొక్క ఆర్డర్ ప్రతి పదం యొక్క పొడవు ద్వారా పెరుగుతూ ఉండాలి, మరియు మీరు
    ఆ నియమాన్ని అనుసరించి జాబితాను క్రమబద్ధీకరించాలి.
    రెండు పదాలు సమాన పొడవు కలిగి ఉంటే, జాబితాను అక్షరాంశంగా క్రమబద్ధీకరించాలి.
    ఫంక్షన్ క్రమబద్ధీకరించబడిన ఆర్డర్లో స్ట్రింగుల జాబితాను తిరిగి ఇవ్వాలి.
    మీరు ఊహించవచ్చు అన్నీ పదాలు ఒకే పొడవును కలిగి ఉంటాయని.
    ఉదాహరణకు:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """ఒక జాబితాను పారామీటర్‌గా తీసుకుని
    బిజోడ పొడవు ఉన్న పదాలను తొలగిస్తుంది
    ఒక ఫంక్షన్‌ను వ్రాయండి, ఇది ఒక సజావుగా ఉన్న జాబితాను తిరిగి ఇస్తుంది
    జాబితా ఎల్లప్పుడూ పదాల జాబితా ఉంటుంది, సంఖ్యల శ్రేణి కాదు
    పునరావృతం ఉండవచ్చు
    జాబితాను ప్రతి పదం యొక్క పొడవు ప్రకారం చిన్న నుండి పెద్ద క్రమంలో సజావుగా చేయాలి
    మరియు ఆ నియమం ప్రకారం సజావుగా ఉన్న జాబితాను తిరిగి ఇవ్వాలి
    రెండు పదాల పొడవు సమానంగా ఉంటే, జాబితాను వర్ణక్రమంలో సజావుగా చేయండి
    ఫంక్షన్ సజావుగా ఉన్న పదాల జాబితాను తిరిగి ఇవ్వాలి
    మీరు ప్రతి పదం యొక్క పొడవు సమానంగా ఉంటుందని అనుకోవచ్చు
    ఉదాహరణ:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """ఒక సరళమైన ప్రోగ్రామ్, ఇది n ప్రైమ్ సంఖ్య అయితే x యొక్క విలువను తిరిగి ఇవ్వాలి,
    లేదంటే y యొక్క విలువను తిరిగి ఇవ్వాలి.

    ఉదాహరణలు:
    x_or_y(7, 34, 12) == 34 కోసం
    x_or_y(15, 8, 5) == 5 కోసం

    """

def x_or_y(n, x, y):
    """n ఒక ప్రధాన సంఖ్య అయితే x విలువను
    మరియు ఇతరwise y విలువను తిరిగి ఇవ్వాలి.

    ఉదాహరణలు:
    x_or_y(7, 34, 12) == 34 కోసం
    x_or_y(15, 8, 5) == 5 కోసం

    """

def x_or_y(n, x, y):
    """n అయితే x విలువను తిరిగి ఇచ్చే సాధారణ ప్రోగ్రామ్
    ఒక ప్రధాన సంఖ్య మరియు లేకపోతే y విలువను తిరిగి ఇవ్వాలి.

    ఉదాహరణలు:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """


def double_the_difference(lst):
    '''
    సంఖ్యల జాబితాను ఇచ్చినప్పుడు, జాబితాలో ఉన్న అసలు సంఖ్యల చతురస్రాల యొక్క योगం ను తిరిగి ఇవ్వండి
    నెగటివ్ గల సంఖ్యలు లేదా పూర్తి సంఖ్యలు కాకుండా ఉన్న సంఖ్యలను దృష్టిలో పెట్టకండి.

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

    ఇన్‌పుట్ జాబితా ఖాళీగా ఉంటే, 0 ను తిరిగి ఇవ్వండి.
    '''

def double_the_difference(lst):
    '''
    సంఖ్యల జాబితాను అందించి, సంఖ్యల స్క్వేర్‌ల మొత్తాన్ని తిరిగి ఇవ్వండి
    బేసిగా ఉన్న జాబితాలో. ప్రతికూల లేదా పూర్ణాంకాలు లేని సంఖ్యలను విస్మరించండి.

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

    ఇన్‌పుట్ జాబితా ఖాళీగా ఉంటే, 0ని తిరిగి ఇవ్వండి.
    '''

def double_the_difference(lst):
    '''
    ఒక సంఖ్యల జాబితాను ఇవ్వబడినప్పుడు, జాబితాలో ఉన్న బేసి సంఖ్యల (సరళ సంఖ్యల) చతురస్రాల మొత్తాన్ని తిరిగి ఇవ్వండి.
    ప్రతికూల సంఖ్యలు లేదా పూర్తి సంఖ్యలు కాకపోయే సంఖ్యలను పరిగణించవద్దు.

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

    ఇన్‌పుట్ జాబితా ఖాళీగా ఉంటే, 0 ను తిరిగి ఇవ్వండి.
    '''


def compare(game,guess):
    """మనకు అన్నీ గుర్తుంటాయి, కొన్ని దీర్ఘకాలంగా ఎదురు చూసిన
    సంఘటనల ఫలితాలు ఎట్టకేలకు తెలియజేయబడినప్పుడు వచ్చిన భావనలు మరియు ఆలోచనలు.
    మీరు ఆ క్షణంలో కలిగే భావనలు మరియు ఆలోచనలు తప్పకుండా రాసుకోవడం మరియు
    పోల్చుకోవడం మంచిది.
    మీ పని అనేక మ్యాచ్‌ల ఫలితాలను సరిగ్గా ఊహించినాయో లేదో నిర్ణయించడం.
    మీరు ఇవ్వబడిన రెండు సమాన పొడవైన స్కోర్లు మరియు ఊహల సరనులను పొందారు,
    ఎక్కడ ప్రతి సూచిక ఒక మ్యాచ్‌ను సూచిస్తుంది.
    ప్రతి ఊహ ఎంత వరకు తప్పు ఉందో సూచించే సమాన పొడవైన సరనును తిరిగి ఇవ్వండి.
    వారు సరిగ్గా ఊహించారంటే, విలువ 0 అవుతుంది, మరియు లేకపోతే, విలువ
    ఊహ మరియు స్కోర్ మధ్య ఆధారిత తేడా.

    ఉదాహరణ:

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

def compare(game,guess):
    ""కొంతకాలంగా ఎదురుచూస్తున్న ఫలితం వచ్చినప్పుడు మనమందరం ఆ అనుభూతిని గుర్తుంచుకుంటాము
    సంఘటన చివరకు తెలిసింది. ఆ సమయంలో మీకు కలిగిన భావాలు మరియు ఆలోచనలు
    ఖచ్చితంగా గమనించడం మరియు పోల్చడం విలువ.
    ఒక వ్యక్తి అనేక మ్యాచ్‌ల ఫలితాలను సరిగ్గా ఊహించాడో లేదో నిర్ణయించడం మీ పని.
    మీకు రెండు శ్రేణుల స్కోర్‌లు మరియు సమాన పొడవు గల అంచనాలు ఇవ్వబడ్డాయి, ఇక్కడ ప్రతి సూచిక ఒక మ్యాచ్‌ని చూపుతుంది.
    ప్రతి అంచనా ఎంత దూరంలో ఉందో సూచించే అదే పొడవు గల శ్రేణిని తిరిగి ఇవ్వండి. వారు సరిగ్గా ఊహించినట్లయితే,
    విలువ 0, మరియు కాకపోతే, విలువ అనేది అంచనా మరియు స్కోర్ మధ్య సంపూర్ణ వ్యత్యాసం.

    ఉదాహరణ:

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

def compare(game,guess):
    """నా అనుమానంలో, చాలా కాలంగా ఎదురు చూసిన ఒక వేడుక యొక్క ఫలితం చివరికి తెలిసినప్పుడు కలిగే భావాన్ని మనందరం గుర్తించగలిగాం.
    ఆ సమయంలో కలిగే భావాలు మరియు ఆలోచనలు తప్పక గమనించదగినవే మరియు వాటిని సరిపోల్చడం కూడా.
    మీ పని, కొన్ని మ్యాచ్‌ల ఫలితాలను ఒక వ్యక్తి సరిగ్గా ఊహించాడా అనే విషయాన్ని నిర్ణయించడం.
    మీకు సమాన పొడవు గల స్కోర్ల మరియు ఊహించిన ఫలితాల రెండు లగాయతాలు ఇవ్వబడ్డాయి, ఇక్కడ ప్రతి ఇండెక్స్ ఒక మ్యాచ్‌ను సూచిస్తుంది.
    ఫలితంగా, ప్రతి ఊహ విభిన్నం ఎంత వరకు తప్పుదారి పడ్డదో చూపించే అదే పొడవు గల లగాయతాను ఇవ్వండి. వారు సరిగ్గా ఊహించి ఉంటే,
    విలువ 0 ఉంటుంది, లేనిపక్షంలో, విలువ స్కోరు మరియు ఊహ మధ్య సార్వత్రిక తేడా ఉంటుంది.

    ఉదాహరణ:

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


def Strongest_Extension(class_name, extensions):
    """మీకు ఒక క్లాస్ యొక్క పేరు (ఒక స్ట్రింగ్) మరియు విస్తరణల జాబితా ఇవ్వబడుతుంది.
    ఈ విస్తరణలను క్లాస్ లో అదనపు క్లాస్ లను లోడ్ చేయడానికి ఉపయోగించాలి.
    విస్తరణ యొక్క శక్తి ఈ విధంగా ఇవ్వబడింది: CAP అనేది విస్తరణ యొక్క పేరు లోని పెద్ద అక్షరాల సంఖ్య,
    మరియు SM అనేది విస్తరణ యొక్క పేరు లోని చిన్న అక్షరాల సంఖ్య, శక్తి CAP - SM అనే భిన్నం ద్వారా ఇవ్వబడుతుంది.
    మీరు అత్యధిక శక్తి గల విస్తరణను కనుగొని ఈ ఫార్మాట్ లో ఒక స్ట్రింగ్ తిరిగి ఇవ్వాలి:
    ClassName.StrongestExtensionName.
    ఒకే శక్తి గల రెండు లేదా ఎక్కువ విస్తరణలు ఉంటే, మీరు జాబితాలో ముందుగా ఉన్నది ఎంపిక చేయాలి.
    ఉదాహరణకి, మీరు "Slices" అనే క్లాస్ మరియు విస్తరణల జాబితాను ఇస్తే: ['SErviNGSliCes', 'Cheese', 'StuFfed']
    అయితే మీరు 'Slices.SErviNGSliCes' ను తిరిగి ఇవ్వాలి ఎందుకంటే 'SErviNGSliCes' అత్యధిక శక్తి గల విస్తరణ
    (ఆదాయమానం -1) అవుతుంది.
    ఉదాహరణ:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """ఒక తరగతి పేరు (స్ట్రింగ్) మరియు విస్తరణల జాబితా అందించండి
    విస్తరణలు అదనపు తరగతులను లోడ్ చేయడానికి ఉపయోగిస్తారు
    విస్తరణల శక్తి ఈ విధంగా నిర్వచించబడింది: CAP అనేది పెద్ద అక్షరాల సంఖ్య
    ఇది విస్తరణ పేరులో కనిపిస్తుంది, SM అనేది చిన్న అక్షరాల సంఖ్య
    శక్తి CAP - SM గా వ్యక్తీకరించబడింది
    అత్యంత శక్తివంతమైన విస్తరణను కనుగొనడం అవసరం మరియు ఈ క్రింది ఫార్మాట్‌లో స్ట్రింగ్‌ను తిరిగి ఇవ్వాలి:
    ClassName.StrongestExtensionName
    రెండు లేదా అంతకంటే ఎక్కువ విస్తరణలు సమాన శక్తి కలిగి ఉంటే, జాబితాలో మొదట కనిపించేది ఎంచుకోండి
    ఉదాహరణకు, తరగతి పేరు "Slices" మరియు విస్తరణల జాబితా ఉంటే
    ['SErviNGSliCes', 'Cheese', 'StuFfed'] ఈ సందర్భంలో
    'SErviNGSliCes' అత్యంత శక్తివంతమైన విస్తరణ (శక్తి -1)
    కాబట్టి 'Slices.SErviNGSliCes' తిరిగి ఇవ్వాలి
    ఉదాహరణ:
    Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """మీకు ఒక క్లాస్ పేరు (స్ట్రింగ్) మరియు విస్తరణల జాబితా ఇవ్వబడుతుంది.
    విస్తరణలు క్లాస్‌కు అదనపు క్లాసులను లోడ్ చేయడానికి ఉపయోగించబడతాయి.
    విస్తరణ యొక్క బలం ఈ విధంగా ఉంటుంది: CAP అనేది విస్తరణ యొక్క పేరు లోని అప్‌పర్‌కేస్
    అక్షరాల సంఖ్యను సూచిస్తుంది, మరియు SM అనేది విస్తరణ యొక్క పేరు లోని లోర్‌కేస్
    అక్షరాల సంఖ్యను సూచిస్తుంది, బలం CAP - SM యొక్క ఘటకం ద్వారా ఇవ్వబడుతుంది.
    మీరు బలమైన విస్తరణను కనుగొని ఈ ఫార్మాట్‌లో ఒక స్ట్రింగ్ తిరిగి ఇవ్వాలి:
    ClassName.StrongestExtensionName.
    రెండు లేదా అంతకంటే ఎక్కువ విస్తరణలు ఒకే బలంతో ఉంటే, మీరు జాబితాలో
    ముందుగా వచ్చే విస్తరణను ఎంచుకోవాలి.
    ఉదాహరణకు, మీరు "Slices" అనే క్లాస్ మరియు విస్తరణల జాబితా ఇవ్వబడితే:
    ['SErviNGSliCes', 'Cheese', 'StuFfed'] అప్పుడు మీరు 'Slices.SErviNGSliCes' ను
    తిరిగి ఇవ్వాలి, ఎందుకంటే 'SErviNGSliCes' అనేది బలమైన విస్తరణ (దాని బలం -1).
    ఉదాహరణ:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """


def cycpattern_check(a , b):
    """మీకు 2 పదాలు ఇవ్వబడతాయి. మీరు రెండవ పదం లేదా దాని ఏ రోటేషన్ అయినా మొదటి పదంలో ఉపపదంగా ఉంటే True తిరిగి ఇవ్వాలి
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """"మీకు 2 పదాలు ఇవ్వబడ్డాయి. మొదటి పదంలో రెండవ పదం లేదా దాని భ్రమణాలలో ఏదైనా సబ్‌స్ట్రింగ్ అయితే మీరు ఒప్పు అని తిరిగి ఇవ్వాలి
    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):
    """మీకు 2 పదాలు ఇవ్వబడ్డాయి. మొదటి పదంలో రెండవ పదం లేదా దాని భ్రమణాలలో ఏదైనా సబ్‌స్ట్రింగ్ అయితే మీరు ఒప్పు అని తిరిగి ఇవ్వాలి
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """


def even_odd_count(num):
    """ఒక పూర్ణసంఖ్య ఇవ్వబడినప్పుడు, ఇది జత మరియు బీజీ అంకెల సంఖ్యలను సూచించే ఒక ట్యుపుల్ ను తిరిగి ఇస్తుంది.

    ఉదాహరణలు:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """పూర్ణాంకం ఇవ్వబడింది. వరుసగా సరి మరియు బేసి అంకెల సంఖ్యను కలిగి ఉండే టుపుల్‌ని తిరిగి ఇవ్వండి.

     ఉదాహరణ:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """ఒక పూర్తి సంఖ్య ఇచ్చినప్పుడు, సగటు సంఖ్య మరియు విచిత్ర సంఖ్యల సంఖ్యను కలిగిన టపుల్‌ని తిరిగి ఇవ్వండి.

     ఉదాహరణ:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """


def int_to_mini_roman(number):
    """
    ఒక సానుకూల పూర్ణాంకాన్ని ఇచ్చినప్పుడు, దాని రోమన్ సంఖ్యా సమానమైన విలువను స్ట్రింగ్‌గా పొందండి,
    మరియు దానిని చిన్న అక్షరాలలో తిరిగి ఇవ్వండి.
    పరిమితి: 1 <= num <= 1000

    ఉదాహరణలు:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    ఒక పాజిటివ్ సంపూర్ణ సంఖ్య ఇవ్వబడినపుడు, దానికి అనుకూలమైన రోమన్ అంకెను స్ట్రింగ్ రూపంలో పొందండి,
    మరియు దాన్ని చిన్నఅక్షరాలలో తిరిగి ఇవ్వండి.
    పరిమితులు: 1 <= num <= 1000

    ఉదాహరణలు:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    ఒక సానుకూల పూర్ణాంకం ఇవ్వబడినప్పుడు, రోమన్ సంఖ్యకు సమానమైన విలువను స్ట్రింగ్‌గా తిరిగి ఇవ్వండి
    మరియు దానిని చిన్న అక్షరాలలో తిరిగి ఇవ్వండి
    పరిమితి: 1 <= num <= 1000

    ఉదాహరణలు:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """


def right_angle_triangle(a, b, c):
    '''
    మూడు భుజాల పొడవులు ఇచ్చినప్పుడు, ఈ మూడు భుజాలు కుడిజ్యామితి గల
    త్రిభుజం అయితే True ని తిరిగి ఇస్తుంది, లేకపోతే False ని తిరిగి ఇస్తుంది.
    కుడిజ్యామితి గల త్రిభుజం అంటే ఒక కోణం 90 డిగ్రీల కోణం ఉన్న త్రిభుజం.
    ఉదాహరణ:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    ఒక త్రిభుజం యొక్క మూడు భుజాల పొడవులు ఇవ్వబడినప్పుడు. మూడు భుజాలు ఒక సమకాలిక
    త్రిభుజం ఏర్పడితే True, లేకపోతే False తిరిగి ఇవ్వండి.
    సమకాలిక త్రిభుజం అనేది ఒక త్రిభుజం, ఇందులో ఒక కోణం సమకాలిక కోణం లేదా
    90 డిగ్రీలు.
    ఉదాహరణ:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    ఒక త్రిభుజం యొక్క మూడు భుజాల పొడవులు ఇవ్వబడినప్పుడు
    ఈ మూడు భుజాలు ఒక సమకోణ త్రిభుజాన్ని ఏర్పరుస్తే, ఇది True ని తిరిగి ఇస్తుంది
    లేకపోతే, ఇది False ని తిరిగి ఇస్తుంది
    ఒక సమకోణ త్రిభుజం అనేది ఒక త్రిభుజం, దాని ఒక కోణం 90 డిగ్రీలు ఉంటుంది
    ఉదాహరణ:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''


def find_max(words):
    """ఒక ఫంక్షన్ వ్రాయండి, ఇది స్ట్రింగ్ల జాబితాను స్వీకరిస్తుంది.
    ఈ జాబితాలో వివిధ పదాలు ఉంటాయి. అధికమైన యూనిక్ అక్షరాల సంఖ్య ఉన్న పదాన్ని
    తిరిగి ఇవ్వండి. అనేక స్ట్రింగ్స్ అధికమైన యూనిక్ అక్షరాల సంఖ్యను కలిగి ఉంటే,
    వాటిలో లెక్సికోగ్రాఫికల్ ఆర్డర్‌లో ముందు వచ్చే పదాన్ని తిరిగి ఇవ్వండి.

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

def find_max(words):
    """అక్షరాల జాబితాను స్వీకరించే ఫంక్షన్‌ను రాయండి.
    జాబితాలో వేర్వేరు పదాలు ఉంటాయి. అత్యధిక సంఖ్యలో ప్రత్యేక అక్షరాలు ఉన్న
    పదాన్ని తిరిగి ఇవ్వండి. గరిష్ట సంఖ్యలో ప్రత్యేక అక్షరాలు కలిగిన బహుళ పదాలు ఉంటే,
    లెక్సికోగ్రాఫికల్ క్రమంలో మొదట వచ్చే పదాన్ని తిరిగి ఇవ్వండి.

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

def find_max(words):
    """ఒక ఫంక్షన్ సృష్టించండి, ఇది స్ట్రింగ్‌ల జాబితాను స్వీకరిస్తుంది
    జాబితా వివిధ పదాలను కలిగి ఉంటుంది. అత్యధిక ప్రత్యేక అక్షరాలతో ఉన్న పదాన్ని తిరిగి ఇవ్వండి.
    ఒకటి కంటే ఎక్కువ స్ట్రింగ్‌లు అత్యధిక ప్రత్యేక అక్షరాలను కలిగి ఉంటే, అక్షర క్రమంలో మొదట వచ్చే పదాన్ని తిరిగి ఇవ్వండి.

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


def eat(number, need, remaining):
    """
    మీరు ఆకలిగొన్న తోడేలు, మరియు మీరు ఇప్పటికే కొంత సంఖ్యలో కారెట్లను తిన్నారు,
    కానీ ఇప్పుడు మీరు రోజు పూర్తయ్యేంత వరకు మరిన్ని కారెట్లను తినాల్సి ఉంది.
    మీరు [మీ భోజనాల తర్వాత తిన్న మొత్తం కారెట్ల సంఖ్య,
          మీ భోజనాల తర్వాత మిగిలి ఉన్న కారెట్ల సంఖ్య] అనే శ్రేణిని తిరిగి ఇవ్వాలి.
    మిగిలిన కారెట్లు సరిపోకపోతే, మీరు అన్ని మిగిలిన కారెట్లను తింటారు, కానీ ఇంకా ఆకలిగా ఉంటారు.

    ఉదాహరణ:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    వేరియబుల్స్:
    @number : integer
        మీరు తిన్న కారెట్ల సంఖ్య.
    @need : integer
        మీరు తినవలసిన కారెట్ల సంఖ్య.
    @remaining : integer
        నిల్వలో ఉన్న మిగిలిన కారెట్ల సంఖ్య.

    నియమాలు:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    సరదాగా గడపండి :)
    """

def eat(number, need, remaining):
    """
    మీరు ఆకలితో ఉన్న ఒక కుందేలు మరియు ఇప్పటికే కొన్ని క్యారెట్లు తిన్నారు
    ఈ రోజు మీ భోజనం పూర్తి చేయడానికి మీకు మరిన్ని క్యారెట్లు తినడం అవసరం
    మీ భోజనం తర్వాత మొత్తం ఎన్ని క్యారెట్లు తిన్నారో మీరు తిరిగి ఇవ్వాలి
    మరియు భోజనం తర్వాత ఎన్ని క్యారెట్లు మిగిలి ఉన్నాయో ఒక జాబితా రూపంలో
    మిగిలిన క్యారెట్లు సరిపోకపోతే, మీరు మిగిలిన అన్ని క్యారెట్లు తింటారు కానీ ఇంకా ఆకలిగా ఉంటారు

    ఉదాహరణ:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    పారామీటర్లు:
    @number  : పూర్ణాంకం
        ఇప్పటికే తిన్న క్యారెట్ల సంఖ్య
    @need : పూర్ణాంకం
        మీకు తినడానికి అవసరమైన క్యారెట్ల సంఖ్య
    @remaining : పూర్ణాంకం
        నిల్వలో మిగిలిన క్యారెట్ల సంఖ్య

    పరిమితులు:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    ఆనందించండి :)
    """

def eat(number, need, remaining):
    """
    మీరు ఒక ఆకలిగిన కప్ప గానీ, ఇప్పటికే కొన్ని గాజర్‌లు తినివేసి,
    కానీ ఇప్పుడు మీరు మరింత గాజర్‌లు తినాలని అవసరం ఉంది రోజంతా భోజనాలు పూర్తి చేయడానికి.
    మీరు ఒక అర్రే తిరిగి ఇవ్వాలి [ మొత్తం తినిన గాజర్‌ల సంఖ్య,
                                    మీ భోజనాల తర్వాత మిగిలిన గాజర్‌ల సంఖ్య ]
    మిగిలిన గాజర్‌లు సరిపోదు అయితే, మీరు అన్నిటిని తినిపోతారు కానీ మీరు ఇంకా ఆకలితో ఉంటారు.

    ఉదాహరణ:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    మార్పిడి:
    @number : అంకెలు
        మీరు తినిన గాజర్‌ల సంఖ్య.
    @need : అంకెలు
        మీరు తినాల్సిన గాజర్‌ల సంఖ్య.
    @remaining : అంకెలు
        గాజర్‌లు ఉన్న మిగిలిన సంఖ్య

    పరిమితి:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    సరదాగా సరదాగా :)
    """


def do_algebra(operator, operand):
    """
    రెండు జాబితాలు operator మరియు operand ఇవ్వబడతాయి. మొదటి జాబితాలో ప్రాథమిక గణిత ఆపరేషన్లు
    ఉంటాయి, మరియు రెండవ జాబితాలో పూర్తసంఖ్యల జాబితా ఉంటుంది. ఈ రెండు జాబితాలను ఉపయోగించి
    గణిత ప్రయోగం నిర్మించండి మరియు ఈ ప్రయోగాన్ని అమలుచేసి దాని ఫలితాన్ని తిరిగి ఇవ్వండి.

    ప్రాథమిక గణిత ఆపరేషన్లు:
    అదనము ( + )
    తీసివేయడం ( - )
    గుణకారము ( * )
    ఫ్లోర్ విభజన ( // )
    ఘాతాంకం ( ** )

    ఉదాహరణ:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    గమనిక:
        operator జాబితా పొడవు operand జాబితా పొడవు మైనస్ ఒకటి కి సమానం.
        operand అనేది ధనపూర్ణాంకాల జాబితా.
        operator జాబితాలో కనీసం ఒక ఆపరేటర్ ఉంటుందీ, మరియు operand జాబితాలో కనీసం రెండు
        ఆపరాండ్లు ఉంటాయి.

    """

def do_algebra(operator, operand):
    """
    రెండు జాబితాలు ఇవ్వబడ్డాయి, ఆపరేటర్ మరియు ఆపరాండ్. మొదటి జాబితాలో ప్రాథమిక బీజగణిత ఆపరేషన్లు ఉన్నాయి
    మరియు రెండవ జాబితా పూర్ణాంకాల జాబితా. ఈ రెండు జాబితాలను ఉపయోగించి ఒక బీజగణిత వ్యక్తీకరణను సృష్టించండి
    మరియు ఈ వ్యక్తీకరణ యొక్క మూల్యాంకన విలువను తిరిగి ఇవ్వండి.

    ప్రాథమిక బీజగణిత ఆపరేషన్లు:
    జోడింపు ( + )
    తీసివేత ( - )
    గుణకారం ( * )
    భాగం మరియు కిందకు దింపడం ( // )
    శక్తి ( ** )

    ఉదాహరణ:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    గమనించండి:
        ఆపరేటర్ జాబితా పొడవు ఆపరాండ్ జాబితా పొడవు కంటే 1 తక్కువ
        ఆపరాండ్ ఒక అ-ఋణాత్మక పూర్ణాంకాల జాబితా
        ఆపరేటర్ జాబితాలో కనీసం 1 ఆపరేటర్ మరియు ఆపరాండ్ జాబితాలో కనీసం 2 ఆపరాండ్లు ఉన్నాయి

    """

def do_algebra(operator, operand):
    """
    రెండు జాబితాలు operator మరియు operand ఇచ్చినవి. మొదటి జాబితా ప్రాథమిక అల్జీబ్రా ఆపరేషన్లను కలిగి ఉంటుంది, మరియు
    రెండవ జాబితా पूर्णాంశాల జాబితా. ఈ రెండు జాబితాలను ఉపయోగించి అల్జీబ్రిక్
    అభివ్యక్తిని నిర్మించండి మరియు ఈ అభివ్యక్తిని మూల్యాంకనం చేసి తిరిగి ఇవ్వండి.

    ప్రాథమిక అల్జీబ్రా ఆపరేషన్లు:
    సమీకరణ ( + )
    విడగొట్టడం ( - )
    గుణనం ( * )
    ఫ్లోర్ భాగం ( // )
    ఘనత ( ** )

    ఉదాహరణ:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    గమనిక:
        operator జాబితా పొడవు operand జాబితా పొడవు ఒకటి తీసేసినంత ఉంటుంది.
        Operand అనేది ప్రతికూలం కాని మొత్తం సంఖ్యల జాబితా.
        Operator జాబితాలో కనీసం ఒక ఆపరేటర్ ఉంటుంది, మరియు operand జాబితాలో కనీసం రెండు ఆపరాండ్లు ఉంటాయి.
    """


def solve(s):
    """మీకు ఒక స్ట్రింగ్ s ఇవ్వబడింది.
    s[i] ఒక అక్షరమైతే, పెద్ద అక్షరాన్ని చిన్న అక్షరంగా, లేదా చిన్న అక్షరాన్ని పెద్ద అక్షరంగా మార్చండి.
    అక్షరం కాకపోతే, అలాగే ఉంచండి.
    స్ట్రింగ్‌లో ఎలాంటి అక్షరాలు లేకపోతే, స్ట్రింగ్‌ను తలక్రిందులు చేయండి.
    ఈ ఫంక్షన్ మార్పులు చేసిన స్ట్రింగ్‌ను తిరిగి ఇస్తుంది.
    ఉదాహరణలు:
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """ఒక స్ట్రింగ్ s కొరకు
    s[i] ఒక అక్షరం అయితే, పెద్ద అక్షరాన్ని చిన్న అక్షరంగా మరియు చిన్న అక్షరాన్ని పెద్ద అక్షరంగా మార్చండి
    అక్షరం కాకపోతే, అలాగే ఉంచండి
    స్ట్రింగ్‌లో ఎలాంటి అక్షరం లేకపోతే, స్ట్రింగ్‌ను తలక్రిందులు చేయండి
    ఫంక్షన్ పొందిన స్ట్రింగ్‌ను తిరిగి ఇస్తుంది
    ఉదాహరణ
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """మీకు ఒక string s ఇవ్వబడింది.
    s[i] అక్షరం అయితే, దాని caseని కింది నుండి పైకి లేదా పై నుండి కిందికి మార్చండి,
    లేకపోతే అది ఉన్నట్లుగా ఉంచండి.
    stringలో అక్షరాలు లేకపోతే, stringను తిప్పండి.
    ఫంక్షన్ ఫలితంగా వచ్చిన stringను తిరిగి ఇవ్వాలి.
    ఉదాహరణలు
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """


def string_to_md5(text):
    """
    ఒక స్ట్రింగ్ 'text' ఇవ్వబడినప్పుడు, దాని md5 హాష్ సమానమైన స్ట్రింగ్‌ను తిరిగి ఇవ్వండి.
    'text' ఖాళీ స్ట్రింగ్ అయితే, None తిరిగి ఇవ్వండి.

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

def string_to_md5(text):
    """
    'text' అనే స్ట్రింగ్ ఇవ్వబడినప్పుడు, దాని md5 హ్యాష్ సమానమైన స్ట్రింగ్ ను తిరిగి ఇవ్వండి.
    'text' ఖాళీ స్ట్రింగ్ అయితే, None తిరిగి ఇవ్వండి.

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

def string_to_md5(text):
    """
    ఇచ్చిన స్ట్రింగ్ 'text' యొక్క md5 హ్యాష్‌కు సరిపోలే స్ట్రింగ్‌ను తిరిగి ఇస్తుంది
    'text' ఖాళీ స్ట్రింగ్ అయితే, ఇది None ను తిరిగి ఇస్తుంది

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


def generate_integers(a, b):
    """
    రెండు పాజిటివ్ पूर्णాంకాలు a మరియు b ఇవ్వబడినప్పుడు, a మరియు b మధ్య ఉన్న
    సమాన అంకెలను, పెరిగే క్రమంలో తిరిగి ఇవ్వండి.

    ఉదాహరణకు:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

def generate_integers(a, b):
    """
    రెండు ధనాత్మక పూర్ణాంకాల a మరియు b ఇచ్చినట్లయితే, a మధ్య సరి అంకెలను తిరిగి ఇవ్వండి
    మరియు b, ఆరోహణ క్రమంలో.

    ఉదాహరణకు:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

def generate_integers(a, b):
    """
    రెండు సానుకూల సంఖ్యలు a మరియు b ఇవ్వబడినప్పుడు, a మరియు b మధ్య ఉన్న సమ నెంబర్లు
    వృద్ధి పరిమాణంలో తిరిగి ఇవ్వండి.

    ఉదాహరణకు:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """