La legge di Ohm ci dice che la corrente (I) in ampere che fluisce attraverso una resistenza (R) in Ohm quando viene applicata una tensione (V) attraverso di essa è data come segue:

V = I / R

Allo stesso modo la potenza (P) in watt dissipata da quella resistenza è data da:

P = V * I

Per riorganizzazione e sostituzione, le formule possono essere derivate per il calcolo di due di queste quantità quando viene data una delle altre due. Queste formule sono riassunte come segue (nota che questa immagine usa Einvece che Vper volt):

Dato un input di due qualsiasi di queste quantità in una stringa, output le altre due.

• I numeri di input saranno decimali in qualunque formato sia appropriato per la tua lingua. La precisione dovrebbe essere di almeno 3 decimali. ( I float binari32 IEEE 754-2008 sono sufficienti.)
• Ogni numero di input sarà suffisso con un'unità. Questo sarà uno V A W Rper Voltaggio, Amperaggio, Potenza e Resistenza (o l'equivalente minuscolo). Inoltre, è possibile utilizzare Ωinvece di R. Le unità non avranno prefissi decimali (Kilo-, Milli-, ecc.).
• Le due quantità di input verranno fornite in qualsiasi ordine in una stringa, separate da un singolo spazio.
• Le quantità di input saranno sempre numeri reali maggiori di 0.
• L'output sarà nello stesso formato dell'input.
• I builtin per la risoluzione di equazioni non sono consentiti.

Ingressi di esempio

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

Uscite corrispondenti

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

Va notato che le soluzioni a questa sfida saranno effettivamente auto-inverse. In altre parole, se si applica una soluzione per l'input A Be si ottiene l'output C D, quindi si applica una soluzione per l'input C D, l'output dovrebbe essere di A Bnuovo, sebbene possibilmente fuori servizio e perturbato a causa dell'arrotondamento di FP. Pertanto, gli ingressi e le uscite di test possono essere utilizzati in modo intercambiabile.

Rubino 171 byte

Input come argomento di funzione. Output su stdout con spazio finale (può essere modificato se necessario.)

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

Spiegazione

Tutte le formule possono essere espresse nella forma in b**x*d**ycui b & d sono i due valori di input e x & y sono potenze. Per ragioni di golf, l'espressione è (b**x*d**y)**0.5stata infine preferita in quanto significa che x e y diventano numeri interi nell'intervallo da -4 a 4.

La tabella seguente mostra le espressioni richieste (gli input sono assunti in ordine alfabetico) e i valori codificati per i poteri. Dove xey sono i poteri raddoppiati, sono codificati come (x+4)+(y+4)*9+9o equivalentemente (x+4)+(y+5)*9. Questo mette tutte le codifiche nell'intervallo ASCII stampabile. Gli operatori di potenza sono esclusi dalle formule per brevità.

nè una sorta di checksum creato dai simboli dell'unità di input; può assumere i valori 0,1,2,4,5,6 (3 non viene utilizzato.)

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 registrato nel programma di 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

Produzione

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

Questo è piuttosto gonfio. C'è sicuramente ancora molto da giocare a golf.

Modifica: risolto temporaneamente l'output. Per qualche motivo, si return' '.join(str(eval(z[m][i]))+t[i]for i in range(2))rifiuta di funzionare correttamente.

Modifica: abbandonato eval.

Questa funzione ora prende in prestito parti di risposta di livello del fiume St . Ho cambiato il opsdizionario, prima in un dizionario di esponenti modificati exponent*2+4per b**((p-4)/2) * d**((q-4)/2), in modo che ciascuno pe qsarebbe un numero di una cifra. Ad esempio, b*d == b**1*d**1 == b**((6-4)/2)*d**((6-4)/2)e il risultato sarebbe 66nel dizionario.

Quindi, ho trasformato il dizionario in una stringa zcon quegli esponenti modificati e le unità necessarie in una riga e in un ordine particolare. Innanzitutto, il valore ASCII di ogni carattere nella ARVWmod 10 è 5, 2, 6, 7. Quando vengono aggiunti due di questi valori, si ottiene un numero univoco mod 10. Pertanto, a ciascuna combinazione di due caratteri può essere assegnato un numero univoco con (ord(x[0]) + ord(y[10] + 3) % 10, dando AR: 0, AV: 4, AW: 5, RV: 1, RW: 2, VW: 6(molto simile al checksum di Lever River St). Organizzare gli esponenti modificati in questo ordine, vale a dire [AR] [RV] [RW] [blank] [AV] [AW] [VW], consente zdi accedere in modo efficiente (in termini di byte).

Modifica: golfato la comprensione della lista sotto return. Golfato la definizione di m.

Codice:

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

Provalo online

Converte l'input del modulo <value> <unit> <value> <unit>in istruzioni di assegnazione. Quindi, utilizzare evalsu ogni formula, try/exceptignorando gli errori da quelli per i quali non sono state assegnate le variabili.