A lei de Ohm nos diz que a corrente (I) em amperes que flui através de uma resistência (R) em Ohms quando uma tensão (V) é aplicada através dela é dada da seguinte maneira:

V = I / R

Da mesma forma, a potência (P) em watts dissipada por essa resistência é dada por:

P = V * I

Por rearranjo e substituição, as fórmulas podem ser derivadas para o cálculo de duas dessas quantidades quando qualquer uma das outras duas é fornecida. Essas fórmulas são resumidas da seguinte forma (observe que esta imagem usa em Evez de Vpara volts):

Dada uma entrada de duas dessas quantidades em uma sequência, produza as outras duas.

• Os números de entrada serão decimais em qualquer formato apropriado ao seu idioma. A precisão deve ser de pelo menos três casas decimais. ( Os flutuadores IEEE 754-2008 binary32 são suficientes.)
• Cada número de entrada terá o sufixo de uma unidade. Este será um de V A W RVoltagem, Amperagem, Potência e Resistência (ou o equivalente em minúsculas). Além disso, você pode usar em Ωvez de R. As unidades não terão prefixos decimais (quilo, mili-, etc.).
• As duas quantidades de entrada serão fornecidas em qualquer ordem em uma sequência, separadas por um único espaço.
• As quantidades de entrada sempre serão números reais maiores que 0.
• A saída estará no mesmo formato que a entrada.
• Construções de solução de equações não são permitidas.

Exemplo de entradas

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

Saídas correspondentes

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

Deve-se notar que as soluções para esse desafio serão efetivamente inversas. Em outras palavras, se você aplicar uma solução à entrada A Be obter saída C D, aplicar uma solução à entrada C D, a saída deve ser A Bnovamente, embora possivelmente fora de ordem e perturbada devido ao arredondamento de FP. Portanto, as entradas e saídas de teste podem ser usadas de forma intercambiável.

Ruby 171 bytes

Entrada como argumento da função. Saída para stdout com espaço à direita (pode ser revisado, se necessário.)

->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],' '}}

Explicação

Todas as fórmulas podem ser expressas na forma em b**x*d**yque b & d são os dois valores de entrada e x & y são potências. Por razões de golfe, a expressão (b**x*d**y)**0.5foi finalmente preferida, pois significa que xey se tornam inteiros no intervalo de -4 a 4.

A tabela a seguir mostra as expressões necessárias (as entradas são assumidas classificadas em ordem alfabética) e os valores codificados para as potências. Onde x e y são os poderes dobrados, eles são codificados como (x+4)+(y+4)*9+9ou equivalentemente (x+4)+(y+5)*9. Isso coloca todas as codificações na faixa ASCII imprimível. Os operadores de energia são omitidos das fórmulas por questões de brevidade.

né um tipo de soma de verificação feita a partir dos símbolos da unidade de entrada; pode levar os valores 0,1,2,4,5,6 (3 não é usado.)

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 #

Ungolfed in program program

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

Saída

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

Isso é bastante inchado. Definitivamente, ainda há muito golfe a fazer.

Editar: Corrigida temporariamente a saída. Por alguma razão, return' '.join(str(eval(z[m][i]))+t[i]for i in range(2))se recusa a funcionar corretamente.

Editar: descartado eval.

Esta função agora empresta peças de resposta do nível do rio St . Mudei o opsdicionário, primeiro para um dicionário de expoentes modificados exponent*2+4para b**((p-4)/2) * d**((q-4)/2), de modo que cada um pe qfosse um número de um dígito. Por exemplo,, b*d == b**1*d**1 == b**((6-4)/2)*d**((6-4)/2)e o resultado estaria 66no dicionário.

Depois, transformei o dicionário em uma string zcom os expoentes modificados e as unidades necessárias em uma linha e em uma ordem específica. Primeiro, o valor ASCII de cada caractere no ARVWmod 10 é 5, 2, 6, 7. Quando quaisquer dois desses valores são adicionados, eles fornecem um número único, mod 10. Assim, cada combinação de dois caracteres pode receber um número único com (ord(x[0]) + ord(y[10] + 3) % 10, dando AR: 0, AV: 4, AW: 5, RV: 1, RW: 2, VW: 6(muito semelhante à soma de verificação de Lever River St). Organizar os expoentes modificados para estar nesta ordem, ou seja [AR] [RV] [RW] [blank] [AV] [AW] [VW], permite zser acessado com eficiência (em termos de bytes).

Edit: Golfed a compreensão da lista em return. Golfed a definição 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))

Ungolfed:

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, 193187 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

Experimente online

Converte a entrada do formulário <value> <unit> <value> <unit>em instruções de atribuição. Em seguida, use evalem todas as fórmulas, try/exceptignorando os erros daqueles para os quais as variáveis ​​não foram atribuídas.