from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ দেওয়া সংখ্যাগুলির তালিকায় কোনো দুটি সংখ্যা একটি নির্দিষ্ট থ্রেশোল্ডের চেয়ে কাছাকাছি কিনা তা পরীক্ষা করুন।
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ প্রদত্ত সংখ্যার তালিকায় দুটি সংখ্যা আছে কিনা তা পরীক্ষা করুন যা নির্ধারিত প্রান্তিক মানের চেয়ে কাছাকাছি
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ প্রদত্ত সংখ্যার তালিকায় এমন দুটি সংখ্যা আছে কি না দেখ যেগুলোর
    মধ্যবর্তী পার্থক্য প্রদত্ত সীমার চেয়ে কম।
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """


from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ এই ফাংশনের ইনপুট হল এমন একটি স্ট্রিং যাতে নেস্টেড অবস্থায় থাকা বন্ধনীর কয়েকটি গ্রুপ
    আছে। তোমার লক্ষ্য হল এই গ্রুপগুলোকে আলাদা স্ট্রিংয়ে নিয়ে সেগুলোকে লিস্ট আকারে ফেরত দেওয়া।
    আলাদা গ্রুপগুলোর ভারসাম্য বজায় থাকবে (প্রতিটি আরম্ভসূচক বন্ধনীর জন্য একটি করে সমাপ্তিসূচক
    বন্ধনী থাকবে) এবং সেগুলো একটি আরেকটির ভেতর নেস্টেড হবে না।
    ইনপুটে স্পেস থাকলে অগ্রাহ্য কর।
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ এই ফাংশনটি একটি স্ট্রিং গ্রহণ করে যা অনেকগুলি সুষম বন্ধনীর গ্রুপ ধারণ করে। লক্ষ্য হল এই গ্রুপগুলোকে
    আলাদা স্ট্রিংয়ে বিভক্ত করা এবং সেই স্ট্রিংগুলোর একটি তালিকা হিসেবে দেখানো।
    আলাদা করা গ্রুপগুলো সুষম হবে (প্রতিটি খোলা বন্ধনী যথাযথভাবে বন্ধ হবে) এবং অগোছালো থাকবে।
    ইনপুট স্ট্রিংয়ের ফাঁকা স্থান উপেক্ষা করুন।
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """এই ফাংশনের ইনপুট একটি স্ট্রিং যা একাধিক গ্রুপের নেস্টেড প্যারেন্টেসিস ধারণ করে।
    আপনার লক্ষ্য হল এই গ্রুপগুলো আলাদা আলাদা স্ট্রিংয়ে বিভক্ত করা এবং তাদের একটি তালিকা রিটার্ন করা।
    আলাদা আলাদা গ্রুপগুলি সুষম (প্রতিটি ওপেন ব্রেস সঠিকভাবে বন্ধ করা হয়েছে) এবং একে অপরের মধ্যে নেস্টেড নয়।
    ইনপুট স্ট্রিংয়ের মধ্যে কোনও স্পেস উপেক্ষা করুন।
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """


def truncate_number(number: float) -> float:
    """ একটি ধনাত্মক দশমিক সংখ্যা দেওয়া আছে, যা একটি পূর্ণসংখ্যা অংশে
    (প্রদত্ত সংখ্যার চেয়ে ছোট বৃহত্তম পূর্ণসংখ্যা) এবং দশমিক অংশে
    (অবশিষ্ট অংশ যা সর্বদা 1 এর চেয়ে ছোট) বিভক্ত করা যেতে পারে।

    সংখ্যার দশমিক অংশ ফেরত দিন
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ একটি ধনাত্মক দশমিক সংখ্যা দেওয়া হয়েছে, যা একটি পূর্ণসংখ্যা অংশে বিভক্ত করা যেতে পারে
    (প্রদত্ত সংখ্যার চেয়ে ছোট বৃহত্তম পূর্ণসংখ্যা) এবং দশমিক অংশে
    (অবশিষ্ট অংশ যা সর্বদা 1 এর চেয়ে ছোট)

    সংখ্যার দশমিক অংশ ফেরত দিন
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ একটি ধনাত্মক দশমিক সংখ্যা দেওয়া হলে, এটি দুটি অংশে বিভক্ত করা যেতে পারে:
    একটি পূর্ণসংখ্যার অংশ (প্রদানকৃত সংখ্যাটির চেয়ে ছোট বৃহত্তম পূর্ণসংখ্যা) এবং দশমিক অংশ
    (বাকি অংশ যা সবসময় ১ এর চেয়ে ছোট)।

    সংখ্যার দশমিক অংশ ফেরত দিন।
    >>> truncate_number(3.5)
    0.5
    """


from typing import List

def below_zero(operations: List[int]) -> bool:
    """আপনাকে একটি ডিপোজিট এবং উইথড্রাল অপারেশনগুলির একটি তালিকা দেওয়া হয়েছে, যেখানে ব্যাংক অ্যাকাউন্টের
    শুরুর ব্যালেন্স শূন্য। আপনার কাজ হল এটি চেক করা যে, কখনও কি অ্যাকাউন্টের ব্যালেন্স শূন্যের নিচে নেমে
    যাচ্ছে, এবং সেই সময় ফাংশনটি True রিটার্ন করবে। অন্যথায় False রিটার্ন করবে।

    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ একটি ব্যাংক অ্যাকাউন্ট জমা এবং উত্তোলনের তালিকা প্রদান করে। এই অ্যাকাউন্টটি শূন্য ব্যালেন্স দিয়ে শুরু হয়।
    আপনার কাজ হল চেক করা যে অ্যাকাউন্টের ব্যালেন্স শূন্যের নিচে নেমে যায় কিনা, এবং সেই মুহূর্তে কাজটিকে True দেওয়া উচিত।
    যদি না হয়, তবে False দেওয়া উচিত।
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ শুরুতে শূন্য ব্যালেন্সবিশিষ্ট একটি ব্যাঙ্ক অ্যাকাউন্টের জমা-খরচের একটি লিস্ট তোমাকে
    দেওয়া হয়েছে। তোমার কাজ হল অ্যাকাউন্টটির ব্যালেন্স কখনও শূন্যের নিচে নামে কি না তা
    খুঁজে বের করা, আর তা হলে তখন ফাংশনটি থেকে True ফেরত পাওয়া যাবে। আর অন্যথায়
    সেটি থেকে False ফেরত পাওয়া যাবে।
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """


from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ প্রদত্ত সংখ্যার তালিকার জন্য গড়কে কেন্দ্র হিসাবে ব্যবহার করে গড় পরম বিচ্যুতি গণনা করা
    গড় পরম বিচ্যুতি হল প্রতিটি উপাদান এবং কেন্দ্রের (এই ক্ষেত্রে গড়) মধ্যে
    পরম পার্থক্যের গড়:
    MAD = গড় | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ প্রদানকৃত সংখ্যার একটি তালিকা দিয়ে, এই ডেটাসেটের গড়ের চারপাশে গড় মান একক বিচ্যুতি হিসাব করুন।
    গড় মান বিচ্যুতি হলো প্রতিটি উপাদান এবং একটি কেন্দ্রবিন্দুর (এখানে গড়) মধ্যে গড় পরিমাণ পার্থক্য:
    MAD = গড় | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ একটি দেওয়া নম্বরের তালিকা থেকে গড় গড়নচিত্রের চারপাশে গড় মূল চ্যুতি (Mean Absolute Deviation) গণনা করুন
    গড় মূল চ্যুতি হল প্রতিটি উপাদান এবং একটি কেন্দ্রবিন্দুর (এখানে গড়) মধ্যে গড় একক পার্থক্য:
    MAD = গড় | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """


from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ ইনপুট তালিকা `numbers` এর ধারাবাহিক উপাদানগুলির মধ্যে 'delimeter' সংখ্যা সন্নিবেশ করুন
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ ইনপুট হিসাবে দেওয়া লিস্ট `numbers'-এর পর পর অবস্থিত প্রতি জোড়া উপাদানের মধ্যে 'delimeter' নামের সংখ্যটি বসাও
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ ইনপুট তালিকা `numbers` এর প্রতিটি দুইটি সন্নিবেশী উপাদানের মধ্যে একটি 'delimeter' সংখ্যা বসান।

    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """


from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ এই ফাংশনের ইনপুট একটি স্ট্রিং যা সেগুলিকে স্পেস দ্বারা আলাদা করা একাধিক গ্রুপে নেস্টেড বন্ধনী (parentheses) প্রতিনিধিত্ব করে।
    প্রতিটি গ্রুপের জন্য, বন্ধনীগুলির সবচেয়ে গভীর স্তরের (level) নেস্টিং আউটপুট করুন।
    উদাহরণ: (()()) এর সর্বাধিক নেস্টিং স্তর 2, এবং ((())) এর স্তর 3।

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

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """এই ফাংশনের ইনপুট একটি স্ট্রিং যা স্পেস দ্বারা আলাদা করা বিভিন্ন গ্রুপের নেস্টেড প্যারেনথেসিস (অর্থাৎ বন্ধনী) প্রদর্শন করে।
    প্রতিটি গ্রুপের জন্য, প্যারেনথেসিসের সর্বোচ্চ স্তরের নেস্টিং আউটপুট করতে হবে।
    উদাহরণস্বরূপ, (()())-এ সর্বোচ্চ দুটি স্তরের নেস্টিং রয়েছে, আবার ((()))-এ তিনটি স্তর রয়েছে।

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

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ এই ফাংশনটি একটি স্ট্রিং গ্রহণ করে যা একাধিক নেস্টেড প্যারেনথেসিসের গ্রুপকে
    স্পেস দ্বারা পৃথক করে। প্রতিটি গ্রুপের জন্য, সর্বাধিক নেস্টিং স্তর নির্ধারণ করে।
    উদাহরণ: (()()) এর সর্বাধিক নেস্টিং স্তর 2, এবং ((())) এর স্তর 3

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


from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ প্রদত্ত স্ট্রিংগুলির তালিকা থেকে নির্দিষ্ট সাবস্ট্রিং ধারণকারী স্ট্রিংগুলি ফিল্টার করুন
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ একটি ইনপুট স্ট্রিং তালিকা ফিল্টার করুন, শুধুমাত্র সেই স্ট্রিংগুলি রাখুন যেগুলি দেওয়া সাবস্ট্রিংটি ধারণ করে।
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """


from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ একটি পূর্ণসংখ্যার তালিকা দেওয়া হলে, সমস্ত পূর্ণসংখ্যার যোগফল এবং গুণফল সমন্বিত একটি টিউপল ফেরত দিন।
    খালি তালিকার জন্য যোগফল 0 এবং গুণফল 1 হওয়া উচিত।
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ প্রদত্ত পূর্ণসংখ্যার একটি তালিকার জন্য, তালিকার সমস্ত পূর্ণসংখ্যার যোগফল এবং গুণফল নিয়ে গঠিত একটি টাপল ফেরত দিন।
    খালি তালিকার যোগফল 0 হবে এবং খালি তালিকার গুণফল 1 হওয়া হবে।
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ প্রদত্ত তালিকার সমস্ত পূর্ণসংখ্যার যোগফল এবং গুণফল সহ একটি টিপল প্রদান করুন
    খালি তালিকার যোগফল 0 হওয়া উচিত এবং খালি তালিকার গুণফল 1 হওয়া উচিত
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """


from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ একটি পূর্ণসংখ্যার তালিকা দেওয়া হলে, প্রতি মুহূর্তে পাওয়া সর্বোচ্চ উপাদান সহ একটি ঘূর্ণায়মান সর্বাধিক তালিকা তৈরি করবে।
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ প্রদত্ত পূর্ণসংখ্যার তালিকা থেকে ক্রমানুসারে নির্দিষ্ট বিন্দু পর্যন্ত প্রাপ্ত ঘূর্ণায়মান সর্বাধিক উপাদানগুলির একটি তালিকা তৈরি করুন
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ প্রদত্ত পূর্ণসংখ্যার তালিকা থেকে, অনুক্রমের প্রদত্ত মুহূর্ত পর্যন্ত প্রাপ্ত ঘূর্ণায়মান সর্বাধিক উপাদানগুলির একটি তালিকা তৈরি করুন।
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """


def is_palindrome(string: str) -> bool:
    """ প্রদত্ত স্ট্রিংটি প্যালিনড্রোম কিনা তা পরীক্ষা করুন """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ প্রদত্ত স্ট্রিং থেকে সবচেয়ে ছোট প্যালিনড্রোম খুঁজে বের করুন
    অ্যালগরিদমের ধারণাটি নিম্নরূপ:
    - স্ট্রিংয়ের সবচেয়ে দীর্ঘ শেষ অংশটি খুঁজুন যা প্যালিনড্রোম
    - প্যালিনড্রোমের শেষ অংশের আগে স্ট্রিংয়ের শুরু অংশটি নিন, উল্টান এবং স্ট্রিংয়ের শেষে যোগ করুন
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """প্রদানকৃত স্ট্রিংটি প্যালিনড্রোম কি না তা পরীক্ষা করুন"""
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """প্রদানকৃত স্ট্রিং দিয়ে সবচেয়ে সংক্ষিপ্ত প্যালিনড্রোম তৈরি করুন।
    অ্যালগরিদমের ধারণা সহজ:
    - প্রদত্ত স্ট্রিংয়ের সবচেয়ে দীর্ঘ পোষ্টফিক্স (suffix) যা একটি প্যালিনড্রোম,
    তা খুঁজে বের করুন।
    - প্যালিনড্রোম সাফিক্সের আগের অংশের উল্টো পিফিক্স (prefix) স্ট্রিংটির শেষে যোগ করুন।
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ প্রদত্ত স্ট্রিংটি প্যালিনড্রোম কিনা তা পরীক্ষা করুন """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ যে স্ট্রিংটি প্রদান করা হয়েছে, তার মাধ্যমে সবচেয়ে সংক্ষিপ্ত প্যালিনড্রোম তৈরি করুন।
    অ্যালগোরিদমের ধারণা সহজ:
    - প্রদত্ত স্ট্রিংয়ের সর্বাধিক প্যালিনড্রোমিক পোস্টফিক্স খুঁজুন।
    - প্যালিনড্রোমিক সাফিক্সের আগে যে স্ট্রিংটি রয়েছে তার উল্টানো অংশটি স্ট্রিংয়ের শেষে যোগ করুন।
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


from typing import List

def string_xor(a: str, b: str) -> str:
    """ ইনপুট দুটি স্ট্রিং a এবং b, যা কেবলমাত্র 1 এবং 0 নিয়ে গঠিত।
    এই ইনপুটগুলোর উপর বাইনারি XOR সম্পাদন করুন এবং ফলাফলও একটি স্ট্রিং হিসেবে ফেরত দিন।
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ ইনপুট হল দুটি স্ট্রিং a এবং b যা শুধুমাত্র 1 এবং 0 ধারণ করে।
    এই ইনপুটগুলির সাথে বাইনারি সংখ্যার XOR প্রয়োগ করুন এবং ফলাফলটি একটি স্ট্রিং হিসাবে ফেরত দিন।
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ ইনপুট হল দুটি স্ট্রিং a এবং b যা শুধুমাত্র 1 এবং 0 ধারণ করে
    এই ইনপুটগুলির সাথে বাইনারি সংখ্যার XOR করুন এবং ফলাফলটি একটি স্ট্রিং হিসাবে ফেরত দিন
    >>> string_xor('010', '110')
    '100'
    """


from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ স্ট্রিংগুলির একটি তালিকা থেকে, সবচেয়ে দীর্ঘ স্ট্রিংটি ফেরত দিন। একাধিক স্ট্রিং একই দৈর্ঘ্যের হলে প্রথমটিই ফেরত দিন।
    ইনপুট তালিকা যদি খালি হয়, তবে None ফেরত দিন।

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ একটি স্ট্রিংয়ের তালিকা থেকে, দীর্ঘতম স্ট্রিংটি ফেরত দিন। যদি একই দৈর্ঘ্যের একাধিক স্ট্রিং থাকে, তাহলে প্রথমটি ফেরত দিন।
    ইনপুট তালিকা খালি থাকলে None ফেরত দিন।
    >>> longest([])

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ তালিকার মধ্যে সবচেয়ে দীর্ঘ স্ট্রিংটি প্রদান করা হবে। যদি একাধিক স্ট্রিং একই দৈর্ঘ্যের হয়, তবে প্রথমটি প্রদান করা হবে।
    যদি ইনপুট তালিকা খালি হয়, তবে None প্রদান করা হবে।
    >>> longest([])

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


def greatest_common_divisor(a: int, b: int) -> int:
    """দুটি পূর্ণসংখ্যা a এবং b এর সর্ববৃহৎ সাধারণ গুণক (GCD) ফেরত দিন
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ a ও b নামের দুটি পূর্ণসংখ্যার গরিষ্ঠ সাধারণ গুণনীয়ক ফেরত দাও
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ a ও b পূর্ণসংখ্যা দুটির একটি গরিষ্ঠ সাধারণ গুণনীয়ক ফেরত দাও
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """


from typing import List

def all_prefixes(string: str) -> List[str]:
    """ ইনপুট স্ট্রিং এর সল্পতম থেকে দীর্ঘতম পর্যন্ত সমস্ত প্রিফিক্সের একটি তালিকা দিন
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ ইনপুট স্ট্রিং থেকে সব প্রিফিক্সের তালিকা ফেরত দিন, সবচেয়ে ছোট থেকে সবচেয়ে বড় পর্যন্ত
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ ইনপুট হিসাবে দেওয়া স্ট্রিংটির সবকটি উপসর্গ ছেট থেকে বড় ক্রমে লিস্ট আকারে বের করে দাও
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """


def string_sequence(n: int) -> str:
    """ একটি স্ট্রিং প্রদান করুন যা 0 থেকে n পর্যন্ত অন্তর্ভুক্ত সংখ্যা দিয়ে স্পেস দিয়ে পৃথক করা থাকবে।
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ একটি স্ট্রিং রিটার্ন করবে যা 0 থেকে শুরু করে n পর্যন্ত স্পেস দ্বারা পৃথককৃত সংখ্যাগুলি ধারণ করবে।
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ 0 থেকে n পর্যন্ত এই দুটিসহ সবকটি সংখ্যা স্পেস দিয়ে দিয়ে আলাদা করে লেখা আছে এমন একটি স্ট্রিং ফেরত দাও।
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """


def count_distinct_characters(string: str) -> int:
    """ একটি স্ট্রিং দেওয়া হলে, এটি কতটি বিভিন্ন চরিত্রের সমন্বয়ে গঠিত (বড়-ছোট অক্ষরের পার্থক্য ছাড়াই) তা নির্ণয় করুন
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ একটি স্ট্রিং দেওয়া আছে, এতে কতগুলো ভিন্ন অক্ষর আছে (ছোট হাতের হোক বা বড় হাতের) তা বের কর
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ একটি স্ট্রিং দেওয়া হয়েছে, তা থেকে কতটি আলাদা অক্ষর (কেস নির্বিশেষে) আছে তা বের করুন
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """


from typing import List

def parse_music(music_string: str) -> List[int]:
    """ এই ফাংশনের কাজ হল একটি স্ট্রিং গ্রহণ করা যা ASCII ফরম্যাটে সঙ্গীতের নোটগুলি উপস্থাপন করে।
    আপনার কাজ হল এই স্ট্রিংটি বিশ্লেষণ করা এবং একটি পূর্ণসংখ্যার তালিকা ফেরত দেওয়া যা প্রতিটি নোটের জন্য বিটের সংখ্যা নির্দেশ করে।

    নিয়মগুলি নিম্নরূপঃ
    'o' - সম্পূর্ণ নোট, 4 বিট নেয়
    'o|' - অর্ধেক নোট, 2 বিট নেয়
    '.|' - চতুর্থাংশ নোট, 1 বিট নেয়

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ এই ফাংশনের কাজ হল একটি স্ট্রিং গ্রহণ করা যা ASCII বিন্যাসে সঙ্গীতের নোটগুলি উপস্থাপন করে
    আপনার কাজ হল এই স্ট্রিংটি বিশ্লেষণ করা এবং একটি পূর্ণসংখ্যার তালিকা দেওয়া যা প্রতিটি নোটের জন্য বিটের সংখ্যা নির্দেশ করে

    নিয়মগুলি নিম্নরূপ:
    'o' - সম্পূর্ণ নোট, 4 বিট নেয়
    'o|' - অর্ধেক নোট, 2 বিট নেয়
    '.|' - চতুর্থাংশ নোট, 1 বিট নেয়

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

from typing import List

def parse_music(music_string: str) -> List[int]:
    """এই ফাংশনে ইনপুট হিসাবে একটি স্ট্রিং দেওয়া হবে যা একটি বিশেষ ASCII ফরম্যাটে সঙ্গীত নোটগুলিকে উপস্থাপন করে।
    আপনার কাজ হল এই স্ট্রিংটি বিশ্লেষণ করা এবং প্রতিটি নোট কতগুলি বিট ধরে তা নির্দেশক পূর্ণসংখ্যার একটি তালিকা ফেরত দেওয়া।

    এখানে একটি লেজেন্ড দেওয়া হলো:
    'o' - পুরো নোট, যা চারটি বিট ধরে
    'o|' - অর্ধেক নোট, যা দুটি বিট ধরে
    '.|' - কোয়ার্টার নোট, যা এক বিট ধরে

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """


def how_many_times(string: str, substring: str) -> int:
    """ নির্ধারণ করুন কতবার উল্লেখিত সাবস্ট্রিংটি মূল স্ট্রিংয়ে পাওয়া যায়, পুনরাবৃত্তি ঘটনাসহ
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ মূল স্ট্রিংটিতে প্রদত্ত সাবস্ট্রিংটি কতবার পাওয়া যাবে তা খুঁজে বের করুন। পুনরাবৃত্তি ঘটনাসহ।
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ মূল স্ট্রিংয়ে একটি দেওয়া সাবস্ট্রিংটি কতবার পাওয়া যায়, তা খুঁজুন।ওভারল্যাপিং কেসগুলিও গণনা করুন।
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """


from typing import List

def sort_numbers(numbers: str) -> str:
    """ ইনপুট একটি স্পেস-ডেলিমিটেড স্ট্রিং যা 'zero' থেকে 'nine' পর্যন্ত সংখ্যা নির্দেশ করে।
    বৈধ পছন্দসমূহ হল 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' এবং 'nine'।
    ছোট থেকে বড় ক্রমানুসারে সংখ্যা সাজিয়ে স্ট্রিংটি ফেরত দিন।
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ ইনপুট একটি স্ট্রিং যা 'zero' থেকে 'nine' পর্যন্ত সংখ্যা দ্বারা গঠিত এবং ফাঁকা স্থান দ্বারা পৃথক
    সঠিক অপশন হল 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'
    ছোট থেকে বড় ক্রমে সাজানো সংখ্যার স্ট্রিং প্রদান করুন
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ ইনপুট একটি স্পেস দ্বারা পৃথক করা শব্দের স্ট্রিং, যা 'zero' থেকে 'nine' পর্যন্ত গুণক নাম ধারণ করে।
    বৈধ পছন্দগুলি হল 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' এবং 'nine'।
    স্ট্রিংটি সংখ্যা গুলি ক্ষুদ্রতম থেকে বৃহত্তম পর্যন্ত সাজানো অবস্থায় ফেরত দিন।
    >>> sort_numbers('three one five')
    'one three five'
    """


from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ প্রদত্ত সংখ্যার একটি লিস্ট (দৈর্ঘ্য অন্তত দুই) থেকে পরস্পরের নিকটতম দুটি সংখ্যা নির্বাচন করে সেগুলোকে
    (ছোট সংখ্যা, বড় সংখ্যা) ক্রমে সাজিয়ে ফেরত দাও।
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ প্রদত্ত সংখ্যার তালিকা থেকে দুটি সংখ্যা নির্বাচন করুন যা সবচেয়ে কাছাকাছি (দৈর্ঘ্য কমপক্ষে 2 বা তার বেশি)
    এবং ক্রমানুসারে সাজান (ছোট সংখ্যা, বড় সংখ্যা)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """প্রদত্ত সংখ্যার তালিকা (যার দৈর্ঘ্য কমপক্ষে দুটি) থেকে দুটি সংখ্যা নির্বাচন করুন
    যা একে অপরের সবচেয়ে কাছাকাছি এবং সেগুলিকে ক্রমে ফেরত দিন (ছোট সংখ্যা, বড় সংখ্যা)।

    উদাহরণ:
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """


from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ একটি নম্বরের তালিকা (যার অন্তত দুটি উপাদান থাকতে হবে) গ্রহণ করুন, এবং একটি সোজা রূপান্তর প্রয়োগ করুন যাতে তালিকাটির সর্বনিম্ন সংখ্যা ০ এবং সর্বাধিক সংখ্যা ১ হয়ে যাবে।
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ একটি তালিকা সংখ্যা দেওয়া হয়েছে যার অন্তত 2টি উপাদান রয়েছে, সেই তালিকায় একটি রৈখিক রূপান্তর প্রয়োগ করুন
    যাতে সবচেয়ে ছোট সংখ্যা 0 হয় এবং সবচেয়ে বড় সংখ্যা 1 হয়
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ সংখ্যা সমূহের একটি তালিকা (যার অন্তত দুটি উপাদান আছে) দেওয়া হয়েছে, একটি রেখাচিত্র রূপান্তর প্রয়োগ করুন
    যাতে সেই তালিকাটির সবচেয়ে ছোট সংখ্যা 0 হয়ে যাবে এবং সবচেয়ে বড় সংখ্যা 1 হয়ে যাবে
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """


from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ যে কোন পাইটন মানের তালিকায় শুধুমাত্র পূর্ণসংখ্যা গুলি ফিল্টার করুন
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ পাইথনের যেকোনো মানসম্পন্ন প্রদত্ত লিস্টটিকে ফিল্টার করে শুধু পূর্ণসংখ্যা বের করে দাও
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ প্রদত্ত যেকোনো পাইথন মানের তালিকা থেকে শুধুমাত্র পূর্ণসংখ্যা ফিল্টার করুন
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """


def strlen(string: str) -> int:
    """ প্রদত্ত স্ট্রিংটির দৈর্ঘ্য ফেরত দিন
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(string: str) -> int:
    """ প্রদত্ত স্ট্রিংয়ের দৈর্ঘ্য ফেরত দিন
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(string: str) -> int:
    """ প্রদত্ত স্ট্রিংয়ের দৈর্ঘ্য প্রদান করুন
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


def largest_divisor(n: int) -> int:
    """ একটি সংখ্যা n এর জন্য, n কে সমানভাবে বিভক্ত করে এমন বৃহত্তম সংখ্যা, যা n এর চেয়ে ছোট
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ একটি সংখ্যা n দেওয়া হলে, n কে সমানভাবে ভাগ করে এমন বৃহত্তম সংখ্যা খুঁজে বের করুন, যা n এর চেয়ে ছোট।
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ n এর চেয়ে ছোট সবচেয়ে বড় সংখ্যা খুঁজুন যা n কে অবশিষ্টাংশ ছাড়া ভাগ করতে পারে
    >>> largest_divisor(15)
    5
    """


from typing import List

def factorize(n: int) -> List[int]:
    """ প্রদত্ত পূর্ণসংখ্যার মৌলিক গুণনীয়কগুলির একটি তালিকা ছোট থেকে বড় ক্রমে ফেরত দিন।
    প্রতিটি গুণনীয়ক তালিকায় অন্তর্ভুক্ত করতে হবে তার ফ্যাক্টরাইজেশনে উপস্থিতির সংখ্যার উপর ভিত্তি করে।
    ইনপুট সংখ্যা অবশ্যই সমস্ত গুণনীয়কের গুণফলের সমান হতে হবে।
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ দেওয়া পূর্ণসংখ্যার মৌলিক গুণনীয়কের তালিকা ফেরত দিন, যা সঠিকভাবে ছোট থেকে বড় পরিমাণে সাজানো থাকবে।
    প্রতিটি গুণনীয়ক কতবার ফ্যাক্টরাইজেশনে উপস্থিত হয়েছে, তার ভিত্তিতে তালিকাভুক্ত হবে।
    ইনপুট সংখ্যাটি সমস্ত গুণনীয়কের গুণফলের সমান হওয়া উচিত।
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ দেওয়া পূর্ণসংখ্যার মৌলিক গুণনীয়কের একটি তালিকা ফেরত দিন যা ছোট থেকে বড় পর্যন্ত সাজানো।
    প্রতিটি গুণনীয়ক তালিকাভুক্ত হওয়া উচিত সেই সংখ্যক সময়, যা তা গুণনিতে উপস্থিত থাকে।
    প্রবেশকৃত সংখ্যা সব গুণনীয়কের গুণফলের সমান হওয়া উচিত।
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """


from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ পূর্ণসংখ্যার একটি তালিকা থেকে, একাধিকবার উপস্থিত হয় এমন সমস্ত উপাদান সরান।
    ইনপুটের সাথে অবশিষ্ট উপাদানগুলির ক্রম অপরিবর্তিত রাখুন।
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ প্রতিটি উপাদান যা তালিকায় একাধিকবার উপস্থিত হয় তা অপসারণ করুন
    ইনপুটের সাথে অবশিষ্ট উপাদানগুলির ক্রম অপরিবর্তিত রাখুন
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ একটি পূর্ণসংখ্যার তালিকা থেকে, সমস্ত উপাদান সরান যা একাধিক বার উপস্থিত।
    বাকি উপাদানগুলির অর্ডার ইনপুটের মতো একই রাখুন।
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """


def flip_case(string: str) -> str:
    """ প্রদত্ত স্ট্রিংয়ে ছোট অক্ষরকে বড় অক্ষরে এবং বড় অক্ষরকে ছোট অক্ষরে পরিবর্তন করুন
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ প্রদত্ত স্ট্রিংয়ের জন্য, ছোট হাতের অক্ষরগুলোকে বড় হাতের অক্ষরে এবং বড় হাতের অক্ষরগুলোকে ছোট হাতের অক্ষরে রূপান্তর করুন।
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ প্রদত্ত স্ট্রিংয়ের সব ছোট হাতের অক্ষরকে বড় হাতের অক্ষরে এবং বড় হাতের অক্ষরকে ছোট হাতের অক্ষরে পরিণত করুন।
    >>> flip_case('Hello')
    'hELLO'
    """


from typing import List

def concatenate(strings: List[str]) -> str:
    """ স্ট্রিংগুলির তালিকাকে একটি একক স্ট্রিংয়ে সংযুক্ত করুন
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List
def concatenate(strings: List[str]) -> str:
    """ স্ট্রিংগুলির একটি তালিকা একক স্ট্রিংয়ে একত্রিত করুন
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ স্ট্রিংগুলির তালিকাকে একক স্ট্রিংয়ে একত্রিত করুন
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """


from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ একটি প্রদত্ত প্রিফিক্স দিয়ে স্ট্রিংয়ের ইনপুট তালিকাটি ফিল্টার করুন, শুধুমাত্র সেগুলিই যা প্রিফিক্স দিয়ে শুরু হয়।
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ স্ট্রিংয়ের ইনপুটের একটি লিস্টকে ফিল্টার করে প্রদত্ত উপসর্গবিশিষ্ট উপাদানগুলো বের করতে হবে।
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ প্রদত্ত উপসর্গ দ্বারা শুরু হওয়া শুধুমাত্র সেই স্ট্রিংগুলির সাথে ইনপুট স্ট্রিংগুলির তালিকা ফিল্টার করুন
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """


def get_positive(l: list):
    """তালিকাতে শুধুমাত্র ধনাত্মক সংখ্যাগুলি ফেরত দিন।
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """

def get_positive(l: list):
    """শুধুমাত্র ধনাত্মক সংখ্যা তালিকায় ফেরত দিন।
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """


def is_prime(n):
    """যদি প্রদত্ত সংখ্যা মৌলিক হয়, তবে true ফেরত দিন, অন্যথায় false ফেরত দিন।
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """প্রদত্ত সংখ্যা একটি মৌলিক সংখ্যা হলে true প্রদান করুন, অন্যথায় মিথ্যা
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """প্রদত্ত সংখ্যা মৌলিক হলে true ফেরত দাও, আর অন্যথায় false ফেরত দাও।
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """


import math

def poly(xs: list, x: float):
    """
    xs এর সহগের সাহায্যে x বিন্দুতে পলিনমিয়াল গণনা করে।
    ফেরত করো xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs হল পলিনোমিয়াল এর গুণাঙ্ক।
    find_zero x খুঁজে বের করে যাতে poly(x) = 0।
    find_zero শুধুমাত্র একটি শূন্য পয়েন্ট রিটার্ন করে, যদিও অনেকগুলি থাকতে পারে।
    তাছাড়া, find_zero শুধুমাত্র এমন xs তালিকা নেয় যার সহগের সংখ্যা সোজা (even number)
    এবং সর্বাধিক অ-শূন্য সহগ থাকে যা একটি সমাধান নিশ্চিত করে।
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    x বিন্দুতে xs সহগ সহ বহুপদী এর মান নির্ণয় করুন।
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs হল একটি বহুপদীর সহগ।
    find_zero x এর মান এমন ভাবে খুঁজে বের করে যাতে poly(x) = 0 হয়।
    find_zero শুধুমাত্র একটি শূন্য বিন্দু প্রদান করে, এমনকি অনেকগুলো থাকলেও।
    এছাড়াও, find_zero শুধুমাত্র এমন xs এর তালিকা গ্রহণ করে যার সহগ জোড় সংখ্যা
    এবং বৃহত্তম অ শূন্য সহগ যা একটি সমাধানের
    নিশ্চয়তা দেয়।
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    তালিকা xs এর পলিনোমিয়াল এর মান x বিন্দুতে নির্ণয় করুন
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs হল পলিনোমিয়াল এর গুণাঙ্ক
    find_zero এমন একটি x এর মান খুঁজবে যা poly(x) = 0 করে
    find_zero শুধুমাত্র একটি শূন্য বিন্দু প্রদান করবে, এমনকি যদি একাধিক সমাধান থাকে
    এছাড়াও, find_zero শুধুমাত্র এমন xs তালিকা গ্রহণ করবে যার গুণাঙ্কের সংখ্যা বিজোড় সংখ্যা
    এবং যার গুণাঙ্কগুলি শূন্য নয়
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """


def sort_third(l: list):
    """এই ফাংশনটি একটি তালিকা l গ্রহণ করে এবং একটি নতুন তালিকা l' ফেরত দেয়
    l' তিন দ্বারা বিভাজ্য নয় এমন সূচকগুলিতে l-এর অনুরূপ, যখন তিন দ্বারা বিভাজ্য সূচকগুলিতে
    এর মানগুলি l এর সংশ্লিষ্ট সূচকগুলির মানের সমান, কিন্তু মানগুলি হবে সাজানো।
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """এই ফাংশনটি একটি তালিকা l গ্রহণ করে এবং একটি নতুন তালিকা l' ফেরত দেয় যাতে
    l' l এর যেসব সূচকগুলির মান 3 দ্বারা নিঃশেষে বিভাজ্য নয় সে মানগুলোর অনুরূপ হয়, এবং তিন দ্বারা বিভাজ্য সূচকগুলিতে এর মানগুলি l এর সংশ্লিষ্ট সূচকগুলির মানের
    সমান হয়, তবে মানগুলো সাজানো থাকবে।
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """এই ফাংশনটি একটি তালিকা l নেয় এবং একটি তালিকা l' রিটার্ন করে যাতে
    l' তালিকাটি l এর মতই থাকে, যেসব ইনডেক্স ৩ দ্বারা বিভাজ্য নয় সেই ইনডেক্সগুলোতে, তবে যেসব ইনডেক্স ৩ দ্বারা বিভাজ্য,
    সেগুলোর মান লিস্ট l এর সেই ইনডেক্সের মানের সাথে মিলে যাবে, তবে সেগুলো সজ্জিত হবে।
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """


def unique(l: list):
    """একটি লিস্টের অনন্য উপাদানগুলো ক্রমানুসারে সাজিয়ে ফেরত দাও
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """একটি তালিকা থেকে অনন্য সাজানো তালিকা ফেরত দিন
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """একটি তালিকা থেকে অনন্য এবং সাজানো তালিকা দাও
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


def max_element(l: list):
    """তালিকায় সর্বাধিক উপাদান বের করুন।
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """

def max_element(l: list):
    """তালিকায় সর্বাধিক উপাদান পুনরুদ্ধার করুন
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """

def max_element(l: list):
    """তালিকার সর্বাধিক উপাদানটি ফেরত দিন।

    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """


def fizz_buzz(n: int):
    """n এর চেয়ে ছোট যে সংখ্যাগুলো 11 বা 13 দ্বারা বিভাজ্য তাদের মধ্যে সংখ্যা 7 কতবার উপস্থিত হয়েছে তা ফেরত দিন।
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """n এর নিচে সম্পূর্ণ সংখ্যায় 7 সংখ্যা কতবার দেখা যায় তা প্রদান করুন যা 11 বা 13 দ্বারা বিভাজ্য
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """ নির্দিষ্ট সংখ্যার (n) কম যে কোন পূর্ণসংখ্যা যা ১১ অথবা ১৩ দিয়ে বিভাজ্য, তাতে কতবার ডিজিট ৭ এসেছে তা ফেরত দিন।
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """


def sort_even(l: list):
    """এই ফাংশনটি একটি তালিকা l নেয় এবং একটি তালিকা l' প্রদান করে, যেখানে
    l' তালিকার অসম ইনডেক্সগুলিতে l-এর মান অপরিবর্তিত থাকে, কিন্তু এর
    সোজা ইনডেক্সগুলির মানগুলি l-এর সোজা ইনডেক্সগুলির মানের সমান হয়ে থাকে,
    তবে তা সাজানো অবস্থায়।
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """এই ফাংশনটি একটি তালিকা l গ্রহণ করে এবং একটি নতুন তালিকা l' প্রদান করে
    l' হবে l এর সাথে সমান বিজোড় সূচীতে, এবং জোড় সূচীতে মান হবে
    l এর জোড় সূচীর মান যা সাজানো হয়েছে
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """এই ফাংশনটি একটি তালিকা l গ্রহণ করে এবং একটি তালিকা l' প্রদান করে যেটি
    l এর অপরিবর্তিত অদ্বিতীয় সূচকগুলির সাথে একে অপরের অনুরূপ, তবে এর মানগুলি এমনভাবে সাজানো হয়
    যে l এর সমান সূচকগুলির মানগুলির সাথে তারা সমান হয়।
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """


def encode_cyclic(s: str):
    """
    তিনটি অক্ষরের গ্রুপে সাইক্লিং করে এনকোড করা স্ট্রিং ফেরত দেয়।
    """
    # স্ট্রিংটিকে গ্রুপে বিভক্ত করুন। প্রতিটি গ্রুপের দৈর্ঘ্য ৩।
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # প্রতিটি গোষ্ঠীতে উপাদানগুলি ঘূর্ণায়মান করুন, যেখানে গোষ্ঠীতে ৩ এর কম উপাদান নেই
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    এনকোড করা স্ট্রিং ইনপুট হিসেবে নিয়ে, ডিকোড করা স্ট্রিং ফেরত দেয়।
    """

def encode_cyclic(s: str):
    """
    তিনটি অক্ষরের ঘূর্ণায়মান গ্রুপ দ্বারা এনকোড করা স্ট্রিং প্রদান করুন।
    """
    # স্ট্রিংটি গ্রুপে বিভক্ত করুন। প্রতিটির দৈর্ঘ্য হবে 3।
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # উপাদানগুলো প্রতিটি গ্রুপে চক্রাকারে ঘুরান। যদি না গ্রুপে 3 এর কম উপাদান থাকে।
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    encode_cyclic ফাংশন দ্বারা এনকোড করা স্ট্রিং ইনপুট হিসাবে গ্রহণ করুন। ডিকোড করা স্ট্রিং প্রদান করুন।
    """

def encode_cyclic(s: str):
    """
    তিনটি অক্ষরের গ্রুপকে চক্রাকারে ঘুরিয়ে এনকোড করা স্ট্রিং ফেরত দেয়।
    """
    # স্ট্রিংকে গ্রুপে ভাগ করা হয়। প্রতিটির দৈর্ঘ্য 3 হয়।
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # প্রতিটি গ্রুপের উপাদান চক্রাকারে ঘোরানো হয়। যদি গ্রুপের উপাদানের সংখ্যা 3-এর চেয়ে কম না হয়।
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    encode_cyclic ফাংশন দিয়ে এনকোড করা স্ট্রিংকে ইনপুট হিসাবে নেয়। ডিকোড করা স্ট্রিং ফেরত দেয়।
    """


def prime_fib(n: int):
    """
    prime_fib nতম সেই সংখ্যা ফেরত দেয় যা একইসাথে একটি ফিবোনাচি সংখ্যা ও একটি মৌলিক সংখ্যা।
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    prime_fib n সংখ্যায় প্রদান করে যা ফিবোনাচি এবং একইসাথে মৌলিক সংখ্যা
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    prime_fib n-তম সংখ্যাটি ফিরিয়ে দেয় যা একটি ফিবোনাচ্চি সংখ্যা এবং এটি প্রাইমও।
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """


def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero একটি পূর্ণসংখ্যার তালিকা ইনপুট হিসেবে নেয়।
    এটি True ফেরত দেয় যদি তালিকায় তিনটি ভিন্ন উপাদান থাকে যেগুলোর যোগফল শূন্য হয়,
    এবং অন্যথায় False ফেরত দেয়।

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero পূর্ণসংখ্যার একটি লিস্টকে ইনপুট হিসাবে নেয়।
    লিস্টে যদি ভিন্ন এমন তিনটি উপাদান থাকে যেগুলোর যোগফল শূন্য
    হবে তাহলে এটি True ফেরত দেয়, আর অন্যথায় False ফেরত দেয়।

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero ইনপুট হিসাবে একটি পূর্ণসংখ্যার তালিকা গ্রহণ করে।
    যদি তালিকায় তিনটি ভিন্ন উপাদানের যোগফল শূন্য হয় তবে এটি True ফেরত দেবে
    এবং অন্যথায় এটি False ফেরত দেবে।

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """


def car_race_collision(n: int):
    """
    অসীম দৈর্ঘ্যের সম্পূর্ণ সরলরৈখিক একটি রাস্তা কল্পনা কর।
    n সংখ্যক গাড়ি বাম থেকে ডানে যাচ্ছে;  একইসাথে n সংখ্যক অন্য আরেক
    সেট গাড়ি ডান থেকে বামে যাচ্ছে।   দুই সেট গাড়ি শুরুতে পরস্পর থেকে
    অনেক দূরে থাকে।  সবকটি গাড়ি একই গতিতে চলে।  বাম থেকে ডানে চলা
    কোনো গাড়ির সাথে ডান থেকে বামে চলা কোনো গাড়ির ধাক্কা লাগলে সেই
    গাড়ি দুটির সংঘর্ষ হয়েছে বলা হয়।
    তবে গাড়িগুলো অসীম পরিমাণে মজবুত ও শক্তিশালী; তাই তার পরও সেগুলো
    এমনভাবে নিজের গতিপথ ধরে চলতে থাকে যেন কোনো সংঘর্ষ হয় নি।

    এই ফাংশনটি থেকে সেসব সংঘর্ষের সংখ্যা আউটপুট হিসাবে পাওয়া যায়।
    """

def car_race_collision(n: int):
    """
    কল্পনা করুন একটি রাস্তাটি যা একটি পুরোপুরি সোজা এবং অবিরাম দীর্ঘ রেখা।
    n টি গাড়ি বাম থেকে ডানে চলছে; একসাথে, একটি ভিন্ন সেটের n টি গাড়ি
    ডান থেকে বামে চলে আসছে। এই দুটি গাড়ির সেট খুব দূর থেকে শুরু হয়।
    সমস্ত গাড়ি একই গতিতে চলে। দুটি গাড়ি সংঘর্ষে আসে যখন একটি গাড়ি
    যা বাম থেকে ডানে চলে, একটি গাড়ির সাথে সংঘর্ষ হয় যা ডান থেকে বামে চলে।
    তবে, গাড়িগুলি অসীম শক্তিশালী এবং মজবুত; এর ফলস্বরূপ, তারা তাদের গতিতে চলতে থাকে
    যেমন তারা সংঘর্ষে আসেনি।

    এই ফাংশনটি এমন সংঘর্ষের সংখ্যা আউটপুট করে।
    """

def car_race_collision(n: int):
    """
    কল্পনা করুন রাস্তা একটি দীর্ঘ অসীম রেখা হিসাবে
    বাম থেকে ডানে যাওয়া nটি গাড়ি আছে, একই সময়ে ডান থেকে বামে যাওয়া nটি গাড়ি আছে
    উভয় সেটের গাড়ি অনেক দূর থেকে শুরু করে
    সব গাড়ি একই গতিতে চলে। যখন বাম থেকে ডানে যাওয়া গাড়ি
    ডান থেকে বামে যাওয়া গাড়ির সাথে ধাক্কা খায়, আমরা বলব দুটি গাড়ি সংঘর্ষ করেছে
    তবে, গাড়িগুলি অসীম শক্তি এবং স্থায়িত্বের অধিকারী, তাই
    তারা তাদের পথে চলতে থাকবে যেন কোনো সংঘর্ষ না ঘটে

    এই ফাংশনটি সেই সংঘর্ষের সংখ্যা প্রদান করবে
    """


def incr_list(l: list):
    """একটি তালিকা ফেরত দিন যেখানে প্রতিটি উপাদান 1 করে বৃদ্ধি পায়।
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """প্রত্যেকটি উপাদান ১ দ্বারা বৃদ্ধি করা তালিকা ফেরত দিন।
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """একটি তালিকা দিন যেখানে প্রতিটি উপাদান 1 দ্বারা বৃদ্ধি পেয়েছে
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """


def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero একটি পূর্ণসংখ্যার তালিকা ইনপুট হিসাবে গ্রহণ করে।
    এটি True রিটার্ন করবে যদি তালিকায় দুটি আলাদা উপাদান থাকে যা শূন্যের সাথে যোগফল করে,
    এবং অন্যথায় False রিটার্ন করবে।
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero পূর্ণসংখ্যার একটি লিস্টকে ইনপুট হিসাবে নেয়।
    লিস্টে যদি ভিন্ন এমন দুটি উপাদান থাকে যেগুলোর যোগফল শূন্য হবে তাহলে এটি
    থেকে True ফেরত পাওয়া যায়, অন্যথায় False পাওয়া যায়।
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero একটি পূর্ণসংখ্যার তালিকা ইনপুট হিসাবে গ্রহণ করে
    যদি তালিকায় দুটি ভিন্ন উপাদান থাকে যার যোগফল শূন্য হয়, এটি True হবে
    যদি না হয়, এটি False হবে
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """


def change_base(x: int, base: int):
    """ইনপুট সংখ্যা x এর সংখ্যাগত বেস পরিবর্তন করুন এবং নির্দিষ্ট বেসে স্ট্রিং রূপে ফলাফল ফেরত দিন।
    বেস সংখ্যা 10 এর চেয়ে ছোট হবে।
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """ইনপুট নম্বর x এর সংখ্যাগত ভিত্তি পরিবর্তন করুন base তে।
    রূপান্তরের পর স্ট্রিং উপস্থাপন ফেরত দিন।
    বেস সংখ্যা 10 এর কম হবে।
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """ইনপুট নম্বর x এর সাংখ্যিক ভিত্তিকে base এ পরিবর্তন করুন।
    রূপান্তরের পরে স্ট্রিং ফর্ম্যাটে মানটি ফেরত দিন।
    ভিত্তি অবশ্যই 10 এর নিচে একটি সংখ্যা হতে হবে।
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """


def triangle_area(a, h):
    """একটি ত্রিভুজের একটি পাশের দৈর্ঘ্য এবং উচ্চতা দেওয়া হলে ত্রিভুজটির ক্ষেত্রফল ফেরত দিন।
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """একটি ত্রিভুজের এক বাহুর দৈর্ঘ্য ও উচ্চতা দেওয়া আছে, সেটির ক্ষেত্রফল বের কর।
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """একটি ত্রিভুজের পাশের দৈর্ঘ্য এবং উচ্চতা দেওয়া হলে ক্ষেত্রফল ফেরত দিন।
    >>> triangle_area(5, 3)
    7.5
    """


def fib4(n: int):
    """সংখ্যার Fib4 ধারা হল ফিবোনাচি ধারার মতো এমন একটি ধারা যার সংজ্ঞা নিম্নরূপ:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    এমন একটি ফাংশন লিখুন যার সাহায্যে fib4 ধারাটির nতম উপাদান কার্যকরভাবে বের করা যাবে।  রিকার্শন ব্যবহার করবেন না।
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """Fib4 সংখ্যা ক্রম হল ফিবোনাচ্চি অনুক্রমের অনুরূপ একটি ক্রম যা নিম্নরূপ বর্ণিতঃ
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    অনুগ্রহ করে fib4 সংখ্যা অনুক্রমের n-তম উপাদানটি দক্ষতার সাথে গণনা করার জন্য একটি ফাংশন লিখুন। পুনরাবৃত্তি ব্যবহার না করে।
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """Fib4 সংখ্যা সিকোয়েন্স হল একটি সিকোয়েন্স যা ফিবোনাচ্চি সিকোয়েন্সের মতো, তবে এটি নিচেরভাবে সংজ্ঞায়িত:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4)।
    দয়া করে একটি ফাংশন লিখুন যা দক্ষভাবে fib4 সংখ্যার সিকোয়েন্সের n-তম উপাদান গণনা করবে। পুনরাবৃত্তি ব্যবহার করবেন না।
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """


def median(l: list):
    """তালিকা l-এ উপাদানগুলির মধ্যম মান ফিরিয়ে দেয়।
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median(l: list):
    """তালিকা l এর উপাদানগুলির মধ্যম মান প্রদান করুন।
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median(l: list):
    """তালিকা l এর উপাদানগুলির মধ্যম মান প্রদান করে
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """


def is_palindrome(text: str):
    """
    প্রদত্ত স্ট্রিংটি প্যালিনড্রোম কিনা তা পরীক্ষা করুন
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    দেওয়া স্ট্রিংটি পালিনড্রোম কিনা তা পরীক্ষা করে
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """


def modp(n: int, p: int):
    """2^n কে p এর মোডুলো হিসেব করে ফেরত দিন (সংখ্যাগত সীমার বিষয়টি মনে রাখবেন)।
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """2^n কে p দ্বারা ভাগ করে অবশিষ্টাংশ ফেরত দিন (সংখ্যা বিবেচনা করুন)।
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """2^n কে p দ্বারা ভাগ করলে অবশিষ্টাংশ ফেরত দেও (সংখ্যা বিবেচনা করুন)
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """


def encode_shift(s: str):
    """
    প্রতিটি অক্ষরকে বর্ণমালায় ৫ অবস্থান সরানোর মাধ্যমে এনকোড করা স্ট্রিং ফেরত দেয়।
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    encode_shift ফাংশন দিয়ে এনকোড করা একটি স্ট্রিংকে ইনপুট হিসাবে নেয়। ডিকোড করা স্ট্রিং ফেরত দেয়।
    """

def encode_shift(s: str):
    """
    প্রতিটি অক্ষরকে বর্ণমালায় ৫ ঘর সরানোর মাধ্যমে এনকোড করা স্ট্রিং ফেরত দেয়।
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    encode_shift ফাংশন দিয়ে এনকোড করা স্ট্রিংকে ইনপুট হিসাবে নেয়। ডিকোড করা স্ট্রিং ফেরত দেয়।
    """

def encode_shift(s: str):
    """
    প্রতিটি অক্ষরকে ইংরেজি বর্ণমালায় 5 স্থান সরিয়ে এনকোড করা স্ট্রিং প্রদান করুন।
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    encode_shift ফাংশন দ্বারা এনকোড করা বার্তাকে ইনপুট হিসেবে গ্রহণ করুন। ডিকোড করা স্ট্রিং প্রদান করুন।
    """


def remove_vowels(text):
    """
    remove_vowels একটি ফাংশন যা একটি স্ট্রিং গ্রহণ করে এবং সেখান থেকে স্বরবর্ণ ছাড়া একটি স্ট্রিং ফেরত দেয়।
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

def remove_vowels(text):
    """
    remove_vowels একটি ফাংশন যা একটি স্ট্রিং গ্রহণ করে এবং স্বরবর্ণবিহীন স্ট্রিং প্রদান করে
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

def remove_vowels(text):
    """
    remove_vowels এমন একটি ফাংশন যা string নিয়ে স্বরবর্ণহীন string ফেরত দেয়।
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """


def below_threshold(l: list, t: int):
    """যদি তালিকা l এর সমস্ত সংখ্যা সীমা t এর নিচে থাকে তবে True ফেরত দিন।
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """l নামের লিস্টের সবকটি সংখ্যা t নামের সীমার নিচে থাকলে True ফেরত দাও।
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """যদি তালিকা l-এর সমস্ত সংখ্যা সীমানা t-এর নিচে থাকে তবে True ফেরত দিন।
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


def add(x: int, y: int):
    """দুটি সংখ্যা x এবং y যোগ করুন
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """

def add(x: int, y: int):
    """দুটি সংখ্যা যোগ করুন x এবং y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


def same_chars(s0: str, s1: str):
    """
    দুটি শব্দে একই অক্ষর আছে কি না তা পরীক্ষা করুন।
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """

def same_chars(s0: str, s1: str):
    """
    যাচাই করুন যদি দুটি শব্দে একই অক্ষর থাকে।
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """

def same_chars(s0: str, s1: str):
    """
    পরীক্ষা করুন যে দুটি শব্দে একই অক্ষর আছে কিনা।
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """


def fib(n: int):
    """ n-তম ফিবোনাচ্চি সংখ্যা ফেরত দিন।
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """

def fib(n: int):
    """n-তম ফিবোনাচ্চি সংখ্যা ফেরত দিন।
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """ brackets হল "<" ও ">" চিহ্নবিশিষ্ট একটি স্ট্রিং।
    প্রতিটি আরম্ভসূচক বন্ধনীর সংশ্লিষ্ট একটি করে সমাপ্তিসূচক বন্ধনী থাকলে True ফেরত দাও।

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

def correct_bracketing(brackets: str):
    """ বন্ধনী "<" এবং ">" এর একটি স্ট্রিং।
    যদি প্রতিটি খোলা বন্ধনীর সাথে মিলিত বন্ধনী থাকে তবে True ফেরত দিন।

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

def correct_bracketing(brackets: str):
    """ ব্র্যাকেট একটি স্ট্রিং যা "<" এবং ">" দ্বারা গঠিত।
    প্রত্যেকটি খোলামুখী ব্র্যাকেটের একটি সংশ্লিষ্ট বন্ধ ব্র্যাকেট আছে কিনা তা পরীক্ষা করে True ফেরত দিন।

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


def monotonic(l: list):
    """তালিকার উপাদানগুলি মনোটোনিকভাবে বৃদ্ধি পাচ্ছে বা হ্রাস পাচ্ছে কিনা তা True ফেরত দিন।
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """যদি তালিকার উপাদানগুলি ক্রমাগত বৃদ্ধি বা হ্রাস পায় তবে True প্রদান করুন
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """এই ফাংশনটি সত্য ফেরত দেয় যদি তালিকার উপাদানগুলি মনোটোনিকভাবে বৃদ্ধি পায় বা হ্রাস পায়।
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """


def common(l1: list, l2: list):
    """দুইটি তালিকার জন্য সাধারণ, সাজানো এবং অনন্য উপাদানগুলি রিটার্ন করুন।
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]
    """

def common(l1: list, l2: list):
    """দুটি তালিকার জন্য সাজানো একক সাধারণ উপাদানগুলি রিটার্ন করুন।
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """দুটি তালিকার অনন্য মিলযুক্ত উপাদানগুলি ক্রমানুসারে প্রদান করুন
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """


def largest_prime_factor(n: int):
    """n এর বৃহত্তম মৌলিক গুণনীয়ক ফেরত দিন। ধরা হবে n > 1 এবং এটি একটি মৌলিক সংখ্যা নয়।

    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """n-এর সর্বোচ্চ মৌলিক উৎপাদক বের করে দাও। ধরে নাও n > 1 ও তা মৌলিক সংখ্যা নয়।
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """n-এর বৃহত্তম মৌলিক গুণনীয়ক ফেরত দাও। ধরে যাক n > 1 এবং এটি মৌলিক সংখ্যা নয়।
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """


def sum_to_n(n: int):
    """sum_to_n এমন একটি ফাংশন যা 1 থেকে n পর্যন্ত সংখ্যাকে যোগ করে।
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """sum_to_n হল একটি ফাংশন যা 1 থেকে n পর্যন্ত সংখ্যাগুলির যোগফল প্রদান করে
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """sum_to_n একটি ফাংশন যা 1 থেকে n পর্যন্ত সংখ্যাগুলির যোগফল বের করে।
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """


def correct_bracketing(brackets: str):
    """
    brackets একটি স্ট্রিং যা "(" এবং ")" দিয়ে গঠিত।
    যদি প্রতিটি খোলার বন্ধনী একটি সঠিক বন্ধনী সহ থাকে, তাহলে True ফেরত দিন।

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

def correct_bracketing(brackets: str):
    """ brackets একটি "(" এবং ")" দ্বারা গঠিত স্ট্রিং।
    যদি প্রতিটি খোলার বন্ধনী একটি সঠিক বন্ধনী থাকে তবে True ফেরত দিন।

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

def correct_bracketing(brackets: str):
    """ brackets হল "(" ও ")" চিহ্নবিশিষ্ট একটি স্ট্রিং।
    আরম্ভসূচক প্রতিটি বন্ধনীর জন্য একটি করে সমাপ্তিসূচক বন্ধনী থাকলে True ফেরত দাও।

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


def derivative(xs: list):
    """ xs একটি বহুপদী পলিনোমিয়ালের সহগগুলির প্রতিনিধিত্ব করে।
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     এই পলিনোমিয়ালের ডেরিভেটিভ সেই একই রূপে ফেরত দিন।
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derivative(xs: list):
    """
    xs হল একটি পলিনোমিয়ালের সহগ গুলি।
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
    এই পলিনোমিয়ালের ডেরিভেটিভ একই আকারে ফিরিয়ে দিন।

    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derivative(xs: list):
    """ xs পলিনোমিয়ালের গুণাঙ্কগুলি উপস্থাপন করে
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
    পলিনোমিয়ালের ডেরিভেটিভকে একই বিন্যাসে উপস্থাপন করে পলিনোমিয়াল প্রদান করুন
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """


def fibfib(n: int):
    """FibFib সংখ্যা ধারাবাহিক একটি ধারাবাহিক যা ফিবোনাচি সংখ্যার অনুরূপ এবং এটি নিম্নরূপ সংজ্ঞায়িত:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    অনুগ্রহ করে একটি কার্যকর ফাংশন লিখুন যা fibfib সংখ্যা ধারাবাহিকের n-তম উপাদান গণনা করে।
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """সংখ্যার FibFib ধারা হল ফিবোনাচি ধারার মতো এমন একটি ধারা যার সংজ্ঞা নিম্নরূপ:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3)।
    এমন একটি ফাংশন লিখুন যার সাহায্যে fibfib ধারাটির nতম উপাদান কার্যকরভাবে বের করা যাবে।
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """ফিবফিব নম্বর সিকোয়েন্স হলো একটি সিকোয়েন্স যা ফিবোনাচ্চি সিকোয়েন্সের মতো কিন্তু কিছু পার্থক্য রয়েছে।
    এটি নিম্নরূপ সংজ্ঞায়িত:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3)
    অনুগ্রহ করে একটি ফাংশন লিখুন যা দক্ষতার সাথে fibfib নম্বর সিকোয়েন্সের n-তম উপাদান হিসাব করবে।
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """


FIX = """
আরও পরীক্ষা যোগ করুন।
"""

def vowels_count(s):
    """vowels_count ফাংশন তৈরি করুন যা একটি স্ট্রিং দ্বারা প্রদত্ত শব্দকে ইনপুট হিসাবে গ্রহণ করে
    এবং সেই স্ট্রিংয়ে উপস্থিত স্বরবর্ণের সংখ্যা ফেরত দেয়।
    এই ক্ষেত্রে স্বরবর্ণগুলি হল 'a', 'e', 'i', 'o', 'u'। এখানে, 'y' ও
    স্বরবর্ণ, কিন্তু শুধুমাত্র যদি এটি প্রদত্ত শব্দের শেষে থাকে।

    উদাহরণঃ
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
আরও টেস্ট কেস যোগ করুন।
"""

def vowels_count(s):
    """একটি ফাংশন লিখুন vowels_count যা একটি স্ট্রিং গ্রহণ করে যা
    একটি শব্দকে উপস্থাপন করে এবং স্ট্রিংয়ের ভাওয়েল সংখ্যা রিটার্ন করে।
    এই ক্ষেত্রে, ভাওয়েলগুলি হল 'a', 'e', 'i', 'o', 'u'। এখানে, 'y'ও একটি
    ভাওয়েল, তবে শুধুমাত্র যখন এটি প্রদত্ত শব্দের শেষে থাকে।

    উদাহরণ:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
আরো টেস্ট কেস যোগ করুন।
"""

def vowels_count(s):
    """একটি ফাংশন লিখুন vowels_count যা একটি শব্দের স্ট্রিং ইনপুট হিসেবে গ্রহণ করে
    এবং স্ট্রিংয়ে ভ্যালসের সংখ্যা রিটার্ন করে।
    এখানে ভ্যালস হলো 'a', 'e', 'i', 'o', 'u'। 'y'-ও একটি ভ্যালস, তবে
    শুধু তখনই এটি ভ্যালস হবে যখন এটি প্রদত্ত শব্দটির শেষে থাকবে।

    উদাহরণ:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """


def circular_shift(x, shift):
    """পূর্ণসংখ্যা x এর অঙ্কগুলিকে বৃত্তাকার শিফট করুন, শিফটের পরিমাণ অনুযায়ী ডিজিটগুলি ডান দিকে শিফট করুন
    এবং ফলাফল একটি স্ট্রিং হিসেবে ফেরত দিন।
    যদি শিফট > ডিজিটের সংখ্যা হয়, তাহলে ডিজিটগুলি উল্টে ফিরিয়ে দিন।
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """একটি পূর্ণসংখ্যা x এর অঙ্কগুলিকে ডানদিকে ঘোরানোর মাধ্যমে ঘূর্ণন করুন
    এবং ফলাফলটি একটি স্ট্রিং হিসাবে প্রদান করুন
    যদি shift > অঙ্কের সংখ্যা হয়, তবে ঘূর্ণিত অঙ্কগুলি জানান
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """একটি পূর্ণসংখ্যা x এর অঙ্কগুলিকে বৃত্তাকারে স্থানান্তর করুন, অঙ্কগুলিকে শিফট করে ডানদিকে স্থানান্তর করুন
     এবং একটি স্ট্রিং হিসাবে ফলাফলটি ফেরত দিন।
    যদি shift > অঙ্কের সংখ্যা হয়, তবে ঘূর্ণিত অঙ্কগুলি ফেরত দিন।
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """


def digitSum(s):
    """কাজ
    একটি ফাংশন লিখুন যা একটি স্ট্রিং ইনপুট হিসেবে নেয় এবং শুধুমাত্র বড় হাতের অক্ষরের
    ASCII কোডের যোগফল রিটার্ন করে।

    উদাহরণ:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """কাজ
    একটি স্ট্রিং ইনপুট হিসেবে নিয়ে শুধুমাত্র আপার ক্যারেক্টারের
    ASCII কোডের যোগফল রিটার্ন করা একটি ফাংশন লিখুন।

    উদাহরণ:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """কাজ
    এমন একটি কাজ লিখুন যা একটি স্ট্রিং ইনপুট হিসাবে গ্রহণ করে এবং শুধুমাত্র বড় হাতের অক্ষরের ASCII সংখ্যার যোগফল প্রদান করে

    উদাহরণ:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """


def fruit_distribution(s,n):
    """
    এই সমস্যাটিতে আপনাকে একটি স্ট্রিং দেওয়া হবে যা ফলের ঝুড়িতে আপেল এবং কমলার মোট সংখ্যা প্রদর্শন করে।
    এই ঝুড়িতে আপেল, কমলা, এবং আম রয়েছে। আপনাকে দেওয়া স্ট্রিংটি যা আপেল এবং কমলার মোট সংখ্যা প্রদর্শন করে এবং
    একটি পূর্ণসংখ্যা যা ঝুড়ির মোট ফলের সংখ্যা প্রদর্শন করে, তার মাধ্যমে আমের সংখ্যা নির্ণয় করতে হবে।

    উদাহরণ:
    fruit_distribution("5 apples and 6 oranges", 19) -> 19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges", 3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges", 120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    এই কাজটিতে, আপনাকে একটি স্ট্রিং দেওয়া হবে যা একটি ঝুড়িতে বিতরণ করা আপেল এবং কমলার সংখ্যা দেখায়
    এই ঝুড়িতে আপেল, কমলা এবং আম অন্তর্ভুক্ত রয়েছে।
    আপনাকে একটি স্ট্রিং দেওয়া হবে যা মোট কমলা এবং আপেলের সংখ্যা দেখায় এবং একটি পূর্ণসংখ্যা যা ঝুড়িতে মোট ফলের সংখ্যা দেখায়
    ঝুড়িতে আমের সংখ্যা ফেরত দিন
    উদাহরণস্বরূপঃ
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    এই কাজে, আপনাকে একটি স্ট্রিং দেওয়া হবে যা আপেল এবং কমলার সংখ্যা
    প্রতিনিধিত্ব করে যা একটি ফলের বাস্কেটে বিতরণ করা হয়েছে
    এই বাস্কেটে আপেল, কমলা, এবং আম ফল রয়েছে। স্ট্রিংটি যেটি
    আপেল এবং কমলার মোট সংখ্যা প্রতিনিধিত্ব করে এবং একটি পূর্ণসংখ্যা যা
    বাস্কেটের মোট ফলের সংখ্যা প্রতিনিধিত্ব করে সে অনুযায়ী আমের ফলের সংখ্যা
    রিটার্ন করুন।
    উদাহরণস্বরূপ:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """


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

    নির্বাচিত নোডটি একটি তালিকা আকারে প্রদান করা উচিত [ছোটতম মান, তার সূচক]
    যদি কোনও জোড় সংখ্যার মান না থাকে বা প্রাপ্ত অ্যারে খালি হয়, তবে []

    উদাহরণ 1:
        ইনপুট: [4,2,3]
        আউটপুট: [2, 1]
        ব্যাখ্যা: 2 এর মান সবচেয়ে ছোট জোড় সংখ্যা এবং 2 এর সূচক সবচেয়ে ছোট

    উদাহরণ 2:
        ইনপুট: [1,2,3]
        আউটপুট: [2, 1]
        ব্যাখ্যা: 2 এর মান সবচেয়ে ছোট জোড় সংখ্যা এবং 2 এর সূচক সবচেয়ে ছোট

    উদাহরণ 3:
        ইনপুট: []
        আউটপুট: []

    উদাহরণ 4:
        ইনপুট: [5, 0, 3, 0, 4, 2]
        আউটপুট: [0, 1]
        ব্যাখ্যা: 0 সবচেয়ে ছোট মান কিন্তু দুটি শূন্য আছে
                     প্রথম শূন্যটি নির্বাচন করুন যার সূচক সবচেয়ে ছোট

    সীমাবদ্ধতা:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

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

    তুলে নেওয়া নোডটি একটি লিস্ট আকারে ফিরিয়ে দিতে হবে, [সবচেয়ে ছোট মান, তার ইনডেক্স]।
    যদি কোনো সবুজ মান না থাকে অথবা দেওয়া অ্যারে খালি থাকে, তবে [] ফেরত দিন।

    উদাহরণ 1:
        ইনপুট: [4,2,3]
        আউটপুট: [2, 1]
        ব্যাখ্যা: 2 হচ্ছে সবচেয়ে ছোট সবুজ মান, এবং 2-এর ইনডেক্স সবচেয়ে ছোট।

    উদাহরণ 2:
        ইনপুট: [1,2,3]
        আউটপুট: [2, 1]
        ব্যাখ্যা: 2 হচ্ছে সবচেয়ে ছোট সবুজ মান, এবং 2-এর ইনডেক্স সবচেয়ে ছোট।

    উদাহরণ 3:
        ইনপুট: []
        আউটপুট: []

    উদাহরণ 4:
        ইনপুট: [5, 0, 3, 0, 4, 2]
        আউটপুট: [0, 1]
        ব্যাখ্যা: 0 সবচেয়ে ছোট মান, কিন্তু দুটি শূন্য আছে,
                     তাই প্রথম শূন্যকে নির্বাচন করা হবে, যেটির ইনডেক্স সবচেয়ে ছোট।

    সীমাবদ্ধতা:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

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

    তুলতে যাওয়া নোডটি একটি তালিকায় ফেরত দেওয়া হবে, [ছোট মান, এর সূচক],
    যদি কোনো জোড়া মান না থাকে অথবা অ্যারে খালি থাকে তবে [] ফেরত দিন।

    উদাহরণ 1:
        প্রবেশ: [4,2,3]
        ফলাফল: [2, 1]
        ব্যাখ্যা: 2 হল সবচেয়ে ছোট জোড়া মান, এবং 2 এর সূচক সবচেয়ে ছোট।

    উদাহরণ 2:
        প্রবেশ: [1,2,3]
        ফলাফল: [2, 1]
        ব্যাখ্যা: 2 হল সবচেয়ে ছোট জোড়া মান, এবং 2 এর সূচক সবচেয়ে ছোট।

    উদাহরণ 3:
        প্রবেশ: []
        ফলাফল: []

    উদাহরণ 4:
        প্রবেশ: [5, 0, 3, 0, 4, 2]
        ফলাফল: [0, 1]
        ব্যাখ্যা: 0 হল সবচেয়ে ছোট মান, কিন্তু দুটি শূন্য রয়েছে,
                            তাই আমরা প্রথম শূন্যটি বেছে নেব, যার সূচক সবচেয়ে ছোট।

    সীমাবদ্ধতা:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


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

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

def search(lst):
    '''
    আপনাকে ধনাত্মক পূর্ণসংখ্যার একটি অ-খালি তালিকা দেওয়া হয়েছে। শূন্যের চেয়ে বড় এবং পূর্ণসংখ্যার মানের থেকে বেশি বা সমান পুনরাবৃত্তি আছে এমন সবচেয়ে বড় পূর্ণসংখ্যাটি ফেরত দিন।
    একটি পূর্ণসংখ্যার পুনরাবৃত্তি হল তালিকায় এটি প্রদর্শিত হওয়ার সংখ্যা।
    যদি এমন কোনো মান না থাকে, তাহলে -1 ফেরত দিন।
    উদাহরণঃ
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    আপনাকে একটি অসম্পূর্ণ পজিটিভ পূর্ণসংখ্যার তালিকা দেওয়া হয়েছে। সর্বাধিক পূর্ণসংখ্যাটি ফেরত দিন যা শূন্যের চেয়ে বড়,
    এবং এর ফ্রিকোয়েন্সি তার নিজেই মানের চেয়ে বড় বা সমান।
    একটি পূর্ণসংখ্যার ফ্রিকোয়েন্সি হল সেই পূর্ণসংখ্যাটি তালিকায় কতবার উপস্থিত হয়েছে।
    যদি এমন কোনো মান না থাকে, তবে -1 ফেরত দিন।
    উদাহরণ:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''


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

    উদাহরণ:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    পূর্ণসংখ্যার একটি তালিকা দেওয়া হয়েছে, এটি একটি অদ্ভুত ক্রমে তালিকা প্রদান করে
    অদ্ভুত ক্রম হল সর্বনিম্ন মান দিয়ে শুরু করা, তারপর অবশিষ্ট পূর্ণসংখ্যার সর্বোচ্চ মান
    তারপর সর্বনিম্ন মান, এবং এভাবে চলতে থাকবে

    উদাহরণ:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

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

    উদাহরণ:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''


def triangle_area(a, b, c):
    '''
    একটি ত্রিভুজের তিনটি পাশের দৈর্ঘ্য দেওয়া হলে,
    যদি এই তিনটি পাশ একটি বৈধ ত্রিভুজ তৈরি করে, তবে ত্রিভুজটির ক্ষেত্রফল
    দুটি দশমিক স্থান পর্যন্ত রাউন্ড করে ফিরিয়ে দিন।
    অন্যথায় -1 রিটার্ন করুন।

    তিনটি পাশ একটি বৈধ ত্রিভুজ তৈরি করে যখন দুটি পাশের যোগফল তৃতীয় পাশের চেয়ে বড় হয়।

    উদাহরণ:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    একটি ত্রিভুজের তিনটি বাহুর দৈর্ঘ্য দেওয়া আছে। যদি সেই তিনটি বাহু একটি বৈধ ত্রিভুজ গঠন করে
    তবে ত্রিভুজটির ক্ষেত্রফল দশমিকের দুই ঘর পর্যন্ত গণনা করে ফেরত দিন।
    অন্যথায় -1 ফেরত দিন।
    তিনটি বাহু একটি বৈধ ত্রিভুজ গঠন করে যখন যেকোনো দুটি বাহুর যোগফল
    তৃতীয় বাহুর চেয়ে বড় হয়।
    উদাহরণঃ
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    একটি ত্রিভুজের তিনটি পাশের দৈর্ঘ্য দেওয়া হয়েছে। যদি তিনটি পাশ একটি বৈধ ত্রিভুজ তৈরি করে, তবে ত্রিভুজের এলাকা ২ দশমিক স্থান পর্যন্ত গোল করা হবে।
    অন্যথায় -1 ফেরত দিন।
    তিনটি পাশ একটি বৈধ ত্রিভুজ তৈরি করে যখন যে কোন দুটি পাশের যোগফল তৃতীয় পাশের চেয়ে বড় হয়।
    উদাহরণ:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''


def will_it_fly(q, w):
    '''
    একটি ফাংশন লিখুন যা True ফেরত দিবে যদি অবজেক্ট q উড়তে পারে, এবং অন্যথায় False ফেরত দিবে।
    অবজেক্ট q উড়তে পারে যদি এটি সুষম (এটি একটি পালিনড্রোমিক তালিকা) হয় এবং এর উপাদানের যোগফল সর্বাধিক সম্ভব ওজন w এর চেয়ে কম বা তার সমান হয়।

    উদাহরণ:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 সর্বাধিক সম্ভব ওজনের চেয়ে কম, কিন্তু এটি সুষম নয়।

    will_it_fly([3, 2, 3], 1) ➞ False
    # এটি সুষম, কিন্তু 3+2+3 সর্বাধিক সম্ভব ওজনের চেয়ে বেশি।

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 সর্বাধিক সম্ভব ওজনের চেয়ে কম, এবং এটি সুষম।

    will_it_fly([3], 5) ➞ True
    # 3 সর্বাধিক সম্ভব ওজনের চেয়ে কম, এবং এটি সুষম।
    '''

def will_it_fly(q,w):
    '''
    এমন একটি ফাংশন তৈরি করুন যা True প্রদান করে যদি বস্তু q উড়তে পারে, এবং False প্রদান করে যদি না পারে
    বস্তু q উড়বে যদি এটি ভারসাম্যপূর্ণ হয় (এটি একটি তালিকা যা প্যালিনড্রোম) এবং উপাদানগুলির যোগফল সম্ভাব্য সর্বোচ্চ ওজন w অতিক্রম না করে

    উদাহরণ:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 সম্ভাব্য সর্বোচ্চ ওজনের নিচে, কিন্তু এটি ভারসাম্যপূর্ণ নয়

    will_it_fly([3, 2, 3], 1) ➞ False
    # এটি ভারসাম্যপূর্ণ, কিন্তু 3+2+3 সম্ভাব্য সর্বোচ্চ ওজন অতিক্রম করে

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 সম্ভাব্য সর্বোচ্চ ওজনের নিচে এবং এটি ভারসাম্যপূর্ণ

    will_it_fly([3], 5) ➞ True
    # 3 সম্ভাব্য সর্বোচ্চ ওজনের নিচে এবং এটি ভারসাম্যপূর্ণ
    '''

def will_it_fly(q,w):
    '''
    একটি ফাংশন লিখুন যা True ফেরত দেয় যদি বস্তু q উড়তে পারে, এবং অন্যথায় False।
    বস্তু q উড়তে পারবে যদি এটি সুষম (এটি একটি পালিনড্রোমিক তালিকা) এবং এর উপাদানগুলির যোগফল w এর চেয়ে কম বা সমান হয়, যা সর্বাধিক সম্ভাব্য ওজন।

    উদাহরণ:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 সর্বাধিক সম্ভবত ওজনের চেয়ে কম, কিন্তু এটি অসমতল।

    will_it_fly([3, 2, 3], 1) ➞ False
    # এটি সুষম, কিন্তু 3+2+3 সর্বাধিক সম্ভবত ওজনের চেয়ে বেশি।

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 সর্বাধিক সম্ভবত ওজনের চেয়ে কম, এবং এটি সুষম।

    will_it_fly([3], 5) ➞ True
    # 3 সর্বাধিক সম্ভবত ওজনের চেয়ে কম, এবং এটি সুষম।
    '''


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

    উদাহরণ:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

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

    উদাহরণ:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

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

    যেমন:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """


def total_match(lst1, lst2):
    '''
    একটি ফাংশন লিখুন যা দুটি স্ট্রিংয়ের তালিকা গ্রহণ করে এবং একটি তালিকা ফেরত দেয় যার মোট অক্ষরের সংখ্যা
    অন্য তালিকার তুলনায় কম।

    যদি দুটি তালিকায় সমান সংখ্যক অক্ষর থাকে, তাহলে প্রথম তালিকাটি ফেরত দিন।

    উদাহরণ
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    একটি ফাংশন লিখুন যা দুটি স্ট্রিংয়ের তালিকা গ্রহণ করে এবং এমন তালিকাটি ফেরত দেয়,
    যার সকল স্ট্রিংয়ের মোট অক্ষরের সংখ্যা অপর তালিকার চেয়ে কম।

    যদি দুটি তালিকার মোট অক্ষরের সংখ্যা সমান হয়, তাহলে প্রথম তালিকাটি ফেরত দিন।

    উদাহরণসমূহ:
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    দুটি স্ট্রিংয়ের তালিকা গ্রহণ করে একটি ফাংশন লিখুন এবং সেই তালিকাটি ফেরত দিন
    যেটি সমস্ত স্ট্রিংয়ের মোট চরিত্রের সংখ্যা অন্য তালিকার চেয়ে কম।

    যদি দুটি তালিকায় সমান সংখ্যক চরিত্র থাকে, তবে প্রথম তালিকাটি ফেরত দিন।

    উদাহরণ
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''


def is_multiply_prime(a):
    """একটি ফাংশন লিখুন যা প্রদানকৃত সংখ্যাটি যদি ৩টি মৌলিক সংখ্যার গুণফল হয় তবে সত্য (True) এবং অন্যথায় মিথ্যা (False) প্রদান করবে।
    জানানো হচ্ছে যে (a) ১০০-এর কম।
    উদাহরণ:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """এমন একটি ফাংশন লেখ যা, প্রদত্ত সংখ্যা যদি ৩টি মৌলিক সংখ্যার গুণফলের সমান হয়
    তাহলে true আর যদি না হয় তাহলে false ফেরত দেবে।
    জানা আছে যে, 100-র চেয়ে (a) ছোট।
    উদাহরণ:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """একটি ফাংশন লিখুন যা true প্রদান করে যদি প্রদত্ত সংখ্যাটি 3টি মৌলিক সংখ্যার গুণফল হয় এবং অন্যথায় false প্রদান করে।
    মনে রাখবেন (a) এর মান 100 থেকে কম।
    উদাহরণঃ
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """


def is_simple_power(x, n):
    """আপনার কাজ হল একটি ফাংশন লেখা যা সত্য ফিরিয়ে দেবে যদি একটি সংখ্যা x, n-এর একটি সাধারণ পাওয়ার হয় এবং অন্যথায় মিথ্যা ফিরিয়ে দেবে।
    x যদি n**int=x হয় তবে x একটি সাধারণ পাওয়ার হবে।
    উদাহরণস্বরূপ:
    is_simple_power(1, 4) => সত্য
    is_simple_power(2, 2) => সত্য
    is_simple_power(8, 2) => সত্য
    is_simple_power(3, 2) => মিথ্যা
    is_simple_power(3, 1) => মিথ্যা
    is_simple_power(5, 3) => মিথ্যা
    """

def is_simple_power(x, n):
    """আপনার কাজ হল এমন একটি ফাংশন লেখা যা true ফেরত দেয় যদি সংখ্যা x n এর একটি সাধারণ শক্তি হয়
    এবং অন্যথায় false ফেরত দেয়।
    x n এর একটি সাধারণ শক্তি মানে n**int=x
    উদাহরণঃ
    is_simple_power(1, 4) => সত্য
    is_simple_power(2, 2) => সত্য
    is_simple_power(8, 2) => সত্য
    is_simple_power(3, 2) => মিথ্যা
    is_simple_power(3, 1) => মিথ্যা
    is_simple_power(5, 3) => মিথ্যা
    """

def is_simple_power(x, n):
    """আপনার কাজ হল এমন একটি ফাংশন লেখা যা true প্রদান করে যদি সংখ্যা x হয় n এর একটি সাধারণ শক্তি
    এবং অন্যথায়  false প্রদান করে
    x n এর একটি সাধারণ শক্তি মানে n**int=x
    উদাহরণ:
    is_simple_power(1, 4) => সত্য
    is_simple_power(2, 2) => সত্য
    is_simple_power(8, 2) => সত্য
    is_simple_power(3, 2) => মিথ্যা
    is_simple_power(3, 1) => মিথ্যা
    is_simple_power(5, 3) => মিথ্যা
    """


def iscube(a):
    '''
    একটি পূর্ণসংখ্যা a গ্রহণ করে একটি ফাংশন লিখুন এবং যদি এটি কোনও
    পূর্ণসংখ্যার ঘনফল হয় তবে True ফেরত দিন।
    লক্ষ্য করুন: আপনি ধরে নিতে পারেন যে ইনপুটটি সর্বদা বৈধ।
    উদাহরণ:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    একটি ফাংশন যা একটি পূর্ণসংখ্যা a গ্রহণ করে এবং True প্রদান করে যদি এই পূর্ণসংখ্যাটি কোনো পূর্ণসংখ্যার ঘন হয়
    মনে রাখবেন: আপনি ধরে নিতে পারেন যে ইনপুট ডেটা সর্বদা সঠিক
    উদাহরণ:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    একটি পূর্ণসংখ্যা a নিন এবং এটি যদি কোন পূর্ণসংখ্যার ঘনমূলক সংখ্যা হয় তবে True ফেরত দিন।
    লক্ষ্য: আপনি ধরতে পারেন যে ইনপুট সবসময় সঠিক হবে।

    উদাহরণস্বরূপ:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''


def hex_key(num):
    """আপনাকে একটি ফাংশন লিখতে বলা হয়েছে যা একটি হেক্সাডেসিমাল সংখ্যা স্ট্রিং আকারে গ্রহণ করবে
    এবং হেক্সাডেসিমাল ডিজিটগুলির মধ্যে যেগুলি প্রাইম সংখ্যা, তাদের সংখ্যা গণনা করবে।
    একটি প্রাইম সংখ্যা হলো এমন একটি প্রাকৃতিক সংখ্যা যা ১ এর বড় এবং দুটি ছোট প্রাকৃতিক সংখ্যা দ্বারা গুন করা যায় না।
    হেক্সাডেসিমাল ডিজিটগুলি হল ০, ১, ২, ৩, ৪, ৫, ৬, ৭, ৮, ৯, A, B, C, D, E, F।
    প্রাইম সংখ্যা গুলি হল ২, ৩, ৫, ৭, ১১, ১৩, ১৭,...
    সুতরাং আপনাকে নিম্নলিখিত ডিজিটগুলির মধ্যে প্রাইম সংখ্যা গুলি গণনা করতে হবে: ২, ৩, ৫, ৭, B (যা দশমিক ১১),
    D (যা দশমিক ১৩)।

    লক্ষ্য: আপনাকে ধরতে হবে যে ইনপুটটি সবসময় সঠিক অথবা একটি খালি স্ট্রিং হবে, এবং A, B, C, D, E, F সবকিছু
    বড় হাতের অক্ষর হবে।

    উদাহরণ:
    num = "AB" এর জন্য আউটপুট হবে ১।
    num = "1077E" এর জন্য আউটপুট হবে ২।
    num = "ABED1A33" এর জন্য আউটপুট হবে ৪।
    num = "123456789ABCDEF0" এর জন্য আউটপুট হবে ৬।
    num = "2020" এর জন্য আউটপুট হবে ২।
    """

def hex_key(num):
    """আপনাকে একটি ফাংশন লেখার কাজ দেওয়া হয়েছে যা একটি
    হেক্সাডেসিমাল নম্বর স্ট্রিং হিসেবে গ্রহণ করে এবং গননা করে
    কতগুলি হেক্সাডেসিমাল ডিজিট প্রাইম (প্রাইম নাম্বার, বা প্রাইম, হল একটি প্রাকৃতিক সংখ্যা
    যা 1 এর চেয়ে বড় এবং দুটি ছোট প্রাকৃতিক সংখ্যার গুণফল নয়)।
    হেক্সাডেসিমাল ডিজিটগুলো হল 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F।
    প্রাইম নাম্বারগুলো হল 2, 3, 5, 7, 11, 13, 17,...
    তাই আপনাকে পরবর্তী ডিজিটগুলির মধ্যে সংখ্যা নির্ধারণ করতে হবে: 2, 3, 5, 7,
    B (=ডেসিমাল 11), D (=ডেসিমাল 13)।
    লক্ষ্য: আপনি ধরে নিতে পারেন ইনপুটটি সবসময় সঠিক বা ফাঁকা স্ট্রিং হবে,
    এবং A, B, C, D, E, F চিহ্নগুলো সবসময় বড় অক্ষরে থাকবে।
    উদাহরণ:
    যদি num = "AB" ফলাফল হওয়া উচিত 1।
    যদি num = "1077E" ফলাফল হওয়া উচিত 2।
    যদি num = "ABED1A33" ফলাফল হওয়া উচিত 4।
    যদি num = "123456789ABCDEF0" ফলাফল হওয়া উচিত 6।
    যদি num = "2020" ফলাফল হওয়া উচিত 2।
    """

def hex_key(num):
    """তোমাকে একটি ফাংশন তৈরি করতে বলা হয়েছে যা একটি হেক্সাডেসিমাল সংখ্যার স্ট্রিং গ্রহণ করে এবং এর মধ্যে প্রাইম সংখ্যার সংখ্যা গণনা করে।
    প্রাইম সংখ্যা (প্রাইম সংখ্যা হল একটি প্রাকৃতিক সংখ্যা যা 1 এর চেয়ে বড় এবং 2 এর চেয়ে ছোট প্রাকৃতিক সংখ্যার গুণফল নয়)
    হেক্সাডেসিমাল অঙ্কগুলি হল 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F
    প্রাইম সংখ্যা হল 2, 3, 5, 7, 11, 13, 17,...
    সুতরাং, নিম্নলিখিত অঙ্কগুলি পরীক্ষা করা গুরুত্বপূর্ণ: 2, 3, 5, 7, B (=ডেসিমাল 11), D (=ডেসিমাল 13)
    নোট: ধরে নেওয়া যেতে পারে যে ইনপুটটি সর্বদা সঠিক হবে বা একটি খালি স্ট্রিং হবে, এবং অক্ষর A, B, C, D, E, F সর্বদা বড় হাতের হবে।
    উদাহরণ:
    যদি num = "AB" ফলাফল হওয়া উচিত 1
    যদি num = "1077E" ফলাফল হওয়া উচিত 2
    যদি num = "ABED1A33" ফলাফল হওয়া উচিত 4
    যদি num = "123456789ABCDEF0" ফলাফল হওয়া উচিত 6
    যদি num = "2020" ফলাফল হওয়া উচিত 2
    """


def decimal_to_binary(decimal):
    """তোমাকে দশমিক রূপের একটি সংখ্যা দেওয়া হবে এবং তোমার কাজ হবে সেটিকে
    বাইনারিতে রূপান্তরিত করা। ফাংশনটি থেকে এমন একটি স্ট্রিং ফেরত পাওয়া যাবে যার প্রতিটি
    অক্ষরই এক একটি বাইনারি অঙ্ক হবে। স্ট্রিংয়ের প্রতিটি অক্ষর হয় '0' নাহয় '1' হবে।

    স্ট্রিংয়ের শুরুতে ও শেষে বাড়তি কিছু অক্ষর 'db' থাকবে।
    বাড়তি অক্ষরগুলো থাকবে ফরম্যাটের সুবিধার্থে।

    উদাহরণ:
    decimal_to_binary(15)   # "db1111db" ফেরত পাওয়া যাবে
    decimal_to_binary(32)   # "db100000db" ফেরত পাওয়া যাবে
    """

def decimal_to_binary(decimal):
    """আপনাকে একটি সংখ্যা দশমিক রূপে দেওয়া হবে এবং আপনার কাজ হল এটি
    বাইনারি ফরম্যাটে রূপান্তর করা। ফাংশনটি একটি স্ট্রিং রিটার্ন করবে,
    যেখানে প্রতিটি ক্যারেক্টার একটি বাইনারি সংখ্যা উপস্থাপন করবে।  স্ট্রিংয়ের প্রতিটি ক্যারেক্টার '0' বা '1' হবে।

    স্ট্রিংয়ের শুরুতে এবং শেষে একটি বিশেষ অক্ষর 'db' থাকবে
    অতিরিক্ত ক্যারেক্টারগুলি ফরম্যাটের সাথে সাহায্য করার জন্য রয়েছে।

    উদাহরণ:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """

def decimal_to_binary(decimal):
    """আপনাকে একটি ডেসিম্যাল সংখ্যা দেওয়া হবে এবং আপনার কাজ হল এটিকে বাইনারিতে রূপান্তর করা।
    ফাংশনটি একটি স্ট্রিং হিসেবে মান ফেরত দেবে, যেখানে প্রতিটি অক্ষর বাইনারি প্রতিনিধিত্ব করে।
    স্ট্রিংয়ের প্রতিটি অক্ষর '0' বা '1' হবে।

    স্ট্রিং এর শুরুতে এবং শেষে অতিরিক্ত দুটি অক্ষর 'db' থাকবে।
    এই বিশেষ অক্ষর দুটি গঠন তৈরিতে সহায়তা করার জন্য।

    উদাহরণঃ
    decimal_to_binary(15)   # "db1111db" ফেরত দেবে
    decimal_to_binary(32)   # "db100000db" ফেরত দেবে
    """


def is_happy(s):
    """আপনাকে একটি স্ট্রিং s দেওয়া হয়েছে।
    আপনার কাজ হল চেক করা যে স্ট্রিংটি খুশি কিনা।
    একটি স্ট্রিং খুশি হবে যদি এর দৈর্ঘ্য কমপক্ষে 3 হয় এবং প্রতিটি 3টি পরপর অক্ষর আলাদা হয়
    উদাহরণ:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """আপনাকে একটি স্ট্রিং s প্রদান করা হয়েছে
    আপনার কাজ হল পরীক্ষা করা যে স্ট্রিংটি সুখী কিনা
    স্ট্রিংটি সুখী হবে যদি এর দৈর্ঘ্য কমপক্ষে ৩ হয় এবং ধারাবাহিক ৩টি অক্ষর ভিন্ন হয়
    উদাহরণ:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """তোমাকে s নামের একটি স্ট্রিং দেওয়া হয়েছে।
    তোমার কাজ হল স্ট্রিংটি খুশি কি না তা পরীক্ষা করা।
    কোনো স্ট্রিংয়ের দৈর্ঘ্য অন্তত ৩ হলে ও পর পর তিনটি অক্ষর সবসময় ভিন্ন হলে স্ট্রিংটি বলে গণ্য হবে
    যেমন:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """


def numerical_letter_grade(grades):
    """এটি সেমিস্টারের শেষ সপ্তাহ এবং শিক্ষককে ছাত্রদের গ্রেড দিতে হবে।
    শিক্ষক তার নিজস্ব গ্রেডিং অ্যালগরিদম তৈরি করেছেন।
    একমাত্র সমস্যা হলো, তিনি যে কোডটি গ্রেডিংয়ের জন্য ব্যবহার করেছেন তা তিনি হারিয়ে ফেলেছেন।
    তিনি আপনাকে কিছু ছাত্রদের GPA এর একটি তালিকা দিয়েছেন এবং আপনাকে একটি ফাংশন লিখতে হবে
    যা নিম্নলিখিত টেবিল ব্যবহার করে একটি তালিকা আউটপুট করবে:
             GPA       |    Letter grade
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    উদাহরণ:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """এটি সেমিস্টারের শেষ সপ্তাহ এবং শিক্ষককে ছাত্রদের গ্রেড দেওয়ার জন্য
    একটি ফাংশন লিখতে হবে। শিক্ষক তার গ্রেডিংয়ের জন্য নিজের একটি অ্যালগরিদম তৈরি করেছেন।
    একমাত্র সমস্যা হলো, তিনি কোডটি হারিয়ে ফেলেছেন যা তিনি গ্রেডিংয়ের জন্য ব্যবহার করেছিলেন।
    তিনি আপনাকে কিছু ছাত্রের GPA এর একটি তালিকা দিয়েছেন এবং আপনাকে একটি ফাংশন লিখতে হবে যা
    নিম্নলিখিত টেবিল ব্যবহার করে লেটার গ্রেডের একটি তালিকা আউটপুট করবে:

            GPA       |    Letter grade
             4.0                A+
           > 3.7                A
           > 3.3                A-
           > 3.0                B+
           > 2.7                B
           > 2.3                B-
           > 2.0                C+
           > 1.7                C
           > 1.3                C-
           > 1.0                D+
           > 0.7                D
           > 0.0                D-
             0.0                E

    উদাহরণ:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """এটি সেমিস্টারের শেষ সপ্তাহ এবং শিক্ষককে শিক্ষার্থীদের গ্রেড দিতে হবে।
    শিক্ষক তার নিজস্ব গ্রেডিং অ্যালগরিদম তৈরি করছেন।
    একমাত্র সমস্যা হল, তিনি তার ব্যবহার করা কোডটি হারিয়ে ফেলেছেন।
    তিনি আপনাকে কিছু শিক্ষার্থীর GPA-এর একটি তালিকা দিয়েছেন এবং আপনাকে একটি ফাংশন লিখতে হবে
    যা নিম্নলিখিত টেবিল ব্যবহার করে একটি তালিকা আক্ষরিক গ্রেড আউটপুট করতে পারে:
             GPA       |    Letter grade
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    উদাহরণ:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """


def prime_length(string):
    """ একটি ফাংশন লিখুন যা একটি স্ট্রিং নেয় এবং যদি স্ট্রিংটির দৈর্ঘ্য একটি মৌলিক সংখ্যা হয়,
    তবে True ফেরত দেয়, অন্যথায় False ফেরত দেয়।

    উদাহরণ:
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """একটি স্ট্রিং নিন এবং একটি ফাংশন তৈরি করুন যা True প্রদান করে
    যদি স্ট্রিংটির দৈর্ঘ্য একটি মৌলিক সংখ্যা হয়
    এবং False প্রদান করে যদি তা না হয়
    উদাহরণ
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """একটি ফাংশন লিখুন যা একটি স্ট্রিং নেয় এবং স্ট্রিংয়ের দৈর্ঘ্য যদি একটি মৌলিক সংখ্যা হয়
    তবে True রিটার্ন করবে অন্যথায় False রিটার্ন করবে
    উদাহরণ
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """


def starts_one_ends(n):
    """
    একটি ধনাত্মক পূর্ণসংখ্যা n দেওয়া হলে, n অঙ্ক বিশিষ্ট ধনাত্মক পূর্ণসংখ্যাগুলির মধ্যে যেগুলি 1 দিয়ে শুরু হয় অথবা 1 দিয়ে শেষ হয়, সেই সংখ্যা গননা করে ফেরত দিন।
    """

def starts_one_ends(n):
    """
    একটি ধনাত্মক পূর্ণসংখ্যা n দেওয়া আছে, 1 দিয়ে শুরু বা শেষ হওয়া n-অঙ্কের ধনাত্মক পূর্ণসংখ্যার অঙ্ক সংখ্যা ফেরত দিন।
    """

def starts_one_ends(n):
    """
    যদি আপনাকে একটি ধনাত্মক পূর্ণসংখ্যা n দেওয়া হয়, তাহলে n সংখ্যক অঙ্কের ধনাত্মক পূর্ণসংখ্যার সংখ্যা প্রদাম করুন যা 1 দিয়ে শুরু হয় বা 1 দিয়ে শেষ হয়
    """


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

    উদাহরণ:
        N = 1000 হলে, ডিজিটগুলির যোগফল হবে 1, আউটপুট হওয়া উচিত "1"।
        N = 150 হলে, ডিজিটগুলির যোগফল হবে 6, আউটপুট হওয়া উচিত "110"।
        N = 147 হলে, ডিজিটগুলির যোগফল হবে 12, আউটপুট হওয়া উচিত "1100"।

    ভেরিয়েবল:
        @N পূর্ণসংখ্যা
             শর্তাবলী: 0 ≤ N ≤ 10000।
    আউটপুট:
         একটি বাইনারি সংখ্যার স্ট্রিং
    """

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

    উদাহরণ
        N = 1000 হলে অঙ্কগুলোর যোগফল হবে 1 আউটপুট আসা উচিত "1"।
        N = 150 হলে অঙ্কগুলোর যোগফল হবে 6 আউটপুট আসা উচিত "110"।
        N = 147 হলে অঙ্কগুলোর যোগফল হবে 12 আউটপুট আসা উচিত "1100"।

    Variables:
        @N পূর্ণসংখ্যা
             শর্ত: 0 ≤ N ≤ 10000।
    আউটপুট:
         বাইনারি সংখ্যার একটি স্ট্রিং
    """

def solve(N):
    """যদি একটি ধনাত্মক পূর্ণসংখ্যা N দেওয়া হয়, তবে বাইনারি ভিত্তিক সংখ্যার পদ্ধতিতে অঙ্কের যোগফল প্রদান করুন

    উদাহরণ
        N = 1000 এই ক্ষেত্রে, অঙ্কের যোগফল হল 1 এবং ফলাফল হওয়া উচিত "1"
        N = 150 এই ক্ষেত্রে, অঙ্কের যোগফল হল 6 এবং ফলাফল হওয়া উচিত "110"
        N = 147 এই ক্ষেত্রে, অঙ্কের যোগফল হল 12 এবং ফলাফল হওয়া উচিত "1100"

    প্যারামিটার:
        @N পূর্ণসংখ্যা
             সীমাবদ্ধতা: 0 ≤ N ≤ 10000.
    ফলাফল:
         বাইনারি ভিত্তিক সংখ্যার মুদ্রা
    """


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

    উদাহরণ:
        add([4, 2, 6, 7]) ==> 2
    """

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

    উদাহরণঃ
        add([4, 2, 6, 7]) ==> 2
    """

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

    উদাহরণ:
        add([4, 2, 6, 7]) ==> 2
    """


def anti_shuffle(s):
    """
    একটি ফাংশন লিখুন যা একটি স্ট্রিং নেয় এবং তার একটি সাজানো সংস্করণ ফেরত দেয়।
    স্ট্রিংয়ের সাজানো সংস্করণ হল এমন একটি স্ট্রিং যেখানে সমস্ত শব্দ (যেগুলি স্পেস দ্বারা আলাদা)
    একটি নতুন শব্দ দ্বারা প্রতিস্থাপিত হয়, যেখানে সমস্ত অক্ষর গুলি তাদের ASCII মানের উপর ভিত্তি করে
    ঊর্ধ্বমুখীভাবে সাজানো থাকে।
    লক্ষ্য করুন: আপনাকে শব্দের ক্রম এবং বাক্যে ফাঁকা স্থানগুলি বজায় রাখতে হবে।

    উদাহরণ:
    anti_shuffle('Hi') রিটার্ন করবে 'Hi'
    anti_shuffle('hello') রিটার্ন করবে 'ehllo'
    anti_shuffle('Hello World!!!') রিটার্ন করবে 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    একটি ফাংশন লিখুন যা একটি স্ট্রিং নেয় এবং তার একটি সাজানো সংস্করণ ফেরত দেয়।
    স্ট্রিং এর সাজানো সংস্করণ হল একটি স্ট্রিং যেখানে সব শব্দ (স্পেস দ্বারা পৃথক করা)
    নতুন একটি শব্দে প্রতিস্থাপিত হয়, যেখানে সব অক্ষরগুলিকে ASCII মান অনুযায়ী
    অবসরক্রমে সাজানো হয়।
    দ্রষ্টব্য: আপনাকে বাক্যের শব্দ এবং ফাঁকা স্থানগুলির আদেশ বজায় রাখতে হবে।

    উদাহরণস্বরূপ:
    anti_shuffle('Hi') returns 'Hi'
    anti_shuffle('hello') returns 'ehllo'
    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    একটি ফাংশন তৈরি করুন যা ঐ স্ট্রিংয়ের সাজানো সংস্করণ প্রদান করে
    স্ট্রিংয়ের সাজানো সংস্করণ মানে হল সমস্ত শব্দ পরিবর্তন করা
    (যেগুলি ফাঁকা স্থান দ্বারা পৃথক করা হয়েছে) নতুন শব্দের সাথে যেখানে সমস্ত অক্ষর সাজানো হয়েছে
    ascii মান অনুযায়ী ক্রমবর্ধমান ক্রমে
    মনে রাখবেন: বাক্যে শব্দ এবং ফাঁকা স্থানের ক্রম সংরক্ষণ করতে হবে

    উদাহরণস্বরূপ:
    anti_shuffle('Hi') প্রদান করবে 'Hi'
    anti_shuffle('hello') প্রদান করবে 'ehllo'
    anti_shuffle('Hello World!!!') প্রদান করবে 'Hello !!!Wdlor'
    """


def get_row(lst, x):
    """
    আপনাকে ২-মাত্রিক ডেটা দেওয়া হয়েছে, যা একটি নেস্টেড লিস্টের মতো,
    তবে ম্যাট্রিক্সের মতো নয়, কারণ প্রতিটি সারিতে বিভিন্ন সংখ্যক কলাম থাকতে পারে।
    দেওয়া lst এবং পূর্ণসংখ্যা x, lst-এ x-এর সমস্ত উপস্থিতি খুঁজে বের করুন,
    এবং তাদের একটি টুপলে সাজানো তালিকা ফেরত দিন, [(x1, y1), (x2, y2) ...] যেখানে
    প্রতিটি টুপল একটি কোঅর্ডিনেট - (সারি, কলাম), যেখানে সূচক ০ থেকে শুরু হবে।
    প্রথমে সারিগুলিকে ক্রমানুসারে সাজান, তারপর সারির কোঅর্ডিনেটগুলো কলাম অনুযায়ী অবতরণক্রমে সাজান।

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

def get_row(lst, x):
    """
    আপনাকে একটি ২ মাত্রিক ডেটা দেওয়া হয়েছে, যা একটি nested lists-এর মতো,
    তবে, ম্যাট্রিক্সের মতো নয়, প্রতিটি row-তে বিভিন্ন সংখ্যার কলাম থাকতে পারে।
    দেওয়া আছে lst এবং পূর্ণসংখ্যা x, তালিকায় x সংখ্যাগুলি খুঁজুন,
    এবং [(x1, y1), (x2, y2) ...] আকারে জোড়ার তালিকা ফেরত দিন, যেখানে প্রতিটি টিউপল একটি coordinate - (row, columns)।
    ক্রমানুসার শুরু হবে 0 থেকে।
    স্থানাঙ্কগুলি সারি অনুযায়ী নিম্ন থেকে উচ্চ ক্রমে সাজানো হবে
    আরও, সারির স্থানাঙ্কগুলি কলাম অনুযায়ী উচ্চ থেকে নিম্ন ক্রমে সাজানো হবে

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

def get_row(lst, x):
    """
    একটি দ্বিমাত্রিক তালিকা একটি নেস্টেড তালিকার আকারে প্রদান করা হয়েছে
    যা একটি ম্যাট্রিক্সের মতো, কিন্তু ম্যাট্রিক্সের থেকে ভিন্ন হল
    প্রতিটি সারিতে বিভিন্ন সংখ্যক কলাম থাকতে পারে
    প্রদত্ত lst এবং পূর্ণসংখ্যা x, তালিকায় পূর্ণসংখ্যা x খুঁজুন
    এবং [(x1, y1), (x2, y2) ...] আকারে জোড়ার তালিকা প্রদান করুন
    যেখানে প্রতিটি জোড়া নির্দেশ করে স্থানাঙ্ক - (সারি, কলাম) 0 থেকে শুরু করে
    স্থানাঙ্কগুলি সারি অনুযায়ী নিম্ন থেকে উর্ধক্রমে সাজানো হবে
    এবং সারির স্থানাঙ্কগুলি কলাম অনুযায়ী উচ্চ থেকে নিম্নক্রমে সাজানো হবে

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