4 बैंड कलर कोडेड रेसिस्टर के प्रतिरोध की गणना करें

Question

प्रतिरोधों में आमतौर पर रंग कोडित बैंड होते हैं जिनका उपयोग ओम में उनके प्रतिरोध की पहचान करने के लिए किया जाता है । इस चुनौती में हम केवल सामान्य 4-बैंड, टैन, अक्षीय-सीसा प्रतिरोधों पर विचार करेंगे। हम उन्हें व्यक्त करेंगे:

xyzt

xपहला महत्वपूर्ण आंकड़ा के लिए पहला बैंड कहां है, yदूसरा महत्वपूर्ण आंकड़ा के लिए दूसरा बैंड, zगुणक के लिए तीसरा बैंड है, और सहिष्णुता केt लिए चौथा बैंड है ।

प्रत्येक xyztएक अक्षर को दर्शाता है जो बैंड के रंग को संक्षिप्त करता है:

K = Black
N = Brown
R = Red
O = Orange
Y = Yellow
G = Green
B = Blue
V = Violet
A = Gray
W = White
g = Gold
s = Silver
_ = None

इसलिए, उदाहरण के लिए, NKOgकुछ विशेष रोकनेवाला है।

प्रतिरोध की गणना इस तालिका की सहायता से की जा सकती है:

जैसा कि तालिका से पता चलता है:

• xऔर yकिसी भी पत्र सिवाय हो सकता है g, sऔर _।
• zसिवाय कुछ भी हो सकता है _।
• हम सीमित कर देंगे, tकेवल होना करने के लिए g, sया _।

( यहां एक आसान प्रतिरोध कैलकुलेटर है जो प्रतिरोधों के ठीक उसी सेट से संबंधित है जो हम हैं। )

प्रतिरोध है 10 * x + yबार zगुणक, के एक सहिष्णुता के लिए tप्रतिशत।

उदाहरण के लिए, के प्रतिरोध की गणना करने के लिए NKOg, हम देखते हैं कि:

1. N 1 के लिए ब्राउन का मतलब है।
2. K 0 के लिए काला मतलब है।
3. O10 ^{3 के} लिए ऑरेंज का मतलब है ।
4. g मतलब Gold 5% के लिए सोना।

तो प्रतिरोध (10*1 + 0)*10^3→ है 10000 Ω ±5%।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो फॉर्म xyztऔर प्रिंट के 4 वर्ण स्ट्रिंग में लेता है या फॉर्म में प्रतिरोध को वापस करता है [resistance] Ω ±[tolerance]%।

• अवरोधक "उल्टा-सीधा" हो सकता है, अर्थात रिवर्स ऑर्डर में tzyx। उदाहरण के लिए, दोनों NKOgका gOKNउत्पादन करना चाहिए 10000 Ω ±5%।
• प्रतिरोध हमेशा सादे ओम में होता है, कभी किलोहम्स, मीगोहेम आदि।
• Ωके साथ प्रतिस्थापित किया जा सकता है ohms, जैसे 10000 ohms ±5%।
• ±के साथ प्रतिस्थापित किया जा सकता है +/-, जैसे 10000 Ω +/-5%।
• दशमलव बिंदु के दाईं ओर शून्य होने के बाद ठीक है। (उदा 10000.0 Ω +/-5%)
• आप मान सकते हैं कि इनपुट हमेशा वैध है ( xऔर yकभी नहीं gs_; zकभी नहीं _; tकेवल gs_)।
• सभी 10 × 10 × 12 × 3 = 3600 संभावित प्रतिरोधों (2 × 3600 संभावित आदानों) का समर्थन करने की आवश्यकता है, भले ही कुछ रंगीन बैंड संयोजन वास्तविक जीवन में उत्पन्न न हों।

बाइट्स में सबसे छोटा कोड जीतता है।

उदाहरण

1. gOKN → 10000 ohms +/-5%
2. KKR_ → 0 Ω +/-20%
3. ggKN → 1 ohms ±5%
4. ggGO → 3.5 Ω ±5%
5. ssGO → 0.350 Ω ±10%
6. GOOs → 53000 ohms +/-10%
7. YAK_ → 48.0 ohms +/-20%
8. _WAV → 78000000000 Ω ±20%
9. gBBB → 66000000.000 ohms ±5%
10. _RYR → 2400.00 ohms ±20%

^{Iff आप मेरी चुनौतियों का आनंद लें, ब्लॉक बिल्डिंग बॉट फ्लक्स की जाँच करने पर विचार करें !}

Answer 1

CJam, 59 58 56 50 बाइट्स

r_W%e>"sgKNROYGBVAW"f#2f-~A*+A@#*" Ω ±"@[KA5]='%

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

Answer 2

CJam, 53 51 50 बाइट्स

" Ω ±"l_W%e<)iB%5*F-'%@"gKNROYGBVAW"f#:(2/'e*s~o

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

(बाइट के लिए @ user23013 का धन्यवाद)

---

मैंने पायथन में शुरुआत की, लेकिन

eval("%d%de%d"%tuple("gKNROYGBVAW".find(x)-1for x in L))

बहुत महंगा था ...

Comments

:(2/'e*s~बचाता है [।

— jimmy23013

@ user23013 आह धन्यवाद, मैं डालने के तरीकों की एक गुच्छा कोशिश कर रहा हूँ eजहाँ यह आवश्यक है, लेकिन मैंने कभी नहीं सोचा /और*

— Sp3000

Answer 3

पायथन 3, 130 114 बाइट्स

def f(v):
 a,b,c,d=["_sgKNROYGBVAW".index(x)-3for x in v[::(1,-1)[v[0]in'sg_']]]
 return "%s Ω ±%s%%"%((10*a+b)*10**c,2.5*2**-d)

संपादित करें: @ Sp3000 बताते हैं कि ऑर्डर को 10 बाइट्स बचाने के min(v,v[::-1])बजाय बेहतर तरीके से पता लगाया जा सकता है v[::(1,-1)[v[0]in'sg_']], न कि इंडेक्स की जाँच करें _और कुछ अनावश्यक व्हाट्सएप को हटा दें।

def f(v):a,b,c,d=["sgKNROYGBVAW".find(x)-2for x in min(v,v[::-1])];return"%s Ω ±%s%%"%((10*a+b)*10**c,2.5*2**-d)

Comments

धन्यवाद - मुझे लाइनों को सुगम बनाने के बारे में एहसास हुआ, लेकिन मैं min()सही क्रम का पता लगाने के लिए उपयोग करने की चाल से चूक गया - अच्छा।

— क्रोनिटिस

Answer 4

पर्ल, 93 बाइट्स

#!perl -lp
ord>90and$_=reverse;s/./-3+index zsgKNROYGBVAW,$&/ge;$_=s/..\K/e/*$_." Ω ±"./.$/*5*$&."%"

Answer 5

हास्केल, 135 132 130 बाइट्स

r y|y<"["=p[k|j<-y,(c,k)<-zip"_ sgKNROYGBVAW"[-4..],c==j]
r y=r.reverse$y
p[a,b,c,d]=show((a*10+b)*10**c)++" Ω ±"++show(-5*d)++"%"

स्पष्टीकरण:

r y|y<"["=            If first letter of argument is a capital
p[..]                 Call p on the list created
[k|                   Make a list of all k
   j<-y               Draw character j from input
       ,(c,k)<-       With (c,k) being a pair from
               zip    A list of pairs of corresponding elements from the lists:
"_ sgKNROYGBVAW"       The space at 2nd position is to match '_' with -4, but 's' with -2
[-4..]                 An infinite list starting at -4
,c==j]                Only use element k if j equals the character c

r y=r.reverse$y       If first call fails, call again with reversed argument.

p[a,b,c,d]=           Assign the first four elements of the argument to a,b,c,d respectively.
show                  Turn (number) into string
10**c                 10 to the power of c
++                    Concatenate strings
-5*d                  This works for the tolerance because '_' makes d=-4

नीमी के लिए धन्यवाद, मैंने एक और 2 बाइट्स का मुंडन किया।