Ohm kanunu bize, amperdeki akımın (I), üzerinde voltaj (V) uygulandığında Ohm'daki bir dirençten (R) geçen akımın aşağıdaki şekilde verildiğini söylemektedir:

V = I / R

Benzer şekilde, bu direnç tarafından dağıtılan watt cinsinden güç (P) :

P = V * I

Yeniden düzenleme ve ikame ile, diğer ikisinden herhangi biri verildiğinde, bu miktarların ikisini hesaplamak için formüller elde edilebilir. Bu formüller aşağıdaki gibi özetlenmiştir (bu görüntünün volt Eyerine kullanıldığına dikkat edin V):

Bu niceliklerden ikisinin bir dizgede girilmesi durumunda, diğer ikisinin çıktısını alın.

• Giriş numaraları, diliniz için uygun olan formatta ondalık sayılar olacaktır. Hassasiyet en az 3 ondalık basamağa kadar olmalıdır. ( IEEE 754-2008 binary32 floatları yeterli.)
• Her giriş numarasına bir ünite eklenir. Bu biri olacakV A W R Gerilim, Amper, Güç ve Direnç (veya eşdeğeri küçük harf) için biri olacaktır. Ayrıca, Ωyerine kullanabilirsiniz R. Birimler ondalık öneklere sahip olmayacak (Kilo, milli-, vb.).
• İki girdi miktarı, tek bir boşlukla ayrılmış tek bir dizgede herhangi bir sırada verilecektir.
• Giriş miktarları her zaman 0'dan büyük gerçek sayılar olacaktır.
• Çıkış, giriş ile aynı formatta olacaktır.
• Denklem çözme yerleşiklere izin verilmez.

Örnek Girişler

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

İlgili Çıktılar

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

Bu zorluğa yönelik çözümlerin etkin bir şekilde kendi kendine ters çevrileceği belirtilmelidir. Başka bir deyişle, girdi A Bve çıktı almak C Diçin bir çözüm uygularsanız C D, o zaman girdi için bir çözüm uygularsanız , o zaman çıktı A B, muhtemelen FP yuvarlama nedeniyle düzensiz ve tedirgin olsa da tekrar olmalıdır . Bu nedenle test girişleri ve çıkışları birbirlerinin yerine kullanılabilir.

Ruby 171 bayt

İşlev argümanı olarak giriş yapın. Sondaki boşluk ile stdout çıktısı (gerekirse revize edilebilir.)

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

açıklama

Tüm formüller, b**x*d**yb & d'nin iki giriş değeri olduğu ve x & y'nin güç olduğu formunda ifade edilebilir . Golf nedeniyle, ifade (b**x*d**y)**0.5sonunda x ve y'nin -4 ila 4 aralığında bir tam sayı olduğu için tercih edildi.

Aşağıdaki tabloda gerekli ifadeler (girişlerin alfabetik olarak sıralandığı varsayılmıştır) ve güçler için kodlanmış değerler gösterilmektedir. X ve y'nin iki kat güç olduğu durumlarda, bunlar (x+4)+(y+4)*9+9eşit olarak veya eşit olarak kodlanır.(x+4)+(y+5)*9 . Bu, tüm kodlamaları yazdırılabilir ASCII aralığına yerleştirir. Güç operatörleri kısalık için formüllerden çıkarılmıştır.

ngiriş birimi sembollerinden yapılan bir tür sağlama toplamıdır; 0,1,2,4,5,6 (3 kullanılmaz) değerleri alabilir

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 #

Test programında Ungolfed

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

Çıktı

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 bayt

Bu oldukça şişmiş. Kesinlikle hala yapılacak çok golf var.

Düzenleme: Çıktı geçici olarak düzeltildi. Nedense return' '.join(str(eval(z[m][i]))+t[i]for i in range(2))düzgün çalışmayı reddediyor.

Düzenle: Bırakıldı eval.

Bu işlev artık Seviye St Nehri'nin cevabının bir kısmını ödünç alıyor . Değiştim opsilk değiştirilmiş üstler bir sözlüğüne, sözlük exponent*2+4için b**((p-4)/2) * d**((q-4)/2), bu yüzden her birinin pve qbir tek basamaklı sayı olacaktır. Örneğin,b*d == b**1*d**1 == b**((6-4)/2)*d**((6-4)/2) , ve sonuç 66sözlükte olur.

Sonra sözlüğü zdeğiştirilmiş üsteller ve bir satırda ve belirli bir sırada ihtiyaç duyulan birimlerle bir dizgeye çevirdim . İlk olarak, ARVWmod 10'daki her karakterin ASCII değeri 5, 2, 6, 7. Bu değerlerden herhangi ikisi eklendiğinde, benzersiz bir mod 10 verir. Böylece, her iki karakterli kombinasyona (Lever River St'in sağlama toplamına çok benzer şekilde) (ord(x[0]) + ord(y[10] + 3) % 10vererek benzersiz bir sayı verilebilir AR: 0, AV: 4, AW: 5, RV: 1, RW: 2, VW: 6. Değiştirilmiş üslerin bu sırada olmasını sağlamak, yani verimli bir şekilde erişime [AR] [RV] [RW] [blank] [AV] [AW] [VW]izin zvermek (bayt cinsinden).

Düzenleme: altındaki liste kavrama golf return. Tanımı Golf 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))

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 bayt

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

Çevrimiçi deneyin

Formun <value> <unit> <value> <unit>girişini atama ifadelerine dönüştürür. Ardından, evalher formülde, try/exceptdeğişkenleri atanmamış olanların hatalarını göz ardı ederek kullanın .