एक कंटेनर में कई धातु सलाखों को पैक करने के लिए संचालन की संख्या खोजने के लिए पायथन प्रोग्राम

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

इसलिए, यदि इनपुट input_arr =[6, 3, 7] जैसा है, तो आउटपुट 22

होगा।

आकार 6 के बार को आकार 1 के बार में बनाने के लिए, हमें 10 ऑपरेशन करने होंगे।
आकार 3 के बार को आकार 1 के बार में बनाने के लिए, हमें 4 ऑपरेशन करने होंगे।
आकार 7 के बार को आकार 1 के बार में बनाने के लिए, हमें 8 ऑपरेशन करने होंगे।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

एक फ़ंक्शन को परिभाषित करें prime_find() । इसमें input_num लगेगा
- prime_check :=((input_num-1)/2) के आकार के फर्श मूल्य की एक नई सूची जिसमें मूल्य सही है
- p_num के लिए श्रेणी 3 में (input_num) +1 के वर्गमूल के तल तक, 2 से बढ़ाएँ, करें
  - अगर prime_check[floor value of (p_num-3)/2] गैर-शून्य है, तो
    - प्राइम_चेक में (p_num ^ 2-3)/2 से p_num के रेंज फ्लोर वैल्यू में प्रत्येक तत्व के लिए, करें
      - Prime_check[element] :=आकार की एक नई सूची (((input_num-p_num ^2)/(2*p_num) + 1) का तल मान जिसमें मान गलत हो
- मैं के लिए 0 की सीमा में (input_num - 1) / 2 के न्यूनतम मान के लिए, करें
  - अगर prime_check[i] सही है -
    - मान 2 + 2 * i + 3 वाली सूची लौटाएं
मुख्य कार्य से, निम्न कार्य करें -
- प्राइम_नम्स :=prime_find(10^6 + 100)
- परिणाम:=0
- इनपुट_एआर में प्रत्येक मान के लिए, करें
  - परिणाम:=परिणाम + मूल्य
  - f_list :=एक नई सूची
  - प्राइम_नम्स में प्रत्येक p_num के लिए, करें
    - जबकि मान mod p_num 0 के समान है, करें
      - f_list के अंत में p_num डालें
      - मान :=का न्यूनतम मान (मान / p_num)
    - यदि p_num^2> मान है, तो
      - यदि मान> 1, तो
        
        f_list के अंत में मान डालें
      - लूप से बाहर निकलें
  - - अस्थायी:=1
    - f_list में प्रत्येक p_num के लिए उल्टे क्रम में करें
      - परिणाम:=परिणाम + अस्थायी
      - अस्थायी:=अस्थायी * p_num
- वापसी का परिणाम

उदाहरण

आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

from math import floor,sqrt
def prime_find(input_num):
   prime_check = [True]*((input_num-1)//2)
   for p_num in range(3,floor(sqrt(input_num))+1,2):
      if prime_check[(p_num-3)//2]: prime_check[(p_num**2-3)//2::p_num] = [False] * ((input_num-p_num**2)//(2*p_num) + 1)
   return [2]+[2*i+3 for i in range((input_num - 1) // 2) if prime_check[i]]
def solve(input_arr):
   prime_nums = prime_find(10**6+100)
   result = 0
   for value in input_arr:
      result += value
      f_list = []
      for p_num in prime_nums:
         while value % p_num == 0:
            f_list.append(p_num)
            value //= p_num
         if p_num**2 > value:
            if value > 1:
               f_list.append(value)
         break
      temp = 1
      for p_num in f_list[-1::-1]:
         result += temp
         temp *= p_num
   return result
if __name__ == "__main__":
print(solve([6, 3, 7]))

इनपुट

[6, 3, 7]