Prawo Ohma mówi nam, że prąd (I) w amperach przepływający przez rezystancję (R) w Ohmach, gdy przyłożone jest do niego napięcie (V), podaje się w następujący sposób:

V = I / R

Podobnie moc (P) w watach rozproszonych przez ten opór jest dana przez:

P = V * I

Przez przegrupowanie i podstawienie można uzyskać wzory do obliczania dwóch z tych wielkości, jeśli podana jest dowolna z dwóch pozostałych. Te formuły są podsumowane w następujący sposób (zwróć uwagę, że ten obraz używa Ezamiast Vwoltów):

Biorąc pod uwagę dowolne dwie z tych wielkości w ciągu, wypisz pozostałe dwie.

• Wprowadzane liczby będą dziesiętne w dowolnym formacie odpowiednim dla Twojego języka. Dokładność powinna wynosić co najmniej 3 miejsca po przecinku. ( IEEE 754-2008 binary32 floats są wystarczające.)
• Każdy numer wejściowy będzie opatrzony przyrostkiem o jednostkę. Będzie to jedno z wartości V A W Rnapięcia, natężenia, mocy i rezystancji (lub równoważne małe litery). Dodatkowo możesz użyć Ωzamiast R. Jednostki nie będą miały żadnych prefiksów dziesiętnych (kilo, mili- itp.).
• Dwie wielkości wejściowe zostaną podane w dowolnej kolejności w jednym ciągu, oddzielone pojedynczym odstępem.
• Ilości wejściowe zawsze będą liczbami rzeczywistymi większymi niż 0.
• Dane wyjściowe będą miały ten sam format co dane wejściowe.
• Wbudowane funkcje rozwiązywania równań są niedozwolone.

Przykładowe dane wejściowe

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

Odpowiednie wyniki

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

Należy zauważyć, że rozwiązaniem tego wyzwania będą skutecznie odwrotności. Innymi słowy, jeśli zastosujesz rozwiązanie do danych wejściowych A Bi uzyskasz dane wyjściowe C D, a następnie zastosujesz rozwiązanie do danych wejściowych C D, wówczas dane wyjściowe powinny być A Bponownie, choć być może nie w porządku i zaburzone z powodu zaokrąglania FP. Zatem wejścia i wyjścia testowe mogą być używane zamiennie.

Ruby 171 bajtów

Wprowadź jako argument funkcji. Wyjście na standardowe wyjście ze spacją (w razie potrzeby można je zmienić).

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

Wyjaśnienie

Wszystkie formuły można wyrazić w postaci, w b**x*d**yktórej b i d to dwie wartości wejściowe, a x i y to potęgi. Ze względów golfowych wyrażenie to (b**x*d**y)**0.5było ostatecznie preferowane, ponieważ oznacza, że ​​xiy stają się liczbami całkowitymi z zakresu od -4 do 4.

Poniższa tabela pokazuje wymagane wyrażenia (dane wejściowe są posortowane alfabetycznie) i zakodowane wartości mocy. Gdzie xiy są podwojonymi mocami, są one kodowane jako (x+4)+(y+4)*9+9lub równoważnie (x+4)+(y+5)*9. To umieszcza wszystkie kodowania w zakresie ASCII do wydruku. Operatory mocy zostały pominięte w formułach dotyczących zwięzłości.

njest rodzajem sumy kontrolnej wykonanej z symboli jednostki wejściowej; może przyjmować wartości 0,1,2,4,5,6 (3 nie jest używane.)

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 #

Niegolfowany w programie testowym

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

Wydajność

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 bajtów

To jest bardzo rozdęte. Na pewno jest jeszcze wiele do gry w golfa.

Edycja: Tymczasowo naprawiono wyjście. Z jakiegoś powodu return' '.join(str(eval(z[m][i]))+t[i]for i in range(2))odmawia poprawnego działania.

Edycja: Upuszczono eval.

Ta funkcja teraz pożycza części odpowiedź na poziom rzeki st . Zmieniłem opssłownik, najpierw na słownik zmodyfikowanych wykładników exponent*2+4dla b**((p-4)/2) * d**((q-4)/2), aby każdy pi qbył liczbą jednocyfrową. Na przykład, b*d == b**1*d**1 == b**((6-4)/2)*d**((6-4)/2)a wynik będzie 66w słowniku.

Następnie zamieniłem słownik na ciąg znaków zz tymi zmodyfikowanymi wykładnikami i jednostkami, które są potrzebne w linii i w określonej kolejności. Po pierwsze, wartość ASCII każdego znaku w ARVWmod 10 wynosi 5, 2, 6, 7. Kiedy dowolne dwie z tych wartości zostaną dodane, dają unikalny numer mod 10. Zatem każdej dwuznakowej kombinacji można nadać unikalny numer (ord(x[0]) + ord(y[10] + 3) % 10, podając AR: 0, AV: 4, AW: 5, RV: 1, RW: 2, VW: 6(bardzo podobny do sumy kontrolnej Lever River St). Ułożenie zmodyfikowanych wykładników w tej kolejności, tzn. [AR] [RV] [RW] [blank] [AV] [AW] [VW]Umożliwia zefektywny dostęp (pod względem bajtów).

Edycja: Odczytanie listy golfowej pod return. Gra w golfa w definicji m.

Kod:

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

Nie golfowany:

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 bajtów

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

Wypróbuj online

Konwertuje dane wejściowe formularza <value> <unit> <value> <unit>na instrukcje przypisania. Następnie użyj evalkażdej formuły, try/exceptignorując błędy tych, dla których zmienne nie zostały przypisane.