Hukum Ohm memberi tahu kita bahwa arus (I) dalam amp yang mengalir melalui resistansi (R) dalam ohm ketika tegangan (V) diterapkan melaluinya diberikan sebagai berikut:

V = I / R

Demikian pula daya (P) dalam watt yang dihamburkan oleh hambatan itu diberikan oleh:

P = V * I

Dengan penataan ulang dan penggantian, rumus dapat diturunkan untuk menghitung dua dari jumlah ini ketika salah satu dari dua lainnya diberikan. Rumus ini diringkas sebagai berikut (perhatikan gambar ini menggunakan Ebukan Vuntuk volt):

Diberikan input dari dua kuantitas ini dalam sebuah string, output dua lainnya.

• Nomor input akan berupa desimal dalam format apa pun yang sesuai untuk bahasa Anda. Ketelitian harus minimal 3 angka desimal. ( IEEE 754-2008 binary32 float sudah cukup.)
• Setiap nomor input akan diakhiri dengan unit. Ini akan menjadi salah satu dari V A W Runtuk Voltage, Ampere, Daya dan Perlawanan (atau huruf kecil setara) Selain itu, Anda dapat menggunakan Ωbukan R. Unit tidak akan memiliki awalan desimal (Kilo, mili-, dll).
• Dua kuantitas input akan diberikan dalam urutan apa pun dalam satu string, dipisahkan oleh spasi tunggal.
• Jumlah input akan selalu bilangan real lebih besar dari 0.
• Output akan berada dalam format yang sama dengan input.
• Batasan penyelesaian persamaan dilarang.

Contoh Input

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

Output yang Sesuai

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

Perlu dicatat bahwa solusi untuk tantangan ini secara efektif adalah inversi sendiri. Dengan kata lain, jika Anda menerapkan solusi untuk input A Bdan mendapatkan output C D, kemudian menerapkan solusi untuk input C D, maka output harus A Blagi, meskipun mungkin rusak dan terganggu karena pembulatan FP. Jadi, uji input dan output dapat digunakan secara bergantian.

Ruby 171 byte

Input sebagai argumen fungsi. Output ke stdout dengan trailing space (dapat direvisi jika perlu.)

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

Penjelasan

Semua rumus dapat diekspresikan dalam bentuk di b**x*d**ymana b & d adalah dua nilai input dan x & y adalah kekuatan. Untuk alasan bermain golf, ekspresi (b**x*d**y)**0.5akhirnya disukai karena itu berarti x dan y menjadi bilangan bulat dalam rentang -4 hingga 4.

Tabel berikut menunjukkan ekspresi yang diperlukan (input diasumsikan diurutkan berdasarkan abjad) dan nilai yang dikodekan untuk kekuatan. Di mana x dan y adalah kekuatan dua kali lipat, mereka dikodekan sebagai (x+4)+(y+4)*9+9atau setara (x+4)+(y+5)*9. Ini menempatkan semua pengkodean dalam rentang ASCII yang dapat dicetak. Operator listrik dihilangkan dari formula untuk singkatnya.

nadalah semacam checksum yang dibuat dari simbol unit input; dapat mengambil nilai 0,1,2,4,5,6 (3 tidak digunakan.)

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 #

Tidak digabungkan dalam program uji

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

Keluaran

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 byte

Ini sangat kembung. Pasti masih banyak golf yang harus dilakukan.

Sunting: Memperbaiki sementara output. Untuk beberapa alasan, return' '.join(str(eval(z[m][i]))+t[i]for i in range(2))menolak untuk bekerja dengan benar.

Edit: Dijatuhkan eval.

Fungsi ini sekarang meminjam bagian dari jawaban Tingkat Sungai St ini . Saya mengubah opskamus, pertama ke kamus eksponen dimodifikasi exponent*2+4untuk b**((p-4)/2) * d**((q-4)/2), sehingga setiap pdan qakan menjadi nomor satu digit. Misalnya,, b*d == b**1*d**1 == b**((6-4)/2)*d**((6-4)/2)dan hasilnya akan ada 66di kamus.

Kemudian, saya mengubah kamus menjadi string zdengan eksponen yang dimodifikasi dan unit yang diperlukan dalam garis dan dalam urutan tertentu. Pertama, nilai ASCII dari setiap karakter di ARVWmod 10 adalah 5, 2, 6, 7. Ketika salah satu dari dua nilai ini ditambahkan, mereka memberikan angka unik mod 10. Dengan demikian, setiap kombinasi dua karakter dapat diberi nomor unik dengan (ord(x[0]) + ord(y[10] + 3) % 10pemberian AR: 0, AV: 4, AW: 5, RV: 1, RW: 2, VW: 6(sangat mirip dengan checksum Lever River St). Mengatur eksponen yang dimodifikasi agar berada dalam urutan ini, yaitu [AR] [RV] [RW] [blank] [AV] [AW] [VW], memungkinkan zuntuk diakses secara efisien (dalam hal byte).

Sunting: Memotong pemahaman daftar di bawah return. Golf definisi m.

Kode:

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

Tidak Disatukan:

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 byte

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

Cobalah online

Mengubah input formulir <value> <unit> <value> <unit>menjadi pernyataan penugasan. Kemudian, gunakan evalpada setiap rumus, dengan try/exceptmengabaikan kesalahan dari yang variabelnya belum ditetapkan.