क्रमबद्ध करने की कसौटी

julia> v = [3, 2, 4, 1]
4-element Vector{Int64}:
 3
 2
 4
 1

julia> sort(v)
4-element Vector{Int64}:
 1
 2
 3
 4

# sort descending
julia> sort(v, rev=true)
4-element Vector{Int64}:
 4
 3
 2
 1

julia> v
4-element Vector{Int64}:
 3
 2
 4
 1

julia> issorted(v)
false

# v is as previously

julia> issorted(v)
false

julia> sort!(v)
4-element Vector{Int64}:
 1
 2
 3
 4

julia> v
4-element Vector{Int64}:
 1
 2
 3
 4

julia> issorted(v)
true

julia> langs = ["Julia", "C++", "Python", "Elixir"]
4-element Vector{String}:
 "Julia"
 "C++"
 "Python"
 "Elixir"

julia> inxs = sortperm(langs)  # => Integers
4-element Vector{Int64}:
 2
 4
 1
 3

julia> langs[inxs]  # sort the entire vector
4-element Vector{String}:
 "C++"
 "Elixir"
 "Julia"
 "Python"

julia> langs[inxs[1:2]]  # slice the indices
2-element Vector{String}:
 "C++"
 "Elixir"

निर्देश

एक ऐसी कंपनी ने आपको सहायक उत्पादन इंजीनियर की नौकरी दी है, जो कछुओं के लिए रज़ाई बनाती है।

दिन भर ऑर्डर आते रहते हैं। हर ऑर्डर में ग्राहक का नाम या नंबर और ऑर्डर की मात्रा होती है। इन्हें अगली सुबह, दिन का उत्पादन शुरू होने से पहले, प्रोसेस किया जाता है।

दिन के सारे ऑर्डर पूरे होते ही आप पूरी तनख्वाह के साथ घर जा सकते हैं, इसलिए कामकाजी दिन को जितना हो सके छोटा करने में ही फायदा है। चूँकि हर ऑर्डर एक ही मशीन पर पूरा होता है, सबसे बड़े ऑर्डर पहले शेड्यूल करने से काम शुरू करने का ओवरहेड छोटे ऑर्डरों पर डाला जा सकता है और कुल उत्पादन समय कम हो जाता है। इसलिए आपने यह तय किया है कि इस शेड्यूलिंग को तेज़ करने में मदद के लिए कुछ क्रमबद्ध करने वाले फंक्शन बनाएँगे, ताकि आप जल्दी घर जाकर अपने कछुए के लिए स्वेटर बुन सकें।

1. मात्राएँ क्रमबद्ध कीजिए!

जैसा कि बताया गया, मात्राओं के ऐरे को सबसे बड़ी से सबसे छोटी तक क्रमबद्ध करना होगा। ये ऐरे बहुत बड़े हो सकते हैं, इसलिए इन्हें जगह पर ही क्रमबद्ध करना चाहिए। सब कुछ का सही हिसाब रखने के लिए आपको मात्राओं के मुताबिक ग्राहकों के ऐरे को भी क्रमबद्ध करना होगा, और इसके लिए मात्राओं का एक क्रमचय चाहिए होगा।

एक फंक्शन sortquantity!(qty) लिखिए, जो Integer मात्राओं का एक Vector लेता है। यह फंक्शन इनपुट qty को जगह पर ही घटते क्रम में क्रमबद्ध करता है और इसी क्रम का क्रमचय लौटाता है।

julia> qty = [8, 9, 5, 6]
4-element Vector{Int64}:
 8
 9
 5
 6

julia> sortquantity!(qty)
4-element Vector{Int64}:
 2
 1
 4
 3

julia> qty # original vector is sorted in-place
4-element Vector{Int64}:
 9
 8
 6
 5

2. ग्राहकों को क्रमबद्ध कीजिए

जैसा ऊपर बताया गया, आपको ग्राहकों को एक तय क्रम में बनाए रखना है।

एक फंक्शन sortcustomer(cust, srtperm) लिखिए, जो ग्राहकों का एक Vector cust और क्रमचय का Vector srtperm लेता है। यह फंक्शन एक नया ऐरे लौटाता है, जिसमें ग्राहक उस क्रम में होते हैं जो यह क्रमचय तय करता है।

julia> cust = ["a", "b", "c"]
3-element Vector{String}:
 "a"
 "b"
 "c"

julia> sortcustomer(cust, [2, 3, 1])
3-element Vector{String}:
 "b"
 "c"
 "a"

julia> cust # original vector remains unsorted
3-element Vector{String}:
 "a"
 "b"
 "c"

3. उत्पादन शेड्यूल बनाइए!

अब इन सबको मिलाकर आप उन कछुओं को गर्म रखने में मदद कर सकते हैं! अब आप मात्राओं और ग्राहकों को ठीक से क्रमबद्ध कर सकते हैं, लेकिन भेजने के लिए इनका मूल क्रम वापस पाना भी ज़रूरी है। यह काम उल्टे क्रमचय की मदद से किया जा सकता है।

एक फंक्शन production_schedule!(cust, qty) लिखिए, जो ग्राहकों का एक Vector और मात्राओं का एक Vector लेता है। यह फंक्शन मात्राओं को जगह पर ही घटते क्रम में क्रमबद्ध करता है। यह मात्राओं के उसी क्रम में क्रमबद्ध ग्राहकों का एक नया Vector लौटाता है, और साथ ही एक उल्टा क्रमचय लौटाता है, जिसकी मदद से क्रमबद्ध वेक्टर को उसके मूल क्रम में वापस लाया जा सकता है।

julia> cust, qty = ["a", "b", "c"], [2, 3, 1]
(["a", "b", "c"], [2, 3, 1])

julia> orderedcust, invperm = production_schedule!(cust, qty)
(["b", "a", "c"], [2, 1, 3])

julia> qty # has been sorted in-place
3-element Vector{Int64}:
 3
 2
 1

julia> orderedcust[invperm], qty[invperm] # inverse permutation gives original ordering
(["a", "b", "c"], [2, 3, 1])