পাইথন উদাহরণ সহ বিগ ও নোটেশন এবং অ্যালগরিদম বিশ্লেষণ

ভূমিকা

একটি কম্পিউটার প্রোগ্রাম ব্যবহার করে সমস্যা সমাধানের জন্য সাধারণত একাধিক উপায় আছে। উদাহরণস্বরূপ, একটি অ্যারেতে আইটেমগুলি সাজানোর বিভিন্ন উপায় রয়েছে - আপনি ব্যবহার করতে পারেন মার্জ সাজান, বুদ্বুদ সাজান, সন্নিবেশ সাজান, এবং তাই। এই সমস্ত অ্যালগরিদমগুলির নিজস্ব সুবিধা এবং অসুবিধা রয়েছে এবং বিকাশকারীর কাজ হল যে কোনও ব্যবহারের ক্ষেত্রে ব্যবহার করার জন্য সর্বোত্তম অ্যালগরিদম বেছে নিতে সক্ষম হওয়ার জন্য তাদের ওজন করা। অন্য কথায়, সমস্যাটির একাধিক সমাধান থাকলে একটি নির্দিষ্ট সমস্যা সমাধানের জন্য কোন অ্যালগরিদম ব্যবহার করতে হবে তা হল প্রধান প্রশ্ন।

অ্যালগরিদম বিশ্লেষণ বিভিন্ন অ্যালগরিদমের জটিলতার বিশ্লেষণ এবং সমস্যা সমাধানের জন্য সবচেয়ে কার্যকর অ্যালগরিদম খুঁজে বের করাকে বোঝায়। বিগ-ও স্বরলিপি অ্যালগরিদমের জটিলতা বর্ণনা করতে ব্যবহৃত একটি পরিসংখ্যানগত পরিমাপ।

এই নির্দেশিকায়, আমরা প্রথমে অ্যালগরিদম বিশ্লেষণের একটি সংক্ষিপ্ত পর্যালোচনা করব এবং তারপর বিগ-ও স্বরলিপিটি গভীরভাবে দেখব। আমরা দেখব কিভাবে বিগ-ও নোটেশন ব্যবহার করে বিভিন্ন পাইথন ফাংশনের সাহায্যে অ্যালগরিদমের জটিলতা খুঁজে বের করা যায়।

কেন অ্যালগরিদম বিশ্লেষণ গুরুত্বপূর্ণ?

অ্যালগরিদম বিশ্লেষণ কেন গুরুত্বপূর্ণ তা বোঝার জন্য, আমরা একটি সাধারণ উদাহরণের সাহায্য নেব। ধরুন একজন ম্যানেজার তার দুই কর্মচারীকে পাইথনে একটি অ্যালগরিদম ডিজাইন করার জন্য একটি টাস্ক দিয়েছেন যা ব্যবহারকারীর দ্বারা প্রবেশ করা একটি সংখ্যার ফ্যাক্টরিয়াল গণনা করে। প্রথম কর্মচারী দ্বারা উন্নত অ্যালগরিদম এই মত দেখায়:

def fact(n):
    product = 1
    for i in range(n):
        product = product * (i+1)
    return product

print(fact(5))

লক্ষ্য করুন যে অ্যালগরিদম কেবল একটি আর্গুমেন্ট হিসাবে একটি পূর্ণসংখ্যা নেয়। ভিতরে fact() নামের একটি ভেরিয়েবল ফাংশন product থেকে শুরু করা হয় 1. একটি লুপ থেকে সঞ্চালিত হয় 1 থেকে n এবং প্রতিটি পুনরাবৃত্তির সময়, এর মান product লুপ দ্বারা পুনরাবৃত্তি করা সংখ্যা দ্বারা গুণিত হয় এবং ফলাফল সংরক্ষিত হয় product আবার পরিবর্তনশীল। লুপ কার্যকর করার পরে, product ভেরিয়েবলে ফ্যাক্টরিয়াল থাকবে।

একইভাবে, দ্বিতীয় কর্মচারীও একটি অ্যালগরিদম তৈরি করেছে যা একটি সংখ্যার ফ্যাক্টরিয়াল গণনা করে। দ্বিতীয় কর্মচারী সংখ্যার ফ্যাক্টরিয়াল গণনা করতে একটি পুনরাবৃত্ত ফাংশন ব্যবহার করেছিল n:

def fact2(n):
    if n == 0:
        return 1
    else:
        return n * fact2(n-1)

print(fact2(5))

কোন অ্যালগরিদম ব্যবহার করবেন তা ম্যানেজারকে সিদ্ধান্ত নিতে হবে। এটি করার জন্য, তারা কোন অ্যালগরিদম দ্রুত চলে তা বেছে নেওয়ার সিদ্ধান্ত নিয়েছে৷ এটি করার একটি উপায় হল একই ইনপুটে কোড চালানোর জন্য প্রয়োজনীয় সময় খুঁজে বের করা।

Jupyter নোটবুকে, আপনি ব্যবহার করতে পারেন %timeit আক্ষরিক তারপর ফাংশন কল দ্বারা কার্যকর করার জন্য ফাংশন দ্বারা নেওয়া সময় খুঁজে বের করার জন্য:

%timeit fact(50)

এটি আমাদের দেবে:

9 µs ± 405 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

আউটপুট বলে যে অ্যালগরিদম লাগে 9 মাইক্রোসেকেন্ড (প্লাস/মাইনাস 45 ন্যানোসেকেন্ড) প্রতি লুপ।

একইভাবে, আমরা গণনা করতে পারি যে দ্বিতীয় পদ্ধতিটি কার্যকর করতে কত সময় লাগে:

%timeit fact2(50)

এর ফলে হবে:

15.7 µs ± 427 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

পুনরাবৃত্তি জড়িত দ্বিতীয় অ্যালগরিদম লাগে 15 মাইক্রোসেকেন্ড (প্লাস/মাইনাস 427 ন্যানোসেকেন্ড)।

সঞ্চালনের সময় দেখায় যে প্রথম অ্যালগরিদমটি পুনরাবৃত্তি জড়িত দ্বিতীয় অ্যালগরিদমের তুলনায় দ্রুত। বড় ইনপুট নিয়ে কাজ করার সময়, কর্মক্ষমতা পার্থক্য আরও তাৎপর্যপূর্ণ হয়ে উঠতে পারে।

যাইহোক, অ্যালগরিদমের জটিলতা পরিমাপ করার জন্য এক্সিকিউশন টাইম একটি ভাল মেট্রিক নয় কারণ এটি হার্ডওয়্যারের উপর নির্ভর করে। একটি অ্যালগরিদমের জন্য আরও উদ্দেশ্যমূলক জটিলতা বিশ্লেষণ মেট্রিক প্রয়োজন। এই যেখানে বড় হে স্বরলিপি খেলা আসে।

বিগ-ও নোটেশন সহ অ্যালগরিদম বিশ্লেষণ

বিগ-ও নোটেশন অ্যালগরিদমের ইনপুট এবং অ্যালগরিদম চালানোর জন্য প্রয়োজনীয় পদক্ষেপগুলির মধ্যে সম্পর্ককে নির্দেশ করে। এটি একটি বড় "O" দ্বারা চিহ্নিত করা হয় এবং একটি খোলা এবং বন্ধ বন্ধনী দ্বারা অনুসরণ করা হয়। বন্ধনীর ভিতরে, ইনপুট এবং অ্যালগরিদম দ্বারা গৃহীত পদক্ষেপের মধ্যে সম্পর্ক "n" ব্যবহার করে উপস্থাপন করা হয়েছে।

মূল টেকঅ্যাওয়ে হল – বিগ-ও একটিতে আগ্রহী নয় বিশেষ উদাহরণ যেখানে আপনি একটি অ্যালগরিদম চালান, যেমন fact(50), বরং, এটা কতটা ভালো করে স্কেল ক্রমবর্ধমান ইনপুট দেওয়া। এটি একটি কংক্রিট উদাহরণের জন্য কংক্রিট সময়ের চেয়ে মূল্যায়নের জন্য অনেক ভাল মেট্রিক!

যেমন, যদি থাকে a রৈখিক সম্পর্ক ইনপুট এবং অ্যালগরিদম দ্বারা গৃহীত পদক্ষেপের মধ্যে এটি কার্যকর করার জন্য, ব্যবহৃত বিগ-ও স্বরলিপি হবে উপর). একইভাবে, জন্য বিগ-ও স্বরলিপি চতুর্ভুজ ফাংশন is O(n²).

অন্তর্দৃষ্টি তৈরি করতে:

• উপর): এ n=1, 1 পদক্ষেপ নেওয়া হয়। এ n=10, 10টি পদক্ষেপ নেওয়া হয়।
• O(n²): এ n=1, 1 পদক্ষেপ নেওয়া হয়। এ n=10, 100টি পদক্ষেপ নেওয়া হয়।

At n=1, এই দুজন একই কাজ করবে! এটি আরেকটি কারণ যে ইনপুট এবং সেই ইনপুটটি প্রক্রিয়া করার জন্য পদক্ষেপের সংখ্যার মধ্যে সম্পর্ক পর্যবেক্ষণ করা কিছু কংক্রিট ইনপুট দিয়ে ফাংশন মূল্যায়ন করার চেয়ে ভাল।

নিম্নলিখিত কয়েকটি সাধারণ বিগ-ও ফাংশন রয়েছে:

নাম	বড় হে
ধ্রুব	ও (সি)
রৈখিক	উপর)
দ্বিঘাত	O(n²)
ঘন	O(n³)
ব্যাখ্যামূলক	O(2ⁿ)
লোগারিদমিক	ও (লগ (এন))
লগ লিনিয়ার	O(nlog(n))

আপনি এই ফাংশনগুলি কল্পনা করতে পারেন এবং তাদের তুলনা করতে পারেন:

সাধারণভাবে বলতে গেলে - রৈখিক থেকে খারাপ কিছু একটি খারাপ জটিলতা হিসাবে বিবেচিত হয় (অর্থাৎ অদক্ষ) এবং সম্ভব হলে এড়ানো উচিত। রৈখিক জটিলতা ঠিক আছে এবং সাধারণত একটি প্রয়োজনীয় মন্দ। লগারিদমিক ভাল. ধ্রুবক আশ্চর্যজনক!

একটি বিগ-ও কীভাবে গণনা করা হয় তার একটি ধারণা পেতে, আসুন ধ্রুবক, রৈখিক এবং দ্বিঘাত জটিলতার কিছু উদাহরণ দেখি।

ধ্রুবক জটিলতা - O(C)

একটি অ্যালগরিদমের জটিলতাকে স্থির বলা হয় যদি একটি অ্যালগরিদম কার্যকর করার জন্য প্রয়োজনীয় পদক্ষেপগুলি স্থির থাকে, ইনপুটের সংখ্যা নির্বিশেষে। ধ্রুবক জটিলতা দ্বারা চিহ্নিত করা হয় ও (সি) কোথায় c যেকোনো ধ্রুবক সংখ্যা হতে পারে।

আসুন পাইথনে একটি সাধারণ অ্যালগরিদম লিখি যা তালিকার প্রথম আইটেমের বর্গ খুঁজে পায় এবং তারপরে এটি স্ক্রিনে প্রিন্ট করে:

def constant_algo(items):
    result = items[0] * items[0]
    print(result)

constant_algo([4, 5, 6, 8])

উপরের স্ক্রিপ্টে, ইনপুট আকার নির্বিশেষে, বা ইনপুট তালিকায় আইটেম সংখ্যা items, অ্যালগরিদম শুধুমাত্র 2টি ধাপ সম্পাদন করে:

1. প্রথম উপাদানের বর্গ খোঁজা
2. স্ক্রিনে ফলাফল প্রিন্ট করা হচ্ছে।

তাই জটিলতা রয়ে গেছে।

যদি আপনি একটি লাইন প্লট আঁকুন এর বিভিন্ন আকারের সাথে items X-অক্ষে ইনপুট এবং Y-অক্ষে ধাপের সংখ্যা, আপনি একটি সরল রেখা পাবেন। আমাদের এটি কল্পনা করতে সাহায্য করার জন্য একটি ছোট স্ক্রিপ্ট তৈরি করা যাক। ইনপুটের সংখ্যা যাই হোক না কেন, সম্পাদিত পদক্ষেপের সংখ্যা একই থাকে:

steps = []
def constant(n):
    return 1
    
for i in range(1, 100):
    steps.append(constant(i))
plt.plot(steps)

রৈখিক জটিলতা - উপর)

একটি অ্যালগরিদমের জটিলতাকে রৈখিক বলা হয় যদি একটি অ্যালগরিদম কার্যকর করার জন্য প্রয়োজনীয় পদক্ষেপগুলি ইনপুটের সংখ্যার সাথে রৈখিকভাবে বৃদ্ধি বা হ্রাস পায়। রৈখিক জটিলতা দ্বারা চিহ্নিত করা হয় উপর).

এই উদাহরণে, আসুন একটি সাধারণ প্রোগ্রাম লিখি যা তালিকার সমস্ত আইটেম কনসোলে প্রদর্শন করে:

def linear_algo(items):
    for item in items:
        print(item)

linear_algo([4, 5, 6, 8])

এর জটিলতা linear_algo() উপরের উদাহরণে ফাংশনটি রৈখিক কারণ ফর-লুপের পুনরাবৃত্তির সংখ্যা হবে ইনপুট আকারের সমান items বিন্যাস. উদাহরণস্বরূপ, যদি 4টি আইটেম থাকে items তালিকা, ফর-লুপ 4 বার কার্যকর করা হবে।

চলুন দ্রুত x-অক্ষের ইনপুট এবং y-অক্ষের ধাপের সংখ্যা সহ রৈখিক জটিলতা অ্যালগরিদমের জন্য একটি প্লট তৈরি করি:

steps = []
def linear(n):
    return n
    
for i in range(1, 100):
    steps.append(linear(i))
    
plt.plot(steps)
plt.xlabel('Inputs')
plt.ylabel('Steps')

এর ফলে হবে:

লক্ষণীয় একটি গুরুত্বপূর্ণ বিষয় হল যে বড় ইনপুটগুলির সাথে, ধ্রুবকগুলি মান হারাতে থাকে। এই কারণেই আমরা সাধারণত বিগ-ও স্বরলিপি থেকে ধ্রুবকগুলি সরিয়ে ফেলি এবং O(2n) এর মতো একটি অভিব্যক্তিকে সাধারণত O(n) তে সংক্ষিপ্ত করা হয়। O(2n) এবং O(n) উভয়ই রৈখিক - রৈখিক সম্পর্কই গুরুত্বপূর্ণ, কংক্রিট মান নয়। উদাহরণস্বরূপ, এর পরিবর্তন করা যাক linear_algo():

def linear_algo(items):
    for item in items:
        print(item)

    for item in items:
        print(item)

linear_algo([4, 5, 6, 8])

দুটি ফর-লুপ রয়েছে যা ইনপুটের উপর পুনরাবৃত্তি করে items তালিকা তাই অ্যালগরিদমের জটিলতা হয়ে যায় ও (2 এন), তবে ইনপুট তালিকার অসীম আইটেমের ক্ষেত্রে, অসীমের দ্বিগুণ এখনও অসীমের সমান। আমরা ধ্রুবক উপেক্ষা করতে পারেন 2 (যেহেতু এটি চূড়ান্তভাবে তুচ্ছ) এবং অ্যালগরিদমের জটিলতা রয়ে গেছে উপর).

X-অক্ষে ইনপুট এবং Y-অক্ষের ধাপের সংখ্যা প্লট করে এই নতুন অ্যালগরিদমটি কল্পনা করা যাক:

steps = []
def linear(n):
    return 2*n
    
for i in range(1, 100):
    steps.append(linear(i))
    
plt.plot(steps)
plt.xlabel('Inputs')
plt.ylabel('Steps')

উপরের স্ক্রিপ্টে, আপনি স্পষ্টভাবে দেখতে পারেন y=2n, যাইহোক, আউটপুট রৈখিক এবং এই মত দেখায়:

চতুর্মুখী জটিলতা- O(n²)

একটি অ্যালগরিদমের জটিলতাকে দ্বিঘাতমূলক বলা হয় যখন একটি অ্যালগরিদম কার্যকর করার জন্য প্রয়োজনীয় পদক্ষেপগুলি ইনপুটে আইটেমগুলির সংখ্যার একটি দ্বিঘাত ফাংশন হয়। দ্বিঘাত জটিলতা হিসাবে চিহ্নিত করা হয় O(n²):

def quadratic_algo(items):
    for item in items:
        for item2 in items:
            print(item, ' ' ,item2)

quadratic_algo([4, 5, 6, 8])

আমাদের একটি বাইরের লুপ রয়েছে যা ইনপুট তালিকার সমস্ত আইটেমের মাধ্যমে পুনরাবৃত্তি করে এবং তারপরে একটি নেস্টেড অভ্যন্তরীণ লুপ, যা আবার ইনপুট তালিকার সমস্ত আইটেমের মাধ্যমে পুনরাবৃত্তি করে। সম্পাদিত পদক্ষেপের মোট সংখ্যা হল n*n, যেখানে n হল ইনপুট অ্যারের আইটেমের সংখ্যা।

নিম্নলিখিত গ্রাফটি দ্বিঘাত জটিলতার সাথে একটি অ্যালগরিদমের ধাপগুলির বিপরীতে ইনপুটের সংখ্যা প্লট করে:

লগারিদমিক জটিলতা - ও (লগইন)

কিছু অ্যালগরিদম লগারিদমিক জটিলতা অর্জন করে, যেমন বাইনারি অনুসন্ধান. বাইনারি অনুসন্ধান একটি অ্যারেতে একটি উপাদানের জন্য অনুসন্ধান করে, চেক করে মধ্যম একটি অ্যারের, এবং অর্ধেক ছাঁটাই করা যেখানে উপাদানটি নেই। এটি বাকি অর্ধেকের জন্য এটি আবার করে এবং উপাদানটি না পাওয়া পর্যন্ত একই পদক্ষেপগুলি চালিয়ে যায়। প্রতিটি ধাপে, এটি অর্ধেক অ্যারেতে উপাদানের সংখ্যা।

এর জন্য অ্যারে সাজানো প্রয়োজন, এবং আমাদের ডেটা সম্পর্কে একটি অনুমান করতে হবে (যেমন এটি সাজানো হয়েছে)।

আপনি যখন ইনকামিং ডেটা সম্পর্কে অনুমান করতে পারেন, তখন আপনি এমন পদক্ষেপ নিতে পারেন যা একটি অ্যালগরিদমের জটিলতা কমিয়ে দেয়। লগারিদমিক জটিলতা আকাঙ্খিত, কারণ এটি উচ্চ স্কেল করা ইনপুট সহও ভাল কর্মক্ষমতা অর্জন করে।

জটিল ফাংশন জটিলতা খুঁজে?

পূর্ববর্তী উদাহরণে, ইনপুটে আমাদের মোটামুটি সহজ ফাংশন ছিল। যদিও, ইনপুটে অন্যান্য ফাংশন (একাধিক) কল করে এমন ফাংশনগুলির বিগ-ও কীভাবে আমরা গণনা করব?

আসুন একবার দেখে নিই:

def complex_algo(items):

    for i in range(5):
        print("Python is awesome")

    for item in items:
        print(item)

    for item in items:
        print(item)

    print("Big O")
    print("Big O")
    print("Big O")

complex_algo([4, 5, 6, 8])

উপরের স্ক্রিপ্টে বেশ কয়েকটি কাজ করা হচ্ছে, প্রথমে, কনসোলে একটি স্ট্রিং 5 বার প্রিন্ট করা হয় print বিবৃতি এরপরে, আমরা স্ক্রিনে দুইবার ইনপুট তালিকা মুদ্রণ করি এবং অবশেষে, কনসোলে অন্য একটি স্ট্রিং তিনবার প্রিন্ট করা হয়। এই ধরনের একটি অ্যালগরিদমের জটিলতা খুঁজে বের করার জন্য, আমাদের অ্যালগরিদম কোডটিকে ভাগে ভাগ করতে হবে এবং পৃথক টুকরোগুলির জটিলতা খুঁজে বের করার চেষ্টা করতে হবে। প্রতিটি অংশের জটিলতা চিহ্নিত করুন।

প্রথম বিভাগে আমাদের আছে:

for i in range(5):
	print("Python is awesome")

এই অংশের জটিলতা ও (5) যেহেতু ইনপুট নির্বিশেষে কোডের এই অংশে পাঁচটি ধ্রুবক পদক্ষেপ সঞ্চালিত হচ্ছে।

পরবর্তী, আমাদের আছে:

for item in items:
	print(item)

আমরা উপরের কোডের জটিলতা জানি উপর). একইভাবে, কোডের নিচের অংশের জটিলতাও রয়েছে উপর):

for item in items:
	print(item)

অবশেষে, নিম্নলিখিত কোডের অংশে, একটি স্ট্রিং তিনবার প্রিন্ট করা হয়েছে, তাই জটিলতা ও (3):

print("Big O")
print("Big O")
print("Big O")

সামগ্রিক জটিলতা খুঁজে পেতে, আমাদের কেবল এই পৃথক জটিলতাগুলি যোগ করতে হবে:

O(5) + O(n) + O(n) + O(3)

উপরেরটি সরলীকরণ করে আমরা পাই:

O(8) + O(2n) = O(8+2n)

আমরা আগে বলেছিলাম যে যখন ইনপুট (এ ক্ষেত্রে দৈর্ঘ্য n আছে) অত্যন্ত বড় হয়ে যায়, তখন ধ্রুবকগুলি তুচ্ছ হয়ে যায় অর্থাৎ অসীমের দ্বিগুণ বা অর্ধেক এখনও অসীম থেকে যায়। অতএব, আমরা ধ্রুবকগুলিকে উপেক্ষা করতে পারি। অ্যালগরিদমের চূড়ান্ত জটিলতা হবে উপর)!

সবচেয়ে খারাপ বনাম সেরা কেস জটিলতা

সাধারণত, যখন কেউ আপনাকে অ্যালগরিদমের জটিলতা সম্পর্কে জিজ্ঞাসা করে – তারা সবচেয়ে খারাপ ক্ষেত্রে জটিলতা (বিগ-ও) এ আগ্রহী। কখনও কখনও, তারা সেরা-কেস জটিলতায়ও আগ্রহী হতে পারে (বিগ-ওমেগা)।

এইগুলির মধ্যে সম্পর্ক বোঝার জন্য, আসুন কোডের আরেকটি অংশ দেখে নেওয়া যাক:

def search_algo(num, items):
    for item in items:
        if item == num:
            return True
        else:
            pass
nums = [2, 4, 6, 8, 10]

print(search_algo(2, nums))

উপরের স্ক্রিপ্টে, আমাদের একটি ফাংশন আছে যা ইনপুট হিসাবে একটি সংখ্যা এবং সংখ্যার একটি তালিকা নেয়। পাস করা নম্বরটি সংখ্যার তালিকায় পাওয়া গেলে এটি সত্য দেখায়, অন্যথায়, এটি ফেরত দেয় None. আপনি যদি তালিকায় 2 অনুসন্ধান করেন তবে এটি প্রথম তুলনাতে পাওয়া যাবে। এটি অ্যালগরিদমের সর্বোত্তম কেস জটিলতা যাতে অনুসন্ধান করা আইটেমটি প্রথম অনুসন্ধান সূচকে পাওয়া যায়। সেরা ক্ষেত্রে জটিলতা, এই ক্ষেত্রে, হয় ও (1). অন্যদিকে, আপনি যদি 10 অনুসন্ধান করেন তবে এটি শেষ অনুসন্ধান করা সূচকে পাওয়া যাবে। অ্যালগরিদমকে তালিকার সমস্ত আইটেম অনুসন্ধান করতে হবে, তাই সবচেয়ে খারাপ ক্ষেত্রে জটিলতা হয়ে উপর).

সেরা এবং সবচেয়ে খারাপ ক্ষেত্রে জটিলতা ছাড়াও, আপনি গণনা করতে পারেন গড় জটিলতা একটি অ্যালগরিদমের (বিগ-থিটা), যা আপনাকে বলে "একটি এলোমেলো ইনপুট দেওয়া হলে, অ্যালগরিদমের প্রত্যাশিত সময়ের জটিলতা কী"?

স্পেস জটিলতা ity

সময় জটিলতা ছাড়াও, যেখানে আপনি একটি অ্যালগরিদম কার্যকর করার জন্য প্রয়োজনীয় পদক্ষেপের সংখ্যা গণনা করেন, আপনি এটিও খুঁজে পেতে পারেন স্থান জটিলতা যা একটি প্রোগ্রাম কার্যকর করার সময় আপনার মেমরিতে বরাদ্দ করার জন্য প্রয়োজনীয় পরিমাণকে বোঝায়।

নিম্নলিখিত উদাহরণটি দেখুন:

def return_squares(n):
    square_list = []
    for num in n:
        square_list.append(num * num)

    return square_list

nums = [2, 4, 6, 8, 10]
print(return_squares(nums))

সার্জারির return_squares() ফাংশন পূর্ণসংখ্যার একটি তালিকা গ্রহণ করে এবং সংশ্লিষ্ট বর্গক্ষেত্রগুলির সাথে একটি তালিকা প্রদান করে। অ্যালগরিদমকে ইনপুট তালিকার মতো একই সংখ্যক আইটেমের জন্য মেমরি বরাদ্দ করতে হবে। অতএব, অ্যালগরিদমের স্থান জটিলতা হয়ে যায় উপর).

উপসংহার

বিগ-ও স্বরলিপি হল একটি অ্যালগরিদমের জটিলতা পরিমাপ করতে ব্যবহৃত স্ট্যান্ডার্ড মেট্রিক। এই নির্দেশিকায়, আমরা বিগ-ও স্বরলিপি কী এবং এটি বিভিন্ন অ্যালগরিদমের জটিলতা পরিমাপ করতে কীভাবে ব্যবহার করা যেতে পারে তা অধ্যয়ন করেছি। আমরা পাইথনের বিভিন্ন উদাহরণের সাহায্যে বিভিন্ন ধরণের বিগ-ও ফাংশন অধ্যয়ন করেছি। পরিশেষে, আমরা সংক্ষিপ্তভাবে স্থান জটিলতার সাথে সবচেয়ে খারাপ এবং সেরা কেস জটিলতা পর্যালোচনা করেছি।