def sort_array(array):
    """
    একটি অ-ঋণাত্মক পূর্ণসংখ্যার অ্যারে দেওয়া হলে, এটি সাজানো অ্যারের একটি অনুলিপি প্রদান কর
    যদি প্রথম অবস্থানের মান এবং শেষ অবস্থানের মানের যোগফল একটি বিজোড় সংখ্যা হয়, তবে এটি নিম্ন থেকে উর্ধ ক্রমে সাজানো হবে
    যদি যোগফল একটি জোড় সংখ্যা হয়, তবে এটি উর্ধ থেকে নিম্ন ক্রমে সাজানো হবে

    মনে রাখবেন:
    * প্রাপ্ত অ্যারেটি পরিবর্তন করবেন না

    উদাহরণ:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    একটি অ-নেতিবাচক পূর্ণসংখ্যার অ্যারে দেওয়া হবে, এবং আপনাকে দেওয়া অ্যারেটি কপি করে ফেরত দিতে হবে,
    আপনি যদি প্রথম এবং শেষ সূচকের মানের যোগফল বিজোড় হয় তবে অ্যারেটি বৃদ্ধি মূলকভাবে সাজাবেন,
    অথবা যদি যোগফল (প্রথম সূচক মান, শেষ সূচক মান) জোড় হয় তবে তা অবতরণমূলকভাবে সাজাবেন।

    মনে রাখবেন:
    * প্রাপ্ত অ্যারেটি পরিবর্তন করবেন না

    উদাহরণ:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    একটি নন-নেগেটিভ পূর্ণসংখ্যার অ্যারে দেওয়া হলে, সেই অ্যারের একটি কপি ফেরত দিন,
    আপনি অ্যারেটি সজ্জিত করবেন বৃদ্ধি আদেশে যদি প্রথম ইনডেক্সের মান এবং শেষ ইনডেক্সের মানের যোগফল বিজোড় হয়,
    অথবা সজ্জিত করবেন অবনমিত আদেশে যদি তাদের যোগফল জোড় হয়।

    লক্ষ্য:
    * মূল অ্যারেটি পরিবর্তন করবেন না।

    উদাহরণস্বরূপ:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """


def encrypt(s):
    """encrypt নামের এমন একটি ফাংশন তৈরি কর যা আর্গুমেন্ট হিসাবে একটি
    স্ট্রিং নেবে ও বর্ণমালা আবর্তিত করে এনক্রিপ্ট করা একটি স্ট্রিং ফেরত দেবে।
    বর্ণমালার আবর্তন এমনভাবে হওয়া উচিত যেন বর্ণগুলো নিচের দিকে দুই গুণ
    দুই অবস্থান সরে যায়।
    যেমন:
    encrypt('hi') থেকে পাওয়া যাবে 'lm'
    encrypt('asdfghjkl') থেকে পাওয়া যাবে 'ewhjklnop'
    encrypt('gf') থেকে পাওয়া যাবে 'kj'
    encrypt('et') থেকে পাওয়া যাবে 'ix'
    """

def encrypt(s):
    """একটি ফাংশন এনক্রিপ্ট তৈরি করুন যা একটি আর্গুমেন্ট হিসাবে স্ট্রিং নেয়
    এবং ঘোরানো অক্ষর দ্বারা এনক্রিপ্ট করা স্ট্রিং ফেরত দেয়।
    অক্ষরগুলি এমনভাবে ঘোরানো উচিত যাতে অক্ষরগুলি দ্বিগুণ করে তার দ্বিতীয় অবস্থানে চলে যায়।
    উদাহরণঃ
    encrypt('hi') ফেরত দেবে 'lm'
    encrypt('asdfghjkl') ফেরত দেবে 'ewhjklnop'
    encrypt('gf') ফেরত দেবে 'kj'
    encrypt('et') ফেরত দেবে 'ix'
    """

def encrypt(s):
    """একটি স্ট্রিং আর্গুমেন্ট হিসাবে নিন এবং একটি এনক্রিপ্ট ফাংশন তৈরি করুন
    যা ঘোরানো অক্ষর দ্বারা এনক্রিপ্ট করা স্ট্রিং প্রদান করে
    অক্ষরগুলি ঘোরানো উচিত যাতে অক্ষরগুলি দ্বিগুণ দ্বিতীয় অবস্থানে চলে যায়
    উদাহরণ:
    encrypt('hi') প্রদান করে 'lm'
    encrypt('asdfghjkl') প্রদান করে 'ewhjklnop'
    encrypt('gf') প্রদান করে 'kj'
    encrypt('et') প্রদান করে 'ix'
    """


def next_smallest(lst):
    """
    আপনাকে পূর্ণসংখ্যার একটি তালিকা দেওয়া হয়েছে।
    একটি ফাংশন next_smallest() লিখুন যা তালিকার ২য় সর্বনিম্ন উপাদান ফেরত দেয়।
    যদি এমন কোন উপাদান না থাকে তবে None ফেরত দিন।

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

def next_smallest(lst):
    """
    একটি পূর্ণসংখ্যার তালিকা দেওয়া হলে
    next_smallest() ফাংশন তৈরি করুন যা তালিকায় দ্বিতীয় ক্ষুদ্রতম সংখ্যা প্রদান করে
    যদি এমন কোনো সংখ্যা না থাকে, তাহলে None দিন

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

def next_smallest(lst):
    """
    আপনাকে একটি পূর্ণসংখ্যার তালিকা দেওয়া হয়েছে।
    next_smallest() নামক একটি ফাংশন লিখুন যা তালিকার ২য় ছোট মানটি রিটার্ন করবে।
    যদি এমন কোন মান না থাকে তবে None রিটার্ন করুন।

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


def is_bored(S):
    """
    আপনাকে শব্দের একটি স্ট্রিং দেওয়া হবে, এবং আপনার কাজ হবে
    বিরক্তির সংখ্যা গোনার। একটি বিরক্তি হল এমন একটি বাক্য যা "I" শব্দ দিয়ে শুরু হয়।
    বাক্যগুলি '.' , '?' অথবা '!' দ্বারা সীমাবদ্ধ।

    উদাহরণ:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    আপনাকে একটি স্ট্রিং দেওয়া হয়েছে, আপনার কাজ হল বোরডমের সংখ্যা গণনা করা
    বোরডম মানে এমন বাক্য যা "I" শব্দ দিয়ে শুরু হয়
    বাক্যগুলি '.', '?' বা '!' দ্বারা পৃথক করা হয়

    উদাহরণ:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    আপনাকে একটি শব্দের স্ট্রিং দেওয়া হবে, এবং আপনার কাজ হল বোরডম (বোরডম হল এমন একটি বাক্য যা 'I' শব্দ দিয়ে শুরু হয়)
    গননা করা। বাক্যগুলি '.' , '?' বা '!' দ্বারা পৃথক করা হবে।

    উদাহরণ:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """


def any_int(x, y, z):
    '''
    একটি ফাংশন তৈরি করুন যা ৩টি সংখ্যা নেয়।
    যদি তিনটির মধ্যে কোন একটি সংখ্যা অন্য দুটি সংখ্যার যোগফলের সমান হয় এবং সব সংখ্যা পূর্ণসংখ্যা হয়,
    তবে True ফেরত দিন। অন্য কোনো ক্ষেত্রে False ফেরত দিন।

    উদাহরণ:
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

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

def any_int(x, y, z):
    '''
    একটি ফাংশন তৈরি করুন যা ৩টি সংখ্যা গ্রহণ করে।
    যদি একটিভাবে কোনো একটি সংখ্যা অন্য দুইটির যোগফল সমান হয়, এবং সব সংখ্যা পূর্ণসংখ্যা হয়, তবে সত্য ফেরত দিন।
    অন্য যেকোনো ক্ষেত্রে মিথ্যা ফেরত দিন।

    উদাহরণ
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''

def any_int(x, y, z):
    '''
    এমন একটি ফাংশন তৈরি কর যা ৩টি সংখ্যা নেবে।
    সংখ্যাগুলোর একটি অন্য দুটির যোগফলের সমান হলে ও সবকটি সংখ্যা পূর্ণসংখ্যা হলে true ফেরত দেবে।
    অন্য সব ক্ষেত্রে false ফেরত দেবে।

    উদাহরণ
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''


def encode(message):
    """
    একটি ফাংশন লিখুন যা একটি বার্তা নেয়, এবং এমনভাবে এনকোড করে যাতে
    সমস্ত অক্ষরের মাত্রা অদলবদল হয়ে যায়, বার্তার সমস্ত স্বরবর্ণকে
    ইংরেজি বর্ণমালায় সেই স্বরবর্ণের 2 স্থান এগিয়ে থাকা
    অক্ষর দিয়ে প্রতিস্থাপন করে।
    শুধুমাত্র অক্ষর বিবেচনা করুন।

    উদাহরণঃ
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    এমন একটি ফাংশন লেখ যা একটি বার্তা নিয়ে সেটিকে এমনভাবে এনকোড
    করবে যেন সব ছোট হাতের বর্ণ বড় হাতের ও সব বড় হাতের বর্ণ ছোট
    হাতের হয়ে যায় এবং সবকটি স্বরবর্ণের পরিবর্তে ইংরেজি বর্ণমালায় সেগুলোর
    ২ ঘর আগে যে বর্ণ আছে সেগুলো বসাবে।
    ধরে নাও শুধু বর্ণ থাকবে।

    উদাহরণ:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    একটি ফাংশন লিখুন যা একটি বার্তা নেয় এবং এইভাবে কোড করে,
    যে সমস্ত অক্ষরের কেস বিপরীত করে, এবং বার্তাটির সকল স্বরবর্ণকে
    ইংরেজি বর্ণমালার মধ্যে সেই স্বরবর্ণের পরবর্তী দুইটি স্থানে থাকা অক্ষরে প্রতিস্থাপন করে।
    শুধুমাত্র অক্ষরগুলির জন্য ধরা হবে।

    উদাহরণ:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """


def skjkasdkd(lst):
    """তোমাকে পূর্ণসংখ্যার একটি লিস্ট দেওয়া হয়েছে।
    তোমাকে সর্বোচ্চ মৌলিক সংখ্যাটির অঙ্কগুলোর যোগফল বের করে দিতে হবে।

    উদাহরণ:
    lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] হলে আউটপুট 10 হওয়া উচিত
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] হলে আউটপুট 25 হওয়া উচিত
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] হলে আউটপুট 13 হওয়া উচিত
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] হলে আউটপুট 11 হওয়া উচিত
    lst = [0,81,12,3,1,21] হলে আউটপুট 3 হওয়া উচিত
    lst = [0,8,1,2,1,7] হলে আউটপুট 7 হওয়া উচিত
    """

def skjkasdkd(lst):
     """আপনাকে একটি পূর্ণসংখ্যার তালিকা দেওয়া হয়েছে।
    আপনাকে সবচেয়ে বড় মৌলিক মানটি খুঁজে বের করতে হবে এবং এর ডিজিটগুলির যোগফল রিটার্ন করতে হবে।

    উদাহরণ:
    lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] এর জন্য আউটপুট হবে 10
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] এর জন্য আউটপুট হবে 25
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] এর জন্য আউটপুট হবে 10
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] এর জন্য আউটপুট হবে 11
    lst = [0,81,12,3,1,21] এর জন্য আউটপুট হবে 3
    lst = [0,8,1,2,1,7] এর জন্য আউটপুট হবে 7
    """

def skjkasdkd(lst):
    """আপনাকে পূর্ণসংখ্যার একটি তালিকা দেওয়া হয়েছে।
    আপনাকে সবচেয়ে বড় মৌলিক সংখ্যা খুঁজে বের করতে হবে এবং এর আঙ্কগুলোর যোগফল ফেরত দিতে হবে।

    উদাহরণঃ
    lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] ফলাফল হবে 10
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] ফলাফল হবে 25
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] ফলাফল হবে 13
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] ফলাফল হবে 11
    lst = [0,81,12,3,1,21] ফলাফল হবে 3
    lst = [0,8,1,2,1,7] ফলাফল হবে 7
    """


def check_dict_case(dict):
    """
    একটি ডিকশনারি দেওয়া আছে, সবকটি কি ছোট বা বড় হাতের বর্ণবিশিষ্ট
    স্ট্রিং হলে True ফেরত দাও, অন্যথায় False ফেরত দাও। প্রদত্ত
    ডিকশনারি শূন্য হলে ফাংশনটি থেকে False ফেরত পাওয়া যাবে।
    উদাহরণ:
    check_dict_case({"a":"apple", "b":"banana"}) থেকে True ফেরত পাওয়া যাওয়া উচিত।
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) থেকে False ফেরত পাওয়া যাওয়া উচিত।
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) থেকে False ফেরত পাওয়া যাওয়া উচিত।
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) থেকে False ফেরত পাওয়া যাওয়া উচিত।
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) থেকে True ফেরত পাওয়া যাওয়া উচিত।
    """

def check_dict_case(dict):
    """
    যদি একটি অভিধান সরবরাহ করা হয়, এটি True প্রদান করবে যদি সমস্ত কী ছোট হাতের অক্ষর হয় বা সমস্ত কী বড় হাতের অক্ষর হয়।
    অন্যথায়, এটি False প্রদান করবে।
    যদি সরবরাহকৃত অভিধানটি খালি হয়, তাহলে ফাংশনটি False প্রদান করবে।
    উদাহরণ:
    check_dict_case({"a":"apple", "b":"banana"}) True ফেরত দেবে
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) False ফেরত দেবে
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) False ফেরত দেবে
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) False প্রদান করবে
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) True প্রদান করবে
    """

def check_dict_case(dict):
    """
    একটি অভিধান দেওয়া আছে, True ফেরত দিন যদি সব কী ছোট হাতের স্ট্রিং হয় বা সব কী বড় হাতের স্ট্রিং হয়, অন্যথায় False ফেরত দিন।
    যদি সরবরাহকৃত অভিধানটি খালি হয়, তাহলে ফাংশনটি False ফেরত দেবে।
    উদাহরণঃ
    check_dict_case({"a":"apple", "b":"banana"}) True ফেরত দেবে
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) False ফেরত দেবে
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) False ফেরত দেবে
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) False ফেরত দেবে
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) True ফেরত দেবে
    """


def count_up_to(n):
    """একটি ফাংশন বাস্তবায়ন করুন যা একটি অ-নেতিবাচক পূর্ণসংখ্যা গ্রহণ করে এবং প্রথম nটি মৌলিক সংখ্যা প্রদান করে
    যা n এর চেয়ে কম।
    উদাহরণ:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """এমন একটি ফাংশন তৈরি করুন যা একটি অ-ঋণাত্মক পূর্ণসংখ্যা নেয় এবং প্রথম n পূর্ণসংখ্যাগুলির একটি অ্যারে প্রদান করে যেগুলো মৌলিক সংখ্যা এবং n এর চেয়ে ছোট।
    উদাহরণস্বরূপঃ
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """এমন একটি ফাংশন তৈরি কর যা একটি অঋণাত্মক পূর্ণসংখ্যা নেবে এবং n-এর চেয়ে ছোট প্রথম n সংখ্যক মৌলিক পূর্ণসংখ্যার একটি অ্যারে ফেরত দেবে।
    যেমন:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """


def multiply(a, b):
    """এই ফাংশনটি দুটি পূর্ণসংখ্যা নেবে এবং তাদের ইউনিট ডিজিটের গুণফল প্রদান করবে।
    ধরা হবে ইনপুট সবসময় বৈধ হবে।
    উদাহরণ:
    multiply(148, 412) এর ফলাফল হবে 16।
    multiply(19, 28) এর ফলাফল হবে 72।
    multiply(2020, 1851) এর ফলাফল হবে 0।
    multiply(14,-15) এর ফলাফল হবে 20।
    """

def multiply(a, b):
    """যে ফাংশন দুটি পূর্ণসংখ্যা নিয়ে সেগুলোর একক অঙ্কগুলোর
    গুণফল ফেরত দেয় সেটিকে পূর্ণ কর।
    ধরে নাও ইনপুট সবসময় সঠিক হবে।
    উদাহরণ:
    multiply(148, 412) থেকে 16 ফেরত পাওয়া উচিত।
    multiply(19, 28) থেকে 72 ফেরত পাওয়া উচিত।
    multiply(2020, 1851) থেকে 0 ফেরত পাওয়া উচিত।
    multiply(14,-15) থেকে 20 ফেরত পাওয়া উচিত।
    """

def multiply(a, b):
    """দুটি পূর্ণসংখ্যা নিন এবং একটি ফাংশন তৈরি করুন যা ঐ সংখ্যাগুলির শেষ অঙ্কগুলির গুণফল প্রদান করে
    ধরে নিন যে ইনপুট ডেটা সর্বদা সঠিক
    উদাহরণ:
    multiply(148, 412) 16 হওয়া উচিত
    multiply(19, 28) 72 হওয়া উচিত
    multiply(2020, 1851) 0 হওয়া উচিত
    multiply(14,-15) 20 হওয়া উচিত
    """


def count_upper(s):
    """
    একটি string s দেওয়া হলে, s-এ জোড় সংখ্যক ইনডেক্সে থাকা বড় হাতের স্বরবর্ণগুলির সংখ্যা গণনা করুন।

    উদাহরণস্বরূপ:
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """

def count_upper(s):
    """
    s নামের একটি স্ট্রিং দেওয়া আছে, জোড় ইনডেক্সে অবস্থিত বড় হাতের স্বরবর্ণের সংখ্যা বের কর।

    যেমন:
    count_upper('aBCdEf') থেকে পাওয়া যাবে 1
    count_upper('abcdefg') থেকে পাওয়া যাবে 0
    count_upper('dBBE') থেকে পাওয়া যাবে 0
    """

def count_upper(s):
    """
    একটি স্ট্রিং s দেওয়া আছে, জোড় সূচকে বড় হাতের স্বরবর্ণের সংখ্যা গণনা করুন।

    উদাহরণঃ
    count_upper('aBCdEf') 1 ফেরত দেবে
    count_upper('abcdefg') 0 ফেরত দেবে
    count_upper('dBBE') 0 ফেরত দেবে
    """


def closest_integer(value):
    '''
    একটি ফাংশন তৈরি করুন যা একটি মান (স্ট্রিং) নেয় যা একটি সংখ্যা প্রতিনিধিত্ব করে
    এবং সেটির কাছাকাছি পূর্ণসংখ্যা ফেরত দেয়। যদি সংখ্যা দুটি পূর্ণসংখ্যার মাঝে সমানভাবে
    দূরে থাকে, তবে এটি শূন্য থেকে দূরে রাউন্ড করবে।

    উদাহরণ:
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    লক্ষ্য:
    শূন্য থেকে দূরে রাউন্ড করার মানে হলো, যদি দেওয়া সংখ্যা দুটি পূর্ণসংখ্যার থেকে সমানভাবে
    দূরে থাকে, তবে আপনাকে সেটির যে পূর্ণসংখ্যা নির্বাচন করতে হবে তা হবে শূন্য থেকে সবচেয়ে
    দূরে থাকা পূর্ণসংখ্যা। উদাহরণস্বরূপ closest_integer("14.5") রিটার্ন করবে 15 এবং
    closest_integer("-14.5") রিটার্ন করবে -15।
    '''

def closest_integer(value):
    '''
    একটি ফাংশন তৈরি করুন যা একটি সংখ্যার প্রতিনিধিত্বকারী একটি মান (স্ট্রিং) নেয়
    এবং এটির নিকটতম পূর্ণসংখ্যা প্রদান করে।
    সংখ্যাটি যদি সমান হয় দুটি পূর্ণসংখ্যা থেকে, এটিকে শূন্য থেকে দূরে বৃত্তাকার করুন।

    উদাহরণ
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    নোট:
    শূন্য থেকে দূরে বৃত্তাকার করা মানে প্রদত্ত সংখ্যা দুটি পূর্ণসংখ্যার সমান দূরত্বে থাকে,
    এটি শূন্য থেকে দূরে থাকা মানটি প্রদান করবে। উদাহরণস্বরূপ, closest_integer("14.5") 15 প্রদান করবে
    এবং closest_integer("-14.5") -15 প্রদান করবে
    '''

def closest_integer(value):
    '''
    এমন একটি ফাংশন তৈরি কর যা একটি সংখ্যা-নির্দেশক মান (স্ট্রিং) নিয়ে
    সেটির নিকটতম পূর্ণসংখ্যা ফেরত দেবে। সংখ্যাটি দুটি পূর্ণসংখ্যা থেকে
    সমদূরবর্তী হলে সেটিকে শূন্যের বিপরীত দিকে বাড়িয়ে পূর্ণসংখ্যা বানাও।

    উদাহরণ
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    নোট:
    শূন্যের বিপরীত দিকে বাড়িয়ে পূর্ণসংখ্যা বানানো মানে হল, প্রদত্ত সংখ্যা যদি দুটি
    পূর্ণসংখ্যা থেকে সমদূরবর্তী হয় তাহলে যে সংখ্যাটি শূন্য থেকে বেশি দূরে অবস্থিত
    তোমাকে সেটি ফেরত দিতে হবে। যেমন, closest_integer("14.5") থেকে 15 ফেরত
    পাওয়া উচিত এবং closest_integer("-14.5") থেকে -15 ফেরত পাওয়া উচিত।
    '''


def make_a_pile(n):
    """
    একটি ধনাত্মক পূর্ণসংখ্যা n দেওয়া হলে, আপনাকে n স্তরের পাথরের একটি স্তূপ তৈরি করতে হবে।
    প্রথম স্তরে n পাথর রয়েছে।
    পরবর্তী স্তরে পাথরের সংখ্যা হবে:
        - যদি n বিজোড় হয় তবে পরবর্তী বিজোড় সংখ্যা।
        - যদি n জোড় হয় তবে পরবর্তী জোড় সংখ্যা।
    একটি তালিকায় প্রতিটি স্তরে পাথরের সংখ্যা ফেরত দিন, যেখানে প্রতিটি উপাদান
    i সূচক সহ স্তরের পাথরের সংখ্যা উপস্থাপন করে (i+1)।

    উদাহরণ:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    এটি একটি ধনাত্মক পূর্ণসংখ্যা n গ্রহণ করে, এবং n স্তরের একটি পাথরের স্তূপ তৈরি করবে
    প্রথম স্তরে n পাথর থাকবে
    পরবর্তী স্তরে পাথরের সংখ্যা নিম্নরূপ হবে:
        - যদি n একটি বিজোড় সংখ্যা হয়, তবে এটি পরবর্তী বিজোড় সংখ্যা হবে
        - যদি n একটি জোড় সংখ্যা হয়, তবে এটি পরবর্তী জোড় সংখ্যা হবে
    প্রতিটি স্তরে পাথরের সংখ্যা একটি তালিকার আকারে দিন, যেখানে সূচক i এর উপাদানটি
    (i+1) স্তরে পাথরের সংখ্যা নির্দেশ করে

    উদাহরণ:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    একটি ধনাত্মক পূর্ণসংখ্যা n দেওয়া হলে, আপনাকে n স্তরের পাথরের একটি ঢিপি তৈরি করতে হবে।
    প্রথম স্তরে n টা পাথর থাকবে।
    পরবর্তী স্তরের পাথরের সংখ্যা হবে:
        - যদি n বিজোড় হয়, তবে পরবর্তী বিজোড় সংখ্যা হবে।
        - যদি n জোড় হয়, তবে পরবর্তী জোড় সংখ্যা হবে।
    প্রতিটি স্তরে পাথরের সংখ্যা একটি তালিকায় ফেরত দিন, যেখানে তালিকার i তম উপাদানটি (i+1) তম স্তরে পাথরের সংখ্যা প্রতিনিধিত্ব করবে।

    উদাহরণ:
    >>> make_a_pile(3)
    [3, 5, 7]
    """


def words_string(s):
    """
    আপনাকে একটি শব্দের স্ট্রিং দেওয়া হবে যা কমা বা স্পেস দ্বারা পৃথকিত। আপনার কাজ হল
    স্ট্রিংটিকে শব্দগুলিতে বিভক্ত করা এবং শব্দগুলির একটি অ্যারে ফেরত দেওয়া।

    উদাহরণস্বরূপ:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    তোমাকে স্পেস বা কমা দিয়ে আলাদা করা কিছু শব্দের একটি স্ট্রিং দেওয়া হবে।
    তোমার কাজ হল স্ট্রিংটিকে ভাগ করে শব্দের একটি অ্যারে ফেরত দেওয়া।

    যেমন:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    আপনাকে কমা বা ফাঁকা স্থান দ্বারা পৃথক করা শব্দ সহ একটি স্ট্রিং দেওয়া হয়েছে,
    আপনার কাজ হল সেই স্ট্রিংটির শব্দগুলিতে বিভক্ত করা এবং শব্দগুলির একটি তালিকা  প্রদান করা

    উদাহরণস্বরূপ:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """


def choose_num(x, y):
    """এই ফাংশনটি দুটি ধনাত্মক পূর্ণসংখ্যা x এবং y গ্রহণ করে এবং [x, y] পরিসরের মধ্যে
    সর্বোচ্চ জোড় পূর্ণসংখ্যা প্রদান করে। যদি এমন কোনো সংখ্যা না থাকে, তাহলে ফাংশনটি -1 প্রদান।

    উদাহরণ:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """এই ফাংশনটি দুটি ধনাত্মক সংখ্যা x এবং y নেয় এবং [x, y] পরিসরের মধ্যে
    (অন্তর্ভুক্ত) সবচেয়ে বড় সোজা পূর্ণসংখ্যা ফেরত দেয়। যদি এমন কোনো সংখ্যা না থাকে,
    তবে ফাংশনটি -1 ফেরত দেবে।

    উদাহরণ:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """এই ফাংশনটি দুটি পজিটিভ সংখ্যা x এবং y গ্রহণ করে এবং [x, y]-এর মধ্যে অন্তর্ভুক্ত সবচেয়ে বড় জোড় সংখ্যাটি ফেরত
    করে। যদি এমন কোনো সংখ্যা না থাকে, তবে ফাংশনটি -1 রিটার্ন করবে।

    উদাহরণস্বরূপ:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """


def rounded_avg(n, m):
    """আপনাকে দুটি ধনাত্মক পূর্ণসংখ্যা n এবং m দেওয়া হয়েছে, এবং আপনার কাজ হলো
    n থেকে m পর্যন্ত (n এবং m সহ) পূর্ণসংখ্যাগুলির গড় হিসাব করা।
    উত্তরটিকে নিকটতম পূর্ণসংখ্যায় রাউন্ড করুন এবং সেটিকে বাইনারি ফরম্যাটে রূপান্তর করুন।
    যদি n, m এর চেয়ে বড় হয়, তাহলে -1 ফেরত দিন।
    উদাহরণ:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """আপনাকে দুটি ধনাত্মক পূর্ণসংখ্যা n এবং m দেওয়া হয়েছে, এবং আপনার কাজ হল n থেকে m পর্যন্ত পূর্ণসংখ্যার গড় গণনা করা (n এবং m সহ)।
    উত্তরটি নিকটতম পূর্ণসংখ্যার পরিবর্তন করুন এবং এটিকে বাইনারিতে রূপান্তর করুন।
    যদি n m এর চেয়ে বড় হয়, তাহলে -1 রিটার্ন করুন।
    উদাহরণঃ
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """আপনাকে দুটি ধনাত্মক পূর্ণসংখ্যা n এবং m দেওয়া হয়েছে, এবং আপনার কাজ হল
    n থেকে m পর্যন্ত (n এবং m সহ) পূর্ণসংখ্যাগুলির গড় হিসাব করা।
    উত্তরটি সবচেয়ে কাছের পূর্ণসংখ্যায় রাউন্ড করুন এবং এটি বাইনারি ফরম্যাটে রূপান্তর করুন।
    যদি n, m এর থেকে বড় হয়, তবে -1 রিটার্ন করুন।
    উদাহরণ:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """


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

    দ্রষ্টব্য: ফেরত দেওয়া লিস্টটি মানের ঊর্ধ্বক্রমে সাজানো থাকতে হবে।

    যেমন:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """যদি একটি ধনাত্মক পূর্ণসংখ্যার তালিকা x দেওয়া হয়, তবে সেই তালিকার সব
    উপাদানগুলির মধ্যে যেগুলির কোনো জোড় সংখ্যা নেই, সেগুলি সর্টেড (বৃদ্ধির দিকে)
    আকারে ফেরত দিন।

    নোট: ফেরত দেওয়া তালিকাটি অবশ্যই ছোট থেকে বড় ক্রমে সাজানো থাকতে হবে।

    উদাহরণ:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """একটি পজিটিভ পূর্ণসংখ্যার একটি তালিকা দেওয়া হয়েছে। সমস্ত উপাদানগুলির একটি সাজানো তালিকা ফেরত দিন
    যেগুলিতে কোনই বাইরের (even) সংখ্যা নেই।

    মনে রাখবে: ফেরত দেওয়া তালিকাটি ছোট থেকে বড় ক্রমে সাজানো হতে হবে

    উদাহরণ:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """


def by_length(arr):
    """
    একটি পূর্ণসংখ্যার অ্যারে দেওয়া হলে, ১ থেকে ৯ এর মধ্যে থাকা পূর্ণসংখ্যাগুলি সাজান,
    ফলস্বরূপ অ্যারেটি উল্টে দিন এবং তারপর প্রতিটি সংখ্যাকে তার সংশ্লিষ্ট নাম দিয়ে প্রতিস্থাপন করুন
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"।

    উদাহরণস্বরূপ:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> অ্যারে সাজান -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> অ্যারে উল্টে দিন -> [8, 5, 4, 3, 2, 2, 1, 1]
      ফলস্বরূপ ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"] হবে।

      যদি অ্যারে খালি থাকে, তবে খালি অ্যারে ফেরত দিন:
      arr = []
      return []

      যদি অ্যারে কোনও অস্বাভাবিক সংখ্যা ধারণ করে, তবে সেগুলি উপেক্ষা করুন:
      arr = [1, -1 , 55]
            -> অ্যারে সাজান -> [-1, 1, 55]
            -> অ্যারে উল্টে দিন -> [55, 1, -1]
      ফলস্বরূপ ['One'] হবে।
    """

def by_length(arr):
    """
    একটি পূর্ণসংখ্যার অ্যারে দেওয়া হয়েছে, 1 থেকে 9 এর মধ্যে থাকা পূর্ণসংখ্যাগুলি সাজান
    তারপর সেই অ্যারের ক্রম উল্টান এবং প্রতিটি সংখ্যা সংশ্লিষ্ট নামের সাথে প্রতিস্থাপন করুন
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"

    উদাহরণ:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> arr সাজান -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> arr এর ক্রম উল্টান -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      এমন ক্ষেত্রে যেখানে অ্যারে খালি, খালি অ্যারে প্রদান করুন।
      arr = []
      return []

      এমন ক্ষেত্রে যেখানে অ্যারেতে অস্বাভাবিক সংখ্যা রয়েছে, সেগুলি উপেক্ষা করুন:
      arr = [1, -1 , 55]
            -> arr সাজান -> [-1, 1, 55]
            -> arr এর ক্রম উল্টান -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    একটি পূর্ণসংখ্যার অ্যারে দেওয়া হয়েছে, 1 এবং 9 এর মধ্যে যা আছে তা সাজিয়ে দিন,
    ফলস্বরূপ অ্যারে উল্টে দিন, এবং তারপর প্রতিটি অঙ্ককে তার সংশ্লিষ্ট নাম দ্বারা প্রতিস্থাপন করুন
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    উদাহরণ:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      এমন ক্ষেত্রে যেখানে অ্যারে খালি, খালি অ্যারে ফেরত দিন:
      arr = []
      return []

      যদি অ্যারেতে কোনো অদ্ভুত সংখ্যা থাকে তবে তা উপেক্ষা করুন:
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """


def f(n):
    """ ফাংশন f বাস্তবায়ন করুন যা n কে একটি প্যারামিটার হিসেবে নেয়,
    এবং এমন একটি আর্গুমেন্টের তালিকা ফেরত দেয় যার আকার n, যেখানে তালিকার i-তম উপাদানের মান হল:
    যদি i জোড় সংখ্যা হয় তবে i-এর ফ্যাক্টরিয়াল (i-এর সমস্ত সংখ্যা গুণফল)
    অথবা যদি i বিজোড় সংখ্যা হয় তবে 1 থেকে i পর্যন্ত সংখ্যাগুলির যোগফল।
    i শুরু হয় 1 থেকে।
    i-এর ফ্যাক্টরিয়াল হল 1 * 2 * 3 * ... * i।
    উদাহরণ:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ ফাংশন f প্রয়োগ করুন যা প্যারামিটার হিসাবে n নেয়,
    এবং n আকারের একটি তালিকা প্রদান করে, যাতে i সূচীতে উপাদানটির মান i এর ফ্যাক্টরিয়াল যদি i জোড় সংখ্যা হয়
    অন্যথায় 1 থেকে i পর্যন্ত সংখ্যার যোগফল।
    i শুরু হয় 1 থেকে।
    i এর ফ্যাক্টোরিয়াল হল 1 থেকে i পর্যন্ত সংখ্যার গুণফল (1 * 2 * ... * i)
    উদাহরণঃ
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ f ফাংশনটি বাস্তবায়ন করুন যা n কে প্যারামিটার হিসেবে গ্রহণ করে,
    এবং n আকারের একটি তালিকা রিটার্ন করে, যেখানে সূচক i তে উপাদানের মান হবে i এর ফ্যাক্টোরিয়াল যদি i সোজা সংখ্যা হয়
    অথবা অন্যথায় i থেকে 1 পর্যন্ত সংখ্যাগুলির যোগফল।
    i শুরু হয় 1 থেকে।
    i এর ফ্যাক্টোরিয়াল হল 1 থেকে i পর্যন্ত সংখ্যাগুলির গুণফল (1 * 2 * ... * i)।
    উদাহরণ:
    f(5) == [1, 2, 6, 24, 15]
    """


def even_odd_palindrome(n):
    """
    প্রদত্ত ধনাত্মক পূর্ণসংখ্যা n, একটি টাপল ফেরত দিন যা (1, n) পরিসরের মধ্যে জোড় এবং বিজোড় পূর্ণসংখ্যার প্যালিনড্রোমের সংখ্যা নির্দেশ করে।

    উদাহরণ 1ঃ

        Input: 3
        Output: (1, 2)
        ব্যাখ্যাঃ
        পূর্ণসংখ্যার প্যালিনড্রোম হল 1, 2, 3 যেখানে 1টি জোড় সংখ্যা এবং 2টি বিজোড় সংখ্যা।

    উদাহরণ 2ঃ

        Input: 12
        Output: (4, 6)
        ব্যাখ্যাঃ
        পূর্ণসংখ্যার প্যালিনড্রোম হল 1, 2, 3, 4, 5, 6, 7, 8, 9, 11 যেখানে 4টি জোড় সংখ্যা এবং 6টি বিজোড় সংখ্যা।

    নোটঃ
        1. 1 <= n <= 10^3
        2. ফেরত দেওয়া টাপলটিতে জোড় এবং বিজোড় পূর্ণসংখ্যার প্যালিনড্রোমের সংখ্যা ক্রমানুসারে থাকবে।
    """

def even_odd_palindrome(n):
    """
    প্রদত্ত ধনাত্মক পূর্ণসংখ্যা n, একটি জোড়া প্রদান করুন যা (1, n) পরিসরের মধ্যে জোড় এবং বিজোড় পূর্ণসংখ্যার প্যালিনড্রোমের সংখ্যা নির্দেশ করে

    উদাহরণ 1:

        ইনপুট: 3
        আউটপুট: (1, 2)
        ব্যাখ্যা:
        পূর্ণসংখ্যার প্যালিনড্রোম হল 1, 2, 3 যেখানে 1 হল জোড় সংখ্যা এবং 2 হল বিজোড় সংখ্যা

    উদাহরণ 2:

        ইনপুট: 12
        আউটপুট: (4, 6)
        ব্যাখ্যা:
        পূর্ণসংখ্যার প্যালিনড্রোম হল 1, 2, 3, 4, 5, 6, 7, 8, 9, 11 যেখানে 4 হল জোড় সংখ্যা এবং 6 হল বিজোড় সংখ্যা

    নোট:
        1. 1 <= n <= 10^3
        2. পাপ্ত যুগলটি জোড় এবং বিজোড় পূর্ণসংখ্যার প্যালিনড্রোমের সংখ্যা ক্রমানুসারে থাকবে
    """

def even_odd_palindrome(n):
    """
    একটি ধনাত্মক পূর্ণসংখ্যা n দেওয়া আছে, এমন একটি টাপল ফেরত দিন যাতে জোড় এবং বিজোড় পূর্ণসংখ্যার প্যালিন্ড্রোমের সংখ্যা রয়েছে যা (1, n), অন্তর্ভুক্ত সীমার মধ্যে পড়ে।

    উদাহরণ 1ঃ

        Input: 3
        Output: (1, 2)
        ব্যাখ্যাঃ
        পূর্ণসংখ্যার প্যালিনড্রোম হল 1, 2, 3। তাদের মধ্যে একটি জোড় এবং দুটি বিজোড়।

    উদাহরণ 2ঃ

        Input: 12
        Output: (4, 6)
        ব্যাখ্যাঃ
        পূর্ণসংখ্যার প্যালিনড্রোম হল 1, 2, 3, 4, 5, 6, 7, 8, 9, 11 তাদের মধ্যে চারটি জোড়, এবং 6টি বিজোড়।

    নোট:
        1. 1 <= n <= 10^3
        2. ফেরত দেওয়া টাপলটিতে জোড় এবং বিজোড় পূর্ণসংখ্যার প্যালিনড্রোমের সংখ্যা ক্রমানুসারে থাকবে।
    """


def count_nums(arr):
    """
    একটি ফাংশন 'count_nums' লিখুন যা পূর্ণসংখ্যার একটি অ্যারে নেয় এবং সেই উপাদানগুলির সংখ্যা ফেরত দেয় যাদের অঙ্কের যোগফল 0 এর বেশি।
    যদি একটি সংখ্যা ঋণাত্মক হয়, তবে এর প্রথম চিহ্নিত অঙ্কটি ঋণাত্মক হবেঃ
    উদাহরণস্বরূপঃ -123 এর চিহ্নিত অঙ্কগুলি হল -1, 2, 3
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    একটি ফাংশন count_nums লিখুন যা একটি পূর্ণসংখ্যার অ্যারে নেয় এবং
    কতটি উপাদানের অঙ্কগুলোর যোগফল > 0 তা ফেরত দেয়।
    যদি একটি সংখ্যা ঋণাত্মক হয়, তবে তার প্রথম সাইনযুক্ত অঙ্কটি ঋণাত্মক হবে:
    যেমন: -123 এর সাইনযুক্ত অঙ্কগুলো হলো -1, 2, এবং 3।
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    একটি ফাংশন count_nums লিখুন যা একটি পূর্ণসংখ্যার অ্যারে নেয় এবং
    সেই সংখ্যাগুলির সংখ্যা প্রদান করে যেগুলির অঙ্কের যোগফল > 0।
    যদি কোন সংখ্যা নেতিবাচক হয়, তবে তার প্রথম চিহ্নিত অঙ্কটি নেতিবাচক হবে:
    উদাহরণস্বরূপ, -123 এর চিহ্নিত অঙ্কগুলি হবে -1, 2, এবং 3।
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """


def move_one_ball(arr):
    """আমাদের কাছে একটি অ্যারে 'arr' রয়েছে যেখানে N সংখ্যক পূর্ণসংখ্যা arr[1], arr[2], ..., arr[N]। অ্যারের সংখ্যাগুলি এলোমেলোভাবে সাজানো থাকবে। আপনার কাজ হল এটি
    নির্ধারণ করা যে,
    এটি কি সম্ভব যে নিম্নলিখিত অপারেশনটি অ্যারে দেওয়া হলে এটি অ-হ্রাসমানভাবে সাজানো হবে:
        আপনি যেকোনো সংখ্যক বার ডানদিকে স্থানান্তর অপারেশন করতে পারবেন।

    একটি ডানদিকে স্থানান্তর অপারেশন মানে হল অ্যারের সমস্ত উপাদানকে এক পজিশন ডান দিকে স্থানান্তর করা।
    অ্যারের শেষ উপাদানটি শুরুতে, অর্থাৎ 0 তম সূচকে স্থানান্তরিত হবে।

    যদি উপরের অপারেশনটি দ্বারা অ-হ্রাসমান সাজানো অ্যারে পাওয়া সম্ভব হয়, তবে True ফেরত দিন, অন্যথায় False।
    যদি দেওয়া অ্যারে খালি হয় তবে True ফেরত দিন।
    যদি দেওয়া অ্যারে খালি হয় তবে True ফেরত দিন।

    লক্ষ্য করুন: দেওয়া তালিকাটি নিশ্চিত করা হয়েছে যে এতে একক উপাদান রয়েছে।

    উদাহরণ:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Explanation: ২টি ডানদিকে স্থানান্তর অপারেশন করলে দেওয়া অ্যারে অ-হ্রাসমানভাবে সাজানো হতে পারে।
    move_one_ball([3, 5, 4, 1, 2])==>False
    ব্যাখ্যা: কোনও সংখ্যক ডানদিকে স্থানান্তর অপারেশন দ্বারা দেওয়া অ্যারে অ-হ্রাসমান সাজানো হতে পারে না।

    """

"""আমাদের কাছে 'arr' নামক N পূর্ণসংখ্যার একটি অ্যারে arr[1], arr[2], ..., arr[N] রয়েছে।
    অ্যারেতে সংখ্যা গুলি এলোমেলোভাবে সাজানো থাকবে। আপনার কাজ হল এটি নির্ধারণ করা,
    যে আপনি কি নির্দিষ্ট অ্যারে উপর নিম্নলিখিত অপারেশনটি সম্পাদন করে অ্যারেটিকে অনুরোধ অনুসারে
    অবিকল ক্রমে সাজাতে পারবেন:
        আপনাকে যেকোনো সংখ্যক বার ডানদিকে স্থানান্তর অপারেশন সম্পাদন করতে অনুমতি দেওয়া হবে।

    একটি ডানদিকে স্থানান্তর অপারেশন মানে হল সমস্ত উপাদানকে এক পজিশন ডান দিকে সরিয়ে নেয়া।
    অ্যারেটির শেষ উপাদানটি অ্যারের শুরুর অবস্থানে, অর্থাৎ 0 তম সূচক স্থানান্তরিত হবে।

    যদি উপরের অপারেশনটি সম্পাদন করে সাজানো অ্যারে পাওয়া সম্ভব হয় তবে True ফেরত দিন,
    অন্যথায় False ফেরত দিন। যদি প্রদত্ত অ্যারে খালি থাকে তবে True ফেরত দিন।

    লক্ষ্য করুন: প্রদত্ত তালিকাটি সুনিশ্চিতভাবে একক উপাদান রয়েছে।

    উদাহরণস্বরূপ:

    move_one_ball([3, 4, 5, 1, 2])==>True
    ব্যাখ্যা: 2টি ডানদিকে স্থানান্তর অপারেশন সম্পাদন করে প্রদত্ত অ্যারের জন্য
                 অনুক্রমিক সাজানো পাওয়া যাবে।
    move_one_ball([3, 5, 4, 1, 2])==>False
    ব্যাখ্যা: কোনো সংখ্যক ডানদিকে স্থানান্তর অপারেশন সম্পাদন করে প্রদত্ত
                অ্যারের জন্য অনুক্রমিক সাজানো পাওয়া সম্ভব নয়।

    """

def move_one_ball(arr):
    """অ্যারে 'arr' একটি সংখ্যা N এর সংখ্যা arr[1], arr[2], ..., arr[N]
    অ্যারের সংখ্যা এলোমেলোভাবে সাজানো হয়েছে। আপনার কাজ হল নির্ধারণ করা
    সম্ভব কিনা অ্যারেটিকে অ-হ্রাসমান ক্রমে সাজানো একটি নিম্নলিখিত অপারেশন করে:
        যতবার প্রয়োজন ডানদিকে ঘূর্ণন করা অনুমোদিত

    একবার ডানদিকে ঘূর্ণন মানে অ্যারের প্রতিটি উপাদানকে এক স্থান ডানদিকে সরানো
    অ্যারের শেষ উপাদানটি অ্যারের শুরুতে স্থানান্তরিত হবে, অর্থাৎ, সূচক 0

    যদি উপরের অপারেশনটি করে অ্যারেটিকে ক্রমে সাজানো সম্ভব হয়, তাহলে True ফেরত দিন
    যদি সম্ভব না হয়, তাহলে False ফেরত দিন
    যদি প্রদত্ত অ্যারে খালি হয়, তাহলে True ফেরত দিন

    মনে রাখবেন: নিশ্চিত করা হয়েছে যে প্রদত্ত অ্যারেতে পুনরাবৃত্তি ছাড়া উপাদান রয়েছে

    উদাহরণ:

    move_one_ball([3, 4, 5, 1, 2])==>True
    ব্যাখ্যা: প্রদত্ত অ্যারেটিকে অ-হ্রাসমান ক্রমে সাজানোর জন্য 2 বার ডানদিকে ঘূর্ণন করা সম্ভব
    move_one_ball([3, 5, 4, 1, 2])==>False
    ব্যাখ্যা: কোন সংখ্যক ডান দিকে শিফট অপারেশন দিয়েও অ্যারেটি অ-অবতল ক্রমে সাজানো যাবে না।

    """


def exchange(lst1, lst2):
    """এই সমস্যাটিতে আপনাকে একটি ফাংশন বাস্তবায়ন করতে হবে যা দুটি সংখ্যার তালিকা নেবে,
    এবং তা নির্ধারণ করবে যে তালিকা ১-এর সমস্ত উপাদানকে শুধু জোড় সংখ্যা করার জন্য
    তাদের মধ্যে উপাদান বিনিময় করা সম্ভব কিনা।
    lst1 এবং lst2-এর মধ্যে বিনিময়ের কোনো সীমা নেই।
    যদি lst1-এর সমস্ত উপাদানকে জোড় সংখ্যা করা সম্ভব হয়, তবে "YES" ফিরিয়ে দিন।
    অন্যথায়, "NO" ফিরিয়ে দিন।
    উদাহরণস্বরূপ:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    এটি ধারণা করা হয়েছে যে ইনপুট তালিকাগুলি খালি হবে না।
    """

def exchange(lst1, lst2):
    """এই সমস্যায়, আপনি একটি ফাংশন বাস্তবায়ন করবেন যা
    সংখ্যার দুটি তালিকা নেয় এবং lst1 শুধুমাত্র জোড় সংখ্যার তালিকা তৈরি করতে
    তাদের মধ্যে উপাদানগুলির বিনিময় করা সম্ভব কিনা তা নির্ধারণ করে।
    lst1 এবং lst2 এর মধ্যে বিনিময় করা যেতে পারে এমন উপাদানগুলির সংখ্যায় কোনও সীমা নেই।
    যদি lst1 এবং lst2 এর মধ্যে উপাদানগুলি বিনিময় করা সম্ভব হয় যাতে lst1 এ শুধুমাত্র জোড় সংখ্যা থাকে, তাহলে "YES" ফেরত দিন।
    যদি সম্ভব না হয়, তাহলে "NO" ফেরত দিন।
    উদাহরণস্বরূপঃ
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    আমরা ধরে নিচ্ছি যে প্রাপ্ত তালিকাগুলি খালি নয়।
    """

def exchange(lst1, lst2):
    """এই সমস্যায়, আমরা দুটি সংখ্যার তালিকা পাব
    এবং আমাদের পরীক্ষা করতে হবে যে উপাদানগুলি পরিবর্তন করা সম্ভব কিনা
    যাতে lst1 শুধুমাত্র জোড় সংখ্যার তালিকা হয়।
    lst1 এবং lst2 এর মধ্যে পরিবর্তন করা যেতে পারে এমন উপাদানগুলির সংখ্যায় কোনও সীমা নেই।
    যদি lst1 এবং lst2 এর মধ্যে উপাদানগুলি পরিবর্তন করা সম্ভব হয় যাতে lst1 শুধুমাত্র জোড় সংখ্যা থাকে, তাহলে "YES" দিন।
    যদি সম্ভব না হয়, তাহলে "NO" দিন।
    উদাহরণ:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    আমরা ধরে নিচ্ছি যে প্রাপ্ত তালিকাগুলি খালি নয়।
    """


def histogram(test):
    """স্পেস দিয়ে আলাদা করে লেখা ছোট হাতের বর্ণবিশিষ্ট একটি স্ট্রিং দেওয়া থাকলে, এমন একটি ডিকশনারি
    ফেরত দাও যাতে সবচেয়ে সবচেয়ে বেশিবার উপস্থিত থাকা বর্ণ ও সেটির উপস্থিতির সংখ্যা থাকবে।
    একাধিক বর্ণ একই সংখ্যকবার থাকলে সেগুলোর সবকটিই ফেরত দাও।

    উদাহরণ:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """একটি স্ট্রিং দেওয়া হবে যা স্পেস দ্বারা পৃথকিত ছোট হাতের অক্ষরগুলির প্রতিনিধিত্ব করে,
    আপনি এমন একটি ডিকশনারি ফেরত দেবেন যাতে সবচেয়ে বেশি পুনরাবৃত্তি হওয়া অক্ষরের সাথে তার
    সম্পর্কিত গণনা থাকবে। যদি একাধিক অক্ষরের সমান উপস্থিতি থাকে, তবে সবগুলো ফেরত দিন।

    উদাহরণ:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}
    """

def histogram(test):
    """একটি ছোট হাতের অক্ষরের ক্রম যা ফাঁকা স্থান দ্বারা পৃথক করা হয়েছে তা পরীক্ষা করুন এবং সর্বাধিক পুনরাবৃত্ত অক্ষর এবং সংশ্লিষ্ট সংখ্যা সহ একটি অভিধান প্রদান করুন
    যদি সমান সংখ্যক পুনরাবৃত্তি সহ একাধিক অক্ষর থাকে, তবে সবগুলো প্রদান করুন

    উদাহরণ:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """


def reverse_delete(s,c):
    """কাজ
    আমাদের s ও c নামের দুটি স্ট্রিং দেওয়া হয়েছে, s-এর যেসব অক্ষর c-র যেকোনো অক্ষরের সাথে মিলে যায় সেগুলো বাদ দিয়ে তোমাকে পরীক্ষা করে দেখতে হবে যে, যে স্ট্রিংটি পাওয়া গেল সেটি প্যালিনড্রোম কি না।
    কোনো স্ট্রিং সামনে-পেছনে দুই দিক থেকেই একই হলে সেটিকে প্যালিনড্রোম বলে।
    শেষে যে স্ট্রিং পাওয়া যাবে সেটিকে ও পরীক্ষার ফল হিসাবে পাওয়া True/False-কে একটি টুপল আকারে তোমাকে ফেরত দিতে হবে।
    উদাহরণ
    s = "abcde", c = "ae" হলে ফল হওয়া উচিত ('bcd',False)
    s = "abcdef", c = "b" হলে ফল হওয়া উচিত ('acdef',False)
    s = "abcdedcba", c = "ab" হলে ফল হওয়া উচিত ('cdedc',True)
    """

def reverse_delete(s,c):
    """কাজ
    আমাদের দুটি স্ট্রিং দেওয়া হয়েছে s এবং c, আপনাকে s-এ সমস্ত অক্ষর মুছে ফেলতে হবে যা c-এ যেকোনো অক্ষরের সমান
    তারপর চেক করতে হবে যে ফলস্বরূপ স্ট্রিংটি পালিনড্রোম কি না।
    একটি স্ট্রিংকে পালিনড্রোম বলা হয় যদি এটি পেছন থেকে সামনের দিকে পড়ার মতো একই হয়।
    আপনাকে একটি tuple ফেরত দিতে হবে যাতে ফলস্বরূপ স্ট্রিং এবং চেকের জন্য True/False থাকে।
    উদাহরণ
    যদি s = "abcde", c = "ae", ফলাফল হওয়া উচিত ('bcd',False)
    যদি s = "abcdef", c = "b"  ফলাফল হওয়া উচিত ('acdef',False)
    যদি s = "abcdedcba", c = "ab", ফলাফল হওয়া উচিত ('cdedc',True)
    """

def reverse_delete(s,c):
    """Task
    আপনাকে দুটি স্ট্রিং s এবং c দেওয়া হয়েছে, s থেকে সমস্ত অক্ষর সরান যা c এর যেকোনো অক্ষরের সাথে মেলে
    এবং চেক করুন যে প্রাপ্ত স্ট্রিংটি প্যালিনড্রোম কিনা।
    একটি স্ট্রিং যা বাম থেকে ডানে বা ডান থেকে বামে পড়া হয় এবং একই থাকে তাকে প্যালিনড্রোম বলা হয়।
    এটি প্রাপ্ত স্ট্রিং এবং চেকের ফলাফল (True/False) সহ একটি টিপল প্রদান করা উচিত।
    উদাহরণ
    যদি s = "abcde", c = "ae" ফলাফল হওয়া উচিত ('bcd',False)
    যদি s = "abcdef", c = "b" ফলাফল হওয়া উচিত ('acdef',False)
    যদি s = "abcdedcba", c = "ab" ফলাফল হওয়া উচিত ('cdedc',True)
    """


def odd_count(lst):
    """একটি স্ট্রিংয়ের একটি তালিকা দেওয়া হয়েছে, যেখানে প্রতিটি স্ট্রিং শুধুমাত্র ডিজিট দিয়ে গঠিত, একটি তালিকা ফেরত দিন।
    ফলাফলের প্রতিটি উপাদান i হওয়া উচিত "ইনপুটের i তম সারির বিজোড় উপাদানগুলির সংখ্যা"
    এখানে, প্রতিটি i ইনপুটের i তম সারির বিজোড় সংখ্যার সংখ্যা দ্বারা প্রতিস্থাপিত হবে

    >>> odd_count(['1234567'])
    ["ইনপুটের 4 তম সারিতে 4 টি বিজোড় উপাদান রয়েছে।"]
    >>> odd_count(['3',"11111111"])
    ["ইনপুটের 1 তম সারিতে 1 টি বিজোড় উপাদান রয়েছে।",
     "ইনপুটের 8 তম সারিতে 8 টি বিজোড় উপাদান রয়েছে।"]
    """

def odd_count(lst):
    """একটি স্ট্রিংয়ের তালিকা দেওয়া হয়েছে, যেখানে প্রতিটি স্ট্রিং শুধুমাত্র ডিজিট নিয়ে গঠিত, একটি তালিকা ফেরত দিন।
    আউটপুটের প্রতিটি উপাদান i হওয়া উচিত "ইনপুটের i তম স্ট্রিংয়ের মধ্যে বিজোড় উপাদানের সংখ্যা।"
    যেখানে সমস্ত i গুলি i তম স্ট্রিংয়ের মধ্যে বিজোড় ডিজিটের সংখ্যায় প্রতিস্থাপিত হবে।

    >>> odd_count(['1234567'])
    ["ইনপুটের 4 তম স্ট্রিংয়ের মধ্যে বিজোড় উপাদানের সংখ্যা।"]
    >>> odd_count(['3',"11111111"])
    ["ইনপুটের 1 তম স্ট্রিংয়ের মধ্যে বিজোড় উপাদানের সংখ্যা।",
     "ইনপুটের 8 তম স্ট্রিংয়ের মধ্যে বিজোড় উপাদানের সংখ্যা।"]
    """

def odd_count(lst):
    """একটি তালিকা দেওয়া হয়েছে, ধরে নেওয়া হয় যে প্রতিটি সারিতে অনন্য সংখ্যা রয়েছে এবং একটি তালিকা দিন
    ফলাফলের প্রতিটি উপাদান i হওয়া উচিত "ইনপুটের i তম সারির বিজোড় উপাদানগুলির সংখ্যা"
    এখানে, প্রতিটি i ইনপুটের i তম সারির বিজোড় সংখ্যার সংখ্যা দ্বারা প্রতিস্থাপিত হবে

    >>> odd_count(['1234567'])
    ["ইনপুটের 4 তম সারিতে 4 টি বিজোড় উপাদান রয়েছে।"]
    >>> odd_count(['3',"11111111"])
    ["ইনপুটের 1 তম সারিতে 1 টি বিজোড় উপাদান রয়েছে।",
     "ইনপুটের 8 তম সারিতে 8 টি বিজোড় উপাদান রয়েছে।"]
    """


def minSubArraySum(nums):
    """
    একটি পূর্ণসংখ্যার অ্যারে nums দেওয়া হয়েছে, nums এর যেকোনো একটি খালি না থাকা উপ-অ্যারের
    সর্বনিম্ন যোগফল খুঁজে বের করুন।
    উদাহরণ
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    nums নামের একটি পূর্ণসংখ্যার অ্যারে দেওয়া আছে, nums-এর যেকোনো অশূন্য
    সাবঅ্যারের সর্বনিম্ন যোগফল বের কর।
    উদাহরণ
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    একটি পূর্ণসংখ্যার তালিকা nums দেওয়া হলে, nums এর একটি খালি নয় এমন সাবসেটের সর্বনিম্ন যোগফল খুঁজুন
    উদাহরণ
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """


import math

def max_fill(grid, capacity):
    """
    আপনাকে কুয়াগুলোর একটি আয়তক্ষেত্রাকার গ্রিড দেওয়া হয়েছে। প্রতিটি সারি একটি কুয়া প্রতিনিধিত্ব করে,
    এবং একটি সারিতে প্রতিটি 1 একটি একক পানি ইউনিট প্রতিনিধিত্ব করে।
    প্রতিটি কুয়ার একটি সংশ্লিষ্ট বালতি রয়েছে যা ব্যবহার করে পানি উত্তোলন করা যায়,
    এবং সমস্ত বালতির ধারণক্ষমতা একই।
    আপনার কাজ হলো বালতিগুলি ব্যবহার করে কুয়াগুলোর পানি খালি করা।
    ফলাফল বের করুন বালতিগুলি কতবার নামাতে হবে।

    উদাহরণ ১:
        প্রবেশ:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        ফলাফল: 6

    উদাহরণ ২:
        প্রবেশ:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        ফলাফল: 5

    উদাহরণ ৩:
        প্রবেশ:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        ফলাফল: 0

    সীমাবদ্ধতা:
        * সমস্ত কূপের উচ্চতা সমান
        * 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):
    """
    একটি আয়তক্ষেত্রাকার গ্রিড দেওয়া হয়েছে যা জল কূপগুলিকে উপস্থাপন করে। প্রতিটি সারি একটি কূপ উপস্থাপন করে।
    প্রতিটি 1 সারিতে একটি জল ইউনিট উপস্থাপন করে।
    প্রতিটি কূপে একটি বালতি রয়েছে যা জল তুলতে ব্যবহার করা যেতে পারে।
    সমস্ত বালতির ক্ষমতা সমান।
    আপনার কাজ হল বালতি ব্যবহার করে কূপগুলি খালি করা।
    বালতি কতবার নামাতে হবে তা প্রদর্শন করুন।

    উদাহরণ 1:
        ইনপুট:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        আউটপুট: 6

    উদাহরণ 2:
        ইনপুট:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        আউটপুট: 5

    উদাহরণ 3:
        ইনপুট:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        আউটপুট: 0

    সীমাবদ্ধতা:
        * সমস্ত কূপের উচ্চতা সমান
        * 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):
    """
    আপনাকে একটি আয়তাকার গ্রিড দেওয়া হয়েছে যা কুয়া গুলির প্রতিনিধিত্ব করে।
    প্রতিটি সারি একটি একক কুয়া প্রতিনিধিত্ব করে, এবং একটি সারিতে প্রতিটি ১ একটি একক পানি ইউনিটকে প্রতিনিধিত্ব করে।
    প্রতিটি কুয়ার একটি সংশ্লিষ্ট বালতি রয়েছে যা থেকে পানি বের করা যেতে পারে, এবং সমস্ত বালতির সমান ধারণক্ষমতা থাকে।
    আপনার কাজ হল বালতি ব্যবহার করে কুয়া খালি করা।
    বালতিগুলিকে নামানোর জন্য আপনাকে কতবার প্রয়োগ করতে হবে তার সংখ্যা আউটপুট হিসেবে ফেরত দিন।

    উদাহরণ ১:
        ইনপুট:
            গ্রিড : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            বালতির ধারণক্ষমতা : 1
        আউটপুট: 6

    উদাহরণ ২:
        ইনপুট:
            গ্রিড : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            বালতির ধারণক্ষমতা : 2
        আউটপুট: 5

    উদাহরণ ৩:
        ইনপুট:
            গ্রিড : [[0,0,0], [0,0,0]]
            বালতির ধারণক্ষমতা : 5
        আউটপুট: 0

    বিধিনিষেধ:
        * সকল কুয়ার দৈর্ঘ্য সমান হবে
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """


def sort_array(arr):
    """
    এই কাতায়, আপনাকে একটি নন-নেগেটিভ পূর্ণসংখ্যার তালিকা সাজাতে হবে, যা তাদের বাইনারি উপস্থাপনায় ১ এর সংখ্যা অনুসারে ক্রমবর্ধমান অর্ডারে সাজানো হবে।
    একে অপরের মতো ১ এর সংখ্যা থাকলে, তাদের দশমিক মানের ভিত্তিতে সাজাতে হবে।

    এটি এইভাবে বাস্তবায়িত করতে হবে:
    >>> 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):
    """
    এই কেটাতে, আপনাকে একটি অ্যারে সজ্জিত করতে হবে যা অ-নেগেটিভ পূর্ণসংখ্যা নিয়ে গঠিত
    তাদের বাইনারি উপস্থাপনায় ১ সংখ্যা অনুযায়ী উঠতি ক্রমে।
    যদি ১ এর সংখ্যা একই হয়, তবে দশমিক মান অনুসারে সজ্জিত করুন।

    এটি এভাবে বাস্তবায়িত করতে হবে:
    >>> 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):
    """
    এই ফাংশনে, আপনাকে একটি ধনাত্মক সংখ্যা সম্বলিত অ্যারের উপাদানগুলোকে তাদের বাইনারি উপস্থাপনার 1 এর সংখ্যার উপর ভিত্তি করে সাজাতে হবে।
    যদি 1 এর সংখ্যা সমান হয়, তবে দশমিক মান অনুযায়ী সাজান।

    আপনাকে নিম্নলিখিতভাবে সাজাতে হবে:
    >>> 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):
    """একটি স্ট্রিং s এবং একটি প্রাকৃতিক সংখ্যা n দেওয়া হলে, আপনাকে একটি ফাংশন বাস্তবায়ন করতে হবে যা
    স্ট্রিং s থেকে সমস্ত শব্দের একটি তালিকা ফেরত দেয়, যেগুলির মধ্যে সঠিকভাবে n টি ব্যঞ্জনবর্ণ রয়েছে,
    যেমনটি তারা স্ট্রিং s-তে উপস্থিত হওয়ার সময় অনুসারে।
    যদি স্ট্রিং s খালি হয় তবে ফাংশনটি একটি খালি তালিকা ফেরত দেবে।
    মনে রাখবেন: আপনি ধরে নিতে পারেন যে ইনপুট স্ট্রিংটিতে শুধুমাত্র অক্ষর এবং ফাঁকা স্থান রয়েছে।
    উদাহরণ:
    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):
    """একটি স্ট্রিং s এবং একটি স্বাভাবিক সংখ্যা n দেওয়া আছে, এমন একটি ফাংশন লিখুন
    যা স্ট্রিং s এ প্রদর্শিত অনুক্রমে স্ট্রিং s এর যেসব শব্দে ব্যঞ্জনবর্ণের সংখ্যা n এর সমান,
    সেই শব্দগুলোর একটি তালিকা ফেরত দেয়।
    যদি স্ট্রিং s খালি থাকে তবে ফাংশনটি একটি খালি তালিকা প্রদান করবে।
    দ্রষ্টব্যঃ আপনি ধরে নিতে পারেন যে ইনপুট স্ট্রিংটিতে শুধুমাত্র অক্ষর এবং ফাঁকা স্থান রয়েছে।
    উদাহরণঃ
    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):
    """একটি স্ট্রিং s এবং একটি ধনাত্মক পূর্ণসংখ্যা n দেওয়া হলে, এমন একটি ফাংশন লিখুন যা একটি তালিকা প্রদান করে
    যেসব শব্দের ব্যঞ্জনবর্ণের সংখ্যা n এর সমান, সেই শব্দগুলো স্ট্রিং s থেকে।
    এই শব্দগুলো স্ট্রিং s এ যেভাবে প্রদর্শিত হয় সেই ক্রমে প্রদান করতে হবে।
    যদি স্ট্রিং s খালি হয়, তাহলে ফাংশনটি খালি তালিকা প্রদান করা উচিত।
    মনে রাখবেন: আপনি ধরে নিতে পারেন যে ইনপুট স্ট্রিংটিতে শুধুমাত্র অক্ষর এবং ফাঁকা স্থান রয়েছে।
    উদাহরণ:
    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):
    """আপনাকে একটি শব্দ দেওয়া হয়েছে। আপনার কাজ হল, সেই শব্দের ডানদিক থেকে,
    দুটি ব্যঞ্জনবর্ণের মাঝে যে সবচেয়ে কাছের স্বরবর্ণটি রয়েছে, তা খুঁজে বের করা (কেস সংবেদনশীল)।

    শুরু এবং শেষের স্বরবর্ণগুলি গোনা হবে না। যদি উপরের শর্ত পূর্ণ করা কোনও স্বরবর্ণ না পাওয়া যায়,
    তবে খালি স্ট্রিং ফেরত দিন।

    আপনি ধরতে পারেন যে, দেওয়া স্ট্রিংটি শুধুমাত্র ইংরেজি অক্ষর ধারণ করবে।

    উদাহরণ:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """আপনার কাছে একটি শব্দ দেওয়া হয়েছে। আপনার কাজ হল সঠিক দিক থেকে দুটি ব্যঞ্জনধ্বনির মধ্যে দাঁড়ানো সবচেয়ে কাছের স্বরবর্ণটি খুঁজে বের করা (কেস সেন্সিটিভ)।

    শুরু এবং শেষের স্বরবর্ণগুলি গন্য হবে না। যদি আপনি কোনও স্বরবর্ণ না পান যা উপরের শর্ত পূর্ণ করে তবে খালি স্ট্রিং ফেরত দিন।

    ধরে নিন যে প্রদত্ত অক্ষরগুলি শুধুমাত্র ইংরেজি অক্ষর অন্তর্ভুক্ত করে

    উদাহরণ:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """একটি শব্দের ডান দিক থেকে দুটি ব্যঞ্জনবর্ণের মধ্যে সবচেয়ে কাছের স্বরবর্ণ খুঁজে বের করার কাজটি সম্পাদন করুন
    (বড় হাতের এবং ছোট হাতের অক্ষর আলাদা করুন)

    শব্দের শুরু এবং শেষে থাকা স্বরবর্ণ অন্তর্ভুক্ত করবেন না। যদি উপরের শর্তগুলি পূরণ করে এমন কোনো স্বরবর্ণ না থাকে,
    তাহলে খালি স্ট্রিং প্রদান করুন

    ধরে নিন যে প্রদত্ত অক্ষরগুলি শুধুমাত্র ইংরেজি অক্ষর অন্তর্ভুক্ত করে

    উদাহরণ:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """


def match_parens(lst):
    '''
    আপনাকে দুটি স্ট্রিংয়ের একটি তালিকা দেওয়া হয়েছে, প্রতিটি স্ট্রিং শুধুমাত্র খোলার বন্ধনী '(' বা বন্ধ করার বন্ধনী ')' ধারণ করে।
    আপনার কাজ হল এই দুটি স্ট্রিংকে যেকোনো ক্রমে একত্রিত করা যাতে চেক করা যায় যে ফলাফল স্ট্রিংটি একটি ভাল স্ট্রিং কিনা।
    একটি স্ট্রিং S কে ভাল বলে মনে করা হবে শুধুমাত্র তখনই যদি S এর সমস্ত বন্ধনী ভারসাম্যপূর্ণ হয়। উদাহরণস্বরূপ, স্ট্রিং '(())()' ভাল বলে মনে করা হয়, কিন্তু স্ট্রিং '())' ভাল নয়।
    যদি একটি ভাল স্ট্রিং তৈরি করার উপায় থাকে, তাহলে 'Yes' দিন, অন্যথায় 'No' দিন।

    উদাহরণ:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    আপনাকে দুটি স্ট্রিংয়ের একটি তালিকা দেওয়া হবে, যেগুলোর মধ্যে প্রতিটি স্ট্রিং শুধুমাত্র খোলামুখী
    বন্ধনী '(' অথবা বন্ধ মুখী বন্ধনী ')' নিয়ে গঠিত।
    আপনার কাজ হল চেক করা যে, কি দুটি স্ট্রিং একসাথে যুক্ত করে এমন একটি সঠিক স্ট্রিং তৈরি করা সম্ভব কিনা।
    একটি স্ট্রিং S সঠিক হিসেবে বিবেচিত হবে যদি এবং শুধুমাত্র যদি S এর সমস্ত বন্ধনীগুলি ব্যালান্সড হয়।
    উদাহরণস্বরূপ: স্ট্রিং '(())()' সঠিক, তবে স্ট্রিং '())' সঠিক নয়।
    যদি একটি সঠিক স্ট্রিং তৈরি করা সম্ভব হয়, তবে 'Yes' ফেরত দিন, নাহলে 'No' ফেরত দিন।

    উদাহরণ:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    আপনাকে দুটি স্ট্রিংয়ের একটি তালিকা দেওয়া হয়েছে, যেখানে উভয় স্ট্রিং শুধুমাত্র খোলামুখী প্যারেন্টিসিস '(' অথবা বন্ধ প্যারেন্টিসিস ')' নিয়ে গঠিত।
    আপনার কাজ হল এটি পরীক্ষা করা যে দুটি স্ট্রিংকে কোন একটি আদেশে একত্রিত করে, কি একটি ভাল স্ট্রিং তৈরি করা সম্ভব।
    একটি স্ট্রিং S শুধুমাত্র তখনই ভাল বলা হয় যদি সমস্ত প্যারেন্টিসিসের মধ্যে সঠিক সমতা থাকে। উদাহরণস্বরূপ: '(())()' একটি ভাল স্ট্রিং, কিন্তু '())' তা নয়।
    যদি একটি ভাল স্ট্রিং তৈরি করার উপায় থাকে, তাহলে 'Yes' ফেরত দিন, অন্যথায় 'No' ফেরত দিন।

    উদাহরণ:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''


def maximum(arr, k):
    """
    একটি পূর্ণসংখ্যার অ্যারে `arr` এবং একটি ধনাত্মক পূর্ণসংখ্যা `k` দেওয়া হলে,
    `arr`-এর সর্বোচ্চ `k` সংখ্যার একটি সাজানো তালিকা ফিরিয়ে দিন।

    উদাহরণ 1:

        ইনপুট: arr = [-3, -4, 5], k = 3
        আউটপুট: [-4, -3, 5]

    উদাহরণ 2:

        ইনপুট: arr = [4, -4, 4], k = 2
        আউটপুট: [4, 4]

    উদাহরণ 3:

        ইনপুট: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        আউটপুট: [2]

    নোট:
        1. অ্যারের দৈর্ঘ্য [1, 1000] পরিসরের মধ্যে হবে।
        2. অ্যারের উপাদানগুলি [-1000, 1000] পরিসরের মধ্যে হবে।
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    একটি পূর্ণসংখ্যার অ্যারে arr এবং একটি ধনাত্মক পূর্ণসংখ্যা k দেওয়া হয়েছে
    arr-এর মধ্যে সর্বাধিক k সংখ্যা নিয়ে একটি সাজানো তালিকা রিটার্ন করুন।

    উদাহরণ ১:

        প্রবেশ: arr = [-3, -4, 5], k = 3
        ফলাফল: [-4, -3, 5]

    উদাহরণ ২:

        প্রবেশ: arr = [4, -4, 4], k = 2
        ফলাফল: [4, 4]

    উদাহরণ ৩:

        প্রবেশ: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        ফলাফল: [2]

    নোট:
        1. অ্যারের দৈর্ঘ্য [1, 1000] এর মধ্যে হবে।
        2. অ্যারের উপাদানগুলি [-1000, 1000] এর মধ্যে হবে।
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    যদি arr হয় পূর্ণসংখ্যার একটি তালিকা এবং k হয় একটি ধনাত্মক পূর্ণসংখ্যা
    তাহলে arr এর মধ্যে k টি বৃহত্তম সংখ্যা নিয়ে k দৈর্ঘ্যের একটি সাজানো তালিকা দাও

    উদাহরণ ১:

        ইনপুট: arr = [-3, -4, 5], k = 3
        আউটপুট: [-4, -3, 5]

    উদাহরণ ২:

        ইনপুট: arr = [4, -4, 4], k = 2
        আউটপুট: [4, 4]

    উদাহরণ ৩:

        ইনপুট: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        আউটপুট: [2]

    নোট:
        1. তালিকার দৈর্ঘ্য [1, 1000] এর মধ্যে হবে
        2. তালিকার উপাদান [-1000, 1000] এর মধ্যে হবে
        3. 0 <= k <= len(arr)
    """


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

    উদাহরণ
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

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

    উদাহরণ:
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==> 0
    """

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

    উদাহরণ
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """


def add_elements(arr, k):
    """
    একটি অ-খালি পূর্ণসংখ্যার অ্যারে arr এবং একটি পূর্ণসংখ্যা k দেয়া হলে, arr এর প্রথম k উপাদানের মধ্যে
    যেগুলির সংখ্যার দৈর্ঘ্য সর্বোচ্চ দুই অংকের, সেগুলির যোগফল ফেরত দিন।

    উদাহরণ:

        প্রবেশ: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        ফলাফল: 24 # 21 + 3 এর যোগফল

    সীমাবদ্ধতা:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    একটি অ-খালি পূর্ণসংখ্যার অ্যারে arr এবং একটি পূর্ণসংখ্যা k দেওয়া আছে।
    arr এর প্রথম k উপাদানগুলির মধ্যে 2 ডিজিটের বেশি নয় এমন উপাদানগুলির যোগফল ফেরত দিন।

    উদাহরণঃ

        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Output: 24 # 21 + 3 এর যোগফল

    সীমাবদ্ধতাঃ
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    একটি নন-এম্পটি পূর্ণসংখ্যার অ্যারে arr এবং একটি পূর্ণসংখ্যা k দেওয়া হয়েছে,
    arr এর প্রথম k উপাদানগুলির মধ্যে যেগুলোর সংখ্যা দুই ডিজিটের বেশি নয়, তাদের যোগফল রিটার্ন করুন।

    উদাহরণ:

        ইনপুট: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        আউটপুট: 24 # 21 + 3 এর যোগফল

    সীমাবদ্ধতা:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """


def get_odd_collatz(n):
    """
    একটি ধনাত্মক পূর্ণসংখ্যা n দেওয়া হলে, একটি সজ্জিত তালিকা ফেরত দিন যা কোল্যাটজ সিকোয়েন্সে বিজোড় সংখ্যাগুলি ধারণ করে।

    কোল্যাটজ অনুমান হল একটি গাণিতিক অনুমান যা একটি সিকোয়েন্সের সাথে সম্পর্কিত
    যা এইভাবে সংজ্ঞায়িত: যেকোনো ধনাত্মক পূর্ণসংখ্যা n দিয়ে শুরু করুন। তারপর প্রতিটি পদ পূর্ববর্তী পদ থেকে পাওয়া যায় এইভাবে: যদি পূর্ববর্তী পদ জোড় হয়, তবে পরবর্তী পদ পূর্ববর্তী পদটির অর্ধেক। যদি পূর্ববর্তী পদ বিজোড় হয়, তবে পরবর্তী পদ হল পূর্ববর্তী পদটির 3 গুণ এবং 1 যোগ। অনুমানটি হল যে যেকোনো মানের জন্য n, সিকোয়েন্সটি সর্বদা 1 এ পৌঁছাবে।

    নোট:
        1. কোল্যাটজ(1) হল [1]।
        2. ফেরত দেওয়া তালিকা বাড়ানো ক্রমে সাজানো।

    উদাহরণস্বরূপ:
    get_odd_collatz(5) returns [1, 5] # 5 এর জন্য কোল্যাটজ সিকোয়েন্স হল [5, 16, 8, 4, 2, 1], সুতরাং বিজোড় সংখ্যা কেবল 1 এবং 5।
    """

def get_odd_collatz(n):
    """
    একটি ধনাত্মক পূর্ণসংখ্যা n দেওয়া হলে, কলটাজ সিকোয়েন্সের মধ্যে থাকা বিজোড় সংখ্যাগুলির একটি সাজানো তালিকা ফেরত দিন।

    কলটাজ কনজেকচার হল একটি গাণিতিক কনজেকচার যা একটি সিকোয়েন্সের সাথে সম্পর্কিত, যা নিম্নলিখিতভাবে সংজ্ঞায়িত:
    যে কোনো ধনাত্মক পূর্ণসংখ্যা n দিয়ে শুরু করুন। তারপর প্রতিটি পদ পূর্ববর্তী পদ থেকে এইভাবে পাওয়া যায়:
    যদি পূর্ববর্তী পদটি সমান হয়, তবে পরবর্তী পদটি পূর্ববর্তী পদটির অর্ধেক। যদি পূর্ববর্তী পদটি বিজোড় হয়,
    তবে পরবর্তী পদটি ৩ গুণ পূর্ববর্তী পদটির মানের যোগফল ১। এই কনজেকচারের ধারণা হল যে, n-এর যে কোনো মানই হোক না কেন,
    সিকোয়েন্সটি সবসময় ১-এ পৌঁছাবে।

    দ্রষ্টব্য:
        ১. Collatz(1) হল [1]।
        ২. ফেরত দেওয়া তালিকা বেড়ে যাওয়ার অর্ডারে সাজানো হবে।

    উদাহরণ:
    get_odd_collatz(5) ফেরত দিবে [1, 5] # 5 এর জন্য কলটাজ সিকোয়েন্স হল [5, 16, 8, 4, 2, 1], তাই বিজোড় সংখ্যা গুলি হল কেবল ১ এবং ৫।
    """

def get_odd_collatz(n):
    """
    এটি একটি ধনাত্মক পূর্ণসংখ্যা n গ্রহণ করে এবং একটি সাজানো তালিকা প্রদান করে যা Collatz ক্রমের বিজোড় সংখ্যা ধারণ করে

    Collatz অনুমান হল একটি গাণিতিক অনুমান যা নিম্নরূপ করে একটি ক্রম সম্পর্কে
    যেকোনো ধনাত্মক পূর্ণসংখ্যা n দিয়ে শুরু করুন, তারপর প্রতিটি পদ আগের পদ থেকে নিম্নলিখিতভাবে প্রাপ্ত হয়
    যদি আগের পদটি একটি জোড় সংখ্যা হয়, তাহলে পরবর্তী পদটি আগের পদের অর্ধেক হবে
    যদি আগের পদটি একটি বিজোড় সংখ্যা হয়, তাহলে পরবর্তী পদটি আগের পদের তিনগুণ হবে তারপর এক যোগ করুন
    এই অনুমানটি বলে যে ক্রমটি সর্বদা 1 হবে n এর মান যাই হোক না কেন

    মনে রাখবেন:
        1. Collatz(1) হল [1]
        2. প্রদান করা তালিকাটি ক্রমবর্ধমান ক্রমে সাজানো হবে

    উদাহরণ:
    get_odd_collatz(5) প্রদান করে [1, 5] # 5 এর Collatz ক্রম হল [5, 16, 8, 4, 2, 1] এবং বিজোড় সংখ্যা শুধুমাত্র 1 এবং 5
    """


def valid_date(date):
    """আপনাকে একটি ফাংশন লিখতে হবে যা একটি নির্দিষ্ট তারিখ স্ট্রিং যাচাই করে এবং
    সত্য যদি তারিখটি বৈধ হয়, অন্যথায় মিথ্যা।
    তারিখটি বৈধ যদি নিম্নলিখিত সমস্ত নিয়ম পূর্ণ হয়:
    1. তারিখ স্ট্রিংটি খালি নয়।
    2. মাস 1,3,5,7,8,10,12 এর জন্য দিনগুলির সংখ্যা 1 এর কম নয় বা 31 দিনের বেশি নয়। এবং মাস 4,6,9,11 এর জন্য দিনগুলির সংখ্যা 1 এর কম নয় বা 30 দিনের বেশি নয়। এবং, মাস 2 এর জন্য দিনগুলির সংখ্যা 1 এর কম নয় বা 29 দিনের বেশি নয়।
    3. মাসগুলির সংখ্যা 1 এর কম নয় বা 12 এর বেশি নয়।
    4. তারিখটি এই ফরম্যাটে হওয়া উচিত: মাস-দিন-সাল

    উদাহরণস্বরূপ:
    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):
    """তারিখের স্ট্রিং যাচাই করার জন্য একটি ফাংশন এবং যদি তারিখ সঠিক হয় তবে True হবে, অন্যথায় False হবে
    একটি তারিখ সঠিক হতে হলে, নিম্নলিখিত সমস্ত নিয়ম অনুসরণ করতে হবে:
    1. তারিখের স্ট্রিং খালি হওয়া উচিত নয়
    2. দিনের সংখ্যা 1 দিনের কম বা 1,3,5,7,8,10,12 মাসে 31 দিনের বেশি হওয়া উচিত নয়, 4,6,9,11 মাসে 30 দিনের বেশি হওয়া উচিত নয়, এবং 2 মাসে 29 দিনের বেশি হওয়া উচিত নয়
    3. মাস 1 এর কম বা 12 এর বেশি হওয়া উচিত নয়
    4. তারিখটি নিম্নলিখিত বিন্যাসে হওয়া উচিত: mm-dd-yyyy

    উদাহরণ:
    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):
    """আপনাকে একটি ফাংশন লিখতে হবে যা একটি প্রদত্ত তারিখ স্ট্রিং যাচাই করে এবং
    যদি তারিখটি বৈধ হয় তবে True এবং না হলে False রিটার্ন করে।
    তারিখটি বৈধ হবে যদি নিম্নলিখিত সমস্ত নিয়ম পূর্ণ হয়:
    1. তারিখ স্ট্রিংটি খালি নয়।
    2. মাস ১,৩,৫,৭,৮,১০,১২ এর জন্য দিন ১ থেকে ৩১ এর মধ্যে হতে হবে, এবং মাস ৪,৬,৯,১১ এর জন্য দিন ১ থেকে ৩০ এর মধ্যে হতে হবে। এবং ফেব্রুয়ারি মাসের জন্য দিন ১
    থেকে ২৯ এর মধ্যে হতে হবে।
    3. মাসটি ১ থেকে ১২ এর মধ্যে হতে হবে।
    4. তারিখটি নিম্নলিখিত ফরম্যাটে থাকা উচিত: mm-dd-yyyy

    উদাহরণ:
    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):
    '''
    শব্দপূর্ণ একটি স্ট্রিং দেওয়া আছে, হোয়াইটস্পেসের ভিত্তিতে ভাগ করা শব্দবিশিষ্ট একটি লিস্ট ফেরত দাও,
    কোনো হোয়াইটস্পেস না থাকলে কমার ',' ভিত্তিতে ভাগ করে দাও, কোনো কমা না থাকলে বের করে দাও বর্ণমালায় বেজোড়
    অবস্থানে অবস্থিত ছোট হাতের কতগুলো বর্ণ স্ট্রিংটিতে আছে, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    উদাহরণ
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    একটি শব্দের স্ট্রিং দেওয়া হলে, স্পেস দ্বারা বিভক্ত একটি শব্দের তালিকা ফেরত দিন, যদি টেক্সটটিতে কোনও স্পেস না থাকে তবে
     আপনাকে কমা ',' দ্বারা বিভক্ত করতে হবে যদি কোনো কমা না থাকে, তাহলে বিজোড় সংখ্যার ছোট হাতের অক্ষরের সংখ্যা ফেরত দিতে হবে
     , ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    উদাহরণ
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    শব্দের একটি স্ট্রিং দেওয়া আছে, হোয়াইটস্পেসে বিভক্ত শব্দগুলির একটি তালিকা প্রদান করুন, যদি স্ট্রিংয়ে কোনো হোয়াইটস্পেস না থাকে,
    তাহলে কমা ',' দ্বারা বিভক্ত করতে হবে, যদি কোন কমা বিদ্যমান না থাকে তবে আপনাকে বর্ণমালায় বিজোড় ক্রম সহ ছোট হাতের অক্ষরগুলির সংখ্যা
    ফেরত দিতে হবে, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    উদাহরণ
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''


def is_sorted(lst):
    '''
    সংখ্যার একটি তালিকা দেওয়া হলে, তা বৃদ্ধি আদেশে সাজানো হয়েছে কিনা তা ফেরত দিন।
    যদি তালিকায় একই সংখ্যার একাধিক অনুলিপি থাকে, তবে False ফেরত দিন।
    ধরা হবে যে কোন নেতিবাচক সংখ্যা নেই এবং শুধুমাত্র পূর্ণসংখ্যা থাকবে।

    উদাহরণস্বরূপ:
    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):
    '''
    একটি সংখ্যার তালিকা দেওয়া আছে, সংখ্যাগুলি ছোট থেকে বড় ক্রমে সাজানো আছে কিনা তা ফেরত দিন।
    যদি তালিকায় একই নম্বরের 1 টির বেশি সদৃশ নম্বর থাকে, তাহলে False ফেরত দিন।
    ধরে নিন কোন ঋণাত্মক সংখ্যা নেই এবং শুধুমাত্র পূর্ণসংখ্যা রয়েছে।

    উদাহরণ
    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):
    '''
    একটি সংখ্যার তালিকা দেওয়া হয়েছে, সংখ্যা গুলি ছোট থেকে বড় ক্রমে সাজানো থাকলে True দিন
    যদি একাধিক সমান সংখ্যা থাকে, False দিন
    ধরে নিন কোন ঋণাত্মক সংখ্যা নেই এবং শুধুমাত্র পূর্ণসংখ্যা রয়েছে

    উদাহরণ
    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):
    """আপনাকে দুটি অন্তরাল দেওয়া হয়েছে,
    যেখানে প্রতিটি অন্তরাল একটি পূর্ণসংখ্যার জোড়া। উদাহরণস্বরূপ, অন্তরাল = (শুরু, শেষ) = (1, 2)।
    প্রদত্ত অন্তরালগুলি বন্ধ, অর্থাৎ অন্তরাল (শুরু, শেষ)
    উভয় শুরু এবং শেষ অন্তর্ভুক্ত করে।
    প্রতিটি প্রদত্ত অন্তরালের জন্য, এটি ধরা হয় যে তার শুরু তার শেষের চেয়ে কম অথবা সমান।
    আপনার কাজ হল নির্ধারণ করা যে এই দুটি
    অন্তরালের সম্মিলনের দৈর্ঘ্য একটি মৌলিক সংখ্যা কিনা।
    উদাহরণস্বরূপ, অন্তরালের সম্মিলন (1, 3), (2, 4) হল (2, 3)
    যার দৈর্ঘ্য 1, যা একটি মৌলিক সংখ্যা নয়।
    যদি সম্মিলনের দৈর্ঘ্য একটি মৌলিক সংখ্যা হয়, তবে "YES" রিটার্ন করুন,
    অন্যথায়, "NO" রিটার্ন করুন।
    যদি দুটি অন্তরাল মিলিত না হয়, তবে "NO" রিটার্ন করুন।

    [ইনপুট/আউটপুট] নমুনা:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """দুটি ইন্টারভাল নির্ণয় করুন
    প্রতিটি ইন্টারভাল একটি পূর্ণসংখ্যার জোড়া, যেমন, ইন্টারভাল = (শুরু, শেষ) = (1, 2)
    প্রদত্ত ইন্টারভালগুলি বন্ধ ইন্টারভাল এবং ইন্টারভাল (শুরু, শেষ) শুরু এবং শেষ অন্তর্ভুক্ত করে
    প্রতিটি ইন্টারভালের জন্য, ধারণা করা হয় যে শুরু হয় ছোট বা সমান শেষের সাথে
    আপনার কাজ হল নির্ধারণ করা যে দুটি ইন্টারভালের ছেদ দৈর্ঘ্য একটি মৌলিক সংখ্যা কিনা
    উদাহরণস্বরূপ, ইন্টারভাল (1, 3), (2, 4) এর ছেদ হল (2, 3)
    এর দৈর্ঘ্য 1 যা একটি মৌলিক সংখ্যা নয়
    যদি ছেদের দৈর্ঘ্য একটি মৌলিক সংখ্যা হয়, তাহলে "YES" দিন
    যদি না হয়, তাহলে "NO" দিন
    যদি দুটি ইন্টারভাল না মেলে, তাহলে "NO" দিন

    [উদাহরণ] ইনপুট/আউটপুট:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """
    আপনাকে দুটি ইন্টারভ্যাল (অবধি) দেওয়া হয়েছে, যেখানে প্রতিটি ইন্টারভ্যাল একটি পূর্ণসংখ্যার জোড়।
    উদাহরণস্বরূপ, interval = (start, end) = (1, 2)।
    দেওয়া ইন্টারভ্যালগুলি ক্লোজড, এর মানে হল যে ইন্টারভ্যাল (start, end)
    শুরু এবং শেষ উভয়কেই অন্তর্ভুক্ত করে।
    প্রতিটি ইন্টারভ্যালের জন্য, এটি ধরা হয় যে তার শুরু তার শেষের চেয়ে ছোট বা সমান।
    আপনার কাজ হল, এই দুটি ইন্টারভ্যালের যে ইন্টারসেকশন (অভিসম্পর্ক) রয়েছে তার দৈর্ঘ্য একটি প্রাইম সংখ্যা কিনা তা নির্ধারণ করা।
    উদাহরণস্বরূপ, ইন্টারভ্যাল (1, 3) এবং (2, 4) এর ইন্টারসেকশন হবে (2, 3),
    যার দৈর্ঘ্য 1, যা একটি প্রাইম সংখ্যা নয়।
    যদি ইন্টারসেকশনের দৈর্ঘ্য প্রাইম সংখ্যা হয়, তাহলে "YES" ফেরত দিন,
    অন্যথায়, "NO" ফেরত দিন।
    যদি দুটি ইন্টারভ্যাল একে অপরের সাথে সম্পর্কিত না হয়, তাহলে "NO" ফেরত দিন।

    [ইনপুট/আউটপুট] উদাহরণসমূহ:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """


def prod_signs(arr):
    """
    আপনাকে একটি পূর্ণসংখ্যার অ্যারে arr দেওয়া হয়েছে এবং আপনাকে এটি
    ফেরত দিতে হবে: সংখ্যাগুলির মৌলিক মানের যোগফল, যা প্রতিটি সংখ্যার চিহ্নের (1, -1, বা 0) গুণফলের সাথে গুণিত।
    নোট: যদি অ্যারে খালি হয়, তবে None ফেরত দিন।

    উদাহরণ:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    আপনাকে একটি পূর্ণসংখ্যার অ্যারে arr দেওয়া হয়েছে এবং আপনাকে ফিরিয়ে দিতে হবে
    অ্যারের প্রতিটি সংখ্যার চিহ্নের গুণফলের সাথে সংখ্যাগুলির পরিমাণের যোগফল, যা 1, -1 বা 0 দ্বারা প্রদর্শিত হয়।
    মনে রাখবেন: খালি অ্যারের ক্ষেত্রে None ফেরত দিন

    উদাহরণ:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    আপনাকে পূর্ণসংখ্যার একটি অ্যারে arr দেওয়া হয়েছে এবং আপনাকে 1, -1 বা 0 দ্বারা উপস্থাপিত অ্যারের প্রতিটি সংখ্যার
    সমস্ত চিহ্নের গুণফল দ্বারা গুণিত পূর্ণসংখ্যার মাত্রার যোগফল ফেরত দিতে হবে।
    দ্রষ্টব্যঃ খালি arr এর জন্য None ফেরত দিন।

    উদাহরণঃ
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """


def minPath(grid, k):
    """
    একটি গ্রিড দেওয়া হয়েছে যার Nটি সারি এবং Nটি কলাম (N >= 2) এবং একটি ধনাত্মক পূর্ণসংখ্যা k,
    গ্রিডের প্রতিটি সেলে একটি মান রয়েছে। [1, N * N] রেঞ্জে প্রতিটি পূর্ণসংখ্যা
    একবার করে গ্রিডের সেলগুলোতে উপস্থিত থাকে।

    আপনাকে গ্রিডে k দৈর্ঘ্যের ন্যূনতম পথ খুঁজে বের করতে হবে। আপনি যেকোনো সেল থেকে শুরু করতে পারেন,
    এবং প্রতিটি পদক্ষেপে আপনি আপনার বর্তমান সেলের সঙ্গী যেকোনো সেলটিতে যেতে পারবেন,
    অর্থাৎ আপনি এমন সেলে যেতে পারবেন যেগুলি আপনার বর্তমান সেলের একটি প্রান্ত ভাগ করে।
    দয়া করে মনে রাখবেন যে k দৈর্ঘ্যের একটি পথ মানে হল ঠিক kটি সেল পরিদর্শন করা (অবশ্যই আলাদা হতে হবে না)।
    আপনি গ্রিডের বাইরে যেতে পারবেন না।
    একটি পথ A (k দৈর্ঘ্যের) একটি পথ B (k দৈর্ঘ্যের) এর চেয়ে কম হবে যদি
    A এবং B যে সেলগুলির মধ্যে দিয়ে গেছে, তাদের মানের সাজানো তালিকা তৈরি করার পর (এগুলোকে lst_A এবং lst_B বলা হবে),
    lst_A lexicographically lst_B এর চেয়ে কম হয়, অর্থাৎ এমন একটি পূর্ণসংখ্যার সূচক i (1 <= i <= k) থাকবে
    যেখানে lst_A[i] < lst_B[i] এবং যে কোনও j (1 <= j < i) এর জন্য lst_A[j] = lst_B[j]।
    এটা নিশ্চিত করা হয়েছে যে উত্তরটি একক।
    যেসব সেলে ন্যূনতম পথটি যাবে, সেই মানগুলির একটি সাজানো তালিকা ফেরত দিন।

    উদাহরণ:

        ইনপুট: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        আউটপুট: [1, 2, 1]

        ইনপুট: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        আউটপুট: [1]
    """

def minPath(grid, k):
    """
    একটি গ্রিড দেওয়া হয়েছে যার সারি N এবং কলাম N (N >= 2) এবং একটি ধনাত্মক পূর্ণসংখ্যা k
    গ্রিডের প্রতিটি সেলে একটি অন্তর্ভুক্ত মান রয়েছে। অ্যারে [1, N * N] এর সমস্ত পূর্ণসংখ্যা
    গ্রিডের সেলে একবারই প্রদর্শিত হয়।

    গ্রিডে সর্বনিম্ন দৈর্ঘ্য k এর একটি পথ খুঁজে বের করতে হবে। এটি যেকোনো সেল থেকে শুরু করতে পারে
    এবং প্রতিটি পদক্ষেপে এটি নিকটবর্তী সেলে যেতে পারে। অর্থাৎ, এটি বর্তমান সেলের সাথে সীমানা ভাগ করে এমন সেলে যেতে পারে।
    দৈর্ঘ্য k এর একটি পথ মানে সঠিকভাবে k সেল পরিদর্শন করা (অবশ্যই আলাদা হতে হবে না)
    গ্রিডের বাইরে যেতে পারবে না।
    দৈর্ঘ্য k এর পথ A কে পথ B এর চেয়ে ছোট বলে মনে করা হবে যদি A এবং B পথগুলি অতিক্রম করে এমন মানগুলির ক্রমের তালিকা তৈরি করার পরে (তাদের lst_A এবং lst_B বলুন)
    lst_A এর একটি অভিধান ক্রম lst_B এর চেয়ে ছোট, অর্থাৎ একটি পূর্ণসংখ্যা সূচক i (1 <= i <= k) আছে
    যেখানে lst_A[i] < lst_B[i] এবং যেকোনো j এর জন্য (1 <= j < i)
    lst_A[j] = lst_B[j]
    নিশ্চিত করা হয়েছে যে উত্তরটি অনন্য
    যে পথটি সর্বনিম্ন তার মাধ্যমে অতিক্রম করা মানগুলির ক্রমের তালিকা প্রদান

    উদাহরণ:

        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):
    """
    একটি গ্রিড দেওয়া হবে যার N সারি এবং N কলাম (N >= 2) এবং একটি ধনাত্মক পূর্ণসংখ্যা k,
    গ্রিডের প্রতিটি সেলে একটি মান থাকবে। [1, N * N] পরিসরের প্রতিটি পূর্ণসংখ্যা
    সেলগুলিতে একবার করে উপস্থিত হবে।

    আপনাকে গ্রিডে k দৈর্ঘ্যের ন্যূনতম পথ খুঁজে বের করতে হবে। আপনি যেকোন সেল থেকে শুরু করতে পারেন,
    এবং প্রতিটি পদক্ষেপে আপনি আপনার বর্তমান সেলের সাথে একে অপরকে সংযুক্ত সেলগুলিতে যেতে পারেন,
    অর্থাৎ, আপনি এমন সেলগুলিতে যেতে পারবেন যা আপনার বর্তমান সেলের সাথে একটি প্রান্ত ভাগ করে।
    দয়া করে লক্ষ্য করুন যে k দৈর্ঘ্যের একটি পথ মানে ঠিক k সেল পরিদর্শন করা (অবশ্যই আলাদা না হতে পারে)।
    আপনি গ্রিডের বাইরে যেতে পারবেন না।

    একটি পথ A (k দৈর্ঘ্যের) একটি পথ B (k দৈর্ঘ্যের) এর তুলনায় ছোট বলে গণ্য হয় যদি
    A এবং B যেসব সেলগুলির মাধ্যমে যাচ্ছে তাদের মানের সাজানো তালিকা তৈরি করার পর (তাদের lst_A এবং lst_B বলুন),
    lst_A লেক্সিকোগ্রাফিক্যালভাবে lst_B এর চেয়ে ছোট হয়, অর্থাৎ, এমন একটি পূর্ণসংখ্যার সূচক i (1 <= i <= k) থাকবে
    যেখানে lst_A[i] < lst_B[i] এবং যেকোন j (1 <= j < i) এর জন্য lst_A[j] = lst_B[j]।

    এটি নিশ্চিত করা হয়েছে যে উত্তরটি একক হবে।

    আপনি যেসব সেলগুলির মাধ্যমে ন্যূনতম পথ যাবে তার মানগুলির একটি সাজানো তালিকা ফেরত দিন।

    উদাহরণ:

        ইনপুট: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        আউটপুট: [1, 2, 1]

        ইনপুট: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        আউটপুট: [1]
    """


def tri(n):
    """প্রত্যেকেই ফিবোনাচ্চি ক্রম জানে, যা শতাব্দী ধরে গণিতবিদদের দ্বারা গভীরভাবে অধ্যয়ন করা হয়েছে
    কিন্তু যা মানুষ জানে না তা হল ট্রিবোনাচ্চি ক্রম
    ট্রিবোনাচ্চি ক্রম নিম্নলিখিতভাবে পুনরাবৃত্তি দ্বারা সংজ্ঞায়িত করা হয়:
    tri(1) = 3
    tri(n) = 1 + n / 2, যখন n একটি জোড় সংখ্যা
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), যখন n একটি বিজোড় সংখ্যা
    উদাহরণস্বরূপ:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    একটি অ-ঋণাত্মক পূর্ণসংখ্যা n দেওয়া হলে, এটি n + 1 এর আগে ট্রিবোনাচ্চি ক্রম একটি তালিকা আকারে প্রদান করা উচিত
    উদাহরণ:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """ফিবোনাচি ধারার কথা সবাই জানে, গত কয়েক শতকে গণিতবিদরা এটি
    নিয়ে ব্যাপক গবেষণা করেছেন। তবে মানুষ ট্রিবোনাচি ধারার কথা জানে না।
    ট্রিবোনাচি ধারা বোঝা যায় পুনরাবৃত্তির এই নিয়মে:
    tri(1) = 3
    tri(n) = 1 + n / 2, n জোড় হলে।
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), n বেজোড় হলে।
    যেমন:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    তোমাকে n নামের একটি অঋণাত্মক পূর্ণসংখ্যা দেওয়া হয়েছে, তোমাকে ট্রিবোনাচি
    ধারার প্রথম n + 1 সংখ্যক সংখ্যা লিস্ট আকারে ফেরত দিতে হবে।
    উদাহরণ:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """সকলেই ফিবোনাচি সিকোয়েন্স সম্পর্কে জানেন, এটি গত কয়েক শতাব্দীতে গণিতবিদরা গভীরভাবে অধ্যয়ন করেছেন।
    তবে, মানুষ ট্রাইবোনাচি সিকোয়েন্স সম্পর্কে জানে না।
    ট্রাইবোনাচি সিকোয়েন্সকে নিম্নলিখিতভাবে সংজ্ঞায়িত করা হয়েছে:
    tri(1) = 3
    tri(n) = 1 + n / 2, যদি ন একটি জোড় সংখ্যা।
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), যদি ন একটি বিজোড় সংখ্যা
    উদাহরণস্বরূপ:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    আপনাকে একটি ধনাত্মক পূর্ণসংখ্যা n দেওয়া হবে, আপনাকে ট্রাইবোনাচি সিকোয়েন্সের প্রথম n + 1 সংখ্যাগুলির একটি তালিকা ফেরত দিতে হবে।
    উদাহরণ:
    tri(3) = [1, 3, 2, 8]
    """


def digits(n):
    """n নামের একটি ধনাত্মক পূর্ণসংখ্যা দেওয়া আছে, বেজোড় অঙ্কগুলোর গুণফল ফেরত দাও।
    সবকটি অঙ্ক জোড় হলে 0 ফেরত দাও।
    যেমন:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """ ধনাত্মক পূর্ণসংখ্যা n দেওয়া হয়েছে, বিজোড় সংখ্যাগুলির গুণফল প্রদান করুন
    যদি সমস্ত সংখ্যা জোড় হয়, তাহলে 0 দিন
    উদাহরণ:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """


def is_nested(string):
    '''
    একটি ফাংশন তৈরি করুন যা একটি স্ট্রিং গ্রহণ করে যা শুধুমাত্র কোণাকোণি বন্ধনী (square brackets) ধারণ করে।
    ফাংশনটি সত্য (True) ফেরত দিবে যদি এবং শুধুমাত্র যদি সেখানে একটি বৈধ সাবসিকুয়েন্স (subsequence) থাকে
    যেখানে অন্তত একটি বন্ধনী nested (নেস্টেড) রয়েছে।

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

def is_nested(string):
    '''
    একটি ফাংশন তৈরি করুন যা শুধুমাত্র বর্গাকার বন্ধনী নিয়ে গঠিত একটি স্ট্রিং ইনপুট হিসাবে গ্রহণ করে।
    ফাংশনটি শুধুমাত্র তখনই True ফেরত দেবে যদি বন্ধনীর একটি বৈধ অনুক্রম থাকে যেখানে অন্তত 1 জোড়া নেস্টেড বন্ধনী থাকে।

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

def is_nested(string):
    '''
    একটি ফাংশন যা শুধুমাত্র বর্গাকার বন্ধনী নিয়ে গঠিত একটি স্ট্রিং ইনপুট হিসাবে গ্রহণ করে
    ফাংশনটি True রিটার্ন করবে যদি এবং শুধুমাত্র যদি সেখানে একটি বৈধ সাবসিকোয়েন্স থাকে যেখানে
    কমপক্ষে একটি ব্র্যাকেট সাবসিকোয়েন্সে নেস্টেড হয়েছে।

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


def sum_squares(lst):
    """একটি সংখ্যার তালিকা প্রদান কর
    প্রদত্ত তালিকার সংখ্যাগুলির বর্গফলের যোগফল প্রদান করা প্রয়োজন
    প্রথমে, তালিকার প্রতিটি উপাদানকে উপরের পূর্ণসংখ্যায় (ceil) রূপান্তর করুন
    উদাহরণ:
    lst = [1,2,3] ফলাফল হওয়া উচিত 14
    lst = [1,4,9] ফলাফল হওয়া উচিত 98
    lst = [1,3,5,7] ফলাফল হওয়া উচিত 84
    lst = [1.4,4.2,0] ফলাফল হওয়া উচিত 29
    lst = [-2.4,1,1] ফলাফল হওয়া উচিত 6
    """

def sum_squares(lst):
    """আপনাকে একটি সংখ্যার তালিকা দেওয়া হয়েছে।
    আপনাকে দেওয়া তালিকায় সংখ্যাগুলির বর্গফলগুলির যোগফল রিটার্ন করতে হবে,
    প্রথমে তালিকার প্রতিটি উপাদানকে উপরের পূর্ণসংখ্যায় (Ceiling) রাউন্ড করুন।
    উদাহরণ:
    For lst = [1,2,3] ফলাফল হওয়া উচিত 14
    For lst = [1,4,9] ফলাফল হওয়া উচিত 98
    For lst = [1,3,5,7] ফলাফল হওয়া উচিত 84
    For lst = [1.4,4.2,0] ফলাফল হওয়া উচিত 29
    For lst = [-2.4,1,1] ফলাফল হওয়া উচিত 6

    """

def sum_squares(lst):
    """তোমাকে একটি সংখ্যার তালিকা দেওয়া হয়েছে।
    তোমাকে প্রথমে প্রদত্ত তালিকার প্রতিটি উপাদানকে int(Ceiling) দিয়ে ওপরের পূর্ণসংখ্যায়
    পরিণত করে তারপর সংখ্যাগুলোর বর্গের যোগফল ফেরত দিতে হবে।
    উদাহরণ:
    lst = [1,2,3] হলে আউটপুট হবে 14
    lst = [1,4,9] হলে আউটপুট হবে 98
    lst = [1,3,5,7] হলে আউটপুট হবে 84
    lst = [1.4,4.2,0] হলে আউটপুট হবে 29
    lst = [-2.4,1,1] হলে আউটপুট হবে 6

    """


def check_if_last_char_is_a_letter(txt):
    '''
    একটি ফাংশন তৈরি করুন যা একটি প্রদত্ত স্ট্রিংয়ের শেষ চরিত্র
    যদি একটি বর্ণমালা চরিত্র হয় এবং এটি কোন শব্দের অংশ না হয়,
    তবে True রিটার্ন করবে, অন্যথায় False রিটার্ন করবে।
    লক্ষ্য করুন: "শব্দ" হলো এমন একটি চরিত্রের গ্রুপ যা একটি স্পেস দ্বারা আলাদা হয়।

    উদাহরণ:
    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):
    '''
    একটি ফাংশন তৈরি করুন যা True প্রদান করে যদি একটি প্রদত্ত স্ট্রিংয়ের শেষ অক্ষরটি একটি বর্ণানুক্রমিক অক্ষর হয়
    এবং একটি শব্দের অংশ না হয় এবং অন্যথায় False প্রদান করে।
    নোট: "শব্দ" হল অক্ষরের একটি গুচ্ছ যা ফাঁকা স্থান দ্বারা পৃথক করা হয়।

    উদাহরণঃ
    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):
    '''
    একটি ফাংশন যা True প্রদান করে যদি প্রদত্ত স্ট্রিংয়ের শেষ অক্ষরটি একটি অক্ষর হয়
    এবং শব্দের অংশ না হয়। অন্যথায়, False প্রদান করে।
    মনে রাখবেন: "শব্দ" হল অক্ষরের একটি গুচ্ছ যা ফাঁকা স্থান দ্বারা পৃথক করা হয়।

    উদাহরণ:
    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):
    """এমন একটি ফাংশন তৈরি কর যা আগের উপাদানটির চেয়ে বড় বা সেটির
    সমান নয় এমন উপাদানের সর্বোচ্চ ইনডেক্স ফেরত দেবে। এমন কোনো উপাদান
    না থাকলে -1 ফেরত দাও। প্রদত্ত অ্যারেতে একই মান একাধিকবার থাকবে না।

    উদাহরণ:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """একটি ফাংশন তৈরি করুন যা একটি উপাদানের বৃহত্তম ইনডেক্স ফিরিয়ে দেয়,
    যা তার আগের উপাদানটির চেয়ে ছোট বা সমান নয়। যদি এমন কোন উপাদান না থাকে,
    তবে -1 ফেরত দিন। প্রদত্ত অ্যারেটিতে কোন ডুপ্লিকেট মান থাকবে না।

    উদাহরণ:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """একটি ফাংশন তৈরি করুন যা সর্বোচ্চ সূচক ফেরত দেয় যেখানে উপাদানটি পূর্ববর্তী উপাদানের চেয়ে বড় নয়
    যদি এমন কোন উপাদান না থাকে, তাহলে -1 প্রদান করুন। প্রদত্ত ক্রমে কোন সদৃশ মান থাকবে না।

    উদাহরণ:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """


def largest_smallest_integers(lst):
    '''
    একটি ফাংশন তৈরি করুন যা একটি ট্যুপল (a, b) রিটার্ন করে, যেখানে 'a' হল ঋণাত্মক পূর্ণসংখ্যাগুলির মধ্যে সর্বাধিক এবং 'b' হল ধনাত্মক পূর্ণসংখ্যাগুলির মধ্যে সর্বনিম্ন।
    যদি কোনো ঋণাত্মক বা ধনাত্মক পূর্ণসংখ্যা না থাকে, তাহলে সেগুলি None হিসেবে রিটার্ন করুন।

    উদাহরণ:
    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):
    '''
    এমন একটি ফাংশন তৈরি কর যা থেকে এমন একটি টুপল (a, b)
    পাওয়া যাবে যেখানে 'a' হবে একটি লিস্টের বৃহত্তম ঋণাত্মক পূর্ণসংখ্যা
    ও 'b' হবে লিস্টটির ক্ষুদ্রতম ধনাত্মক পূর্ণসংখ্যা।
    ধনাত্মক বা ঋণাত্মক কোনো পূর্ণসংখ্যাই না পাওয়া গেলে প্রতিটির ক্ষেত্রে
    None ফেরত দাও।

    উদাহরণ:
    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):
    '''
    একটি ফাংশন যা একটি টিপল (a, b) প্রদান করে যেখানে 'a' হল তালিকার বৃহত্তম ঋণাত্মক সংখ্যা
    এবং 'b' হল তালিকার ক্ষুদ্রতম ধনাত্মক সংখ্যা।
    যদি কোন ঋণাত্মক বা ধনাত্মক সংখ্যা না থাকে, তাহলে None হবে

    উদাহরণ:
    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):
    """
    একটি ফাংশন তৈরি করুন যা পূর্ণসংখ্যা, দশমিক সংখ্যা, অথবা স্ট্রিং (যা বাস্তব সংখ্যা প্রতিনিধিত্ব করে) গ্রহণ করে এবং প্রদত্ত ভেরিয়েবল টাইপে বড় মানটি রিটার্ন করবে।
    যদি মান দুটি সমান হয়, তাহলে None রিটার্ন করুন।
    মনে রাখবেন: যদি প্রকৃত সংখ্যা স্ট্রিং হিসাবে উপস্থাপিত হয়, দশমিক বিন্দু . বা , হতে পারে,

    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 compare_one(a, b):
    """
    পূর্ণসংখ্যা, দশমিক সংখ্যা, বা প্রকৃত সংখ্যা উপস্থাপনকারী স্ট্রিং হিসাবে মান পরীক্ষা করুন
    একটি ফাংশন তৈরি করুন যা প্রদত্ত প্যারামিটারের ধরন অনুযায়ী বৃহত্তম মানের প্যারামিটারটি প্রদান করে
    যদি মান সমান হয়, তাহলে None দিন
    মনে রাখবেন: যদি প্রকৃত সংখ্যা স্ট্রিং হিসাবে উপস্থাপিত হয়, দশমিক বিন্দু . বা , হতে পারে

    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 compare_one(a, b):
    """
    একটি ফাংশন তৈরি করুন যা পূর্ণসংখ্যা, দশমিক সংখ্যা বা স্ট্রিং (যেগুলি বাস্তব সংখ্যা হিসাবে উপস্থাপিত) গ্রহণ করে,
    এবং তার দেওয়া ধরণে বড় মানটি ফেরত দেয়।
    যদি মানগুলি সমান হয় তবে None ফেরত দিন।
    লক্ষ্য: যদি কোনো বাস্তব সংখ্যা স্ট্রিং হিসেবে উপস্থাপিত হয়, তবে দশমিক চিহ্নটি . অথবা , হতে পারে।

    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):
    """প্রদত্ত সংখ্যা n ঠিক 4টি ধনাত্মক জোড় সংখ্যার যোগফল হিসাবে লেখা যায় কিনা তা মূল্যায়ন করুন
    উদাহরণ
    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):
    """মূল্যায়ন করুন যে প্রদত্ত সংখ্যা n কে কি ঠিক ৪টি ধনাত্মক এবং সোজা সংখ্যা যোগফল হিসেবে লেখা যায় কিনা।

    উদাহরণ:
    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):
    """মূল্যায়ন কর যে প্রদত্ত সংখ্যা n কি ৪টি ধনাত্মক জোড় সংখ্যার সমষ্টি হিসাবে উপস্থাপন করা যেতে পারে
    উদাহরণ
    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):
    """ব্রাজিলীয় ফ্যাক্টোরিয়াল নিম্নরূপে সংজ্ঞায়িত করা হয়ঃ
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    যেখানে n > 0

    উদাহরণঃ
    >>> special_factorial(4)
    288

    এই ফাংশনটি ইনপুট হিসাবে একটি পূর্ণসংখ্যা গ্রহণ করবে এবং এই পূর্ণসংখ্যার বিশেষ ফ্যাক্টোরিয়াল ফেরত দেবে।
    """

def special_factorial(n):
    """বিশেষ ফ্যাক্টোরিয়াল নিম্নরূপে সংজ্ঞায়িত করা হয়:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    যেখানে n > 0

    উদাহরণ:
    >>> special_factorial(4)
    288

    এই ফাংশনটি একটি পূর্ণসংখ্যা ইনপুট হিসাবে গ্রহণ করা উচিত এবং এই পূর্ণসংখ্যার বিশেষ ফ্যাক্টোরিয়াল প্রদান করা উচিত
    """

def special_factorial(n):
    """ব্রাজিলিয়ান ফ্যাক্টোরিয়াল এইভাবে সংজ্ঞায়িত করা হয়েছে:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    where n > 0

    উদাহরণ:
    >>> special_factorial(4)
    288

    ফাংশনটি একটি পূর্ণসংখ্যা ইনপুট হিসাবে নিবে এবং এই পূর্ণসংখ্যার
    বিশেষ ফ্যাক্টোরিয়াল ফেরত দেবে।
    """


def fix_spaces(text):
    """
    একটি স্ট্রিং text দেওয়া হলে, তার সমস্ত স্পেসকে আন্ডারস্কোরে (_) প্রতিস্থাপন করুন,
    এবং যদি স্ট্রিংয়ের মধ্যে ২টির বেশি পরপর স্পেস থাকে, তবে সমস্ত পরপর স্পেসকে ড্যাশ (-) দিয়ে প্রতিস্থাপন করুন।

    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):
    """
    একটি স্ট্রিং text দেওয়া হলে, এতে থাকা সব স্পেসগুলোকে আন্ডারস্কোর দিয়ে প্রতিস্থাপন করুন,
    এবং যদি কোন স্ট্রিংয়ে ২টির বেশি ধারাবাহিক স্পেস থাকে,
    তবে সব ধারাবাহিক স্পেসগুলোকে - দিয়ে প্রতিস্থাপন করুন।

    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):
    """
    একটি স্ট্রিং text গ্রহণ করে, সমস্ত ফাঁকা স্থানগুলি আন্ডারস্কোর দিয়ে প্রতিস্থাপন করে
    যদি স্ট্রিংয়ে পরপর দুটি বা তার বেশি ফাঁকা স্থান থাকে
    সমস্ত পরপর ফাঁকা স্থানগুলি - দিয়ে প্রতিস্থাপন করে

    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):
    """একটি ফাংশন তৈরি করুন যা একটি স্ট্রিং নেয়, যা একটি ফাইলের নামের প্রতিনিধিত্ব করে, এবং যদি ফাইলের নাম বৈধ হয় তবে 'Yes' এবং অন্যথায় 'No' রিটার্ন করে।
    একটি ফাইলের নাম বৈধ হবে যদি এবং কেবল যদি সমস্ত নিম্নলিখিত শর্ত পূর্ণ হয়:
    - ফাইলের নামের মধ্যে তিনটির বেশি ডিজিট ('0'-'9') থাকা উচিত নয়।
    - ফাইলের নামের মধ্যে একটাই ডট ('.') থাকা উচিত।
    - ডটের আগে উপস্ট্রিংটি খালি না হওয়া উচিত এবং এটি ল্যাটিন বর্ণমালার একটি অক্ষর দিয়ে শুরু হওয়া উচিত ('a'-'z' এবং 'A'-'Z')।
    - ডটের পরবর্তী উপস্ট্রিংটি ['txt', 'exe', 'dll'] এর মধ্যে একটি হতে হবে।
    উদাহরণ:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (নামটি একটি ল্যাটিন বর্ণমালা অক্ষর দিয়ে শুরু হওয়া উচিত)
    """

def file_name_check(file_name):
    """একটি স্ট্রিং দ্বারা উপস্থাপিত ফাইলের নাম পরীক্ষা করুন এবং একটি ফাংশন তৈরি করুন যা 'Yes'
    হবে যদি ফাইলের নামটি সঠিক হয়, এবং 'No' হবে যদি তা না হয়।
    ফাইলের নামটি সঠিক বলে বিবেচিত হবে যদি নিম্নলিখিত সমস্ত শর্ত সত্য হয়:
    - ফাইলের নামের মধ্যে উপস্থিত সংখ্যা ('0'-'9') 3 এর বেশি হওয়া উচিত নয়
    - ফাইলের নামের মধ্যে একটি মাত্র ডট '.' থাকতে হবে
    - ডটের আগে অংশটি খালি হওয়া উচিত নয় এবং এটি একটি লাতিন অক্ষর ('a'-'z' এবং 'A'-'Z') দিয়ে শুরু হতে হবে
    - ডটের পরে অংশটি নিম্নলিখিতগুলির মধ্যে একটি হতে হবে: ['txt', 'exe', 'dll']
    উদাহরণ:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (নামটি একটি লাতিন অক্ষর দিয়ে শুরু হওয়া উচিত)
    """

def file_name_check(file_name):
    """একটি ফাংশন তৈরি করুন যা একটি স্ট্রিং নিয়ে ফাইলের নামের প্রতিনিধিত্ব করে, এবং যদি ফাইলের নাম বৈধ হয় তবে
    'Yes' রিটার্ন করবে, এবং অন্যথায় 'No' রিটার্ন করবে।
    একটি ফাইলের নামকে বৈধ হিসেবে ধরা হবে যদি এবং শুধুমাত্র যদি নিম্নলিখিত সমস্ত শর্ত পূর্ণ হয়:
    - ফাইলের নামের মধ্যে তিনটি বা তার বেশি ডিজিট ('0'-'9') থাকা উচিত নয়।
    - ফাইলের নামের মধ্যে একটিই ডট '.' থাকতে হবে।
    - ডটের আগে সাবস্ট্রিংটি খালি থাকা উচিত নয়, এবং এটি একটি ল্যাটিন বর্ণমালার ( 'a'-'z' এবং 'A'-'Z' ) বর্ণ দিয়ে শুরু হতে হবে।
    - ডটের পরের সাবস্ট্রিংটি এইগুলির মধ্যে একটি হওয়া উচিত: ['txt', 'exe', 'dll']
    উদাহরণ:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (নামটি একটি লাতিন অক্ষর দিয়ে শুরু হওয়া উচিত)
    """


def sum_squares(lst):
    """"
    এই ফাংশনটি একটি পূর্ণসংখ্যার তালিকা নেবে। তালিকার প্রতিটি উপাদান জন্য, যদি তার সূচক ৩ এর গুণ হয়, তাহলে ফাংশনটি সেই উপাদানটিকে বর্গ করবে; এবং যদি তার সূচক ৪ এর গুণ হয় কিন্তু ৩ এর গুণ না হয়, তাহলে ফাংশনটি সেই উপাদানটিকে ঘন করবে। ফাংশনটি এমন উপাদানগুলিকে পরিবর্তন করবে না, যাদের সূচক ৩ বা ৪ এর গুণ নয়। এরপর, ফাংশনটি সমস্ত উপাদানের যোগফল ফিরিয়ে দেবে।

    উদাহরণ:
    lst = [1,2,3] হলে আউটপুট হবে ৬
    lst = [] হলে আউটপুট হবে ০
    lst = [-1,-5,2,-1,-5] হলে আউটপুট হবে -১২৬
    """

def sum_squares(lst):
    """
    এই ফাংশনটি পূর্ণসংখ্যার একটি তালিকা গ্রহণ করে। তালিকার প্রতিটি উপাদানের জন্য, যদি সূচকটি 3 এর গুণিতক হয়, তবে সেই উপাদানটি বর্গ করা হবে এবং
    যদি সূচকটি 4 এর গুণিতক হয় কিন্তু 3 এর গুণিতক না হয় তবে সেই উপাদানটি ঘন করা হবে। উপাদানগুলি যা 3 বা 4 এর গুণিতক নয় সেগুলি অপরিবর্তিত থাকবে।
    তারপর এটি সমস্ত উপাদানের যোগফল ফেরত দেবে।

    উদাহরণঃ
    lst = [1,2,3] এর জন্য ফলাফল হবে 6
    lst = [] এর জন্য ফলাফল হবে 0
    lst = [-1,-5,2,-1,-5] এর জন্য ফলাফল হবে -126
    """

def sum_squares(lst):
    """"
    এই ফাংশনটি একটি পূর্ণসংখ্যার তালিকা গ্রহণ করবে। তালিকার সব এন্ট্রির জন্য, ফাংশনটি তার ইনডেক্স যদি ৩-এর গুণিতক হয় তবে
    পূর্ণসংখ্যাটি বর্গ করে দেবে এবং যদি ইনডেক্স ৪-এর গুণিতক হয় এবং ৩-এর গুণিতক না হয় তবে পূর্ণসংখ্যাটি ঘন করবে। ফাংশনটি তালিকার এমন এন্ট্রিগুলি পরিবর্তন করবে না
    যেগুলির ইনডেক্স ৩ অথবা ৪-এর গুণিতক নয়। তারপর ফাংশনটি সব এন্ট্রির যোগফল রিটার্ন করবে।

    উদাহরণ:
    যদি lst = [1,2,3] হয় তবে ফলাফল হবে 6
    যদি lst = []  হয় তবে ফলাফল হবে 0
    যদি lst = [-1,-5,2,-1,-5]  হয় তবে ফলাফল হবে -126
    """


def words_in_sentence(sentence):
    """
    আপনাকে একটি স্ট্রিং দেওয়া হয়েছে যা একটি বাক্য নির্দেশ করে,
    বাক্যটি কিছু শব্দ ধারণ করে যা স্পেস দ্বারা আলাদা করা হয়েছে,
    এবং আপনাকে একটি স্ট্রিং রিটার্ন করতে হবে যা মূল বাক্যের সেই সমস্ত শব্দ ধারণ করবে,
    যাদের দৈর্ঘ্য একটি মৌলিক সংখ্যা,
    নতুন স্ট্রিং-এ শব্দগুলির ক্রম মূল বাক্যের মতোই থাকতে হবে।

    উদাহরণ 1:
        ইনপুট: sentence = "This is a test"
        আউটপুট: "is"

    উদাহরণ 2:
        ইনপুট: sentence = "lets go for swimming"
        আউটপুট: "go for"

    সীমাবদ্ধতা:
        * 1 <= len(sentence) <= 100
        * বাক্যে শুধুমাত্র অক্ষর থাকবে
    """

def words_in_sentence(sentence):
    """
    আপনাকে একটি বাক্য প্রতিনিধিত্বকারী একটি স্ট্রিং দেওয়া হয়েছে,
    বাক্যটিতে খালি স্থান দ্বারা বিভক্ত কিছু শব্দ রয়েছে,
    এবং আপনাকে মূল বাক্যের যেসব শব্দের দৈর্ঘ্য মৌলিক সংখ্যা সেসব শব্দের একটি স্ট্রিং ফিরিয়ে দিতে হবে,
    নতুন স্ট্রিংয়ে শব্দগুলির ক্রম মূল স্ট্রিংয়ে মতো হতে হবে।

    উদাহরণ ১ঃ
        Input: sentence = "This is a test"
        Output: "is"

    উদাহরণ ২ঃ
        Input: sentence = "lets go for swimming"
        Output: "go for"

    সীমাবদ্ধতাঃ
        * 1 <= len(sentence) <= 100
        * বাক্যটিতে শুধুমাত্র অক্ষর রয়েছে
    """

def words_in_sentence(sentence):
    """
    তোমাকে এমন একটি স্ট্রিং দেওয়া হয়েছে যা দিয়ে একটি বাক্য বোঝায়,
    বাক্যটিতে স্পেস দিয়ে দিয়ে কিছু শব্দ দেওয়া আছে,
    তোমাকে এমন একটি স্ট্রিং ফেরত দিতে হবে যাতে আদি বাক্যটির এমন সব শব্দ থাকবে
    যেগুলোর দৈর্ঘ্য এক একটি মৌলিক সংখ্যা,
    নতুন স্ট্রিংয়ের শব্দগুলোর ক্রম আদি স্ট্রিংটির মতোই হতে হবে।

    উদাহরণ ১:
        ইনপুট: sentence = "This is a test"
        আউটপুট: "is"

    উদাহরণ ২:
        ইনপুট: sentence = "lets go for swimming"
        আউটপুট: "go for"

    শর্ত:
        * 1 <= len(sentence) <= 100
        * sentence-এ শুধু বর্ণ থাকবে
    """


def simplify(x, n):
    """আপনার কাজ হলো একটি ফাংশন বাস্তবায়ন করা যা x * n এক্সপ্রেশনটি সরলীকৃত করবে।
    ফাংশনটি True রিটার্ন করবে যদি x * n একটি পূর্ণসংখ্যা হয় এবং False
    অন্যথায়। x এবং n উভয়ই একটি ভগ্নাংশের স্ট্রিং রূপ, এবং তাদের নিম্নলিখিত ফরম্যাট রয়েছে,
    <গণক>/<ভাগফল> যেখানে গণক এবং ভাগফল উভয়ই ধনাত্মক পূর্ণসংখ্যা।

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

def simplify(x, n):
    """আপনার কাজ হল একটি ফাংশন তৈরি করা যা সমীকরণ x * n সহজ করে।
    ফাংশনটি True ফেরত দেবে যদি x * n একটি পূর্ণ সংখ্যা নির্ণয় করে এবং অন্যথায় False ফেরত দেবে।
    x এবং n উভয়ই হল স্ট্রিং ফর্ম্যাটে ভগ্নাংশের উপস্থাপনা, এবং এগুলি নিম্নলিখিত ফর্ম্যাটে থাকে
    <উপরের অংশ>/<নিচের অংশ> যেখানে উপরের অংশ এবং নিচের অংশ উভয়ই ধনাত্মক পূর্ণ সংখ্যা।

    আপনি ধরে নিতে পারেন যে x এবং n হল বৈধ ভগ্নাংশ এবং নিচের অংশ শূন্য নয়।

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

def simplify(x, n):
    """আপনার কাজ হল একটি ফাংশন বাস্তবায়ন করা যা এক্সপ্রেশনটি সরল করবে
    x * n। ফাংশনটি True ফেরত দেবে যদি x * n একটি পূর্ণসংখ্যায় পরিণত হয় এবং False
    অন্যথায়। x এবং n, উভয়ই একটি ভগ্নাংশের স্ট্রিং রূপ, এবং উভয়টির ফরম্যাট হবে,
    <মুল্য>/<হিসাব> যেখানে মুল্য এবং হিসাব উভয়ই ধনাত্মক পূর্ণসংখ্যা।

    আপনি ধরে নিতে পারেন যে x এবং n বৈধ ভগ্নাংশ, এবং তাদের হিশাবের মান শূন্য নয়।

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


def order_by_points(nums):
    """
    একটি ফাংশন লিখুন যা দেওয়া সংখ্যার তালিকাকে
    তাদের অঙ্কগুলোর যোগফলের উপর ভিত্তি করে ক্রমবর্ধমান ক্রমে সাজাবে।
    নোট: যদি একাধিক সংখ্যার অঙ্কগুলোর যোগফল সমান হয়,
    সেক্ষেত্রে তাদের মূল তালিকার সূচকের ক্রমানুসারে সাজান।

    উদাহরণস্বরূপ:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    এমন একটি ফাংশন লিখুন যা প্রদত্ত পূর্ণসংখ্যার তালিকাকে ডিজিটের যোগফলের উপর ভিত্তি করে ছোট থেকে বড় ক্রমে সাজায়।
    নোট: যদি একাধিক তালিকা থাকে যাদের ডিজিটের যোগফল সমান, তাহলে তাদেরকে মূল তালিকার সূচকের ক্রমানুসারে সাজায়।

    উদাহরণঃ
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    এমন একটি ফাংশন লিখুন যা প্রদত্ত পূর্ণসংখ্যার তালিকাকে ছোট থেকে বড় ক্রমে সাজাও সংখ্যার যোগফলের উপর ভিত্তি করে
    নোট: যদি একাধিক তালিকা থাকে যাদের সংখ্যার যোগফল সমান, তাহলে তাদের মূল তালিকার সূচকের ক্রমে সাজাও

    উদাহরণ:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """


def specialFilter(nums):
    """একটি ফাংশন লিখুন যা একটি সংখ্যার অ্যারের ইনপুট গ্রহণ করে এবং
    অ্যারেতে থাকা সেই উপাদানগুলোর সংখ্যা ফেরত দেয়, যা ১০ এর বেশি
    এবং সংখ্যাটির প্রথম এবং শেষ অঙ্ক উভয়ই বিজোড় (1, 3, 5, 7, 9)।
    উদাহরণস্বরূপ:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """এমন একটি ফাংশন লেখ যা সংখ্যার একটি অ্যারেকে ইনপুট হিসাবে নেয়
    এবং অ্যারেটির যেসব উপাদানের মান 10-এর চেয়ে বড় এবং প্রথম ও শেষ
    দুটি অঙ্কই বেজোড় (1, 3, 5, 7, 9) সেগুলোর সংখ্যা ফেরত দেয়।
    যেমন:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """একটি ফাংশন লিখুন যা ইনপুট হিসাবে সংখ্যার একটি অ্যারে নেয় এবং অ্যারের উপাদান হিসাবে 10 এর থেকে বড় সংখ্যা প্রদান করে এবং
    একটি সংখ্যার প্রথম এবং শেষ উভয় সংখ্যাই বিজোড় (1, 3, 5, 7, 9)।
    উদাহরণস্বরূপঃ
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """


def get_max_triples(n):
    """
    আপনাকে একটি ধনাত্মক পূর্ণসংখ্যা n দেওয়া হয়েছে। আপনাকে দৈর্ঘ্য n এর একটি পূর্ণসংখ্যার অ্যারে a তৈরি করতে হবে।
        প্রতিটি i (1 ≤ i ≤ n) এর জন্য, a[i] = i * i - i + 1 হবে।
        তারপর, আপনি এমন triples (a[i], a[j], a[k]) এর সংখ্যা ফেরত দেবেন যেখানে i < j < k,
    এবং a[i] + a[j] + a[k] ৩ এর গুণিতক।

    উদাহরণ:
        ইনপুট: n = 5
        আউটপুট: 1
        ব্যাখ্যা:
        a = [1, 3, 7, 13, 21]
        একমাত্র বৈধ triple হল (1, 7, 13)।
    """

def get_max_triples(n):
    """
    আপনাকে একটি ধনাত্মক পূর্ণসংখ্যা n দেওয়া আছে। আপনাকে n দৈর্ঘ্যের একটি পূর্ণসংখ্যার অ্যারে a তৈরি করতে হবে
        প্রতিটি i (1 ≤ i ≤ n) এর জন্য a[i] এর মান হল a[i]=i * i - i + 1
        (a[i], a[j], a[k]) এর ত্রিগুণের সংখ্যা ফেরত দিন
    যেখানে i < j < k, এবং a[i] + a[j] + a[k] হল 3 এর গুণিতক

    উদাহরণঃ
        Input: n = 5
        Output: 1
        ব্যাখ্যাঃ
        a = [1, 3, 7, 13, 21]
        একমাত্র বৈধ ট্রিপল হল (1, 7, 13)
    """

def get_max_triples(n):
    """
    যদি n একটি ধনাত্মক পূর্ণসংখ্যা হয়, তবে আপনাকে n দৈর্ঘ্যের একটি পূর্ণসংখ্যার অ্যারে a তৈরি করতে হবে
        প্রতিটি i (1 ≤ i ≤ n) এর জন্য a[i] এর মান হল i * i - i + 1
        যখন i < j < k সেট তিনটির সংখ্যা (a[i], a[j], a[k]) অ্যারেতে
    যেখানে a[i] + a[j] + a[k] হল 3 এর গুণিতক

    উদাহরণ:
        ইনপুট: n = 5
        আউটপুট: 1
        ব্যাখ্যা:
        a = [1, 3, 7, 13, 21]
        একমাত্র সঠিক তিনটি সেট হল (1, 7, 13)
    """


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 এর কক্ষপথের মধ্যে থাকা সমস্ত গ্রহকে অন্তর্ভুক্ত করবে,
    সূর্যের সাথে নিকটতার ক্রমানুসারে সাজানো।
    যদি planet1  বা planet2 সঠিক গ্রহের নাম না হয় তবে ফাংশনটি একটি খালি টাপল প্রদান করবে।
    উদাহরণ
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    আমাদের সৌরজগতে মোট আটটি গ্রহ রয়েছে: সূরের সবচেয়ে কাছে Mercury,
    তারপরে Venus, তারপর Earth, Mars, Jupiter, Saturn, Uranus, Neptune।
    একটি ফাংশন লিখুন যা planet1 এবং planet2 নামে দুটি গ্রহের নাম স্ট্রিং হিসাবে গ্রহণ করে।
    ফাংশনটি একটি tuple ফেরত দেবে যেখানে এমন সব গ্রহ থাকবে যাদের কক্ষপথ
    planet1 এবং planet2-এর কক্ষপথের মধ্যবর্তী স্থানে অবস্থিত, এবং
    সূরের নিকটতার ক্রমানুসারে সাজানো থাকবে।
    ফাংশনটি একটি ফাঁকা tuple ফেরত দেবে যদি planet1 বা planet2
    সঠিক গ্রহের নাম না হয়।
    উদাহরণ
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''


def sorted_list_sum(lst):
    """একটি ফাংশন লিখুন যা একটি স্ট্রিং-এর তালিকা প্যারামিটার হিসেবে গ্রহণ করে,
    এবং সেই তালিকা থেকে যেসব স্ট্রিংয়ের দৈর্ঘ্য বেজোড় (odd) সেগুলো মুছে ফেলে,
    তারপর যে তালিকাটি অবশিষ্ট থাকে তা ফেরত দেয়, সেটি সাজানো অবস্থায়।
    তালিকাটি সর্বদা স্ট্রিং-এর তালিকা হবে এবং কখনও সংখ্যা যুক্ত অ্যারে হবে না,
    এবং এতে ডুপ্লিকেট থাকতে পারে।
    তালিকাটি শব্দের দৈর্ঘ্যের ভিত্তিতে ঊর্ধ্বমুখীভাবে সাজানো উচিত,
    এবং আপনাকে সেই নিয়মে তালিকাটি সাজিয়ে ফিরিয়ে দিতে হবে।
    যদি দুটি শব্দের দৈর্ঘ্য সমান হয়, তবে তালিকাটি বর্ণানুক্রমিকভাবে সাজানো উচিত।
    ফাংশনটি স্ট্রিং-এর একটি সাজানো তালিকা ফেরত দেবে।
    আপনি অনুমান করতে পারেন যে সব শব্দের দৈর্ঘ্য সমান হবে।
    উদাহরণস্বরূপ:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
        """একটি ফাংশন লিখুন যা একটি স্ট্রিংয়ের তালিকা প্যারামিটার হিসেবে গ্রহণ করে,
    এবং যে স্ট্রিংগুলোর অজগLength সংখ্যা রয়েছে তা মুছে দেয়,
    এবং ফলস্বরূপ তালিকাটি একটি সাজানো অবস্থায় ফেরত দেয়,
    তালিকাটি সবসময় স্ট্রিংয়ের তালিকা এবং কখনও সংখ্যার অ্যারে নয়,
    এবং এটি ডুপ্লিকেট থাকতে পারে।
    তালিকার আদেশ প্রতিটি শব্দের দৈর্ঘ্য অনুযায়ী বাড়ানো উচিত, এবং আপনি
    সেই নিয়ম অনুযায়ী সাজানো তালিকাটি ফেরত দেবেন।
    যদি দুটি শব্দ একই দৈর্ঘ্যের হয়, তবে তালিকাটি আলফাবেটিক্যালভাবে সাজান।
    ফাংশনটি একটি সাজানো স্ট্রিংয়ের তালিকা ফেরত দিতে হবে।
    আপনি ধারণা করতে পারেন যে সব শব্দের দৈর্ঘ্য একই হবে।
    উদাহরণস্বরূপ:
    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):
    """এটি একটি সাধারণ প্রোগ্রাম যা x এর মান ফেরত দেবে যদি n
    একটি মৌলিক সংখ্যা হয় এবং অন্যথায় y এর মান ফেরত দেবে।

    উদাহরণ:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """ একটি সিম্পল প্রোগ্রাম যা n যদি একটি মৌলিক সংখ্যা হয়, তবে x এর মান ফেরত দেবে এবং অন্যথায় y এর মান ফেরত দেবে।

    উদাহরণ:
    x_or_y(7, 34, 12) == 34
    x_or_y(15, 8, 5) == 5
    """