def double_the_difference(lst):
    '''
    সংখ্যার একটি লিস্ট দেওয়া আছে, লিস্টের বেজোড় সংখ্যাগুলোর বর্গের
    সমষ্টি ফেরত দাও। যেগুলো পূর্ণসংখ্যা নয় বা ঋণাত্মক সেগুলো অগ্রাহ্য কর।

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

    ইনপুটের লিস্টটি শূন্য হলে 0 ফেরত দাও।
    '''

def double_the_difference(lst):
    '''
    সংখ্যার একটি লিস্ট দেওয়া আছে, লিস্টটিতে অবস্থিত বেজোড় সংখ্যাগুলোর বর্গের
    যোগফল ফেরত দাও। যেগুলো পূর্ণসংখ্যা নয় বা ঋণাত্মক সংখ্যা সেগুলোকে অগ্রাহ্য কর।

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

    ইনপুট হিসাবে দেওয়া লিস্টটি শূন্য হলে 0 ফেরত দাও।
    '''

def double_the_difference(lst):
    '''
    একটি সংখ্যার তালিকা দেওয়া আছে, তালিকার বিজোড় সংখ্যার বর্গের সমষ্টি ফেরত দিন।
    ঋণাত্মক সংখ্যা বা পূর্ণসংখ্যা নয় এমন সংখ্যা উপেক্ষা করুন।

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

    যদি প্রদত্ত তালিকা খালি হয়, তাহলে 0 ফেরত দিন।
    '''


def compare(game,guess):
    """আমি মনে করি আমরা সকলেই সেই অনুভূতিটি মনে রাখি যখন কিছু দীর্ঘ প্রতীক্ষিত ঘটনার
    ফলাফল অবশেষে জানা যায়। সেই মুহুর্তে আপনার অনুভূতি এবং চিন্তাভাবনাগুলি
    অবশ্যই লক্ষ্য করা এবং তুলনা করার মতো মূল্যবান।
    আপনার কাজ হল একজন ব্যক্তির কয়টি অনুমান ফলাফলের সাথে সঠিকভাবে ম্যাচ করেছে তা নির্ধারণ করা।
    আপনাকে সমান দৈর্ঘ্যের দুটি অ্যারে দেওয়া হবে যা স্কোর এবং পূর্বাভাস নির্দেশ করে, প্রতিটি সূচক একটি ম্যাচ নির্দেশ করে।
    প্রতিটি অনুমানের বিচ্যুতি নির্দেশ করে একই দৈর্ঘ্যের একটি অ্যারে ফেরত দিন। যদি তারা সঠিকভাবে অনুমান করে থাকে, তবে মান হবে 0 এবং
    যদি না হয়, তাহলে মানটি হবে অনুমান এবং স্কোরের মধ্যে পরম পার্থক্য।

    উদাহরণঃ

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

def compare(game,guess):
    """আমরা সবাই মনে করি, যখন কোনো দীর্ঘ প্রতীক্ষিত
    ইভেন্টের ফলাফল অবশেষে জানা যায়। তখন যে অনুভূতি এবং চিন্তাভাবনা হয়
    তা অবশ্যই নোট করা এবং তুলনা করার মতো।
    আপনার কাজ হলো একটি ব্যক্তির সঠিকভাবে কিছু ম্যাচের ফলাফল অনুমান করেছে কিনা তা নির্ধারণ করা।
    আপনাকে দুটি স্কোর এবং অনুমান করার অ্যারে দেওয়া হবে, যেগুলোর দৈর্ঘ্য সমান, যেখানে প্রতিটি সূচক একটি ম্যাচকে চিহ্নিত করে।
    একই দৈর্ঘ্যের একটি অ্যারে ফেরত দিন যা দেখায় প্রতিটি অনুমান কতটুকু ভুল ছিল।  যদি তারা সঠিক অনুমান করে থাকে,
    তবে মান হবে 0, এবং যদি না হয়, তবে মান হবে অনুমান এবং স্কোরের মধ্যে পরম পার্থক্য।

    উদাহরণ:

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

def compare(game, guess):
    """আমরা সবাই জানি, যখন কোন একটি দীর্ঘ প্রতীক্ষিত ঘটনা শেষে তার ফলাফল জানা যায়, তখন যে অনুভূতি এবং চিন্তা আসে তা সত্যিই স্মরণীয়।
    সেই মুহূর্তে আপনার অনুভূতি এবং চিন্তাগুলো অবশ্যই লেখা ও তুলনা করা উচিত।
    আপনার কাজ হলো, একজন ব্যক্তি কি সঠিকভাবে একটি ম্যাচের ফলাফল পূর্বানুমান করেছেন, তা নির্ধারণ করা।
    আপনি দুটি স্কোর এবং অনুমানের সমান দৈর্ঘ্যের অ্যারে পাবেন, যেখানে প্রতিটি ইনডেক্স একটি ম্যাচকে নির্দেশ করে।
    প্রত্যেকটি অনুমান কতটা সঠিক ছিল, তা নির্ধারণ করার জন্য একটি নতুন অ্যারে রিটার্ন করুন।
    যদি সঠিক অনুমান হয়, তবে মান হবে 0, এবং যদি না হয়, তবে মান হবে অনুমান এবং স্কোরের মধ্যকার পরিমাণগত পার্থক্য।

    উদাহরণ:

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


def Strongest_Extension(class_name, extensions):
    """আপনাকে একটি ক্লাসের নাম (একটি স্ট্রিং) এবং এক্সটেনশনগুলির একটি তালিকা দেওয়া হবে।
    এই এক্সটেনশনগুলি ক্লাসে অতিরিক্ত ক্লাস লোড করতে ব্যবহৃত হবে। এক্সটেনশনের শক্তি নিম্নরূপ:
    CAP হল এক্সটেনশনের নামের মধ্যে বড় হাতের অক্ষরের সংখ্যা, এবং SM হল ছোট হাতের অক্ষরের সংখ্যা,
    শক্তি দেওয়া হবে সুত্র CAP - SM।
    আপনাকে সবচেয়ে শক্তিশালী এক্সটেনশন খুঁজে বের করে এই ফরম্যাটে একটি স্ট্রিং রিটার্ন করতে হবে:
    ClassName.StrongestExtensionName।
    যদি দুটি বা তার বেশি এক্সটেনশন একই শক্তি রাখে, তবে আপনাকে সেই এক্সটেনশনটি নির্বাচন করতে হবে
    যা তালিকার প্রথমে আসে।

    উদাহরণ:
    যদি আপনি "Slices" ক্লাস এবং এক্সটেনশনগুলির তালিকা পান: ['SErviNGSliCes', 'Cheese', 'StuFfed'],
    তবে আপনাকে 'Slices.SErviNGSliCes' রিটার্ন করতে হবে, কারণ 'SErviNGSliCes' সবচেয়ে শক্তিশালী এক্সটেনশন
    (তার শক্তি -1)।

    উদাহরণ:
    Strongest_Extension('my_class', ['AA', 'Be', 'CC']) রিটার্ন করবে 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """আপনাকে একটি ক্লাসের নাম (একটি স্ট্রিং) এবং একটি এক্সটেনশনের তালিকা দেওয়া হবে।
    এক্সটেনশনগুলি অতিরিক্ত শ্রেণী লোড করতে ব্যবহৃত হয়। এক্সটেনশনের শক্তি নিম্নরূপ সংজ্ঞায়িত করা হয়: CAP হল বড় অক্ষরের সংখ্যা
    যা এক্সটেনশনের নামের মধ্যে উপস্থিত, SM হল ছোট অক্ষরের সংখ্যা শক্তি CAP - SM হিসাবে প্রকাশ করা হয়।
    আপনাকে সবচেয়ে শক্তিশালী এক্সটেনশনটি খুঁজে বের করতে হবে এবং নিম্নলিখিত ফরম্যাটে
    একটি স্ট্রিং ফেরত দিতে হবে: ClassName.StrongestExtensionName.
    যদি দুটি বা তার বেশি এক্সটেনশনের শক্তি সমান হয়, তবে আপনাকে প্রথমে আসা এক্সটেনশনটি
    বেছে নিতে হবে।
    উদাহরণস্বরূপ, যদি আপনাকে "Slices" নামে একটি ক্লাস এবং এক্সটেনশনের তালিকা: ['SErviNGSliCes', 'Cheese', 'StuFfed'] ফেরত দিতে হবে 'Slices.SErviNGSliCes' কারন
    'SErviNGSliCes' হল সবচেয়ে শক্তিশালী এক্সটেনশন (এর শক্তি -1)
    (its strength is -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 cycpattern_check(a, b):
    """ আপনাকে দুটি শব্দ দেওয়া হবে। আপনাকে দ্বিতীয় শব্দটি বা তার যেকোনো ঘূর্ণন যদি প্রথম শব্দের মধ্যে একটি সাবস্ট্রিং হয়, তবে True ফেরত দিতে হবে।
    cycpattern_check("abcd", "abd") => False
    cycpattern_check("hello", "ell") => True
    cycpattern_check("whassup", "psus") => False
    cycpattern_check("abab", "baa") => True
    cycpattern_check("efef", "eeff") => False
    cycpattern_check("himenss", "simen") => True
    """

def cycpattern_check(a , b):
    """তোমাকে ২টি শব্দ দেওয়া হয়েছে। দ্বিতীয় শব্দটি বা সেটির কোনো আবর্তন প্রথম শব্দটির সাবস্ট্রিং হলে তোমাকে True ফেরত দিতে হবে
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """আপনাকে ২টি শব্দ দেওয়া হয়েছে। যদি দ্বিতীয় শব্দটি বা এর কোনো ঘূর্ণন প্রথম শব্দের একটি অংশ হয় তবে True ফেরত দিতে হবে
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """


def even_odd_count(num):
    """একটি পূর্ণসংখ্যা দেওয়া আছে। এমন একটি টুপল ফেরত দাও যাতে যথাক্রমে জোড় ও বেজোড় অঙ্কের সংখ্যা দেওয়া থাকবে।

     উদাহরণ:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """একটি পূর্ণসংখ্যা দেওয়া হয়েছে এবং একটি জোড়া প্রদান কর যা ক্রমানুসারে জোড় এবং বিজোড় সংখ্যার অঙ্কের সংখ্যা নির্দেশ করে

     উদাহরণ:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """একটি পূর্ণসংখ্যা দেওয়া হয়েছে। একটি টিউপল ফেরত দিন যাতে যথাক্রমে জোড় এবং বিজোড় অংকের সংখ্যা থাকে।

     উদাহরণ:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """


def int_to_mini_roman(number):
    """
    একটি ধনাত্মক পূর্ণসংখ্যা দেওয়া হলে, এর রোমান সংখ্যার সমতুল্য একটি স্ট্রিং হিসাবে বের করুন,
    এবং এটি ছোট হাতের অক্ষরে ফেরত দিন।
    সীমাবদ্ধতা: 1 <= num <= 1000

    উদাহরণ:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    একটি ধনাত্মক পূর্ণসংখ্যা দেওয়া হলে, এর রোমান অংকের সমতুল্য স্ট্রিং হিসেবে প্রাপ্ত করুন,
    এবং এটি ছোট হাতের অক্ষরে ফিরিয়ে দিন।
    সীমাবদ্ধতা: ১ <= নম্বর <= ১০০০

    উদাহরণ:
    >>> 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 ফেরত দাও।
    সমকোণী ত্রিভুজ হল এমন ত্রিভুজ যার একটি কোণ সমকোণ বা ৯০ ডিগ্রি।
    উদাহরণ:
    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 : পূর্ণসংখ্যা
        আপনি যতো গাজর খেয়েছেন।
    @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 : 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 : integer
        ইতিমধ্যে খাওয়া গাজরের সংখ্যা
    @need : integer
        তোমার খেতে প্রয়োজনীয় গাজরের সংখ্যা
    @remaining : integer
        মজুদে অবশিষ্ট গাজরের সংখ্যা

    সীমাবদ্ধতা:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    উপভোগ করো :)
    """


def do_algebra(operator, operand):
    """
    দুটি তালিকা operator এবং operand দেওয়া হয়েছে। প্রথম তালিকাটি মৌলিক অ্যালজেব্রিক অপারেশন ধারণ করে, এবং
    দ্বিতীয় তালিকাটি একটি পূর্ণসংখ্যার তালিকা। এই দুটি তালিকা ব্যবহার করে অ্যালজেব্রিক অভিব্যক্তি তৈরি করুন এবং
    সেই অভিব্যক্তির মান ফেরত দিন।

    মৌলিক অ্যালজেব্রিক অপারেশনগুলি:
    যোগফল ( + )
    বিয়োগ ( - )
    গুণফল ( * )
    ফ্লোর ডিভিশন ( // )
    এক্সপোনেনশিয়েশন ( ** )

    উদাহরণ:
    operator = ['+', '*', '-']
    operand = [2, 3, 4, 5]
    ফলাফল হবে 2 + 3 * 4 - 5
    => ফলাফল = 9

    লক্ষ্য:
        operator তালিকার দৈর্ঘ্য operand তালিকার দৈর্ঘ্যের এক কম।
        Operand একটি অ-নেগেটিভ পূর্ণসংখ্যার তালিকা।
        Operator তালিকায় কমপক্ষে একটি অপারেটর থাকবে, এবং operand তালিকায় কমপক্ষে দুটি অপার্যান্ড থাকবে।
    """

def do_algebra(operator, operand):
    """
    দুটি তালিকা operator এবং operand দেওয়া হয়েছে। প্রথম তালিকায় মৌলিক অ্যালজেব্রিক অপারেশনগুলি রয়েছে, এবং
    দ্বিতীয় তালিকাটি একটি পূর্ণসংখ্যার তালিকা। এই দুটি দেওয়া তালিকা ব্যবহার করে অ্যালজেব্রিক এক্সপ্রেশন তৈরি করুন এবং
    এই এক্সপ্রেশনটির মূল্যায়ন ফেরত দিন।

    মৌলিক বীজগণিত অপারেশন:
    যোগফল ( + )
    বিয়োগফল ( - )
    গুণফল ( * )
    ফ্লোর ডিভিশন ( // )
    এক্সপোনেনশিয়েশন ( ** )

    উদাহরণ:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    মনে রাখবেন:
        অপারেটর তালিকার দৈর্ঘ্য অপারেন্ড তালিকার দৈর্ঘ্য থেকে 1 কম।
        অপারেন্ড একটি অ-ঋণাত্মক পূর্ণসংখ্যার তালিকা।
        অপারেটর তালিকায় অন্তত 1 অপারেটর এবং অপারেন্ড তালিকায় অন্তত 2 অপারেন্ড রয়েছে।

    """

def do_algebra(operator, operand):
    """
    দুটি তালিকা দেওয়া হয়েছে, অপারেটর এবং অপারেন্ড। প্রথম তালিকায় মৌলিক বীজগণিত অপারেশন রয়েছে
    এবং দ্বিতীয় তালিকাটি পূর্ণসংখ্যার তালিকা। প্রদত্ত এই দুটি তালিকা ব্যবহার করে একটি বীজগণিত অভিব্যক্তি তৈরি করুন
    এবং এই অভিব্যক্তির মূল্যায়নের মান ফেরত দিন।

    মৌলিক বীজগণিত অপারেশন:
    যোগ ( + )
    বিয়োগ ( - )
    গুণ ( * )
    ভাগ এবং নিচে নামানো ( // )
    শক্তি ( ** )

    উদাহরণ:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    মনে রাখবেন:
        অপারেটর তালিকার দৈর্ঘ্য অপারেন্ড তালিকার দৈর্ঘ্য থেকে 1 কম
        অপারেন্ড একটি অ-ঋণাত্মক পূর্ণসংখ্যার তালিকা
        অপারেটর তালিকায় অন্তত 1 অপারেটর এবং অপারেন্ড তালিকায় অন্তত 2 অপারেন্ড রয়েছে

    """


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):
    """একটি স্ট্রিং s এর জন্য
    যদি s[i] একটি অক্ষর হয়, বড় হাতের অক্ষরকে ছোট হাতের অক্ষরে এবং ছোট হাতের অক্ষরকে বড় হাতের অক্ষরে পরিবর্তন করো
    যদি না হয়, যেমন আছে তেমনই রাখো
    যদি স্ট্রিংয়ে কোনো অক্ষর না থাকে, স্ট্রিংটি উল্টে দাও
    ফাংশনটি প্রাপ্ত স্ট্রিংটি প্রদান করবে
    উদাহরণ
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """


def string_to_md5(text):
    """
    একটি স্ট্রিং 'text' দেওয়া হলে, তার md5 হ্যাশ সমতুল্য স্ট্রিং ফিরিয়ে দিন।
    যদি 'text' একটি খালি স্ট্রিং হয়, তবে None ফিরিয়ে দিন।

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

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) => []
    """