असामान्य मूल्य के प्रतिरोध

Question

परिचय

इलेक्ट्रॉनिक्स प्रोजेक्ट का निर्माण करते समय, एक योजनाबद्ध एक असामान्य मूल्य (कहो, 510 ओम) के एक अवरोधक के लिए कॉल कर सकता है। आप अपने भागों की जांच करते हैं और पाते हैं कि आपके पास कोई 510-ओम प्रतिरोध नहीं है। लेकिन आपके पास इस मूल्य से ऊपर और नीचे कई सामान्य मूल्य हैं। समानांतर और श्रृंखला में प्रतिरोधों के संयोजन से, आपको 510-ओम अवरोधक को लगभग अच्छी तरह से समझने में सक्षम होना चाहिए।

कार्य

आपको एक फ़ंक्शन या प्रोग्राम लिखना होगा जो प्रतिरोधक मानों की सूची (प्रतिरोधक जो आप स्टॉक करते हैं) और एक लक्ष्य मान (जिसे आप अनुमानित करना चाहते हैं) को स्वीकार करता है। कार्यक्रम पर विचार करना चाहिए:

• व्यक्तिगत प्रतिरोधों
• श्रृंखला में दो प्रतिरोधक
• समानांतर में दो प्रतिरोधक

कार्यक्रम को स्टॉक सूची से 1 और 2 प्रतिरोधों के सभी संभावित संयोजनों की गणना करनी चाहिए (एक ही प्रतिरोधक मूल्य की दो प्रतियों सहित), उनकी श्रृंखला और समानांतर प्रतिरोध की गणना करें, फिर कॉन्फ़िगरेशन के अनुसार वे कितनी अच्छी तरह से लक्ष्य मान का अनुमान लगाते हैं।

आउटपुट स्वरूप प्रति पंक्ति एक कॉन्फ़िगरेशन होना चाहिए, जिसमें एक +डीनोटिंग सीरीज़ और |समरूपता को दर्शाते हुए, और नेट प्रतिरोध से पहले कुछ स्थान या एक = चिह्न होता है।

सूत्र

• एक प्रतिरोध का प्रतिरोध है R1
• श्रृंखला में दो प्रतिरोधों का शुद्ध प्रतिरोध है R1 + R2
• समानांतर में दो प्रतिरोधों का शुद्ध प्रतिरोध है 1 / (1/R1 + 1/R2)
• एक अनुमानित प्रतिरोध मान और लक्ष्य मान के बीच की दूरी को छद्म लघुगणक दूरी के रूप में गणना की जा सकती है, न कि रैखिक दूरी dist = abs(Rapprox / Rtarget - 1):। उदाहरण के लिए, 200 100 के करीब 350 के करीब है।
• एक बेहतर दूरी माप सही लघुगणक दूरी है dist = abs(log(Rapprox/Rtarget)), लेकिन चूंकि यह मूल प्रश्न में निर्दिष्ट नहीं किया गया था, इसलिए आप या तो माप का उपयोग करने के लिए स्वतंत्र हैं।

स्कोरिंग

स्कोर को सामान्य गोल्फ नियमों के अनुसार, कोड के पात्रों में मापा जाता है। सबसे कम स्कोर जीतता है।

उदाहरण

हमारे पास स्टॉक में निम्नलिखित प्रतिरोधक हैं [100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700]और 510ओम को लक्षित करना चाहते हैं । कार्यक्रम को 143 कॉन्फ़िगरेशन का उत्पादन करना चाहिए, लगभग दिखाया गया है (आप प्रारूप को बदल सकते हैं, लेकिन सुनिश्चित करें कि अर्थ आसानी से निर्धारित किया गया है):

680 | 2200     519.444
1000 | 1000    500.
150 + 330      480.
220 + 330      550.
470            470
680 | 1500     467.89
680 | 3300     563.819
100 + 470      570.
220 + 220      440.
100 + 330      430.
470 | 4700     427.273
680 | 4700     594.052
1000 | 1500    600.
470 | 3300     411.406
680 | 1000     404.762
150 + 470      620.
...
many more rows
...
2200 + 4700    6900.
3300 + 4700    8000.
4700 + 4700    9400.

इस उदाहरण में, 510 ओम का सबसे अच्छा सन्निकटन 680- और 2200-ओम प्रतिरोधों द्वारा समानांतर में दिया गया है।

अब तक की प्रत्येक भाषा के सर्वश्रेष्ठ (1 जून 2014):

1. जे - 70 चार
2. एपीएल - 102 चार
3. गणितज्ञ - १२२ चार
4. रूबी - 154 चार
5. जावास्क्रिप्ट - 156 चार
6. जूलिया - 163 चार
7. पर्ल - 185 चार
8. पायथन - 270 चार

Comments

@ कोलुडु 100 + 150 और 150 + 100 के बीच कोई अंतर नहीं है; दोनों 250 ओम प्रतिरोध का उत्पादन करते हैं और 100-ओम अवरोधक और 150-ओम अवरोधक का उपभोग करते हैं, इसलिए हमें डबल-काउंट नहीं करना चाहिए। हालांकि, उन्हें 125 + 125 से अलग किया जाना चाहिए, क्योंकि यह भी 250 ओम की पैदावार देता है, यह विभिन्न प्रतिरोधों का उपभोग करता है (जो कि हमारे हिस्से को देखते हुए, बेहतर हो सकता है)।

— फॉसजेन

510 E24 श्रृंखला में है, इसलिए यह असामान्य नहीं है कि हाथ पर

— gnibbler

Phosgene, ROUV के बारे में क्या है?

— चाचा

मुझे नहीं लगता कि वे मौजूद हैं।

— फॉसजेन

हम आमतौर पर कोड गोल्फ सवालों के लिए समय सीमा निर्धारित नहीं करते हैं, क्योंकि यह कुछ लोगों को पोस्ट करने से हतोत्साहित कर सकता है। आप हमेशा स्वीकृत उत्तरों को बदल सकते हैं।

— नजला

Answer 1

जे - 86 71 70 चार

((]/:[|@<:@%~2{::"1])(;a:,<)"0,[:,/(<,.+`|,.+/;+&.%/)"1@;@((<@,.{:)\))

मैं हर छोटे से विवरण को परेशान करने के लिए नहीं जा रहा हूं क्योंकि बहुत सारे कोड अलग-अलग कार्यों के परिणामों को समन्वयित करने में खर्च किए जाते हैं, लेकिन यहां गोल्फ का सार है:

• ;@((<@,.{:)\) प्रतिरोधों की हर संभव जोड़ी बनाता है, या तो समानांतर या श्रृंखला में जुड़ा होना।

• [:,/(<,.+`|,.+/;+&.%/)"1@ फिर उन्हें जोड़ता है, समानांतर और श्रृंखला में, संभावित कनेक्शनों की एक बड़ी सूची बनाता है।

• (;a:,<)"0, अनुमानित रूप से केवल एक ही अवरोधक का उपयोग करने की संभावना में जोड़ता है।

• (]/:[|@<:@%~2{::"1])|@<:@%प्रत्येक संयोजन से लक्ष्य और परिणामी प्रतिरोध के बीच pseudolog दूरी ( ) द्वारा प्रतिरोधों के संयोजन की सूची को सॉर्ट करें ।

और इसका उपयोग कैसे करना है:

   rouv =: ((]/:[|@<:@%~2{::"1])(;a:,<)"0,[:,/(<,.+`|,.+/;+&.%/)"1@;@((<@,.{:)\))
   # 510 rouv 100 150 220 330 470 680 1000 1500 2200 3300 4700      NB. how many?
143
   10 {. 510 rouv 100 150 220 330 470 680 1000 1500 2200 3300 4700  NB. view first 10
+---------+-+-------+
|680 2200 |||519.444|
+---------+-+-------+
|1000 1000|||500    |
+---------+-+-------+
|150 330  |+|480    |
+---------+-+-------+
|220 330  |+|550    |
+---------+-+-------+
|470      | |470    |
+---------+-+-------+
|680 1500 |||467.89 |
+---------+-+-------+
|680 3300 |||563.819|
+---------+-+-------+
|100 470  |+|570    |
+---------+-+-------+
|220 220  |+|440    |
+---------+-+-------+
|100 330  |+|430    |
+---------+-+-------+

आपको केवल पहले 10 देखने की ज़रूरत नहीं है जैसे मैंने ऊपर किया था, लेकिन यह एक फ़ंक्शन है और जे रेप्लस बहुत बड़े रिटर्न मानों को छोटा करता है, और इस उदाहरण के लिए पूर्ण आउटपुट में 287 लाइनें हैं। आप इसे सभी को tmoutput toCRLF , LF ,.~ ": blah rouv blahविंडोज पर किसी चीज़ के साथ जबरदस्ती कर सकते हैं - जैसे कि toCRLFलिनक्स पर ड्रॉप करें - लेकिन rouvएक फ़ंक्शन है और आंतरिक रूप से, सभी पंक्तियाँ मौजूद हैं।

ध्यान दें:

ऐसा लगता है कि हमारी नाक के नीचे प्रश्न बदला गया है, और अब लॉग दूरी को abs(log(Rapprox/Rtarget))इसके बजाय परिभाषित किया गया है abs(Rapprox/Rtarget-1)। मेरी गोल्फ में इसे ठीक करने के लिए, हम बदल सकते हैं |@<:@%करने के लिए |@^.@%: <:घटते क्रम में है, जबकि ^.लघुगणक है।

Comments

यद्यपि आपका कोड स्पष्ट रूप से अथाह है, फिर भी हम रहस्य की सराहना कर सकते हैं। एक दिन के बाद सर्वश्रेष्ठ स्कोर - क्या यह खड़ा होगा?

— फॉस्जीन

नहीं, मैं एक मेल नहीं भेजना चाहता हूँ -। &

— A

Answer 2

मेथेमेटिका, 151 122 पात्रों

में rऔर उपलब्ध प्रतिरोधों की सूची में संग्रहित लक्ष्य प्रतिरोध की अपेक्षा करता है l।

SortBy[Join[{#,#}&/@l,Join@@(#@@@Union[Sort/@N@l~Tuples~{2}]&/@{{"+",##,#+#2}&,{"|",##,#*#2/(#+#2)}&})],Abs[#[[-1]]/r-1]&]

कम गोल्फ:

SortBy[Join[{#, #} & /@ l,
  Join @@ (# @@@ 
       Union[Sort /@ N@l~Tuples~{2}] & /@ {{"+", ##, # + #2} &, {"|", ##, 
        #*#2/(# + #2)} &})], Abs[#[[-1]]/r - 1] &]

आउटपुट स्वरूप सुझाए गए एक से भिन्न होता है लेकिन कॉन्फ़िगरेशन आसानी से निर्धारित होता है। आउटपुट कॉन्फ़िगरेशन की एक सूची है। प्रत्येक कॉन्फ़िगरेशन निम्न रूपों में से एक है:

{R1, Total}
{"+", R1, R2, Total}
{"|", R1, R2, Total}

तो आउटपुट के पहले तीन तत्व पढ़े

{{"|", 680., 2200., 519.444}, {"|", 1000., 1000., 500.}, {"+", 150., 330., 480.}, ...}

यदि आप तर्कसंगत संख्याओं के साथ ठीक हैं, तो मैं दो पात्रों को छोड़ने से बचा सकता हूं N@। यही है, पहला तत्व (उदाहरण के लिए) के 4675/9बजाय वापस आ जाएगा 519.444।

Comments

अच्छा काम। आप मुझे इसे (और छोटे कोड के साथ) हरा देते हैं।

— डेविड

Didn '# your den # है # w @ rn you @ g @ ins # e @ # ing # h @ # ज्यादा सिंक # @ c # ic सुगर @ r?

— फोसगेन

@ न @ ल टुपल्स? प्रोग्रामर रोग के कुछ प्रकार है?

— क्लैबचियो

@clabacchio अद्भुत, मैंने वह भी नहीं देखा। फोसगेन, वह इसका उल्लेख करना भूल गया होगा ... या शायद वह सिर्फ गोल्फ खेलना पसंद करता है, ...

— मार्टिन एंडर

Answer 3

एपीएल (102)

{V←{⊃¨⍺{⍺,⍺⍺,⍵,'=',⍺⍵⍵⍵}⍺⍺/¨Z/⍨≤/¨Z←,∘.,⍨⍵}⋄K[⍋|¯1+⍺÷⍨0 4↓K←↑('|'{÷+/÷⍺⍵}V⍵),('+'+V⍵),{⍵,'  =',⍵}¨⍵;]}

यह लक्ष्य प्रतिरोध को बाएं तर्क के रूप में लेता है और उपलब्ध प्रतिरोधों की सूची को सही तर्क के रूप में लेता है।

स्पष्टीकरण:

• V←{... }: Vएक समारोह है कि:
  • Z/⍨≤/¨Z←,∘.,⍨⍵: में दो मूल्यों के प्रत्येक अद्वितीय संयोजन को ढूँढता है ⍵,
    • Z←,∘.,⍨⍵: में प्रत्येक मूल्य के ⍵साथ प्रत्येक मूल्य में शामिल ⍵, में स्टोर Z,
    • Z/⍨≤/¨Z: Zउन संयोजनों से चयन करें जहां पहला मूल्य दूसरे मूल्य से कम या बराबर है
  • ⍺{... }⍺⍺/¨: और फिर निम्नलिखित फ़ंक्शन लागू होता है, बाएं फ़ंक्शन के साथ बाध्य होता है (⍺⍺ ) दाईं ओर और बाएं तर्क ( ⍺) बाईं ओर, प्रत्येक पृष्ठ पर:
    • ⍺,⍺⍺,⍵,'=',⍺⍵⍵⍵बाएँ तर्क, उसके बाद बाएँ तर्क, उसके बाद दाएँ तर्क, उसके =बाद दाएँ फ़ंक्शन ( ⍵⍵) दोनों तर्कों पर लागू होते हैं। (यह प्रारूपण फ़ंक्शन है X [configuration] Y [equals] (X [fn] Y)।)
  • ⊃¨: और फिर प्रत्येक तत्व को अनबॉक्स करें।
• {⍵,' =',⍵}¨⍵: प्रत्येक तत्व के ⍵लिए, अलग-अलग प्रतिरोधों के लिए कॉन्फ़िगरेशन बनाएं। ( ⍵, कुछ भी नहीं, कुछ भी नहीं)= , ⍵)।
• ('+'+V⍵): Vसभी सीरियल कॉन्फ़िगरेशन (चरित्र है '+'और फ़ंक्शन है +) बनाने के लिए फ़ंक्शन का उपयोग करें ।
• '|'{÷+/÷⍺⍵}V⍵: Vसभी समानांतर कॉन्फ़िगरेशन (वर्ण है) बनाने के लिए फ़ंक्शन का उपयोग करें'|' और फ़ंक्शन है {÷+/÷⍺⍵}, तर्कों के व्युत्क्रम के व्युत्क्रम में)।
• K←↑: इसे एक मैट्रिक्स में बनाएं और इसे स्टोर करें K ।
• 0 4↓K: से 4 पहले कॉलम ड्रॉप करें K केवल प्रतिरोध मूल्यों को छोड़कर, छोड़ें।
• |¯1+⍺÷⍨: के बीच की दूरी की गणना करें ⍺ प्रत्येक विन्यास के करें।
• K[⍋... ;]: Kदूरियों के आधार पर छाँटें।

Comments

मैं आपका वचन लेता हूँ कि यह काम करता है। मेरा कीबोर्ड इन वर्णों के बजाय बहुत याद आ रहा है: D

— phosgene

@phosgene: यदि आप इसका परीक्षण करना चाहते हैं, तो आप dyalog.com पर Dyalog APL का परीक्षण संस्करण डाउनलोड कर सकते हैं। फिर बस पूरी चीज़ को अंदर डालें, यह काम करना चाहिए। तर्क पक्ष पर चलते हैं, इसलिए उदाहरण के लिए:510 code_here 100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700

— मारिनस

@phosgene आप इस ऑनलाइन दुभाषिया को आज़मा सकते हैं , हालाँकि यह पूर्ण आउटपुट प्रदान नहीं करता है आप यह सत्यापित कर सकते हैं कि कुछ पंक्तियाँ और अंतिम कुछ पंक्तियाँ समान हैं।

— user12205

सत्यापित! एपीएल कुछ गूढ़ सामान है।

— फॉसजेन

@ace TryAPL बहुत सीमित है, और आमतौर पर यह काम नहीं करता है। यह इस पर काम करने के लिए होता है कि यह केवल एक संयोग है। यह eval ( ⍎), I / O ( ⎕), या किसी भी सिस्टम वैरिएबल (यहां तक ​​कि ⎕UCSऔर ⎕Aकाम नहीं करता) का समर्थन नहीं करता है , इसलिए अधिकांश APL प्रोग्राम नहीं चलेंगे। यदि वास्तव में अक्षम कार्यों में से एक का उपयोग किया जाता है तो यह वास्तव में एक SYNTAX ERROR देगा । तथ्य यह है कि ऐसा होता है कि TryAPL का समर्थन नहीं करने वाले कई कार्यों में से एक का उपयोग नहीं करना एक संयोग है।

— मारिनस

Answer 4

अजगर 3 - 250 247 270 बाइट्स

from itertools import*
import sys
r=sys.argv[1:]
t=int(r.pop())
p=set(map(tuple,map(sorted,product(r,r))))
a=[('+'.join(b),sum(map(int,b)))for b in p]+[('|'.join(b),1/sum(map(lambda n:1/int(n),b)))for b in p]
for s in sorted(a,key=lambda b:abs(float(b[1])/t-1)):print(s)

इस तरह से चलाएं:

python resistors.py 100 150 220 330 470 680 1000 1500 2200 3300 4700 510

(जो अंत में लक्ष्य मान के साथ, प्रतिरोधों की एक अंतरिक्ष-सीमांकित सूची है)

आउटपुट:

('2200|680', 519.4444444444445)
('1000|1000', 500.0)
('150+330', 480)
('220+330', 550)
('1500|680', 467.88990825688074)
('3300|680', 563.8190954773869)

[snip]

('2200+4700', 6900)
('3300+4700', 8000)
('4700+4700', 9400)

मैं कहूंगा कि आउटपुट देना, कहना, 680|2200 और2200|680 अलग से अभी भी बहुत स्पष्ट है। अगर यह अस्वीकार्य है, तो मैं इसे बदल सकता हूं, लेकिन यह मुझे बाइट्स देगा।स्वीकार्य नहीं था। लागत मुझे बाइट्स। अब मैं टपल्स को सेट में चककर देने से पहले हल करता हूं, अन्यथा समाधान समान है।

Comments

ज़रूर, आउटपुट मुझे बहुत स्पष्ट दिखता है!

— phosgene

हालाँकि, आप चीजों को दोहरा रहे हैं। 150 + 330 विद्युत रूप से 330 + 150 के समान है, इसलिए उनमें से केवल एक परिणाम में दिखाई देना चाहिए (उदाहरण के लिए 143 कुल कॉन्फ़िगरेशन)।

— फॉसजेन

@ एफो ओके, फिक्स्ड। कुछ अतिरिक्त बाइट्स लेकिन समाधान अब मान्य होना चाहिए।

— अंडरग्राउंडोरेल

इसके अलावा, मुझे लगता है कि आपका कार्यक्रम एक एकल अवरोधक की तलाश में नहीं है, बिल्कुल (a + = [(a) r के लिए]]। आप एक = को छोड़ सकते हैं ... जैसा कि आप बिल्कुल एक बार उपयोग करते हैं। इसके बारे में import sys;r=sys.args[1:], उपयोग करें r=input().split()और कहें कि आपको स्टड पर मान देना होगा। अंत में: आप का उपयोग 1/sum(1/int(n)for n in b)करने के बजाय 1/sum(map(lambda n:1/int(n),b)। सभी के सभी, कि 274 वर्ण होना चाहिए

— WorldSEnder

मैं सिर्फ 1 और चार गोल्‍ड लगाता हूं: प्रिंट का उपयोग करें (* सॉर्ट किया गया (...), sep = '\ n')

— WorldSEnder

Answer 5

रूबी 2.1, 156 154 बाइट्स

s=->(a,z){c={};a.map{|e|a.map{|f|c[e]=e;c[e+f]="#{e}+#{f}";c[1/(1.0/f+1.0/e)]="#{e}|#{f}"}};c.sort_by{|k,|(k/z.to_f-1).abs}.map{|e|puts"#{e[1]}=#{e[0]}"}}

Ungolfed:

s =->(a,z) {
  c={}
  a.map{|e|
    a.map{|f|
      c[e]=e
      c[e+f]="#{e}+#{f}"
      c[1/(1.0/f+1.0/e)]="#{e}|#{f}"
    }
  }
  c.sort_by{|k,|
    (k/z.to_f-1).abs
  }.map{|e|
    puts "#{e[1]}=#{e[0]}"
  }
}

यह क्या करता है:

• में प्रत्येक मूल्य eके लिए a;
  • aहैश में मुद्रित मूल्यों की कुंजी के रूप में एकल, श्रृंखला और समानांतर मूल्यों की गणना के माध्यम से Iterate c;
• में zप्रत्येक कुंजी के लिए से दूरी का निर्धारण c; तथा,
• प्रत्येक मान के लिए e[1]प्रत्येक कुंजी के लिए e[0]में c, मुद्रित e[1]=e[0]।

नमूना उपयोग:

s[[100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700], 510]

नमूना उत्पादन:

2200|680=519.4444444444445
1000|1000=500.0
330+150=480
330+220=550
470=470
1500|680=467.88990825688074
3300|680=563.8190954773869
.
.
.
4700+1500=6200
3300+3300=6600
4700+2200=6900
4700+3300=8000
4700+4700=9400

Answer 6

जावास्क्रिप्ट (ECMAScript 6) - 186 वर्ण

f=(R,T)=>(D=x=>Math.abs(x[3]/T-1),r={p:(x,y)=>x*y/(x+y),s:(x,y)=>x+y},[...[[x,0,0,x]for(x of R)],...[[x,y,z,r[z](x,y)]for(x of R)for(y of R)for(z in r)if(x<=y)]].sort((a,b)=>D(a)-D(b)))

इनपुट:

• Rरोकनेवाला ताकत की एक सरणी ; तथा
• Tलक्ष्य प्रतिरोध।

आउटपुट:

Tप्रत्येक से युक्त सरणियों की एक सरणी (दूरी से क्रमबद्ध ):

• छोटे अवरोधक का मान;
• उच्च प्रतिरोधक मान (या 0 यदि एक एकांत अवरोधक);
• p, sया 0 यदि प्रतिरोध समानांतर, धारावाहिक या एकान्त में हैं; तथा
• शुद्ध प्रतिरोध।

स्पष्टीकरण:

f=(R,T)=>(                               // Create a function f with arguments R & T
  D=x=>Math.abs(x[3]/T-1),               // A function D to calculate relative
                                         // distance from the target value
  r={p:(x,y)=>x*y/(x+y),s:(x,y)=>x+y},   // An object containing the formulae
                                         // to calculate resistance in serial and parallel
  solitary = [[x,0,0,x]for(x of R)],     // Create an array of solitary resistors
  pairs =                                // Use Array Comprehension to create the array of
   [[x,y,z,r[z](x,y)]                    // arrays
      for(x of R)                        // for each resistor value
      for(y of R)                        // for each resistor value (again)
      for(z in r)                        // for both serial & parallel
      if(x<=y)],                         // where the first resistor value is smaller than the second
  [
    ...solitary,                         // Use the spread ... operator to combine
    ...pairs                             // the two arrays
  ]
    .sort((a,b)=>D(a)-D(b))              // Sort the arrays by minimum distance
                                         // and return.
)

Comments

एकल रोकनेवाला लापता (उदाहरण इनपुट के लिए आउटपुट लेन 143 के बजाय 132 है)। मुझे

— एरियर

आह, एकान्त प्रतिरोधकों को भूल गए

— MT0

Answer 7

जूलिया - 179 163 बाइट्स

f(t,s)=(\ =repmat;m=endof(s);A=A[v=(A=s\m).>=(B=sort(A))];B=B[v];F=[s,C=A+B,A.*B./C];n=sum(v);print([[s P=[" "]\m P;A [+]\n B;A [|]\n B] F][sortperm(abs(F-t)),:]))

यह पुराने संस्करण की तरह ही काम करता है, लेकिन प्रिंट स्टेटमेंट में तर्क को आवश्यक रूप से वर्ग कोष्ठक की संख्या को कम करने के लिए थोड़ा अलग तरीके से आयोजित किया गया है। 4 बाइट बचाता है। प्रिंट तर्क में रिक्त स्थान वेक्टर निर्माण को अवशोषित करने से अतिरिक्त 2 बाइट्स की बचत होती है। तार्किक रूप का उपयोग करने के लिए प्रासंगिक सूचकांक प्राप्त करने के लिए "खोज" का उपयोग करने से भी स्विच किया गया है। 6 बाइट बचाता है। एक और एक 2 बाइट्स के समायोजन में सूचकांक वेक्टर की गणना को अवशोषित करना। अंत में, योग (वी) के साथ एंडोफ़ (वी) की जगह 2 और बाइट्स बचाए गए। कुल बचत: 16 बाइट्स।

पुराना संस्करण:

f(t,s)=(\ =repmat;m=endof(s);A=s\m;v=find(A.>=(B=sort(A)));A=A[v];B=B[v];F=[s,C=A+B,A.*B./C];n=endof(v);P=[" "]\m;print([[s,A,A] [P,[+]\n,[|]\n] [P,B,B] F][sortperm(abs(F-t)),:]))

समारोह के भीतर, यहाँ यह क्या कर रहा है:

\ =repmat            # Overloads \ operator to save lots of characters
m=endof(s)           # Length of input s ("Stock")
A=s\m                # Equivalent to repmat(s,m) (see first command)
B=sort(A)            # Same as A but sorted - rather than cycling through
                     # the resistors m times, it repeats each one m times
v=find(A.>=B)        # Identify which pairs for A,B have A>=B
A=A[v];B=B[v]        # Remove pairs where A<B (prevents duplicates)
F=[s,C=A+B,A.*B./C]  # Constructs vector containing results for single resistor,
                     # resistors in series, and resistors in parallel
n=endof(v)           # equivalent to n=(m+1)m/2, gets number of relevant pairs
P=[" "]\m            # Construct array of blank entries for use in constructing output
print([[s,A,A] [P,[+]\n,[|]\n] [P,B,B] F][sortperm(abs(F-t)),:]))
# The following are the components of the argument in the print statement:
[s,A,A]              # Set of resistor values for resistor 1
[P,[+]\n,[|]\n]      # Operator column, prints either nothing, +, or |
[P,B,B]              # Set of resistor values for resistor 2 (blank for single resistor)
F                    # Contains resulting equivalent resistance
[sortperm(abs(F-t)),:] # Determines permutation for sorting array by distance from Target t
                     # and applies it to array

नमूना उत्पादन:

julia> f(170,[100,220,300])
300  |  300  150
100  +  100  200
300  |  220  126.92307692307692
220          220
220  |  220  110
100          100
300  |  100  75
220  |  100  68.75
100  |  100  50
300          300
220  +  100  320
300  +  100  400
220  +  220  440
300  +  220  520
300  +  300  600

Comments

अच्छा! कई जूलिया प्रस्तुतियाँ न देखें - क्या यह लोकप्रियता में बढ़ रही है?

— फोसगेन

@phosgene - मुझे आशा है कि यह है; मैं ज्यादातर इन्हें जमा कर रहा हूं क्योंकि वे मुझे भाषा के साथ अतिरिक्त अनुभव दे रहे हैं।

— ग्लेन ओ

Answer 8

जावास्क्रिप्ट (ई 6) 156 162 164 186

अंतिम संपादन सभी अवरोधक मानों को मानकर> 0, आप उन्हें लूप कंडीशन के लिए उपयोग कर सकते हैं

F=(t,s)=>{D=a=>Math.abs(a[1]/t-1);for(i=r=[];a=s[j=i++];r[l]=[a,a])for(;b=s[j--];)l=r.push([a+'+'+b,c=a+b],[a+'|'+b,a*b/c]);return r.sort((a,b)=>D(a)-D(b))}

उपयोग: F(510, [100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700])

Ungolfed

F = (t,s) => 
{
  D = a => Math.abs(a[1]/t-1);
  for (i=r=[]; a=s[j=i++]; r[l]=[a,a])
    for(; b=s[j--];)
      l = r.push([a+'+'+b, c=a+b], [a+'|'+b, a*b/c]);
   return r.sort((a,b) => D(a)-D(b))
}

Comments

धक्का चाहिए (स्कोर, कम)!

— फॉस्जीन

अंतिम बार मैंने जाँच की, मेरे सभी प्रतिरोधों को सकारात्मक रूप से महत्व दिया गया था। मुझे लगता है कि यह एक सुरक्षित धारणा है।

— फोसगेन

Answer 9

जावास्क्रिप्ट, 248 बाइट्स

function r(T,L){R=[],O="";for(i in L){R.push([a=L[i],a]);for(j=i;j<L.length;)b=L[j++],s=a+b,R.push([a+"+"+b,s],[a+"|"+b,a*b/s])}R.sort(function(a,b){A=Math.abs;return A(a[1]/T-1)-A(b[1]/T-1)});for(i in R)q=R[i],O+=q[0]+"="+q[1]+"\n";console.log(O)}

उपयोग: r(510, [100, 150, 220, 330, 470, 680, 1000, 1500, 2200, 3300, 4700]);

उत्पादन

670|2200=519.4444444444445
1000|1000=500
150+330=480

(...such rows...)

2200+4700=6900
3300+4700=8000
4700+4700=9400

Answer 10

पर्ल, 213 199 185 बाइट्स

213 बाइट्स:

$t=pop;sub t{abs 1-(split/=/,pop)[1]/$t}sub S{$_[0]+$_[1]}sub P{$_[0]*$_[1]/&S}$"=',';@i=@ARGV;say for sort{t($a)<=>t($b)}grep s!(..\b(\d+)\b,?\b(\d+)?\b\))=\K(??{$2<$3})!$1!ee&&/\d$/,<{S,P}({@i},{@i})= S({@i})=>;

199 बाइट्स:

$t=pop;sub t{abs 1-(split/=/,pop)[1]/$t}sub S{$_[0]+$_[1]}sub P{$_[0]*$_[1]/&S}$"=',';@i=@ARGV;say for sort{t($a)<=>t($b)}grep/(..(\d+),?(\d+)?\))/&&$2>=$3&&($_.=eval$1),<{S,P}({@i},{@i})= S({@i})=>;

185 बाइट्स:

$t=pop;sub t{abs 1-$_[0]=~s!.*=!!r/$t}sub S{$_[0]+$_[1]}sub P{$_[0]*$_[1]/&S}$"=',';$i="{@ARGV}";say for sort{t($a)<=>t$b}grep{my($x,$y)=/\d+/g;$_.='='.eval,$x>=$y}<{S,P}($i,$i) S($i)>

सभी उपलब्ध प्रतिरोधों को तर्क के रूप में पास करें। लक्ष्य प्रतिरोध अंतिम होना चाहिए:

$ perl -E 'code' R1 R2 R3 ... Rn target

यह कैसे काम करता है (पुराना कोड)

• सबरूटीन्स को परिभाषित करें Sऔर Pदो प्रतिरोधों के योग और समानांतर मानों की गणना करें।

• सेट $"करने के लिए "," प्रक्षेप करने के लिए@ARGVglobऑपरेटर के अंदर

• <{S,P}({@i},{@i})= S({@i})=> सभी संभावनाओं का एक कार्टेशियन उत्पन्न करता है:

  S (100,100), S (100,150), S (100,220), ... P (100,100), P (100,150) ... S (100), S (150) ...

• कम्बाइन s///eeके साथ grepबराबर प्रतिरोध का मूल्यांकन करने और अवांछित दोहराता को फ़िल्टर (द्वारा किया जाता करने के लिए (??{$2<$3})और/\d$/

• sort फिटनेस के द्वारा सबरूटीन में गणना की जाती है t

नए कोड में परिवर्तन

• के उपयोग से बचें s///ee, सशर्त जाँच के साथ छोटे रेगेक्स का उपयोग करें औरeval अंदर केgrep

• का रिपीट रिप्लेस "{@i}" with$ I` के

• परिचय $x, $yके बजाय$2 ,$3

• बदलने के split/=/,pop के साथ$_[0]=~s!!!r

• अनुगामी की कोई आवश्यकता नहीं ;

• eval; के बराबर है eval $_;

• =साथ जोड़ेंevalसामने वाले को घोषित करने के बजाय उत्तर

आउटपुट:

Pसमानांतर में प्रतिरोधों का Sप्रतिनिधित्व करता है, श्रृंखला में प्रतिरोधों का प्रतिनिधित्व करता है।

P(2200,680)=519.444444444444
P(1000,1000)=500
S(330,150)=480
S(330,220)=550
S(470)=470
P(1500,680)=467.889908256881
P(3300,680)=563.819095477387
S(470,100)=570
S(220,220)=440
S(330,100)=430
P(4700,470)=427.272727272727
P(4700,680)=594.052044609665
P(1500,1000)=600
P(3300,470)=411.405835543767
P(1000,680)=404.761904761905
S(470,150)=620
P(2200,470)=387.265917602996
S(220,150)=370
S(330,330)=660
P(1500,470)=357.868020304569
S(680)=680
P(680,680)=340
P(2200,1000)=687.5
S(330)=330
S(470,220)=690
S(220,100)=320
P(1000,470)=319.727891156463
P(4700,330)=308.349900596421
S(150,150)=300
P(3300,330)=300
P(2200,330)=286.95652173913
P(680,470)=277.913043478261
P(1500,330)=270.491803278689
P(1500,1500)=750
P(3300,1000)=767.441860465116
S(150,100)=250
P(1000,330)=248.12030075188
S(680,100)=780
P(470,470)=235
P(680,330)=222.178217821782
S(470,330)=800
S(220)=220
P(4700,220)=210.162601626016
P(3300,220)=206.25
S(100,100)=200
P(2200,220)=200
P(4700,1000)=824.561403508772
P(470,330)=193.875
P(1500,220)=191.860465116279
S(680,150)=830
P(1000,220)=180.327868852459
P(680,220)=166.222222222222
P(330,330)=165
S(150)=150
P(470,220)=149.855072463768
P(4700,150)=145.360824742268
P(3300,150)=143.478260869565
P(2200,150)=140.425531914894
P(1500,150)=136.363636363636
P(330,220)=132
P(1000,150)=130.434782608696
P(2200,1500)=891.891891891892
P(680,150)=122.89156626506
S(680,220)=900
P(470,150)=113.709677419355
P(220,220)=110
P(330,150)=103.125
S(100)=100
P(4700,100)=97.9166666666667
P(3300,100)=97.0588235294118
P(2200,100)=95.6521739130435
P(1500,100)=93.75
P(1000,100)=90.9090909090909
P(220,150)=89.1891891891892
P(680,100)=87.1794871794872
P(470,100)=82.4561403508772
S(470,470)=940
P(330,100)=76.7441860465116
P(150,150)=75
P(220,100)=68.75
P(150,100)=60
P(100,100)=50
S(1000)=1000
S(680,330)=1010
P(3300,1500)=1031.25
S(1000,100)=1100
P(2200,2200)=1100
P(4700,1500)=1137.09677419355
S(680,470)=1150
S(1000,150)=1150
S(1000,220)=1220
P(3300,2200)=1320
S(1000,330)=1330
S(680,680)=1360
S(1000,470)=1470
P(4700,2200)=1498.55072463768
S(1500)=1500
S(1500,100)=1600
S(1500,150)=1650
P(3300,3300)=1650
S(1000,680)=1680
S(1500,220)=1720
S(1500,330)=1830
P(4700,3300)=1938.75
S(1500,470)=1970
S(1000,1000)=2000
S(1500,680)=2180
S(2200)=2200
S(2200,100)=2300
S(2200,150)=2350
P(4700,4700)=2350
S(2200,220)=2420
S(1500,1000)=2500
S(2200,330)=2530
S(2200,470)=2670
S(2200,680)=2880
S(1500,1500)=3000
S(2200,1000)=3200
S(3300)=3300
S(3300,100)=3400
S(3300,150)=3450
S(3300,220)=3520
S(3300,330)=3630
S(2200,1500)=3700
S(3300,470)=3770
S(3300,680)=3980
S(3300,1000)=4300
S(2200,2200)=4400
S(4700)=4700
S(3300,1500)=4800
S(4700,100)=4800
S(4700,150)=4850
S(4700,220)=4920
S(4700,330)=5030
S(4700,470)=5170
S(4700,680)=5380
S(3300,2200)=5500
S(4700,1000)=5700
S(4700,1500)=6200
S(3300,3300)=6600
S(4700,2200)=6900
S(4700,3300)=8000
S(4700,4700)=9400

Comments

लापता दो लाइनें हैं S(100)=100और S(1000)=1000।

— एल्गोरिथमशार्क

@ अल्गोरिद्मशर्क: यप, मिल गया। रेगेक्स अनजाने में उन्हें खा रहा था

— जैद

यह देखना दिलचस्प होगा कि क्या कोई छोटे पर्ल समाधान के साथ आ सकता है।

— ज़ैद