Phân tích thứ nguyên

Tính một sản phẩm hoặc tỷ lệ đơn vị SI.

Ví dụ, kg m / s s(bình phương kilogam trên giây bình phương) sẽ trở lại N(newton).

Đầu vào sẽ luôn là:

Danh sách các ký hiệu cho các đơn vị SI, được phân tách bằng dấu cách (đại diện cho sản phẩm) hoặc
Ở trên, /và ở trên (đại diện cho một tỷ lệ).

Đầu vào sẽ không bao giờ chứa bất kỳ ký tự nào khác (chẳng hạn như chữ số hoặc dấu chấm câu khác).

Bạn có thể cho rằng điều này sẽ luôn bằng một đơn vị SI.

Sử dụng các ký hiệu sau:

Base quantities:
s               # second
m               # meter
kg              # kilogram
A               # ampere

Derived quantities:
N  = kg m / s s # newton
J  = N m        # joule
W  = J / s      # watt
Hz = W / J      # hertz
Pa = N / m m    # pascal
C  = s A        # coulomb
V  = J / C      # volt
F  = C / V      # farad
Ω  = V / A      # ohm      (you may use the O symbol instead, for a penalty of +3 bytes)
S  = A / V      # siemens
Wb = J / A      # weber
T  = Wb / m m   # tesla
H  = Wb / A     # henry

Ví dụ:

m            => m
N m          => J
J / W        => s
A J / W      => C
T m m        => Wb
N / A m      => T
V s / A      => H
J S / F A    => V
s / s s      => Hz
Hz kg m Hz   => N
Hz s / Ω     => S
Wb / H       => A
V Pa S s / C => Pa
N s / m Hz   => kg
V A          => W
s / Ω        => F
J / A s A    => Ω

Mã ngắn nhất (tính bằng byte) thắng.

code-golf math physics

— Ypnypn
nguồn

kg m / s ssẽ thực sự là kilogam-mét-giây mỗi giây, hoặc chỉ kilogam-mét. Nhân và chia công việc LTR. Những gì bạn đang tìm kiếm là kg m / (s s). Điều này cũng áp dụng cho các ví dụ khác.

— LegionMammal978

@Legion: Không nhất thiết. Ngẫu nhiên nhân và chia với dấu gạch chéo là mơ hồ; các ordr phụ thuộc vào quy ước. Ở đây phép nhân ngầm được thực hiện để có độ ưu tiên cao hơn phép chia.

— Deusovi

... Điều đó phá vỡ tất cả về toán học. Phép nhân ngầm và rõ ràng có nghĩa là cùng một điều chính xác.

— LegionMammal978

@ LegionMammal978 Không thực sự. Có 1 / 2xthực sự có nghĩa x / 2?

— Ypnypn

@ LegionMammal978 - thực ra, 1 / 2x là ký hiệu phổ biến cho 1 / (2x). Tổng quát hơn, trong trường hợp không mơ hồ, dấu gạch chéo sẽ được hiểu là đường phân chia giữa tử số và mẫu số. Quy ước đang được sử dụng ở đây là tốt - đặc biệt vì quy ước này là tiêu chuẩn theo đơn vị. kg / ms có nghĩa là kg / (m * s) khi được viết dưới dạng một đơn vị. Lấy nó từ một chàng trai có bằng tiến sĩ toán học.

— Glen O

Câu trả lời:

CJam, 184 105 98 96 byte

00000000: 22 73 20 6d 20 6b 67 41 20 4e 20 4a 20 57 20 48  "s m kgA N J W H     
00000010: 7a 50 61 43 20 56 20 46 20 ce a9 53 20 57 62 54  zPaC V F ..S WbT     
00000020: 20 48 22 32 2f 53 66 2d 22 d6 9c 64 c6 a1 24 a4   H"2/Sf-"..d..$.     
00000030: 4b f9 1c 4a 57 f4 61 79 31 ed 82 34 22 33 31 38  K..JW.ay1..4"318     
00000040: 62 35 62 32 66 6d 34 2f 6c 53 25 32 24 32 24 65  b5b2fm4/lS%2$2$e
00000050: 72 22 2f 22 61 2f 3a 3a 2e 2b 3a 2e 2d 61 23 3d  r"/"a/::.+:.-a#=

Trên đây là một hexdump; nó có thể được đảo ngược với xxd -r.

Xác minh tất cả các trường hợp kiểm tra cùng một lúc trong trình thông dịch CJam . ¹

Chạy thử nghiệm

$ LANG=en_US
$ cjam si.cjam <<< 'Hz s / Ω'; echo
S
$ cjam si.cjam <<< 'J / A s A'; echo
Ω

Ý tưởng

Chúng ta có thể mã hóa mỗi đơn vị u = s ^a m ^b kg ^c A ^d là vectơ t _u = (a + c - d, b, c, d) . ²

Bằng cách này, đối với đầu vào u ₁ Giảm u _n / v ₁ Lối v _m , chúng ta chỉ phải tính toán (t _{u ₁} + Bắn + t _{u _n} ) - (t _{v ₁} + Lỗi + t _{v _m} ) và kiểm tra đơn vị nào nó tương ứng với.

Mã

"s m kgA N J W HzPaC V F Î©S WbT H"

2/     e# Split the string into chunks of length 2.
Sf-    e# Remove all spaces (if any) from each chunk.

"ÖdÆ¡$¤KùJWôay1í4"

318b   e# Convert from base 318 to integer.
5b     e# Convert from integer to base 5.
2fm    e# Subtract 2 from each base-5 digit.
4/     e# Split into chunks of length 4.
lS%    e# Read one line of input sand split it at spaces.
2$2$   e# Copy the unit names and the vector table.
er     e# Perform transliteration.
"/"a/  e# Split at "/".
::.+   e# Add the vectors of numerator and denominator (if any).
:.-    e# Subtract the resulting sums (or leave a single sum untouched).
a#     e# Find the index of the resulting vector in the vector table.
=      e# Retrieve the corresponding unit.

¹ _{Lưu ý rằng, do các hạn chế của trình thông dịch trực tuyến, tôi không thể sử dụng mã hóa khác cho mã nguồn và I / O. Do đó, ký hiệu Ω hiển thị dưới dạng mã hóa UTF-8 (Î ©). Trình thông dịch Java chính thức không chia sẻ giới hạn này.}
² _{Điều này lưu một vài byte qua ánh xạ đơn giản tới (a, b, c, d) , vì nó rút ngắn phạm vi của tọa độ đầu tiên.}

— Dennis
nguồn

GNU sed, 1118

Cách quá lâu nhưng hoàn thành công việc.

Điểm bao gồm +1 cho -rtùy chọn để sed. Như thể nó quan trọng ở đây. Điểm không bao gồm ý kiến.

### convert 2-letter units to 1-letter substitutes
s/kg/k/g
s/Hz/z/g
s/Pa/P/g
s/Wb/b/g
### remove spaces
s/ //g
### start label for main loop to render all in terms of base units
:
### convert N in denominator to s s / kg m
s|/(.*)N|ss/\1km|;t
### convert N in numerator to kg m / ss
s|N(.*)/|\1km/ss|;t
### convert N in non-rational to kg m / ss
s|N(.*)|\1km/ss|;t
### ... etc for all other derived units
s|/(.*)J|ss/\1kmm|;t
s|J(.*)/|\1kmm/ss|;t
s|J(.*)|\1kmm/ss|;t
s|/(.*)W|sss/\1kmm|;t
s|W(.*)/|\1kmm/sss|;t
s|W(.*)|\1kmm/sss|;t
s|/(.*)z|s/\1|;t
s|z(.*)/|\1/s|;t
s|z(.*)|\1/s|;t
s|/(.*)P|mss/\1k|;t
s|P(.*)/|\1k/mss|;t
s|P(.*)|\1k/mss|;t
s|C|sA|;t
s|/(.*)V|sssA/\1kmm|;t
s|V(.*)/|\1kmm/sssA|;t
s|V(.*)|\1kmm/sssA|;t
s|/(.*)F|kmm/\1ssssAA|;t
s|F(.*)/|\1ssssAA/kmm|;t
s|F(.*)|\1ssssAA/kmm|;t
s|/(.*)Ω|sssAA/\1kmm|;t
s|Ω(.*)/|\1kmm/sssAA|;t
s|Ω(.*)|\1kmm/sssAA|;t
s|/(.*)S|kmm/\1sssAA|;t
s|S(.*)/|\1sssAA/kmm|;t
s|S(.*)|\1sssAA/kmm|;t
s|/(.*)b|ssA/\1kmm|;t
s|b(.*)/|\1kmm/ssA|;t
s|b(.*)|\1kmm/ssA|;t
s|/(.*)T|ssA/\1k|;t
s|T(.*)/|\1k/ssA|;t
s|T(.*)|\1k/ssA|;t
s|/(.*)H|ssAA/\1kmm|;t
s|H(.*)/|\1kmm/ssAA|;t
s|H(.*)|\1kmm/ssAA|;t
### cancel out any units appearing in both numerator and denominator
s|(.)(.*/.*)\1|\2|;t
### remove trailing slash when rational cancels down to non-rational
s|/$||
### sort numerator and denominator kg > m > s > A
:A;s|([^/A])A|A\1|;tA
:s;s|([^/s])s|s\1|;ts
:m;s|([^/m])m|m\1|;tm
:k;s|([^/k])k|k\1|;tk
### Final replacements back to derived units
s|kmm/sssAA|Ω|
s|kmm/sssA|V|
s|kmm/sss|W|
s|kmm/ssAA|H|
s|kmm/ssA|Wb|
s|kmm/ss|J|
s|km/ss|N|
s|k/mss|Pa|
s|k/ssA|T|
s|/s|Hz|
s|ssssAA/kmm|F|
s|sssAA/kmm|S|
s|sA|C|
s/k/kg/

— Chấn thương kỹ thuật số
nguồn

Javascript ES6, 479 byte

f=(s,b="s, m, gk, A, gkm,ss gkmm,ss gkmm,sss gkmm,AAss gk,mss As, gkmm,Asss AAssss,gkmm gkmm,AAsss AAsss,gkmm gkmm,Ass gk,Ass ,s".split` `,d="s m kgA N J W H PaC V F Ω S WbT Hz",p=s.split` / `.map(i=>i.split` `.map(i=>b[d.indexOf(i)/2].split`,`).reduce((p,c)=>(p[0]+=c[0],p[1]+=c[1],p),[[],[]])))=>(p[1]&&(p[0][0]+=p[1][1],p[0][1]+=p[1][0]),[x,y]=p[0].map(i=>[...i].sort().join``),d.match(/../g)[b.indexOf([...x].reduce((p,c)=>(y==(n=y.replace(c,""))&&(p+=c),y=n,p),"")+","+y)])

Ung dung:

f=(s,                                              // define function, accept string to calculate
                                                   // vvv derived quantities reduced to base quantities in the form of <numerator>,<denominator>
   b="s, m, gk, A, gkm,ss gkmm,ss gkmm,sss gkmm,AAss gk,mss As, gkmm,Asss AAssss,gkmm gkmm,AAsss AAsss,gkmm gkmm,Ass gk,Ass ,s".split` `,
   d="s m kgA N J W H PaC V F Ω S WbT Hz",         // symbols list
   p=s.split` / `                                  // split input into [numerator,denominator]
      .map(i=>i.split` `                           // split numerator and denominator strings into list of symbols
               .map(i=>b[d.indexOf(i)/2].split`,`) // convert symbols to their base quantities
               .reduce((p,c)=>(p[0]+=c[0],p[1]+=c[1],p),[[],[]])) // consolidate base quantities
  )=>(
    p[1]&&(p[0][0]+=p[1][1],p[0][1]+=p[1][0]),     // if input was in form of numerator / denominator, reduce to numerator / 1
    [x,y]=p[0].map(i=>[...i].sort().join``),       // sort base quantities in numerator and denominator strings
    d.match(/../g)[b.indexOf(                      // derive symbol from base quantities
        [...x].reduce((p,c)=>(y==(n=y.replace(c,""))&&(p+=c),y=n,p),"")+","+y // remove duplicate symbols from numerator and denominator
  )])

Chạy thử:

>> ["m","N m","J / W","A J / W","T m m","N / A m","V s / A",
    "J S / F A","s / s s","Hz kg m Hz","Hz s / Ω","Wb / H",
    "V Pa S s / C","N s / m Hz","V A","s / Ω","J / A s A"]
     .forEach(i=>console.log((i+" ".repeat(12)).slice(0,12)+"  ->  "+f(i)))

<< m             ->  m 
   N m           ->  J 
   J / W         ->  s 
   A J / W       ->  C 
   T m m         ->  Wb
   N / A m       ->  T 
   V s / A       ->  H 
   J S / F A     ->  V 
   s / s s       ->  Hz
   Hz kg m Hz    ->  N 
   Hz s / Ω      ->  S 
   Wb / H        ->  A 
   V Pa S s / C  ->  Pa
   N s / m Hz    ->  kg
   V A           ->  W 
   s / Ω         ->  F 
   J / A s A     ->  Ω

— Dendrobium
nguồn