Das Ohmsche Gesetz besagt, dass der Strom (I) in Ampere, der durch einen Widerstand (R) in Ohm fließt, wenn eine Spannung (V) daran angelegt wird, wie folgt angegeben ist:

V = I / R

In ähnlicher Weise ist die Leistung (P) in Watt, die durch diesen Widerstand abgegeben wird, gegeben durch:

P = V * I

Durch Umlagerung und Substitution können Formeln abgeleitet werden, um zwei dieser Größen zu berechnen, wenn eine der beiden anderen gegeben ist. Diese Formeln sind wie folgt zusammengefasst (beachten Sie, dass dieses Bild Eanstelle von VVolt verwendet wird):

Bei einer Eingabe von zwei dieser Größen in einer Zeichenfolge geben Sie die anderen beiden aus.

• Die eingegebenen Zahlen sind Dezimalzahlen in dem für Ihre Sprache geeigneten Format. Die Genauigkeit sollte mindestens 3 Dezimalstellen betragen. ( IEEE 754-2008-Binary32-Floats sind ausreichend.)
• Jede eingegebene Nummer wird mit einer Einheit versehen. Dies ist einer der V A W RWerte für Spannung, Stromstärke, Leistung und Widerstand (oder der entsprechende Kleinbuchstabe). Zusätzlich können Sie Ωanstelle von verwenden R. Die Einheiten haben keine Dezimalpräfixe (Kilo-, Milli- usw.).
• Die beiden Eingabegrößen werden in beliebiger Reihenfolge in einer Zeichenfolge angegeben, die durch ein einzelnes Leerzeichen getrennt ist.
• Eingabegrößen sind immer reelle Zahlen größer als 0.
• Die Ausgabe erfolgt im gleichen Format wie die Eingabe.
• Integrierte Funktionen zum Lösen von Gleichungen sind nicht zulässig.

Beispieleingaben

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

Entsprechende Ausgänge

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

Es sollte beachtet werden, dass Lösungen für diese Herausforderung effektiv invers sind. Mit anderen Worten, wenn Sie eine Lösung auf die Eingabe anwenden A Bund die Ausgabe abrufen C D, und dann eine Lösung auf die Eingabe anwenden C D, sollte die Ausgabe A Berneut erfolgen, wenn auch möglicherweise nicht in Ordnung und aufgrund von FP-Rundungen gestört. Daher können Testein- und -ausgänge austauschbar verwendet werden.

Ruby 171 Bytes

Eingabe als Funktionsargument. Ausgabe auf stdout mit nachgestelltem Leerzeichen (kann bei Bedarf überarbeitet werden.)

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

Erläuterung

Alle Formeln können in der Form ausgedrückt werden, in der b**x*d**yb & d die beiden Eingabewerte und x & y Potenzen sind. Aus Golfgründen wurde der Ausdruck (b**x*d**y)**0.5schließlich bevorzugt, da er bedeutet, dass x und y ganze Zahlen im Bereich von -4 bis 4 sind.

Die folgende Tabelle zeigt die erforderlichen Ausdrücke (Eingaben werden alphabetisch sortiert angenommen) und die codierten Werte für die Potenzen. Wenn x und y die doppelten Potenzen sind, werden sie als (x+4)+(y+4)*9+9oder gleichwertig codiert (x+4)+(y+5)*9. Dadurch werden alle Codierungen in den druckbaren ASCII-Bereich versetzt. Der Kürze halber sind in den Formeln die Netzbetreiber weggelassen.

nist eine Art Prüfsumme, die aus den Symbolen der Eingabeeinheit gebildet wird; es kann die Werte 0,1,2,4,5,6 annehmen (3 wird nicht verwendet.)

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 im Testprogramm

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

Ausgabe

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

Das ist ziemlich aufgebläht. Es gibt definitiv noch viel zu golfen.

Bearbeiten: Die Ausgabe wurde vorübergehend korrigiert. Aus irgendeinem Grund return' '.join(str(eval(z[m][i]))+t[i]for i in range(2))weigert sich, richtig zu arbeiten.

Bearbeiten: Abgelegt eval.

Diese Funktion leiht jetzt Teile der Antwort von Level River St aus . Ich habe das opsWörterbuch zunächst in ein Wörterbuch mit modifizierten Exponenten exponent*2+4für geändert b**((p-4)/2) * d**((q-4)/2), so dass jedes pund jede qeine einstellige Zahl wäre. Zum Beispiel, b*d == b**1*d**1 == b**((6-4)/2)*d**((6-4)/2)und das Ergebnis wäre 66im Wörterbuch.

Dann habe ich das Wörterbuch in eine Zeichenfolge zmit den geänderten Exponenten und den Einheiten umgewandelt, die in einer Zeile und in einer bestimmten Reihenfolge benötigt werden. Erstens ist der ASCII-Wert jedes Zeichens in ARVWMod 10 5, 2, 6, 7. Wenn zwei dieser Werte addiert werden, erhalten sie eine eindeutige Nummer mod 10. Somit kann jeder zweistelligen Kombination eine eindeutige Nummer (ord(x[0]) + ord(y[10] + 3) % 10zugewiesen werden AR: 0, AV: 4, AW: 5, RV: 1, RW: 2, VW: 6(sehr ähnlich der Prüfsumme von Lever River St). Durch Anordnen der modifizierten Exponenten in dieser Reihenfolge [AR] [RV] [RW] [blank] [AV] [AW] [VW]kann zeffizient (in Bytes) auf diese zugegriffen werden.

Edit: Golfed das Listenverständnis unter return. Golfed die Definition von 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))

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

Probieren Sie es online aus

Konvertiert die Eingabe des Formulars <value> <unit> <value> <unit>in Zuweisungsanweisungen. Verwenden Sie dann evalfür jede Formel, try/exceptwobei Sie die Fehler derjenigen ignorieren, für die die Variablen nicht zugewiesen wurden.