Widerstände haben üblicherweise farbcodierte Bänder , mit denen sie identifiziert werden Widerstand in Ohm angegeben wird . Bei dieser Herausforderung werden nur die normalen 4-Band-Widerstände mit gelbbrauner, axialer Leitung betrachtet. Wir werden sie ausdrücken als:

xyzt

Wo xist das erste Band für die erste bedeutende Figur,y das zweite Band für die zweite signifikante Zahl, zdas dritte Band für den Multiplikator und tdas vierte Band für die Toleranz ist .

Jedes von xyztstellt einen Buchstaben dar, der die Farbe des Bandes abkürzt:

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

So ist zum Beispiel NKOgein bestimmter Widerstand.

Der Widerstand kann mit Hilfe dieser Tabelle berechnet werden:

Wie aus der Tabelle hervorgeht:

• xund ykann beliebige Buchstaben außer sein g,s und _.
• z kann alles sein außer _ .
• Wir beschränken tnur sein g, soder_ .

( Hier ist ein praktischer Widerstandsrechner, der sich mit genau demselben Satz von Widerständen befasst, die wir sind. )

Der Widerstand ist 10 * x + ymal der zMultiplikator bis zu einer Toleranz des tProzentsatzes.

Um beispielsweise den Widerstand von zu berechnen NKOg, sehen wir Folgendes:

1. N bedeutet braun für 1.
2. K bedeutet Schwarz für 0.
3. Obedeutet Orange für 10 ³ .
4. g bedeutet Gold für ± 5%.

Der Widerstand ist also (10*1 + 0)*10^3→ 10000 Ω ±5%.

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die eine 4-stellige Zeichenfolge des Formulars verwendet xyztund den Widerstand im Formular ausgibt oder zurückgibt [resistance] Ω ±[tolerance]%.

• Der Widerstand kann "umgedreht" sein, dh in umgekehrter Reihenfolge tzyx. Zum Beispiel beides NKOgund gOKNsoll produzieren 10000 Ω ±5%.
• Der Widerstand ist immer in einfachen Ohm, niemals in Kiloohm, Megaohm usw.
• Ωkann ersetzt werden durch ohmsz 10000 ohms ±5%.
• ±kann ersetzt werden durch +/-z 10000 Ω +/-5%.
• Nachgestellte Nullen rechts vom Dezimalpunkt sind in Ordnung. (zB 10000.0 Ω +/-5%)
• Sie können davon ausgehen, dass die Eingabe immer gültig ist ( xund yniemals gs_, zniemals _, tnur gs_).
• Alle 10 × 10 × 12 × 3 = 3600 möglichen Widerstände (2 × 3600 mögliche Eingänge) müssen unterstützt werden, auch wenn einige Farbbandkombinationen nicht im wirklichen Leben hergestellt werden.

Der kürzeste Code in Bytes gewinnt.

Beispiele

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%

^{Wenn Ihnen meine Herausforderungen gefallen, sollten Sie Block Building Bot Flocks ausprobieren!}

CJam, 59 58 56 50 Bytes

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

Probieren Sie es online im CJam-Interpreter aus .

CJam, 53 51 50 Bytes

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

Probieren Sie es online aus .

(Danke an @ user23013 für ein Byte)

Ich habe in Python angefangen, aber

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

war zu teuer ...

Python 3, 130 114 Bytes

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)

edit: @ SP3000 weist darauf hin , dass die Reihenfolge kann besser mit erfaßt werden , min(v,v[::-1])anstatt v[::(1,-1)[v[0]in'sg_']](10 Byte zu speichern), nicht überprüft den Index_ und einige unnötigen Leerzeichen entfernen.

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)

Perl, 93 Bytes

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

Haskell, 135-132 130 Bytes

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)++"%"

Erläuterung:

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

Dank Nimi habe ich noch 2 Bytes abgeschabt.