একটি অ্যারে থেকে একটি এলোমেলো উপাদান চয়ন করুন

Question

ধরুন আমার কাছে একটি অ্যারে রয়েছে এবং আমি এলোমেলোভাবে একটি উপাদান বাছাই করতে চাই।

এটি করার সহজ উপায়টি কী হবে?

সুস্পষ্ট উপায় হবে array[random index]। তবে সম্ভবত রুবির মতো কিছু আছে array.sample? বা যদি না হয় তবে কোনও এক্সটেনশন ব্যবহার করে এ জাতীয় পদ্ধতি তৈরি করা যায়?

Comments

আপনি এখনও অন্য কোন পদ্ধতি চেষ্টা করেছেন?

— ফোর প্রিফেক্ট

আমি চেষ্টা করব array[random number from 0 to length-1], তবে আমি কীভাবে দ্রুত এলোমেলো ইন্ট্রাস্ট তৈরি করতে পারি তা খুঁজে পাচ্ছি না, যদি আমাকে অবরুদ্ধ না করা হত তবে স্ট্যাকের ওভারফ্লোতে জিজ্ঞাসা করব :) আমি যখন অর্ধ সমাধান দিয়ে প্রশ্নটিকে দূষিত করতে চাই না তখনই থাকতে পারে array.sample

— রুবির

আপনি আরক 4 ব্র্যান্ডম () আপনার পছন্দ মতো ওবজ-সি

— আরবিটুর

আপনার প্রশ্নটি কেন জিকুয়েরি প্রতিরূপের মতো একই প্রতিক্রিয়া পাচ্ছে না তার কোনও ব্যাখ্যা নেই। তবে সাধারণভাবে কোনও প্রশ্ন পোস্ট করার সময় আপনার এই নির্দেশিকাগুলি অনুসরণ করা উচিত। একটি ভাল প্রশ্ন জিজ্ঞাসা কিভাবে? । এটিকে দেখতে এমন মনে করুন যেন আপনি অন্য কারও কাছে সাহায্যের আগে জিজ্ঞাসা করার আগে সমাধান বের করার জন্য একটু চেষ্টা করেছিলেন। আমি যখন গুগল "র্যান্ডম নম্বর সুইফট" চয়ন করি তখন প্রথম পৃষ্ঠাটি arc4random_uniform পরামর্শ দেওয়ার উত্তর দিয়ে পূর্ণ হয়। এছাড়াও, আরটিএফডি ... "f'ing ডকুমেন্টেশন পড়ুন"। এইভাবে কত প্রশ্নের উত্তর দেওয়া যায় তা অবাক করা।

— অস্টিন এ 21

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

— ফেলা উইঙ্কেলমোলেেন

Answer 1

উপরে 4.2 এবং উপরে

নতুন প্রস্তাবিত পন্থা একটি বিল্ট-ইন সংগ্রহ প্রোটোকল উপর পদ্ধতি: randomElement()। এটির আগে আমি যে খালি মামলাটি ধরে নিয়েছিলাম তা এড়াতে এটি একটি optionচ্ছিক প্রত্যাবর্তন করে।

let array = ["Frodo", "Sam", "Wise", "Gamgee"]
print(array.randomElement()!) // Using ! knowing I have array.count > 0

আপনি যদি অ্যারে তৈরি না করেন এবং গ্যারান্টিযুক্ত গণনা> 0 না পান তবে আপনার মতো কিছু করা উচিত:

if let randomElement = array.randomElement() { 
    print(randomElement)
}

সুইচ ৪.১ এবং নীচে

আপনার প্রশ্নের উত্তর দেওয়ার জন্য, আপনি এলোমেলো অ্যারে নির্বাচন অর্জন করতে এটি করতে পারেন:

let array = ["Frodo", "sam", "wise", "gamgee"]
let randomIndex = Int(arc4random_uniform(UInt32(array.count)))
print(array[randomIndex])

কাস্টিংগুলি কুৎসিত, তবে আমি বিশ্বাস করি অন্য কারও সাথে না থাকলে এগুলি প্রয়োজন they

Comments

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

— অস্টিন এ 21

একটি নোট যোগ করতে, এই র্যান্ডম নম্বর জেনারেটর পদ্ধতিটি "মডুলো পক্ষপাত" রোধ করতে পারে। পড়ুন man arc4randomএবং stackoverflow.com/questions/10984974/...

— কেন্ট Liau

@ অস্টিনা, সুইফট ৪.২ এর একটি নেটিভ র্যান্ডম সংখ্যার জেনারেটর ফাংশন রয়েছে যা আপনি আশা করতে পারেন এমন সমস্ত স্কেলারের ডেটা ধরণের উপর প্রয়োগ করা হয়েছে: ইনট, ডাবল, ফ্লোট, ইউআইএনটি 32, এবং এটি আপনাকে মানগুলির জন্য লক্ষ্য রেঞ্জ সরবরাহ করতে দেয়। খুব সহজ। আপনি অ্যারে ব্যবহার করতে পারেন [Int.random (0 .. <অ্যারে কোড)] Sw সুইফটে 4.2

— ডানকান সি

আমি চাই সুইফট ৪.২ removeRandomElement()এর পাশাপাশি একটি ফাংশনও বাস্তবায়িত করুক randomElement()। এটি মডেল করা হবে removeFirst(), তবে একটি এলোমেলো সূচীতে কোনও বস্তু সরান।

— ডানকান সি

@ ডানকানসি আপনার এড়ানো উচিত 0..<array.count(একাধিক কারণে, মূল কারণগুলি এটি টুকরোগুলির জন্য কাজ করে না এবং এর ত্রুটির প্রবণতা রয়েছে) should আপনি করতে পারেন let randomIndex = array.indices.randomElement(), তারপরে অনুসরণ করুন let randomElement = array.remove(at: randomIndex)। আপনি এটিতেও ইনলাইন করতে পারেন let randomElement = array.remove(at: array.indices.randomElement())।

— আলেকজান্ডার - মনিকা পুনরায়

Answer 2

লুকাস যা বলেছিল তা রিফিং করে আপনি অ্যারে শ্রেণিতে এভাবে এক্সটেনশন তৈরি করতে পারেন:

extension Array {
    func randomItem() -> Element? {
        if isEmpty { return nil }
        let index = Int(arc4random_uniform(UInt32(self.count)))
        return self[index]
    }
}

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

let myArray = [1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16]
let myItem = myArray.randomItem() // Note: myItem is an Optional<Int>

Comments

সুইফ্ট 2 এ Tনতুন নামকরণ করা হয়েছে Element।

— জিড্যাঞ্জার

লক্ষ্য করুন যে একটি খালি অ্যারে এখানে ক্র্যাশ

— ঘটায়

@ বারিক ওয়েল আপনি একটি alচ্ছিক এলিমেন্টটি ফিরিয়ে দিতে পারেন এবং তারপরে guardঅ্যারেটি খালি রয়েছে কিনা তা দেখতে সর্বদা একটি চেক করুন এবং তারপরে ফিরে আসবেন nil।

— হরিশ

একমত। অ্যারেগুলি বাই-অফ-বাউন্ডে ক্র্যাশ করে যাতে তারা অভিনয় করতে পারে। কল করা arc4randomকোনও কর্মক্ষমতা লাভকে সম্পূর্ণ তুচ্ছ করে তোলে। আমি উত্তর আপডেট করেছি।

— বেরিক

Answer 3

সুইফট 4 সংস্করণ:

extension Collection where Index == Int {

    /**
     Picks a random element of the collection.

     - returns: A random element of the collection.
     */
    func randomElement() -> Iterator.Element? {
        return isEmpty ? nil : self[Int(arc4random_uniform(UInt32(endIndex)))]
    }

}

Comments

এই সংগ্রহের যেখানে উপর সীমার একটি সূচক আউট বিপর্যস্ত করতেstartIndex != 0

— ড্যান

Answer 4

ইন সুইফট 2.2 এই তাই সাধারণ যেতে পারে যে, আমরা:

UInt.random
UInt8.random
UInt16.random
UInt32.random
UInt64.random
UIntMax.random

// closed intervals:

(-3...3).random
(Int.min...Int.max).random

// and collections, which return optionals since they can be empty:

(1..<4).sample
[1,2,3].sample
"abc".characters.sample
["a": 1, "b": 2, "c": 3].sample

প্রথমত, এর randomজন্য স্থিতিশীল সম্পত্তি বাস্তবায়ন UnsignedIntegerType:

import Darwin

func sizeof <T> (_: () -> T) -> Int { // sizeof return type without calling
    return sizeof(T.self)
}

let ARC4Foot: Int = sizeof(arc4random)

extension UnsignedIntegerType {
    static var max: Self { // sadly `max` is not required by the protocol
        return ~0
    }
    static var random: Self {
        let foot = sizeof(Self)
        guard foot > ARC4Foot else {
            return numericCast(arc4random() & numericCast(max))
        }
        var r = UIntMax(arc4random())
        for i in 1..<(foot / ARC4Foot) {
            r |= UIntMax(arc4random()) << UIntMax(8 * ARC4Foot * i)
        }
        return numericCast(r)
    }
}

তারপরে, সীমানা ClosedIntervalসহ এর জন্য UnsignedIntegerType:

extension ClosedInterval where Bound : UnsignedIntegerType {
    var random: Bound {
        guard start > 0 || end < Bound.max else { return Bound.random }
        return start + (Bound.random % (end - start + 1))
    }
}

তারপর (একটু বেশি জড়িত), জন্য ClosedIntervalসঙ্গে গুলি SignedIntegerTypeসীমা (সাহায্যকারী পদ্ধতি ব্যবহার করে আরও নিচে বর্ণিত):

extension ClosedInterval where Bound : SignedIntegerType {
    var random: Bound {
        let foot = sizeof(Bound)
        let distance = start.unsignedDistanceTo(end)
        guard foot > 4 else { // optimisation: use UInt32.random if sufficient
            let off: UInt32
            if distance < numericCast(UInt32.max) {
                off = UInt32.random % numericCast(distance + 1)
            } else {
                off = UInt32.random
            }
            return numericCast(start.toIntMax() + numericCast(off))
        }
        guard distance < UIntMax.max else {
            return numericCast(IntMax(bitPattern: UIntMax.random))
        }
        let off = UIntMax.random % (distance + 1)
        let x = (off + start.unsignedDistanceFromMin).plusMinIntMax
        return numericCast(x)
    }
}

... যেখানে unsignedDistanceTo, unsignedDistanceFromMinএবং plusMinIntMaxসাহায্যকারী পদ্ধতি নিম্নরূপ বাস্তবায়ন করা যেতে পারে:

extension SignedIntegerType {
    func unsignedDistanceTo(other: Self) -> UIntMax {
        let _self = self.toIntMax()
        let other = other.toIntMax()
        let (start, end) = _self < other ? (_self, other) : (other, _self)
        if start == IntMax.min && end == IntMax.max {
            return UIntMax.max
        }
        if start < 0 && end >= 0 {
            let s = start == IntMax.min ? UIntMax(Int.max) + 1 : UIntMax(-start)
            return s + UIntMax(end)
        }
        return UIntMax(end - start)
    }
    var unsignedDistanceFromMin: UIntMax {
        return IntMax.min.unsignedDistanceTo(self.toIntMax())
    }
}

extension UIntMax {
    var plusMinIntMax: IntMax {
        if self > UIntMax(IntMax.max) { return IntMax(self - UIntMax(IntMax.max) - 1) }
        else { return IntMax.min + IntMax(self) }
    }
}

অবশেষে, সমস্ত সংগ্রহের জন্য যেখানে Index.Distance == Int:

extension CollectionType where Index.Distance == Int {
    var sample: Generator.Element? {
        if isEmpty { return nil }
        let end = UInt(count) - 1
        let add = (0...end).random
        let idx = startIndex.advancedBy(Int(add))
        return self[idx]
    }
}

... যা পূর্ণসংখ্যার জন্য একটু অনুকূল করা যায় Range:

extension Range where Element : SignedIntegerType {
    var sample: Element? {
        guard startIndex < endIndex else { return nil }
        let i: ClosedInterval = startIndex...endIndex.predecessor()
        return i.random
    }
}

extension Range where Element : UnsignedIntegerType {
    var sample: Element? {
        guard startIndex < endIndex else { return nil }
        let i: ClosedInterval = startIndex...endIndex.predecessor()
        return i.random
    }
}

Answer 5

আপনি এক্সটেনশনের জন্য সুইফটের অন্তর্নির্মিত এলোমেলো () ফাংশনটিও ব্যবহার করতে পারেন:

extension Array {
    func sample() -> Element {
        let randomIndex = Int(rand()) % count
        return self[randomIndex]
    }
}

let array = [1, 2, 3, 4]

array.sample() // 2
array.sample() // 2
array.sample() // 3
array.sample() // 3

array.sample() // 1
array.sample() // 1
array.sample() // 3
array.sample() // 1

Comments

আসলে এলোমেলো () স্ট্যান্ডার্ড সি লাইব্রেরি ব্রিজ থেকে আসা, আপনি এটি এবং টার্মিনালের বন্ধুরা "ম্যান এলোমেলো" দেখতে পারেন। তবে খুশি হলেন আপনি প্রাপ্যতাটি দেখিয়েছেন!

— ডেভিড এইচ

এটি প্রতিবার রান করার জন্য একই র্যান্ডম ক্রম উত্পাদন করে

— itsangar

@Itsangar আপনি ঠিক বলেছেন! র্যান্ড () সঠিকভাবে ব্যবহার করা যায়। আমার উত্তর আপডেট করা হচ্ছে।

— নাতাশাওরোবট

এটি মডুলো পক্ষপাতিত্বের পক্ষেও সংবেদনশীল।

— এডান গোমেজ

@ ম্যাট্ট এলোমেলো সংখ্যা তৈরির জন্য একটি দুর্দান্ত নিবন্ধ লিখেছিল । টিএল; ডিআরআর্ক 4 ব্র্যান্ডম পরিবারের যে কোনও একটি ভাল পছন্দ।

— এলিটালন

Answer 6

আরও একটি সুইফট 3 পরামর্শ

private extension Array {
    var randomElement: Element {
        let index = Int(arc4random_uniform(UInt32(count)))
        return self[index]
    }
}

Answer 7

অন্যদের উত্তর অনুসরণ করা কিন্তু সুইফট 2 সমর্থন সহ।

সুইফট 1.x

extension Array {
    func sample() -> T {
        let index = Int(arc4random_uniform(UInt32(self.count)))
        return self[index]
    }
}

সুইফট 2.x

extension Array {
    func sample() -> Element {
        let index = Int(arc4random_uniform(UInt32(self.count)))
        return self[index]
    }
}

উদাহরণ:

let arr = [2, 3, 5, 7, 9, 11, 13, 17, 19, 23, 29, 31]
let randomSample = arr.sample()

Answer 8

খালি অ্যারের জন্য চেক সহ একটি বিকল্প কার্যকরী বাস্তবায়ন।

func randomArrayItem<T>(array: [T]) -> T? {
  if array.isEmpty { return nil }
  let randomIndex = Int(arc4random_uniform(UInt32(array.count)))
  return array[randomIndex]
}

randomArrayItem([1,2,3])

Answer 9

আরও সুরক্ষার জন্য খালি অ্যারে চেক সহ অ্যারেগুলিতে এখানে একটি এক্সটেনশান দেওয়া হয়েছে :

extension Array {
    func sample() -> Element? {
        if self.isEmpty { return nil }
        let randomInt = Int(arc4random_uniform(UInt32(self.count)))
        return self[randomInt]
    }
}

আপনি এটি এর মতো সহজ ব্যবহার করতে পারেন :

let digits = Array(0...9)
digits.sample() // => 6

---

আপনি যদি এমন কোনও ফ্রেমওয়ার্ক পছন্দ করেন যাতে আরও কিছু সুবিধাজনক বৈশিষ্ট্য রয়েছে তবে হ্যান্ডি সুইফট চেকআউট করুন । আপনি এটি কার্থেজের মাধ্যমে আপনার প্রকল্পে যুক্ত করতে পারেন তারপরে উপরের উদাহরণের মতো এটি ব্যবহার করুন:

import HandySwift    

let digits = Array(0...9)
digits.sample() // => 8

অতিরিক্তভাবে এটি একসাথে একাধিক এলোমেলো উপাদান পাওয়ার একটি বিকল্প অন্তর্ভুক্ত করে :

digits.sample(size: 3) // => [8, 0, 7]

Answer 10

সুইফট 3

গেমকিট আমদানি করুন

func getRandomMessage() -> String {

    let messages = ["one", "two", "three"]

    let randomNumber = GKRandomSource.sharedRandom().nextInt(upperBound: messages.count)

    return messages[randomNumber].description

}

Answer 11

সুইফট 3 - ব্যবহার করা সহজ।

1. অ্যারে তৈরি করুন

   var arrayOfColors = [UIColor.red, UIColor.yellow, UIColor.orange, UIColor.green]

2. র্যান্ডম রঙ তৈরি করুন

   let randomColor = arc4random() % UInt32(arrayOfColors.count)

3. আপনার রঙে সেই রঙটি সেট করুন

   your item = arrayOfColors[Int(randomColor)]

এলোমেলোভাবে কোনও SpriteKitপ্রকল্প আপডেট করার প্রকল্পের উদাহরণ এখানে :SKLabelNodeString

    let array = ["one","two","three","four","five"]

    let randomNumber = arc4random() % UInt32(array.count)

    let labelNode = SKLabelNode(text: array[Int(randomNumber)])

Answer 12

আপনি যদি কোনও ডুপ্লিকেট ছাড়াই আপনার অ্যারে থেকে একাধিক এলোমেলো উপাদান পেতে সক্ষম হতে চান , গেমপ্লেকিটটি আপনি আবৃত করেছেন:

import GameplayKit
let array = ["one", "two", "three", "four"]

let shuffled = GKMersenneTwisterRandomSource.sharedRandom().arrayByShufflingObjects(in: array)

let firstRandom = shuffled[0]
let secondRandom = shuffled[1]

এলোমেলো করার জন্য আপনার কয়েকটি পছন্দ আছে, জি কেআর্যান্ডমসোর্স দেখুন :

দ্য GKARC4RandomSourceবর্গ একটি আলগোরিদিম সি ফাংশন arc4random পরিবারে নিযুক্ত অনুরূপ ব্যবহার করে। (তবে, এই শ্রেণীর উদাহরণগুলি arc4random ফাংশনগুলির কল থেকে স্বতন্ত্র))

GKLinearCongruentialRandomSourceবর্গ একটি আলগোরিদিম যে দ্রুত, কিন্তু কম র্যান্ডম, GKARC4RandomSource বর্গ চেয়ে ব্যবহার করে। (বিশেষত, উত্পন্ন সংখ্যার কম বিট উচ্চ বিটের তুলনায় প্রায়শই পুনরাবৃত্তি করে)) শক্তিশালী অবিশ্বাস্যতার চেয়ে কর্মক্ষমতা বেশি গুরুত্বপূর্ণ যখন এই উত্সটি ব্যবহার করুন।

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

Answer 13

আমি গেমকিটের GKRandomSource.sharedRandom () ব্যবহার করে আমার পক্ষে সবচেয়ে ভাল কাজ করে।

import GameKit

let array = ["random1", "random2", "random3"]

func getRandomIndex() -> Int {
    let randomNumber = GKRandomSource.sharedRandom().nextIntWithUpperBound(array.count)
    return randomNumber

অথবা আপনি নির্বাচিত এলোমেলো সূচীতে বস্তুটি ফিরিয়ে দিতে পারেন। নিশ্চিত করুন যে ফাংশনটি প্রথমে একটি স্ট্রিং দেয় এবং তারপরে অ্যারের সূচকটি ফেরত দেয় Make

    return array[randomNumber]

সংক্ষিপ্ত এবং বিন্দু।

Answer 14

এখন একটি অন্তর্নির্মিত পদ্ধতি রয়েছে Collection:

let foods = ["🍕", "🍔", "🍣", "🍝"]
let myDinner = foods.randomElement()

আপনি যদি nসংগ্রহ থেকে এলোমেলো উপাদানগুলি বের করতে চান তবে আপনি এটির মতো একটি এক্সটেনশন যুক্ত করতে পারেন:

extension Collection {
    func randomElements(_ count: Int) -> [Element] {
        var shuffledIterator = shuffled().makeIterator()
        return (0..<count).compactMap { _ in shuffledIterator.next() }
    }
}

এবং আপনি যদি সেগুলি অনন্য হতে চান তবে আপনি একটি ব্যবহার করতে পারেন Setতবে সংগ্রহের উপাদানগুলি অবশ্যই Hashableপ্রোটোকলের সাথে সঙ্গতিপূর্ণ :

extension Collection where Element: Hashable {
    func randomUniqueElements(_ count: Int) -> [Element] {
        var shuffledIterator = Set(shuffled()).makeIterator()
        return (0..<count).compactMap { _ in shuffledIterator.next() }
    }
}

Answer 15

সর্বশেষতম swift3 কোড এটি কার্যকর কাজ করে দেখুন

 let imagesArray = ["image1.png","image2.png","image3.png","image4.png"]

        var randomNum: UInt32 = 0
        randomNum = arc4random_uniform(UInt32(imagesArray.count))
        wheelBackgroundImageView.image = UIImage(named: imagesArray[Int(randomNum)])

Answer 16

আমি সুইফট ৪.২-তে নতুন নতুন বৈশিষ্ট্যগুলি ব্যবহার করে এটি করার জন্য খুব আলাদা উপায় খুঁজে পেয়েছি।

// 👇🏼 - 1 
public func shufflePrintArray(ArrayOfStrings: [String]) -> String {
// - 2 
       let strings = ArrayOfStrings
//- 3
       var stringans =  strings.shuffled()
// - 4
        var countS = Int.random(in: 0..<strings.count)
// - 5
        return stringans[countS] 
}

1. আমরা স্ট্রিংগুলির অ্যারে গ্রহণ করে একটি স্ট্রিং ফিরিয়ে আনার সাথে পরামিতিগুলির সাথে একটি ফাংশন ঘোষণা করি।

2. তারপরে আমরা একটি ভেরিয়েবলের মধ্যে অ্যারেআফস স্ট্রিংস গ্রহণ করি ।

3. তারপরে আমরা বদলানো ফাংশনটিকে কল করি এবং এটি একটি ভেরিয়েবলের মধ্যে সঞ্চয় করি। (কেবল ৪.২ এ সমর্থিত)
4. তারপরে আমরা একটি ভেরিয়েবল ঘোষণা করি যা স্ট্রিংয়ের মোট গণনার শফলেড মান সংরক্ষণ করে।
5. অবশেষে আমরা কাউন্টস এর সূচক মানের পরিবর্তিত স্ট্রিংটি ফিরিয়ে দেব।

এটি মূলত স্ট্রিংগুলির অ্যারে পরিবর্তন করে এবং তারপরেও মোট গণনার সংখ্যার একটি এলোমেলো বাছাই করে এবং তারপরে এলোমেলো অ্যারেটির এলোমেলো সূচি ফিরে আসে।