जोड़ी कैपेसिटर

Question

कैपेसिटर उच्च सहिष्णुता के साथ निर्मित होने के लिए कुख्यात हैं। यह कई मामलों में स्वीकार्य है, लेकिन कुछ बार तंग सहिष्णुता के साथ क्षमता की आवश्यकता होती है। एक सामान्य रणनीति जिसकी आपको आवश्यकता होती है उसकी सटीक मूल्य के साथ क्षमता प्राप्त करने के लिए है दो समानांतर रूप से मापा कैपेसिटर का उपयोग करें जैसे कि उनकी क्षमता आपके द्वारा आवश्यक सीमा में कुछ में जोड़ देती है।

इस चुनौती में लक्ष्य क्षमता का एक (बहु) सेट दिया गया है, कैपेसिटर को युग्मित करने के लिए कि प्रत्येक जोड़ी की कुल क्षमता एक दी गई सीमा में है। आपको पेयरिंग का सबसे अच्छा सेट भी खोजने की आवश्यकता है, अर्थात, ऐसी जोड़ी का सेट जो कि अधिक से अधिक जोड़े मिलें।

प्रतिबन्ध

1. इनपुट में पसंद का एक प्रारूप शामिल है
   • आपके पास मौजूद कैपेसिटर के सेट (बहु) का प्रतिनिधित्व करने वाली क्षमताओं की एक अनियंत्रित सूची
   • लक्ष्य रेंज के निचले और ऊपरी हिस्से (समावेशी) का प्रतिनिधित्व करने वाली क्षमता की एक जोड़ी
2. इनपुट में सभी क्षमताएं सकारात्मक पूर्णांक 2 ³⁰ से छोटी हैं , इकाई pF है (यह मायने नहीं रखता है)।
3. इनपुट में कैपेसिटी की सूची के अलावा, कैपेसिटर के सेट में 0 पीएफ के मान के साथ कैपेसिटर की एक अनंत राशि भी होती है।
4. आउटपुट पसंद के प्रारूप में शामिल होते हैं, क्षमता के जोड़े की एक सूची जैसे कि प्रत्येक जोड़ी का योग निर्दिष्ट लक्ष्य सीमा में है। न तो जोड़े का क्रम और न ही किसी जोड़ी के भीतर क्षमताओं का क्रम निर्दिष्ट है।
5. आउटपुट की कोई क्षमता आपके द्वारा कैपेसिटर के सेट में दिखाई देने की तुलना में अधिक बार दिखाई नहीं दे सकती है । दूसरे शब्दों में: आपके द्वारा उत्पादित जोड़े ओवरलैप नहीं होने चाहिए।
6. ऐसी कोई संभावित आउटपुट संतोषजनक स्थिति 4 और 5 नहीं होगी जिसमें आपके प्रोग्राम द्वारा उत्पादित आउटपुट की क्षमता से अधिक जोड़े हों।
7. आपका कार्यक्रम O ( n !) समय में समाप्त हो जाएगा, जहां n आपके पास कैपेसिटर के सेट का प्रतिनिधित्व करने वाली सूची की लंबाई है
8. खामियों का दुरुपयोग नहीं किया जाएगा
9. तय सीमा खाली नहीं होगा

स्कोरिंग

आपका स्कोर ऑक्टेट्स में आपके समाधान की लंबाई है। यदि आपका समाधान कुछ k के लिए बहुपद समय O ( n ^k ) में इस समस्या को हल करने का प्रबंधन करता है , तो अपने स्कोर को 10 से विभाजित करें। मुझे नहीं पता कि क्या यह वास्तव में संभव है।

नमूना इनपुट

• श्रेणी 100 से 100, इनपुट सरणी 100 100 100, मान्य आउटपुट:

  0 100
  0 100
  0 100
  

• रेंज 100 से 120, इनपुट सरणी 20 80 100, मान्य आउटपुट:

  0 100
  20 80
  

  आउटपुट 20 100मान्य नहीं है

• सीमा 90 से 100, इनपुट सरणी 50 20 40 90 80 30 60 70 40, मान्य आउटपुट:

  0 90
  20 80
  30 70
  40 60
  40 50
  

• सीमा 90 से 90, इनपुट सरणी 20 30 40 40 50 60 70 80 90, मान्य आउटपुट:

  0 90
  20 70
  30 60
  40 50
  

• सीमा 90 से 110, इनपुट सरणी 40 60 50, मान्य आउटपुट:

  40 60
  

Comments

मुझे पूरा यकीन है कि इसे आसानी से O (n log n) में हल किया जा सकता है। सबसे पहले, 0 पीएफ के साथ सीमा के भीतर किसी भी कैपेसिटर को जोड़ी। बाकी को छाँट लें। सबसे कम और उच्चतम संधारित्र को युग्मित करते रहें, यदि यह सीमा से ऊपर है तो उच्चतम छोड़ें, यदि यह सबसे नीचे है तो त्यागें।

— orlp

कुछ इनपुट / आउटपुट परीक्षण अच्छा होगा।

— orlp

@orlp मैंने पहले ही पूछा है, ओपी इस पर काम कर रहा है

— बीटा डिके

@ orlp का एल्गोरिथ्म काम करता है, लेकिन एक टिप्पणी के लिए सबूत एक शेड लंबा है। संक्षेप में, एक न्यूनतम counterexample है चाहिए a <= b <= c <= dकि इस तरह के a + d, a + c, b + dरेंज में सभी कर रहे हैं, लेकिन b + cनहीं है, लेकिन है कि एक विरोधाभास देता है।

— पीटर टेलर

@orlp प्रदान किया गया नमूना इनपुट आपके लिए उपयोगी है?

— फ़ूजएक्सएक्सएल

Answer 1

सीजेएम, 5.6

यह orlp के उत्तर में एल्गोरिथ्म का प्रत्यक्ष पुन: कार्यान्वयन है । यदि आप मेरे उत्तर को बढ़ाते हैं, तो कृपया सुनिश्चित करें कि आप इस उत्तर को भी उत्थान करेंगे । मैं यह भी सुझाव देता हूं कि मूल एल्गोरिथ्म के साथ उत्तर को स्वीकार किया जाता है, क्योंकि मुझे बहुत संदेह है कि मुझे पता लगा होगा कि इस सुरुचिपूर्ण तरीके से ओ (एन * लॉग (एन)) को कैसे हल किया जाए।

l~_,0a*+${(\)@_2$+4$~2$\>{;;\;\+}{<{;+}{oSop}?}?_,1>}g;;

इसे ऑनलाइन आज़माएं

नमूना इनपुट:

[90 100] [50 20 40 90 80 30 60 70 40]

स्पष्टीकरण:

l~      Get and interpret input.
_,      Get length of resistor list.
0a*+    Append the same number of 0 values.
$       Sort the list.
{       Loop until less than 2 entries in list.
  (       Pop off first value.
  \)      Pop off last value.
  @_      Pull first value to top, and copy it.
  2$      Copy last value to top.
  +       Add first and last value.
  4$~     Copy specified range to top, and unwrap the two values.
  2$      Copy sum to top.
  \>      Swap and compare for sum to be higher than top of range.
  {       It's higher.
    ;;\;    Some stack cleanup.
    \+      Put first value back to start of resistor list.
  }
  {       Not higher, so two cases left: value is in range, or lower.
    <       Compare if sum is lower than bottom of range.
    {       It's lower.
      ;+      Clean up stack and put last value back to end of resistor list.
    }
    {       Inside range, time to produce some output.
      o       Output first value.
      So      Output space.
      p       Output second value and newline.
    }?      Ternary operator for comparison with lower limit.
  }?      Ternary operator for comparison with upper limit.
  _,      Get length of remaining resistor list.
  1>      Check if greater 1.
}g      End of while loop for processing resistor list.
;;      Clean up stack, output was generated on the fly.

Comments

आप अपनी भाषा के लिए अधिक उपयुक्त होने के लिए आउटपुट स्वरूप को बदल सकते हैं। आउटपुट का सटीक प्रारूप निर्दिष्ट नहीं है, केवल आपके पास आउटपुट के लिए डेटा है।

— फ़ूजएक्सएक्सएक्स

Answer 2

अजगर 2, 11.5

एक बार के लिए पायथन गोल्फ:

(a,b),l=input()
l=[0]*len(l)+sorted(l)
while l:
 e=l[0]+l[-1]
 if a<=e<=b:print l[0],l[-1]
 l=l[e<=b:len(l)-(a<=e)]

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

उदाहरण इनपुट / आउटपुट:

[[90,100], [20,30,40,40,50,60,70,80,90]]

0 90
20 80
30 70
40 60
40 50