आकार जांच

Question

एसआई इकाइयों के एक उत्पाद या अनुपात की गणना करें।

उदाहरण के लिए, kg m / s s(किलोग्राम-मीटर प्रति सेकंड चुकता) को N(न्यूटन) लौटना चाहिए ।

इनपुट हमेशा रहेगा:

• एसआई इकाइयों के लिए प्रतीकों की एक सूची, अंतरिक्ष-पृथक (एक उत्पाद का प्रतिनिधित्व) या
• ऊपर, /और ऊपर (एक अनुपात का प्रतिनिधित्व करते हुए)।

इनपुट में कभी भी अन्य वर्ण (जैसे संख्यात्मक शाब्दिक या अन्य विराम चिह्न) नहीं होंगे।

आप मान सकते हैं कि यह हमेशा एक एसआई इकाई के बराबर होगा।

निम्नलिखित प्रतीकों का उपयोग करें:

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

उदाहरण:

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

सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

kg m / s sवास्तव में किलोग्राम-मीटर-सेकंड प्रति सेकंड या सिर्फ किलोग्राम-मीटर होगा। गुणन और विभाजन कार्य LTR। तुम जो खोज रहे हो, वह है kg m / (s s)। यह अन्य उदाहरणों पर भी लागू होता है।

— २२:०२ पर लेजियन मम्मल

@ लोशन: जरूरी नहीं। स्लैश के साथ निहित गुणा और विभाजन अस्पष्ट हैं; ordr सम्मेलन पर निर्भर करता है। यहाँ अंतर्निहित गुणा को विभाजन की तुलना में अधिक पूर्वता के लिए लिया जाता है।

— देउसोवी

... कि गणित के बारे में सब टूट जाता है। स्पष्ट और स्पष्ट गुणन का मतलब ठीक उसी चीज़ से है।

— 22ion में LegionMammal978

@ LegionMammal978 वास्तव में नहीं। 1 / 2xवास्तव में क्या मतलब है x / 2?

— Ypnypn

@ LegionMammal978 - वास्तव में, 1 / 2x 1 / (2x) के लिए सामान्य संकेतन है। आम तौर पर, जहां यह अस्पष्ट नहीं है, स्लैश को अंश और हर के बीच विभाजन रेखा के रूप में व्याख्या की जाएगी। यहाँ इस्तेमाल किया जा रहा सम्मेलन ठीक है - विशेष रूप से क्योंकि यह सम्मेलन इकाइयों में मानक है। एक इकाई के रूप में लिखे जाने पर kg / ms का मतलब kg / (m * s) है। इसे मैथ्स में पीएचडी वाले लड़के से लें।

— ग्लेन ओ

Answer 1

CJam, 184 105 98 96 बाइट्स

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

ऊपर एक हेक्सडंप है; इसके साथ उलटा हो सकता है xxd -r।

CJam दुभाषिया में एक बार में सभी परीक्षण मामलों की जाँच करें । ¹

परीक्षण चालन

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

विचार

हम प्रत्येक इकाई u = s ^a m ^b kg ^c A ^d को वेक्टर t _u = (a + c - d, b, c, d) के रूप में एन्कोड कर सकते हैं । ²

इस तरह, इनपुट के लिए u ₁ … u _n / v ₁ … v _m , हमें केवल गणना करना है (t _{u 1} +… + t _{u n} ) - (t _{v 1} +… + t _{v 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.

---

¹ _{ध्यान दें कि, ऑनलाइन दुभाषिया की सीमाओं के कारण, मैं स्रोत कोड और I / O के लिए एक अलग एन्कोडिंग का उपयोग नहीं कर सकता। इसलिए, प्रतीक, अपने UTF-8 एन्कोडिंग (। ©) के रूप में दिखाता है। आधिकारिक जावा दुभाषिया इस सीमा को साझा नहीं करता है।}
² _{यह (a, b, c, d) के लिए सीधी मैपिंग पर कुछ बाइट्स को बचाता है , क्योंकि यह पहले समन्वय की सीमा को छोटा करता है।}

Answer 2

जीएनयू सेड, 1118

रास्ता बहुत लंबा है लेकिन काम हो जाता है।

स्कोर में -rsed के विकल्प के लिए +1 शामिल है । मानो यहीं मायने रखता है। स्कोर टिप्पणियों को छोड़कर।

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

Answer 3

जावास्क्रिप्ट ईएस 6, 479 बाइट्स

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

Ungolfed:

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

टेस्ट रन:

>> ["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     ->  Ω