La loi d'Ohm nous dit que le courant (I) en ampères traversant une résistance (R) en Ohms lorsqu'une tension (V) est appliquée aux bornes est donné comme suit:

V = I / R

De même, la puissance (P) en watts dissipée par cette résistance est donnée par:

P = V * I

Par réarrangement et substitution, des formules peuvent être dérivées pour calculer deux de ces quantités lorsque l'une des deux autres est donnée. Ces formules sont résumées comme suit (notez que cette image utilise Eau lieu de Vpour les volts):

Étant donné une entrée de deux de ces quantités dans une chaîne, sortez les deux autres.

• Les nombres entrés seront des décimales dans le format approprié à votre langue. La précision doit être d'au moins 3 décimales. (Les flottants binaires32 IEEE 754-2008 sont suffisants.)
• Chaque numéro d'entrée sera suffixé d'une unité. Ce sera l'un de V A W RTension, Ampérage, Puissance et Résistance (ou l'équivalent en minuscules). En outre, vous pouvez utiliser à la Ωplace de R. Les unités n'auront pas de préfixe décimal (Kilo-, milli-, etc.).
• Les deux quantités en entrée seront données dans n'importe quel ordre dans une même chaîne, séparées par un seul espace.
• Les quantités entrées seront toujours des nombres réels supérieurs à 0.
• La sortie sera au même format que l'entrée.
• Les fonctions intégrées de résolution d'équations sont interdites.

Exemples d'entrées

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

Sorties correspondantes

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

Il convient de noter que les solutions à ce défi seront effectivement des auto-inverses. En d'autres termes, si vous appliquez une solution à l'entrée A Bet obtenez la sortie C D, puis appliquez une solution à l'entrée C D, la sortie doit être à A Bnouveau, bien que probablement hors service et perturbée en raison de l'arrondi FP. Les entrées et sorties de test peuvent donc être utilisées de manière interchangeable.

Ruby 171 octets

Entrez comme argument de fonction. Sortie vers stdout avec espace de fin (peut être révisée si nécessaire.)

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

Explication

Toutes les formules peuvent être exprimées sous la forme b**x*d**yoù b & d sont les deux valeurs d'entrée et x & y sont des puissances. Pour des raisons de golf, l'expression (b**x*d**y)**0.5a finalement été préférée car elle signifie que x et y deviennent des entiers compris entre -4 et 4.

Le tableau suivant montre les expressions requises (les entrées sont supposées triées alphabétiquement) et les valeurs codées pour les puissances. Où x et y sont les puissances doublées, elles sont codées comme (x+4)+(y+4)*9+9ou de manière équivalente (x+4)+(y+5)*9. Cela place tous les encodages dans la plage ASCII imprimable. Les opérateurs de puissance sont omis des formules par souci de concision.

nest une sorte de somme de contrôle faite à partir des symboles d'unité d'entrée; il peut prendre les valeurs 0,1,2,4,5,6 (3 n'est pas utilisé.)

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 #

Non testé dans le programme de test

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

Sortie

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 octets

C'est assez gonflé. Il y a certainement encore beaucoup de golf à faire.

Modifier: correction temporaire de la sortie. Pour une raison quelconque, return' '.join(str(eval(z[m][i]))+t[i]for i in range(2))refuse de fonctionner correctement.

Edit: abandonné eval.

Cette fonction emprunte maintenant partie de la réponse de niveau de la rivière St . J'ai changé le opsdictionnaire, d'abord en un dictionnaire d'exposants modifiés exponent*2+4pour b**((p-4)/2) * d**((q-4)/2), afin que chacun pet qsoit un nombre à un chiffre. Par exemple, b*d == b**1*d**1 == b**((6-4)/2)*d**((6-4)/2)et le résultat serait 66dans le dictionnaire.

Ensuite, j'ai transformé le dictionnaire en une chaîne zavec ces exposants modifiés et les unités nécessaires dans une ligne et dans un ordre particulier. Tout d'abord, la valeur ASCII de chaque caractère du ARVWmod 10 est 5, 2, 6, 7. Lorsque deux de ces valeurs sont ajoutées, elles donnent un numéro unique mod 10. Ainsi, chaque combinaison de deux caractères peut recevoir un numéro unique avec (ord(x[0]) + ord(y[10] + 3) % 10, donnant AR: 0, AV: 4, AW: 5, RV: 1, RW: 2, VW: 6(très similaire à la somme de contrôle de Lever River St). Arranger les exposants modifiés pour qu'ils soient dans cet ordre, c'est-à-dire [AR] [RV] [RW] [blank] [AV] [AW] [VW], permet zun accès efficace (en termes d'octets).

Edit: Golfé la compréhension de la liste sous return. Golfé la définition de m.

Code:

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))

Non 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 octets

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

Essayez-le en ligne

Convertit l'entrée du formulaire <value> <unit> <value> <unit>en instructions d'affectation. Ensuite, utilisez evalsur chaque formule, en try/exceptignorant les erreurs de celles pour lesquelles les variables n'ont pas été affectées.