Calcular a resistência de um resistor com código de cores de 4 bandas

29

Os resistores geralmente possuem bandas codificadas por cores que são usadas para identificar sua resistência em Ohms . Neste desafio, consideraremos apenas os resistores normais de 4 bandas, tan e chumbo axial. Vamos expressá-los como:

xyzt

Onde xestá a primeira banda para o primeiro número significativo, yé a segunda banda para o segundo número significativo, za terceira banda para o multiplicador e ta quarta banda para a tolerância .

Cada um dos xyztrepresenta uma letra que abrevia a cor da banda:

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

Então, por exemplo, NKOgé um resistor em particular.

A resistência pode ser calculada com a ajuda desta tabela:

Tabela de códigos de cores do resistor

Como a tabela sugere:

  • xe ypode haver qualquer letra g, exceto s, e _.
  • zpode ser qualquer coisa, exceto _.
  • Vamos restringir ta ser apenas g, sou _.

( Aqui está uma calculadora de resistência prática que lida exatamente com o mesmo conjunto de resistores que somos. )

A resistência é multiplicada 10 * x + ypelo zmultiplicador, até uma tolerância da tporcentagem.

Por exemplo, para calcular a resistência de NKOg, vemos que:

  1. N significa marrom para 1.
  2. K significa preto para 0.
  3. Osignifica laranja para 10 3 .
  4. g significa ouro para ± 5%.

Então a resistência é (10*1 + 0)*10^310000 Ω ±5%.

Desafio

Escreva um programa ou função que utilize uma seqüência de 4 caracteres do formulário xyzte imprima ou retorne a resistência no formulário [resistance] Ω ±[tolerance]%.

  • O resistor pode estar "de cabeça para baixo", ou seja, na ordem inversa tzyx. Por exemplo, ambos NKOge gOKNdevem produzir 10000 Ω ±5%.
  • A resistência está sempre em ohms simples, nunca em quilohms, megohms, etc.
  • Ωpode ser substituído por ohms, por exemplo 10000 ohms ±5%.
  • ±pode ser substituído por +/-, por exemplo 10000 Ω +/-5%.
  • Ter zeros à direita de um ponto decimal é bom. (por exemplo 10000.0 Ω +/-5%)
  • Você pode assumir que a entrada é sempre válida ( xe ynunca gs_; znunca _; tsomente gs_).
  • Todos os 10 × 10 × 12 × 3 = 3600 possíveis resistores (2 × 3600 possíveis entradas) precisam ser suportados, mesmo que algumas combinações de bandas de cores não sejam produzidas na vida real.

O código mais curto em bytes vence.

Exemplos

  1. gOKN10000 ohms +/-5%
  2. KKR_0 Ω +/-20%
  3. ggKN1 ohms ±5%
  4. ggGO3.5 Ω ±5%
  5. ssGO0.350 Ω ±10%
  6. GOOs53000 ohms +/-10%
  7. YAK_48.0 ohms +/-20%
  8. _WAV78000000000 Ω ±20%
  9. gBBB66000000.000 ohms ±5%
  10. _RYR2400.00 ohms ±20%

Se você gosta dos meus desafios, considere dar uma olhada nos Block Building Bot Flocks!

Passatempos de Calvin
fonte

Respostas:

10

CJam, 59 58 56 50 bytes

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

Experimente on-line no intérprete CJam .

Dennis
fonte
9

CJam, 53 51 50 bytes

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

Experimente online .

(Obrigado a @ user23013 por um byte)


Comecei em Python, mas

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

era muito caro ...

Sp3000
fonte
2
:(2/'e*s~salva o [.
Jimmy23013
@ user23013 Ah, obrigado, eu tenho tentado um monte de maneiras de inserir a eonde é necessário, mas eu nunca pensei de /e*
SP3000
4

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 indica que a ordem pode ser detectada melhor com (em min(v,v[::-1])vez de v[::(1,-1)[v[0]in'sg_']](economizando 10 bytes), não verifique o índice _e remova algum espaço em branco desnecessário.

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)
cronite
fonte
Obrigado - percebi a concatenação das linhas, mas perdi o truque de usar min()para detectar a ordem correta - legal.
cronite 26/05
3

Perl, 93 bytes

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

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

Explicação:

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

Graças a nimi, reduzi outros 2 bytes.

AplusKminus
fonte