বুদ্বুদ বাছাই হোমওয়ার্ক

Question

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

পাইথনে এটি আমার প্রচেষ্টা:

mylist = [12, 5, 13, 8, 9, 65]

def bubble(badList):
    length = len(badList) - 1
    unsorted = True

    while unsorted:
        for element in range(0,length):
            unsorted = False
            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                print badList
            else:
                unsorted = True

print bubble(mylist)

এখন, এটি (যতদূর আমি বলতে পারি) সঠিকভাবে বাছাই করে তবে এটি একবার শেষ হলে এটি অনির্দিষ্টকালের জন্য লুপ হয়।

এই কোডটি কীভাবে ঠিক করা যায় যাতে ফাংশনটি সঠিকভাবে শেষ হয় এবং সঠিকভাবে কোনও (যুক্তিসঙ্গত) আকারের তালিকা সাজায়?

পিএস আমি জানি আমার কোনও ফাংশনে আসলেই প্রিন্ট থাকা উচিত নয় এবং আমার ফিরতে হবে তবে আমার কোডটি এখনও কার্যকর না হওয়ায় আমি এখনও এটি করিনি।

Comments

@ কেএম - তার কি আপনার লন পাওয়া উচিত?

— আইডেন বেল

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

— জন ফুহি

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

— বিল

একটি ভাল "হোমওয়ার্ক" কীভাবে জিজ্ঞাসা করা যায় তার জন্য এই প্রশ্নটি পোস্টার-শিশু। জন ফুহির বক্তব্য, এখানে একটি কোডের নমুনা রয়েছে, এটি ভাল লেখা আছে, এবং পোস্টারটি আমাদের পক্ষে সহায়তা করা সহজ করার জন্য কঠোর চেষ্টা করছে। ভাল হয়েছে, জোশান্ট।

— জারেট হার্ডি

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

— শ্রীভাতসার

Answer 1

কেন আপনার স্ক্রিপ্টটি ডান এখন কাজ করছে না ব্যাখ্যা করার জন্য, আমি পরিবর্তনশীল নামান্তর করব unsortedকরার sorted।

প্রথমে, আপনার তালিকাটি এখনও বাছাই করা হয়নি। অবশ্যই, আমরা সেট sortedকরতে False।

whileলুপটি শুরু করার সাথে সাথে আমরা ধরে নিই যে তালিকাটি ইতিমধ্যে সাজানো হয়েছে। ধারণাটি হ'ল: আমরা দুটি উপাদান যা সঠিক ক্রমে নেই তা খুঁজে পাওয়ার সাথে সাথে আমরা sortedআবার সেট করেছিলাম False। sortedথাকবে True শুধুমাত্র যদি ভুল ক্রমে কোন উপাদান ছিল ।

sorted = False  # We haven't started sorting yet

while not sorted:
    sorted = True  # Assume the list is now sorted
    for element in range(0, length):
        if badList[element] > badList[element + 1]:
            sorted = False  # We found two elements in the wrong order
            hold = badList[element + 1]
            badList[element + 1] = badList[element]
            badList[element] = hold
    # We went through the whole list. At this point, if there were no elements
    # in the wrong order, sorted is still True. Otherwise, it's false, and the
    # while loop executes again.

কিছু ছোট ছোট সমস্যা রয়েছে যা কোডটিকে আরও দক্ষ বা পঠনযোগ্য হতে সহায়তা করবে।

• ইন forলুপ, আপনি ভেরিয়েবল ব্যবহার element। প্রযুক্তিগতভাবে, elementএকটি উপাদান নয়; এটি একটি তালিকা সূচক উপস্থাপন করে। এছাড়াও, এটি বেশ দীর্ঘ। এই ক্ষেত্রে, কেবলমাত্র i"সূচক" এর মতো একটি অস্থায়ী পরিবর্তনশীল নাম ব্যবহার করুন ।

  for i in range(0, length):

• rangeকমান্ড এছাড়াও মাত্র এক যুক্তি (নামে নিতে পারেন stop)। সেক্ষেত্রে আপনি 0 থেকে সেই যুক্তি পর্যন্ত সমস্ত পূর্ণসংখ্যার একটি তালিকা পাবেন।

  for i in range(length):

• পাইথন স্টাইল গাইড করার পরামর্শ দেয় ভেরিয়েবল আন্ডারস্কোর সঙ্গে ছোট হাতের নাম হবে না। এটি এর মতো একটি ছোট স্ক্রিপ্টের জন্য খুব ছোট্ট একটি নিটপিক; পাইথন কোডটি প্রায়শই সাদৃশ্যপূর্ণ বলে আপনাকে অভ্যস্ত করা আরও বেশি।

  def bubble(bad_list):

• দুটি ভেরিয়েবলের মানগুলি অদলবদল করতে, এগুলিকে টুপল অ্যাসাইনমেন্ট হিসাবে লিখুন। ডান হাতটি একটি টিউপল (বলে, (badList[i+1], badList[i])হয় (3, 5)) হিসাবে মূল্যায়ন হয় এবং তারপরে বাম হাতের দুটি ভেরিয়েবলকে বরাদ্দ করা হয় ( (badList[i], badList[i+1]))।

  bad_list[i], bad_list[i+1] = bad_list[i+1], bad_list[i]

সব একসাথে রাখুন, এবং আপনি এটি পান:

my_list = [12, 5, 13, 8, 9, 65]

def bubble(bad_list):
    length = len(bad_list) - 1
    sorted = False

    while not sorted:
        sorted = True
        for i in range(length):
            if bad_list[i] > bad_list[i+1]:
                sorted = False
                bad_list[i], bad_list[i+1] = bad_list[i+1], bad_list[i]

bubble(my_list)
print my_list

(আমি আপনার মুদ্রণ বিবৃতিটিও, উপায় দ্বারা সরিয়েছি))

Comments

কোডটির শেষ বিটটিতে, বুদবুদ কোনও কিছুই ফেরায় না, সুতরাং শেষ ফলাফলটি 'কিছুই নয়' মুদ্রিত। আপনি সম্ভবত তালিকাটি ফিরে আসতে চান, বা বুদ্বুদ (মাই_লিস্ট) করতে চান এবং তারপরে আমার_লিস্ট মুদ্রণ করতে চান।

— টুং নগুইন

+1 সুগঠিত, পরিষ্কার পরামর্শ। আপনি কী করেছেন এবং কেন কেবল দ্রুত ফিক্স লেখার চেয়ে আপনি পাঠককে হাঁটাচ্ছেন তা দেখে দুর্দান্ত।

— টম লিজ

আমি একটি সি # প্রোগ্রামার, সুতরাং এটি কেবল কারণ পাইথন পাইনি কারণ এটি হতে পারে তবে সাধারণ বুদ্বুদ সাজানোর অ্যালগরিদম পেতে দৈর্ঘ্যে 1 টি বিয়োগ করতে যখন আপনার কিছু প্রয়োজন হয় না?

— মার্টিন ব্রাউন

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

— ওয়েসলি

Put it all together, and you get this:... ভাল, আপনি এটি মিস করেছেন:The range command can also take just one argument (named stop).

— পিটার পেরে

Answer 2

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

def bubble(badList):
    length = len(badList)
    for i in range(0,length):
        swapped = False
        for element in range(0, length-i-1):
            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                swapped = True
        if not swapped: break

    return badList

আপনার সংস্করণ 1, সংশোধন করা হয়েছে:

def bubble(badList):
    length = len(badList) - 1
    unsorted = True
    while unsorted:
        unsorted = False
        for element in range(0,length):
            #unsorted = False
            if badList[element] > badList[element + 1]:
                 hold = badList[element + 1]
                 badList[element + 1] = badList[element]
                 badList[element] = hold
                 unsorted = True
                 #print badList
             #else:
                 #unsorted = True

     return badList

Answer 3

যখন আপনি নেতিবাচক অর্থের পরিবর্তনশীল নাম ব্যবহার করেন তখন এটি ঘটে থাকে, আপনাকে তাদের মানগুলি উল্টাতে হবে। নিম্নলিখিতগুলি বোঝা সহজ হবে:

sorted = False
while not sorted:
    ...

অন্যদিকে, অ্যালগরিদমের যুক্তি কিছুটা বন্ধ off লুপের সময় দুটি উপাদান অদলবদল হয়েছে কিনা তা আপনাকে পরীক্ষা করতে হবে। এখানে আমি এটি কীভাবে লিখব:

def bubble(values):
    length = len(values) - 1
    sorted = False
    while not sorted:
        sorted = True
        for element in range(0,length):
            if values[element] > values[element + 1]:
                 hold = values[element + 1]
                 values[element + 1] = values[element]
                 values[element] = hold
                 sorted = False
    return values

Comments

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

— ড্যানিয়েল মার্টিন

@ ড্যানিয়েল: অন্যান্য খ্যাতিমান ব্যক্তিরা (১০০) যা করতে পারে তা আপনি করতে পারেন - ভুল উত্তরটিকে নীচে নামান। সত্যের একটি জীবাণু রয়েছে - পতাকা চলকগুলিতে অন্তর্ভুক্ত অবহেলিত পরিস্থিতি খারাপ। এটি পুরো উত্তর নয়, যদিও - @ এমসিওয়াফলেসটিক্সের এটি সঠিক আছে, আমি মনে করি।

— জোনাথন লেফলার

আপনারা বলছেন ঠিক, আমি এই সম্পর্কে অকাল উত্তর দিয়েছি। এর জন্যে দুঃখিত.

— মার্টিন কোট

@ মার্টিন - এবং আমার উল্লেখ করা উচিত যে আমি উত্তরের চেয়ে ভোট দিয়ে বেশি অবাক / হতবাক হয়েছি। খ্যাতি ব্যবস্থা আপনাকে সরাসরি এই প্রথম উত্তরটি পেতে এখনই উত্সাহ দেয়। ভাঙা অংশটি কীভাবে একটি ভুল উত্তর দিয়ে যায়।

— ড্যানিয়েল মার্টিন

আমার সন্দেহ হয় যে বেশিরভাগ লোকেরা প্রথম প্রশ্নটিতে প্রশ্নটি না বুঝে ভোট দেয় (ঠিক যেমনটি আমি প্রশ্নের উত্তর দিয়েছি)। ওটো, যে ব্যক্তি প্রশ্নটি জিজ্ঞাসা করে তার পরে 'সঠিক' উত্তরটি বেছে নেওয়ার সুযোগ রয়েছে।

— মার্টিন কোট

Answer 4

অরসোর্টড ভেরিয়েবলের আপনার ব্যবহার ভুল; আপনি একটি ভেরিয়েবল রাখতে চান যা আপনাকে বলে যে আপনি দুটি উপাদান অদলবদল করেছেন কিনা; যদি আপনি এটি করেন, আপনি আপনার লুপটি প্রস্থান করতে পারেন, অন্যথায়, আপনাকে আবার লুপ করতে হবে। আপনি এখানে কী পেয়েছেন তা স্থির করতে আপনার "কেস" এর শর্তে কেবল "অরক্ষিত = মিথ্যা" রাখুন; আপনার অন্য কেস অপসারণ; এবং আপনার forলুপের আগে "অরসেটড = সত্য" রাখুন ।

Answer 5

def bubble_sort(l):
    for passes_left in range(len(l)-1, 0, -1):
        for index in range(passes_left):
            if l[index] < l[index + 1]:
               l[index], l[index + 1] = l[index + 1], l[index]
    return l

Comments

আমি প্রশ্নটি আরও সহ্য করি যে 'এই কোডটি কীভাবে সংশোধন করা যায়' এর লাইনে আরও ছিল, 'আপনার বুদ্বুদ বাছাই কী?'

— জোশ হান্ট

আপনি একেবারে ঠিক বলেছেন, তবে সঠিক উপায়ে এটি করা আরও গুরুত্বপূর্ণ

— mtasic85

সত্য, সম্ভবত, ম্যাটাসিক ... তবে হোম ওয়ার্ক হিসাবে ট্যাগ হওয়া যে কোনও কিছুই পুনর্লিখনের চেয়ে নির্দেশমূলকভাবে টুইট করা হয়েছে (বিশেষত যখন এটি ওপি দ্বারা হোমওয়ার্ক হিসাবে ট্যাগ হয়)।

— জারেট হার্ডি

এটি বেশিরভাগ লোকেরা অধ্যয়ন করে পাঠ্য বই সি বুদ্বুদ সাজানোর একটি নিখুঁত পুনরায় লেখা write আমিও তাই লিখেছি।

— লক্ষ্মণ প্রসাদ

ভাল তথ্য যুক্ত করা আমার দৃষ্টিতে সহায়ক। এত ভাল উত্তর .. ভেবেছিলাম আপনি যত তাড়াতাড়ি সম্ভব বিরতিতে পতাকা ব্যবহার করতে পারেন।

— গ্রিজেশ চৌহান

Answer 6

# খুব সহজ ফাংশন, ২ য় অ্যারের সমস্যা স্থান হ্রাস করে (স্পষ্টতই) অনুকূলিত করা যায়। তবে একই ও (এন ^ 2) জটিলতা।

def bubble(arr):
    l = len(arr)        
    for a in range(l):
        for b in range(l-1):
            if (arr[a] < arr[b]):
            arr[a], arr[b] = arr[b], arr[a]
    return arr 

Comments

পাইথনে আপনি যেভাবে মূল্যবোধ বদলাতে পারবেন তাতে এটি একটু কমই বিহ্বলিত হয়েছে: arr[a], arr[b] = arr[b], arr[a]

— মাকোটো

Answer 7

আপনি সেখানে বেশ কয়েকটি ত্রুটি পেয়েছেন। প্রথমটি দৈর্ঘ্যে, এবং দ্বিতীয়টি আপনার অরসোর্টড (ম্যাকওয়্যাফ্লেস্টিক্সের বক্তব্য অনুসারে) ব্যবহারে রয়েছে। আপনি যদি তালিকাটি মুদ্রণ করতে যাচ্ছেন তবে আপনি সম্ভবত তালিকাটিও ফিরিয়ে দিতে চান:

mylist = [12, 5, 13, 8, 9, 65]

def bubble(badList):
    length = len(badList) - 2
    unsorted = True

    while unsorted:
        for element in range(0,length):
            unsorted = False

            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                print badList
                unsorted = True

    return badList

print bubble(mylist)

এবং: আপনি ঠিক বলেছেন, উপরেরটি নরকের মতো বগি। আরও কিছু উদাহরণ পরীক্ষা না করে আমার খারাপ bad

def bubble2(badList):
    swapped = True
    length = len(badList) - 2

    while swapped:
        swapped = False
        for i in range(0, length):
            if badList[i] > badList[i + 1]:

                # swap
                hold = badList[i + 1]
                badList[i + 1] = badList[i]
                badList[i] = hold

                swapped = True

    return badList

Comments

"অরসোর্টড = ভুয়া" লুপের বাইরে থাকা উচিত নয়?

— সোভান্তে

এটির তুলনায় এর আরও কয়েকটি সমস্যা ছিল;)

— ট্রেভর ওকে

Answer 8

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

lista1 = [12, 5, 13, 8, 9, 65]

i=0
while i < len(lista1)-1:
    if lista1[i] > lista1[i+1]:
        x = lista1[i]
        lista1[i] = lista1[i+1]
        lista1[i+1] = x
        i=0
        continue
    else:
        i+=1

print(lista1)

Answer 9

মূল অ্যালগরিদমের সমস্যাটি হ'ল তালিকায় যদি আপনার আরও কম নম্বর থাকে তবে এটি এটিকে সঠিক বাছাই করা অবস্থানে আনতে পারে না। এই সংখ্যাটি যাতে সমস্তভাবে সাজানো হয় তা নিশ্চিত করার জন্য প্রোগ্রামটি প্রতিটি সময় শুরুতে ফিরে যেতে হবে।

আমি কোডটি সরল করে দিয়েছি এবং এখন এটি তালিকা নির্বিশেষে এবং পুনরাবৃত্তি সংখ্যাগুলি রয়েছে এমন কোনও সংখ্যার তালিকার জন্য কাজ করবে। এখানে কোড

mylist = [9, 8, 5, 4, 12, 1, 7, 5, 2]
print mylist

def bubble(badList):
    length = len(badList) - 1
    element = 0
    while element < length:
        if badList[element] > badList[element + 1]:
            hold = badList[element + 1]
            badList[element + 1] = badList[element]
            badList[element] = hold
            element = 0
            print badList
        else:
            element = element + 1

print bubble(mylist)

Answer 10

def bubble_sort(l):
    exchanged = True
    iteration = 0
    n = len(l)

    while(exchanged):
        iteration += 1
        exchanged = False

        # Move the largest element to the end of the list
        for i in range(n-1):
            if l[i] > l[i+1]:
                exchanged = True
                l[i], l[i+1] = l[i+1], l[i]
        n -= 1   # Largest element already towards the end

    print 'Iterations: %s' %(iteration)
    return l

Comments

বুদ্বুদ বৃহত্তর উপাদান শেষ পর্যন্ত। এবং শেষের কাউন্টারটিকে হ্রাস করুন, "এন" যাতে আপনাকে এটি আবার তুলনা করতে হবে না। এক্সচেঞ্জ হওয়া অবধি লুপটি দিয়ে চালিয়ে যান। সবচেয়ে খারাপ কেস: ও (এন ^ 2) সেরা কেস: ও (এন)

— জিল রেহমান

Answer 11

def bubbleSort(alist):
if len(alist) <= 1:
    return alist
for i in range(0,len(alist)):
   print "i is :%d",i
   for j in range(0,i):
      print "j is:%d",j
      print "alist[i] is :%d, alist[j] is :%d"%(alist[i],alist[j])
      if alist[i] > alist[j]:
         alist[i],alist[j] = alist[j],alist[i]
return alist

তালিকাভুক্ত = [54,26,93,17,77,31,44,55,20, -23, -34,16,11,11,11]

মুদ্রণ বুদ্বুদ

Comments

দয়া করে আপনার কোডের নমুনাটি সঠিকভাবে ইনডেন্ট করুন: এটি অবশ্যই পাইথনের বিশেষত গুরুত্বপূর্ণ। আপনার সমাধানটি কেন 100 ভোটের সাথে একটি উত্তর রয়েছে তা বিবেচনা করার জন্য কেন বিবেচনা করা উচিত তাও আপনি ব্যাখ্যা করতে চাইতে পারেন

— kdopen

Answer 12

def bubble_sort(a):
    t = 0
    sorted = False # sorted = False because we have not began to sort
    while not sorted:
    sorted = True # Assume sorted = True first, it will switch only there is any change
        for key in range(1,len(a)):
            if a[key-1] > a[key]:
                sorted = False
                t = a[key-1]; a[key-1] = a[key]; a[key] = t;
    print a

Answer 13

একটি সহজ উদাহরণ:

a = len(alist)-1
while a > 0:
    for b in range(0,a):
        #compare with the adjacent element
        if alist[b]>=alist[b+1]:
            #swap both elements
            alist[b], alist[b+1] = alist[b+1], alist[b]
    a-=1

এটি কেবলমাত্র উপাদানগুলি 0 থেকে একটিতে নিয়ে যায় (মূলত, এই রাউন্ডের সমস্ত অনিবদ্ধ উপাদান) এবং এর সংলগ্ন উপাদানগুলির সাথে এটি তুলনা করে এবং এটি সংলগ্ন উপাদানগুলির চেয়ে বড় হলে একটি অদলবদল তৈরি করে। রাউন্ডের শেষে, শেষ উপাদানটি বাছাই করা হয়, এবং সমস্ত উপাদান বাছাই না করা অবধি প্রক্রিয়াটি এটি ব্যতীত আবার চলে।

sortসত্য কিনা তা শর্তের দরকার নেই।

মনে রাখবেন যে এই অ্যালগরিদম কেবল অদলবদল করার সময় সংখ্যার অবস্থান বিবেচনা করে, সুতরাং পুনরাবৃত্তি সংখ্যা এটি প্রভাবিত করবে না।

পুনশ্চ. আমি জানি এই প্রশ্নটি পোস্ট হওয়ার পরে অনেক দিন হয়েছে, তবে আমি এই ধারণাটি ভাগ করে নিতে চেয়েছিলাম।

Answer 14

arr = [5,4,3,1,6,8,10,9] # array not sorted

for i in range(len(arr)):
    for j in range(i, len(arr)):
        if(arr[i] > arr[j]):
            arr[i], arr[j] = arr[j], arr[i]

            print (arr)

Answer 15

def bubble_sort(li):
    l = len(li)
    tmp = None
    sorted_l = sorted(li)
    while (li != sorted_l):
        for ele in range(0,l-1):
            if li[ele] > li[ele+1]:
                tmp = li[ele+1]
                li[ele+1] = li [ele]
                li[ele] = tmp
    return li

Answer 16

def bubbleSort ( arr ):
    swapped = True 
    length = len ( arr )
    j = 0

    while swapped:
        swapped = False
        j += 1 
        for i in range ( length  - j ):
            if arr [ i ] > arr [ i + 1 ]:
                # swap
                tmp = arr [ i ]
                arr [ i ] = arr [ i + 1]
                arr [ i + 1 ] = tmp 

                swapped = True

if __name__ == '__main__':
    # test list
    a = [ 67, 45, 39, -1, -5, -44 ];

    print ( a )
    bubbleSort ( a )
    print ( a )

Answer 17

def bubblesort(array):
    for i in range(len(array)-1):
        for j in range(len(array)-1-i):
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
    return(array)

print(bubblesort([3,1,6,2,5,4]))

Comments

যদিও এই কোডটি প্রশ্নের উত্তর দিতে পারে, কীভাবে এবং / বা কেন এটি সমস্যার সমাধান করে তা সম্পর্কিত অতিরিক্ত প্রসঙ্গ সরবরাহ করলে উত্তরের দীর্ঘমেয়াদী মান উন্নত হবে।

— আলেকজান্ডার

Answer 18

আমি আমার সমাধান যুক্তি বিবেচনা করি কারণ এখানে কখনও সমাধান থাকে

1. বৃহত্তর সময়
2. বৃহত্তর স্থান জটিলতা
3. বা খুব বেশি অপারেশন করছে

তারপর হওয়া উচিত

সুতরাং, এখানে আমার সমাধান:

---

def countInversions(arr):
    count = 0
    n = len(arr)
    for i in range(n):
        _count = count
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                count += 1
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
        if _count == count:
            break
    return count

Answer 19

যদি কেউ তালিকা বোধগম্যতা ব্যবহার করে সংক্ষিপ্ত বাস্তবায়নে আগ্রহী হন:

def bubble_sort(lst: list) -> None:
    [swap_items(lst, i, i+1) for left in range(len(lst)-1, 0, -1) for i in range(left) if lst[i] > lst[i+1]]


def swap_items(lst: list, pos1: int, pos2: int) -> None:
    lst[pos1], lst[pos2] = lst[pos2], lst[pos1]

Answer 20

forলুপ ছাড়াই বুদ্বুদ সাজানোর ভিন্ন ভিন্নতা । মূলত আপনি ধীরে ধীরে এবং lastIndexএর বিষয়টি বিবেচনা করছেনarraydecrementing এটা না হওয়া পর্যন্ত অ্যারের প্রথম সূচক।

algorithmযতক্ষণ না একটি সম্পূর্ণ পাস কোনো ছাড়া তৈরি করা হয় এই মত বিন্যাস মাধ্যমে সরানো অব্যাহত থাকবে swapsঘটছে।

মূলত Quadratic Time: O(n²)পারফরম্যান্সের ক্ষেত্রে বাবলটি সাজানো হয় ।

class BubbleSort: 
  def __init__(self, arr):
    self.arr = arr;

  def bubbleSort(self):
    count = 0;
    lastIndex = len(self.arr) - 1;
    
    while(count < lastIndex):
      if(self.arr[count] > self.arr[count + 1]):
        self.swap(count)  
      count = count + 1;

      if(count == lastIndex):
        count = 0;
        lastIndex = lastIndex - 1;   

  def swap(self, count):
    temp = self.arr[count];
    self.arr[count] = self.arr[count + 1];
    self.arr[count + 1] = temp;
    
arr = [9, 1, 5, 3, 8, 2]
p1 = BubbleSort(arr)

print(p1.bubbleSort())

Answer 21

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

def bubble(badList):
    length = len(badList) - 1
    n = 0
    while n < len(badList):
        for element in range(0,length):
            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                n = 0
            else:
                n += 1
    return badList

if __name__ == '__main__':
    mylist = [90, 10, 2, 76, 17, 66, 57, 23, 57, 99]
    print bubble(mylist)

মন্তব্যগুলিতে আমার কোড কীভাবে উন্নত করা যায় সে সম্পর্কে যদি কেউ কোনও পয়েন্টার সরবরাহ করতে পারে তবে এটি অনেক প্রশংসা হবে।

Comments

আপনি জানেন যে আপনার তালিকার যে অংশটি ইতিমধ্যে সাজানো হয়েছে (পূর্ববর্তী পুনরাবৃত্তির কারণে) আপনার তালিকার সেই অংশটি এড়িয়ে আপনি একটি বুদ্বুদ সাজানোর গতি বাড়িয়ে তুলতে পারেন। দেখুন en.wikipedia.org/wiki/Bubble_sort#Alternative_implementations

— Blorgbeard বাইরে

আবার, আপনার সত্যিই যা করতে হবে তা হ'ল একটি বুলিয়ান ব্যবহার করুন (এটিকে ছোঁয়া বলা)। এটি আপনার লুপের বাইরে ঘোষণা করুন; লুপ অব আউটচুড = সত্য। আপনার সময় লুপের মধ্যে, সত্য হতে অস্পষ্ট সেট করুন; আপনার যদি এটির শৃঙ্খলাবদ্ধ না হয় তবে মিথ্যা হতে অস্বীকার করা। এটি করে আপনি নিজের অন্য কেসটি খালি করতে পারেন। এইভাবে, আপনি যদি কখনও দুটি উপাদান স্যুইচ করেন তবে আপনার লুপটি অবিরত থাকবে; আপনি না, লুপ না।

— পল সোনিয়ার

Answer 22

এটা চেষ্টা কর

a = int(input("Enter Limit"))


val = []

for z in range(0,a):
    b = int(input("Enter Number in List"))
    val.append(b)


for y in range(0,len(val)):
   for x in range(0,len(val)-1):
       if val[x]>val[x+1]:
           t = val[x]
           val[x] = val[x+1]
           val[x+1] = t

print(val)

Answer 23

আইডিকি যদি এটি 9 বছর পরে আপনাকে সহায়তা করতে পারে ... এটি একটি সাধারণ বুদ্বুদ সাজানোর প্রোগ্রাম

    l=[1,6,3,7,5,9,8,2,4,10]

    for i in range(1,len(l)):
        for j in range (i+1,len(l)):
            if l[i]>l[j]:
                l[i],l[j]=l[j],l[i]

Answer 24

def merge_bubble(arr):
    k = len(arr)
    while k>2:
        for i in range(0,k-1):
            for j in range(0,k-1):
                if arr[j] > arr[j+1]:
                    arr[j],arr[j+1] = arr[j+1],arr[j]

        return arr
        break
    else:
        if arr[0] > arr[1]:
            arr[0],arr[1] = arr[1],arr[0]
        return arr 

Answer 25

def bubble_sort(l):
    for i in range(len(l) -1):
        for j in range(len(l)-i-1):
            if l[j] > l[j+1]:
                l[j],l[j+1] = l[j+1], l[j]
    return l

Comments

আপনার কোডটিতে কিছু ব্যাখ্যা যুক্ত করা ভাল।

— মাসউদ রহিমি

Answer 26

def bubble_sorted(arr:list):
    while True:
        for i in range(0,len(arr)-1):
            count = 0
            if arr[i] > arr[i+1]:
                count += 1
                arr[i], arr[i+1] = arr[i+1], arr[i]
        if count == 0:
            break
    return arr
arr = [30,20,80,40,50,10,60,70,90]
print(bubble_sorted(arr))
#[20, 30, 40, 50, 10, 60, 70, 80, 90]

Answer 27

def bubbleSort(a): def swap(x, y): temp = a[x] a[x] = a[y] a[y] = temp #outer loop for j in range(len(a)): #slicing to the center, inner loop, python style for i in range(j, len(a) - j):
#find the min index and swap if a[i] < a[j]: swap(j, i) #find the max index and swap if a[i] > a[len(a) - j - 1]: swap(len(a) - j - 1, i) return a