पायथन का उपयोग करके भोजन पैकेट प्राप्त करने वाले लोगों की संख्या का पता लगाने के लिए कार्यक्रम

मान लीजिए एक सम्मेलन में दो तरह के लोग हैं। पहले प्रकार के लोग शाकाहारी भोजन पसंद करते हैं, और दूसरे प्रकार के लोग मांसाहारी भोजन पसंद करते हैं। लेकिन सीमित संख्या में पैकेट हैं, और यदि शाकाहारियों को मांसाहारी पैकेट मिलता है या इसके विपरीत; वे उस पैकेट को नहीं लेंगे और तब तक प्रतीक्षा करेंगे जब तक कि उन्हें अपना पसंदीदा पैकेट न मिल जाए। तो, दो अलग-अलग प्रकार के पैकेट और लोगों को शाकाहारी के लिए 0 और मांसाहारी के लिए 1 के रूप में दर्शाया गया है। अब हमें दो सरणियाँ दी गई हैं, एक में खाने के पैकेटों की संख्या n है जिसे 0 और 1 से दर्शाया गया है और दूसरी सारणी में लोगों की संख्या m की कतार है, और उनकी वरीयताएँ 0 और 1 से दर्शाई गई हैं। इसलिए, यदि एक व्यक्ति को उनकी संख्या प्राप्त नहीं होती है पसंदीदा पैकेट, वे अंत में कतार में फिर से प्रवेश करते हैं और अपने पसंदीदा पैकेट की प्रतीक्षा करते हैं। इसलिए, हमें बिना भोजन के पैकेट वाले लोगों की संख्या का पता लगाना होगा ताकि हम उनके पसंदीदा पैकेट की व्यवस्था कर सकें।

इसलिए, अगर इनपुट लोगों की तरह है =[0,1,1,0], पैकेट =[0, 1, 0, 0], तो आउटपुट 1 होगा।

तो दो लोग नॉन-वेज खाना पसंद कर रहे हैं और एक ही नॉन-वेज पैकेट है। लाइन में पहले व्यक्ति को नॉन-वेज पसंद करने वाले को वह पैकेट मिल जाता है और दूसरा व्यक्ति इंतजार करता रहता है क्योंकि कोई दूसरा नॉन-वेज पैकेट नहीं है। तो, आउटपुट 1 है।

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

• temp_arr :=0 और 0 मानों वाली एक नई सूची

• लोगों में प्रत्येक व्यक्ति के लिए, करें

  • temp_arr[व्यक्ति]:=temp_arr[व्यक्ति] + 1

• कश्मीर:=0

• जबकि k <पैकेट का आकार, करें

  • अगर temp_arr[packets[k]]>0, तो

    • temp_arr[packets[k]] :=temp_arr[packets[k]] - 1

  • अन्यथा,

    • लूप से बाहर आएं

  • कश्मीर:=के + 1

• पैकेट का वापसी आकार - k

उदाहरण

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

def solve(people, packets):
   temp_arr = [0,0]
   for person in people:
      temp_arr[person] += 1
   k = 0
   while k < len(packets):
      if temp_arr[packets[k]]>0:
         temp_arr[packets[k]]-=1
      else:
         break
      k += 1
   return len(packets) - k

print(solve([0,1,1,0], [0, 1, 0, 0]))

इनपुट

[0,1,1,0], [0, 1, 0, 0]

आउटपुट

1