कुशल वैज्ञानिक संकेतन

Question

दूसरे दिन मेरे रसायन विज्ञान के शिक्षक हमें वैज्ञानिक संकेतन के बारे में समझा रहे थे (छोटी संख्या का उपयोग करके और बड़ी संख्या को आसानी से व्यक्त करने के लिए इसे दस की शक्तियों से गुणा करना), जिसने मुझे पहली बार सीखने पर कुछ साल वापस लाए। मूल बातें सीखने के बाद, हमने सामान्य गणित के प्रश्नों का एक समूह बनाया था, जिनमें से कुछ निम्नलिखित थे:

वैज्ञानिक संकेतन में निम्नलिखित का प्रतिनिधित्व करें:
a) 50000000
b) 120000000000000
c) 90000000000000000000000000000000000000
d) pi ^ e ^ i ^ j ^ k ^ std :: वेक्टर
...
z) 200
...

और मैंने सोचा, "क्या? हमें बताया गया था कि वैज्ञानिक संकेतन का उपयोग बड़ी संख्या में लेखन को अधिक कुशल बनाने के लिए किया गया था, लेकिन कुछ मामले बिल्कुल भी कुशल नहीं हैं!"

संख्या पर विचार करें

300

और वैज्ञानिक अंकन में इसका प्रतिनिधित्व:

3x10^2

क्या, वैज्ञानिक रूप से प्रसिद्ध संस्करण वास्तव में अधिक स्थान लेता है? हम नहीं कर सकते कि अब हम कर सकते हैं? (स्क्रीन स्पेस अनमोल है।)
हम खुद को निर्धारित कर सकते हैं कि यह वैज्ञानिक नोटेशन में नंबर लिखने के लिए अधिक स्पेस कुशल है या नहीं, या ...

कार्य

आपके प्रोग्राम या फ़ंक्शन को इनपुट का एक धनात्मक संख्या nके रूप में मनमाना आकार (आपकी भाषा का समर्थन करता है) तक ले जाना चाहिए और संख्या के वैज्ञानिक रूप से नोट किए गए संस्करण को आउटपुट करना चाहिए।
हालाँकि, यदि मूल संख्या n, अनुगामी शून्य और अनुगामी दशमलव स्थान को हटाने के बाद, इसके वैज्ञानिक रूप से संकलित संस्करण की तुलना में प्रदर्शित करने के लिए कम या उतने ही वर्णों की आवश्यकता होती है, तो आपको nइसके बजाय उस मूल संख्या को आउटपुट करना होगा ।

आपके कोड को जितना संभव हो उतना छोटा होना चाहिए क्योंकि आउटपुट भी जितना संभव हो उतना कम होना चाहिए।

विशेष विवरण

कुशल वैज्ञानिक अधिसूचना को निम्नानुसार परिभाषित किया गया है:

bx10^e

bइनपुट संख्या को 10 की शक्तियों द्वारा उचित रूप से विभाजित किया गया है 1 <= b < 10। इस संख्या में सभी अनुगामी शून्य (और यदि आवश्यक हो तो दशमलव बिंदु) होना चाहिए, लेकिन मूल संख्या (आपकी भाषा में दशमलव बिंदु सीमा तक) की सटीकता होनी चाहिए। Ie 90000हो जाता है 9, 13.500बन जाता है 1.35, आदि। यदि यह संख्या समाप्त 0.000675हो जाती है , 6.75जिसमें आपकी भाषा की तुलना में अधिक दशमलव स्थान होते हैं, तो इसे उस अधिकतम दशमलव स्थानों पर गोल किया जाना चाहिए।

eवह घातांक है जिसको दस इस तरह से उठाया जाता है n = b x 10^e(याद रखें कि यदि यह संख्या n1 से छोटी है तो नकारात्मक होना चाहिए )। इस संख्या में कोई अनुगामी शून्य या दशमलव स्थान नहीं होना चाहिए (मुख्यतः क्योंकि अगर यह पूर्णांक नहीं है तो कुछ गलत है ...)।

अक्षर वैसे ही बने रहने x10^ चाहिए जैसे बीच में स्ट्रिंग में bऔर e।

परीक्षण के मामलों

Input -> output
1 -> 1
20 -> 20
3000000 -> 3x10^6
400000 -> 400000
0.008093 -> 0.008093
0.007835000000000 -> 0.007835
0.000003000000 -> 3x10^-6
0.00000065 -> 6.5x10^-7
0 -> 0

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है।

अन्य नियम और स्पष्टीकरण

• अनुगामी शून्य (और / या अनुगामी दशमलव स्थान) को मूल इनपुट संख्या की वर्ण गणना की ओर नहीं गिना जाता है n। टेस्ट केस 6 जैसे मामलों को ध्यान में रखें
• आप यह मान सकते हैं कि यदि इनपुट नंबर 1 से कम है, तो यह हमेशा 0 अंक वाले स्थान पर शुरू होगा (जैसा कि परीक्षण मामलों में 5-8)।
• इनपुट नंबर कभी भी नकारात्मक नहीं होगा
• बिल्ट-इन जो इस चुनौती को तुच्छ बनाते हैं और मानक खामियों को रोक दिया जाता है
• आउटपुट में एक अनुगामी न्यूलाइन ठीक है

EDIT
धन्यवाद परीक्षण के मामलों की ओर इशारा करते हुए user81655 के लिए धन्यवाद 7 और 8 में दस की गलत शक्तियां थीं। मैंने अब उन्हें ठीक कर दिया है ताकि यह सुनिश्चित हो सके कि आपका कोड उनका सही मूल्यांकन करता है।

Comments

तो, उह, क्या मुझे पूछना चाहिए कि इनपुट के लिए आउटपुट क्या pi^e^i^j^k^std::vectorहोगा?

— जिओबिट्स

@Geobits हम्म, अच्छी तरह से अगर आप std :: वेक्टर के लिए एक संख्यात्मक मान निर्दिष्ट कर सकते हैं तो शायद ... नहीं, केवल संख्या इनपुट में मौजूद होगी (फ्लोटिंग पॉइंट इनपुट के लिए एक दशमलव स्थान को छोड़कर)।

— एमसी MCT

यह बहुत आसान होगा और हम आपके "अनमोल स्क्रीन स्पेस" का कम इस्तेमाल करेंगे, अगर इसका इस्तेमाल किया जाए e: 9000 -> 9e3(लगभग 9,000 से अधिक !)

— साइओस

@ मुझे लगता है कि इसके बारे में सोचा था, लेकिन मैंने वास्तव में इस चुनौती को उस तरीके पर आधारित किया है जो आम तौर पर लिखा जाता है (जैसा कि शारीरिक रूप से लिखा गया है), जो कि लगता है x10^। और यह सवाल पर एक उचित सा काम होगा, जो मुझे नहीं लगता कि यह अब उचित है कि यह पोस्ट किया गया है

— MC 16T

@ghosts_in_the_code वह नहीं थी, इसलिए "मुझे कुछ वर्षों में वापस लाया जब मैंने पहली बार इसे [गणित वर्ग में] सीखा"

— MC 7T

Answer 1

ईएस 6, 83 81 बाइट्स

x=>(e=s=>s.replace(/e\+?/,'x10^'),z=e(x.toExponential()),y=e(''+x))[z.length]?z:y

संभवतः कुछ किनारे मामलों के लिए विफल रहता है जहां toStringघातीय प्रारूप पर जोर दिया गया है।

संपादित करें: @ उपयोगकर्ता81655 के लिए 2 बाइट्स धन्यवाद सहेजे गए।

Comments

अछा सुझाव। वैसे, ऐसा लगता है कि आप /रेगेक्स के अंत में भूल गए ।

— user81655

इसके अलावा आप 2 बाइट्स को बचाने के लिए इसे थोड़ा व्यवस्थित कर सकते हैं:x=>(e=s=>s.replace(/e\+?/,'x10^'),z=e(x.toExponential()),y=e(''+x))[z.length]?z:y

— user81655

@ user81655 आह, वहाँ क्या हुआ कि मेरे ब्राउज़र ने लंबी लाइन को इस तरह से लपेट कर मुझे भ्रमित कर दिया जैसे मैंने सोचा कि गलती से एक नई लाइन वहां आ गई थी।

— नील

Answer 2

पायथन 3, 346 342 319 302 बाइट्स

L=len;N=str(float(input()))
if N.endswith('.0'):N=N[:-2]
if'e'in N:C,P=N.split('e');N=N.replace('e','x10^')
else:
 C=N.strip('.0').replace('.','');F=N.find('.')
 if L(C)>1:C=C[0]+'.'+C[1:]
 P=((L(N) if F==-1 else F)-1-N.lstrip('0').find(C[0]))
print(min([N,'{0}x10^{1}'.format(C,int(P))],key=L))

शायद बुरी तरह से गोल्फ, लेकिन हे, यह इस तरह से कुछ पर मेरी पहली कोशिश है। यह पढ़ना कठिन है, इसलिए यह अच्छा होना चाहिए।

जहां तक ​​मुझे पता है, यह हर मामले पर काम करना चाहिए, यहां तक ​​कि पायथन की प्रवृत्ति को स्वचालित रूप से संख्याओं को वैज्ञानिक नोटेशन (जो कि शांत और फैंसी 'ई को छोड़कर) में बदल देता है। मुझे ठीक से याद नहीं है कि मैंने कैसे बनाया कि मानक फॉर्म संख्या वापस करने में सक्षम हो, लेकिन यह ऐसा करता है।

Answer 3

पर्ल 6, 96 90 बाइट्स

मुझे ऐसा लगता है कि यह छोटा हो सकता है, लेकिन यह मेरे लिए सबसे अच्छा है

{my \s=($_,*×(1>$_??10!!.1)…10>*>=1);min(s[*-1]~"x10^"~(1>$_??1-s!!s-1),$_,by=>&chars)}

उपयोग : इसे किसी वैरिएबल पर असाइन करें

यहाँ यह कुछ खराब टिप्पणी के साथ थोड़ा सा असंयमित है:

my &f = -> $n {
    my $a = 1 > $n ?? 10 !! .1;             # If $n < 1, we will multiply by 10
                                            # in the sequence below, else by 0.1

    my @seq = ($n, * × $a ... 10 > * >= 1); # Sequence starting at $n, 
                                            # multiply the previous value by $a
                                            # until we reach a number 1 <= x < 10

    # Join the last element in @seq, "x10^", and the length of @seq,
    # with an extra subtraction for numbers less than 1.
    # this gets us our scientific notation.
    my $science = @seq[*-1] ~ "x10^" ~ @seq - (1 > $n ?? @seq*2 !! 1); 

    min($science, $n, by => &chars) # Uses the &chars function to
                                    # choose a min value and return it.
}

Comments

स्वैप $_ <1के साथ 1>$_और 1 <=* <10साथ10>*>=1

— ब्रैड गिल्बर्ट b2gills

मुझे वास्तव में कल रात ऐसा करने का मतलब था लेकिन मैं भूल गया था। घर पहुंचने पर मैं इसे अपडेट करूंगा

— Hotkeys

Answer 4

TI बेसिक (nspire): 112 बाइट्स

Define f(x)=
Prgm
string(x)➝a
If x≥1 Then
format(x,"s")➝a
EndIf
instring(a,"ᴇ")➝b
left(a,b-1)&"x10^"&mid(a,b+1)➝a
If dim(a)<dim(string(n)) or x<1 Then
Disp a
Else
Disp x
Endif
EndPrgm

व्याख्या

If x≥1 Then
format(x,"s")➝a
EndIf

यदि यह पहले से ही उस प्रारूप में नहीं है, तो छोटे-छोटे दशमलव स्वचालित रूप से परिवर्तित हो जाते हैं, तो इनपुट को वैज्ञानिक संकेतन में रूपांतरित करता है।

instring(a,"ᴇ")➝b
left(a,b-1)&"x10^"&mid(a,b+1)➝a

फैंसी ई की स्थिति को ढूँढता है जो घातांक को दर्शाता है और इसे "x10 ^" से बदल देता है।

If dim(a)<dim(string(x)) or x<1 Then
Disp a
Else
Disp x
Endif

जाँच करता है कि कौन सा आउटपुट बड़ा है और इष्टतम को लौटाता है। जब तक कि यह एक छोटा दशमलव न हो, जो डिफ़ॉल्ट रूप से छोटा हो।

Answer 5

पायथन (3.5) 177 बाइट्स

नियमित अभिव्यक्ति का उपयोग कर एक समाधान

import re
g=lambda s:re.sub(r"e\+?(-?)0?","x10^\\1",s)
def f(i):
 t=g(re.sub(r"\.[0]*e","e","%e"%i))
 u=g(re.sub(r"(\..*)[0]*$","\\1",str(i)))
 return t if len(u)>len(t) else u

व्याख्या

रेगेक्सपी मॉड्यूल का महत्व

import re

लैम्ब्डा समारोह की परिभाषा को बदलने के लिए eद्वाराx10^

g=lambda s:re.sub("e\+?(-?)0?","x10^\\1",s)
def f(i):

वैज्ञानिक संकेतन में स्ट्रिंग का रूपांतरण

 t=g(re.sub(r"\.[0]*e","e","%e"%i))

मूल स्ट्रिंग में 0 गद्दी निकालें

 u=g(re.sub(r"(\..*)[0]*$","\\1",str(i)))

लंबाई की तुलना करें

 return t if len(u)>len(t) else u

परिणाम

>>> [f(i) for i in [1, 20, 3000000, 400000, 0.008093, 0.007835000000000, 0.000003000000, 0.00000065, 0]]
['1', '20', '3x10^6', '400000', '0.008093', '0.007835', '3x10^-6', '6.5x10^-7', '0']