La ley de Ohm nos dice que la corriente (I) en amperios que fluye a través de una resistencia (R) en ohmios cuando se aplica un voltaje (V) a través de ella se da de la siguiente manera:

V = I / R

Del mismo modo, la potencia (P) en vatios disipada por esa resistencia viene dada por:

P = V * I

Por reordenamiento y sustitución, se pueden derivar fórmulas para calcular dos de estas cantidades cuando se da cualquiera de los otros dos. Estas fórmulas se resumen de la siguiente manera (tenga en cuenta que esta imagen utiliza en Elugar de Vpara voltios):

Dada una entrada de cualquiera de estas dos cantidades en una cadena, genera las otras dos.

• Los números de entrada serán decimales en el formato apropiado para su idioma. La precisión debe ser de al menos 3 decimales. (Los flotadores binarios IEEE 754-2008 binary32 son suficientes).
• Cada número de entrada tendrá el sufijo de una unidad. Este será uno de V A W Rvoltaje, amperaje, potencia y resistencia (o la minúscula equivalente). Además, puede usar en Ωlugar de R. Las unidades no tendrán prefijos decimales (Kilo-, mili-, etc.).
• Las dos cantidades de entrada se darán en cualquier orden en una cadena, separadas por un solo espacio.
• Las cantidades de entrada siempre serán números reales mayores que 0.
• La salida tendrá el mismo formato que la entrada.
• Las soluciones integradas para resolver ecuaciones no están permitidas.

Entradas de ejemplo

1W 1A
12V 120R
10A 10V
8R 1800W
230V 13A
1.1W 2.333V

Salidas correspondientes

1V 1R
0.1A 1.2W
1R 100W
120V 15A
2990W 17.692R
0.471A 4.948R

Cabe señalar que las soluciones a este desafío serán efectivamente autoinverso. En otras palabras, si aplica una solución a la entrada A By obtiene la salida C D, luego aplique una solución a la entrada C D, entonces la salida debería estar A Bnuevamente, aunque posiblemente fuera de orden y perturbada debido al redondeo de FP. Por lo tanto, las entradas y salidas de prueba se pueden usar indistintamente.

Ruby 171 bytes

Entrada como argumento de función. Salida a stdout con espacio final (puede revisarse si es necesario).

->s{a,b,c,d=s.split.map{|z|[z[-1],z.to_f]}.sort.flatten
%w{EA9.EAAVAA.WVA GS;.A?#WWV.RRR}.map{|w|m=w[n=(a+c+?!).sum%10].ord;print (b**(m%9-4)*d**(m/9-5))**0.5,w[n+7],' '}}

Explicación

Todas las fórmulas se pueden expresar en la forma b**x*d**yen que b & d son los dos valores de entrada y x & y son potencias. Por razones de golf, (b**x*d**y)**0.5finalmente se prefirió la expresión ya que significa que xey se convierten en enteros en el rango de -4 a 4.

La siguiente tabla muestra las expresiones requeridas (se supone que las entradas están ordenadas alfabéticamente) y los valores codificados para las potencias. Donde x e y son las potencias duplicadas, se codifican como (x+4)+(y+4)*9+9o de manera equivalente (x+4)+(y+5)*9. Esto pone todas las codificaciones en el rango ASCII imprimible. Los operadores de potencia se omiten de las fórmulas por brevedad.

nes un tipo de suma de verificación hecha de los símbolos de la unidad de entrada; puede tomar los valores 0,1,2,4,5,6 (3 no se usa)

n     formula 1 formula 2      formula 1                formula 2
value                      powers x+4 y+4 encoding   powers x+4 y+4 encoding

0      A*R=V    A2*R=W       1 1    6 6   69 E        2 1     8 6   71 G  
1    R-1*V=A  R-1*V2=W      -1 1    2 6   65 A       -1 2     2 8   83 S
2 R-.5*W.5=A R.5*W.5=V     -.5 .5   3 5   57 9       .5 .5    5 5   59 ;
3          .         .                       .                         .
4      A*V=W   A-1*V=R       1 1    6 6   69 E       -1 1     2 6   65 A
5    A-1*W=V   A-2*W=R      -1 1    2 6   65 A       -2 1     0 6   63 ?
6    V-1*W=A  V2*W-1=R      -1 1    2 6   65 A        2 -1    8 2   35 #

Sin golf en el programa de prueba

f=->s{
  a,b,c,d=s.split.map{|z|[z[-1],z.to_f]}.        #split the input into an array [[symbol1,value1],[symbol2,value2]]
  sort.flatten                                   #sort alphabetically by symbol and flatten to assign the 4 objects to different variables
  n=(a+c+?!).sum%10                              #sum the ascii codes of the symbols (plus that of ! for good value distribution) and take mod 10. gives a number 0..6 (3 is not used)
  %w{EA9.EAAVAA.WVA GS;.A?#WWV.RRR}.             #for each of the outputs, there is a 14 character string. 1st 7 characters encode powers, 2nd 7 characters are output symbol
  map{|w|                                        #iterate through the 2 outputs
    m=w[n].ord                                   #select one character according to value of n and convert to a number encoding the powers to raise the two inputs to
    print (b**(m%9-4)*d**(m/9-5))**0.5,w[n+7],' '#decode the powers, evaluate the expression and output, append the unit symbol and a space
  }
}

f["6W 3A"]
puts
f["12V 120R"]
puts
f["10A 10V"]
puts
f["8R 1800W"]
puts
f["6W 2V"]
puts
f["2A 3R"]
puts

Salida

2.0V 0.6666666666666666R
0.1A 1.2W
100.0W 1.0R
15.0A 120.0V
3.0A 0.6666666666666666R
6.0V 12.0W

Python 3, 329 347 343 339 326 305 267 251 249 245 237 bytes

Esto es bastante hinchado. Definitivamente todavía hay mucho golf por hacer.

Editar: se corrigió temporalmente la salida. Por alguna razón, se return' '.join(str(eval(z[m][i]))+t[i]for i in range(2))niega a funcionar correctamente.

Editar: caído eval.

Esta función ahora toma partes de la respuesta del nivel del río St . He cambiado el opsdiccionario, por primera vez en un diccionario de exponentes modificados exponent*2+4para b**((p-4)/2) * d**((q-4)/2), de manera que cada uno py qsería un número de un dígito. Por ejemplo, b*d == b**1*d**1 == b**((6-4)/2)*d**((6-4)/2)y el resultado estaría 66en el diccionario.

Luego, convertí el diccionario en una cadena zcon esos exponentes modificados y las unidades que se necesitan en una línea y en un orden particular. Primero, el valor ASCII de cada carácter en ARVWmod 10 es 5, 2, 6, 7. Cuando se agregan dos de estos valores, dan un número único mod 10. Por lo tanto, cada combinación de dos caracteres puede recibir un número único con (ord(x[0]) + ord(y[10] + 3) % 10, dando AR: 0, AV: 4, AW: 5, RV: 1, RW: 2, VW: 6(muy similar a la suma de comprobación de Lever River St). Organizar los exponentes modificados para que estén en este orden, es decir [AR] [RV] [RW] [blank] [AV] [AW] [VW], permite zacceder de manera eficiente (en términos de bytes).

Editar: Golfed la lista de comprensión bajo return. Golfed la definición de m.

Código:

def e(s):x,y=sorted((i[-1],float(i[:-1]))for i in s.split());m=(ord(x[0])+ord(y[0])+3)%10*6;z="6686VW2628AW3555AV0000002666RW0626RV2682AR";return' '.join(str((x[1]**(int(z[m+i*2])-4)*y[1]**(int(z[m+i*2+1])-4))**.5)+z[m+i+4]for i in(0,1))

Sin golf:

def electric(s):
    x, y = sorted((i[-1],float(i[:-1]))for i in s.split())
    m = (ord(x[0]) + ord(y[0]) + 3) % 10 * 6
    z = "6686VW2628AW3555AV0000002666RW0626RV2682AR"
    h = []
    for i in range(2):
         f = (x[1] ** (int(z[m*6+i*2])-4) * y[1] ** (int(z[m*6+i*2+1])-4)) ** 0.5
         h.append(str(f)+z[m*6+i+4])
    return ' '.join(h)

Python 3, 193 187 bytes

import re
exec(re.sub('(.+?) (.)',r'\2=\1;',input()))
for s,r in zip('AVRW'*3,'V/R W**.5*R V/A V*V/R W/V W/A V*V/W R*A*A W**.5/R A*R W/A**2 V*A'.split()):
 try:print(eval(r),s,)
 except:0

Pruébalo en línea

Convierte la entrada del formulario <value> <unit> <value> <unit>en declaraciones de asignación. Luego, use evalen cada fórmula, try/exceptignorando los errores de aquellos para los cuales no se han asignado las variables.