Les résistances ont généralement des bandes codées par couleur qui sont utilisées pour identifier leur résistance en Ohms . Dans ce défi, nous ne considérerons que les résistances normales à 4 bandes, bronzage et plomb axial. Nous les exprimerons comme:

xyzt

Où xest la première bande pour le premier chiffre significatif, yest la deuxième bande pour le deuxième chiffre significatif, zla troisième bande pour le multiplicateur, et test la quatrième bande pour la tolérance .

Chacun xyztreprésente une lettre qui abrège la couleur de la bande:

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

Ainsi, par exemple, NKOgest une résistance particulière.

La résistance peut être calculée à l'aide de ce tableau:

Comme le suggère le tableau:

• xet ypeut être des lettres , à l' exception g, set _.
• zpeut être tout sauf _.
• Nous bloquons têtre seulement g, sou _.

( Voici un calculateur de résistance pratique qui traite exactement le même ensemble de résistances que nous sommes. )

La résistance est multipliée par 10 * x + yle zmultiplicateur, jusqu'à une tolérance du tpourcentage.

Par exemple, pour calculer la résistance de NKOg, on voit que:

1. N signifie Brown pour 1.
2. K signifie noir pour 0.
3. Osignifie Orange pour 10 ³ .
4. g signifie or pour ± 5%.

La résistance est donc (10*1 + 0)*10^3→ 10000 Ω ±5%.

Défi

Écrivez un programme ou une fonction qui prend une chaîne de 4 caractères du formulaire xyztet imprime ou renvoie la résistance dans le formulaire [resistance] Ω ±[tolerance]%.

• La résistance peut être "à l'envers", c'est-à-dire dans l'ordre inverse tzyx. Par exemple, les deux NKOget gOKNdevraient produire 10000 Ω ±5%.
• La résistance est toujours en ohms simples, jamais en kilohms, en mégohms, etc.
• Ωpeut être remplacé par ohms, par exemple 10000 ohms ±5%.
• ±peut être remplacé par +/-, par exemple 10000 Ω +/-5%.
• Avoir des zéros de fin à droite d'un point décimal est très bien. (par exemple 10000.0 Ω +/-5%)
• Vous pouvez supposer que l'entrée est toujours valide ( xet yjamais gs_; zjamais _; tseulement gs_).
• Toutes les résistances 10 × 10 × 12 × 3 = 3600 possibles (2 × 3600 entrées possibles) doivent être prises en charge même si certaines combinaisons de bandes de couleurs ne sont pas produites dans la vie réelle.

Le code le plus court en octets gagne.

Exemples

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%

^{Ssi vous apprécierez mes défis, pensez à vérifier Building Block Bot Troupeaux!}

CJam, 59 58 56 50 octets

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

Essayez-le en ligne dans l' interpréteur CJam .

CJam, 53 51 50 octets

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

Essayez-le en ligne .

(Merci à @ user23013 pour un octet)

J'ai commencé en Python, mais

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

était trop cher ...

Python 3, 130 114 octets

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 souligne que l'ordre peut être mieux détecté avec min(v,v[::-1])plutôt que v[::(1,-1)[v[0]in'sg_']](en économisant 10 octets), ne pas vérifier l'index de _et supprimer certains espaces inutiles.

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 octets

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

Haskell, 135132130 octets

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

Explication:

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

Grâce à nimi, j'ai rasé encore 2 octets.