राउंडिंग को संतुष्ट करना

Question

राउंडिंग को संतुष्ट करना

आप जानते हैं कि जब आप विज्ञान वर्ग में होते हैं, और 2 सेर अंजीर से गोल करने के लिए कहा जाता है, लेकिन आपका जवाब है 5.2501...? आपको गोल करना चाहिए 5.3, लेकिन यह सिर्फ इतना असंतोषजनक है! राउंडिंग द्वारा 5.3, आप एक संपूर्ण 0.05 द्वारा बंद कर रहे हैं, जो कि 0.1 की तुलना में एक बड़ी राशि है (जिस स्थान का मूल्य आप ले रहे हैं)! इसलिए संतोषजनक तरीके से मेरी मदद करें।

संतोषजनक तरीके से गोल करने के लिए, आपको पहले अंक में गोल करना चाहिए जो कि आप भर में आते हैं, जो अपेक्षाकृत छोटी त्रुटि पैदा करता है - गोलाई में अधिकतम संभव त्रुटि का आधे से भी कम। मूल रूप से, जब भी आप 0, 1, 8, या 9 से मुठभेड़ करते हैं, तो आपको गोल करने की आवश्यकता होती है। यदि ऐसा कभी नहीं होता है, तो इनपुट को उसी रूप में लौटाएं। अग्रणी शून्य या लोगों पर गोल न करें - यह सिर्फ संतोषजनक नहीं लगता है।

इनपुट

एक स्ट्रिंग या फ्लोट मान जो एक nonnegative दशमलव संख्या का प्रतिनिधित्व करता है।

उत्पादन

एक ही दशमलव संख्या संतोषजनक रूप से, स्ट्रिंग या फ्लोट प्रारूप में गोल।

उदाहरण

Input -> Output
0 -> 0
0.5 -> 0.5
0.19 -> 0
0.8 -> 1
5.64511 -> 5.645
18.913 -> 20
88.913 -> 100
36.38299 -> 36.4
621 -> 620
803.22 -> 1000
547.4726 -> 547.4726

यह एक कोड-गोल्फ चुनौती है, इसलिए सबसे छोटा कोड जीतता है!

Comments

सैंडबॉक्स

— क्विंटेक

क्या ऐसे तार को 036.40000वैध आउटपुट माना जाता है?

— अरनौलड

क्या हम मान सकते हैं कि .0पूर्णांक के लिए एक हिस्सा दिया जाएगा? इसके अलावा, 0सकारात्मक नहीं है।

— आउटगोल्फर

@EriktheOutgolfer नहीं, आप नहीं भी हो सकते हैं - धन्यवाद, नॉनगेटिव में बदल गया।

— क्विंटेक

इतना 19गोल 20लेकिन 0.19गोल करने के लिए 0? क्यों?

— नील

Answer 1

जावास्क्रिप्ट (ईएस 6),  100 99 98  78 बाइट्स

एक स्ट्रिंग के रूप में इनपुट लेता है। एक फ्लोट देता है।

s=>+(0+s).replace(/\d/g,(d,i)=>j&&+d+((n=s[i+!++s[i]])<2&&i?--j:n>7&&j--),j=1)

इसे ऑनलाइन आज़माएं!

कैसे?

हम पहली बार इनपुट स्ट्रिंग के लिए एक अग्रणी $0$ को प्रस्तुत करते हैं, ताकि हम संभावित $8$ या $9$ से पहले एक अंक प्राप्त करने की गारंटी दें , जिसे तुरंत राउंडिंग को ट्रिगर करना होगा।

झंडा $j$ को $1$ सेट किया जाता है जब तक हम एक अंक की तलाश कर रहे हैं जिस पर हम एक संतोषजनक राउंडिंग कर सकते हैं, और $0$ सेट कर सकते हैं ।

क्योंकि एक अग्रणी $0$ को उस स्ट्रिंग में जोड़ा गया था जिसे हम चल रहे हैं लेकिन $s$ अपरिवर्तित रह गया था, $d$ में वर्तमान वर्ण है और $s[i]$ अगले वर्ण की ओर इशारा करता है ।

हम निम्नलिखित कोड का उपयोग $n$ में अगले अंक को लोड करने के लिए करते हैं , एक संभावित दशमलव विभाजक को छोड़ते हुए:

n = s[i + !++s[i]]

हालांकि तार जावास्क्रिप्ट में अडिग हैं, अभिव्यक्ति ++s[i]वापस आ जाएगी $s[i]+1$ अगर यह एक अंकीय मान होता है, भले ही $s[i]$ वास्तव में वृद्धि की जाती नहीं है। इसलिए, अभिव्यक्ति !++s[i]के लिए मूल्यांकन किया जाता है $false$ (करने के लिए मजबूर $0$ (सहित सभी अंक के लिए) $0$ ) और करने के लिए $true$ (करने के लिए मजबूर $1$ ) के लिए दशमलव विभाजक "."।

जब राउंडिंग होती है, तो हम उपज d + --jअगर अगले अंकों $n$ है $0$ या $1$ (और यह मूल इनपुट के अग्रणी अंकों नहीं है) और d + j--यदि $n$ है $8$ या $9$ । इसलिए, $j$ के लिए सेट है $0$ दोनों ही मामलों में, लेकिन हम जोड़ने के $0$ के लिए $d$ पहला मामला (नीचे गोलाई) और में $1$ दूसरे मामले में (ऊपर गोलाई)।

Comments

और पिनबॉल / रबर की गेंद खाई में गिरती है! :)

— क्विंटेक

Answer 2

रूबी , 79 77 69 67 65 बाइट्स

->n,z=n+".0"{z[i=z=~/\./]='';n.to_f.round (z=~/(?!^)[01]|8|9/)-i}

इसे ऑनलाइन आज़माएं!

व्याख्या

• ->n इनपुट को एक स्ट्रिंग के रूप में लें
• z=n+".0"एक अस्थायी स्ट्रिंग बनाएं zजिसमें एक डॉट और एक प्रासंगिक अंक शामिल होने की गारंटी है।
• i=z=~/\./दशमलव डॉट की स्थिति निर्धारित करें zऔर उसे असाइन करें i।
• z[i]='' डॉट को ड्रॉप करें ताकि यह आगे के रास्ते में न आए।
• z=~/(?!^)[01]|8|9/जो भी पहले आए, नॉन-स्टार्टिंग 0-1या किसी की भी स्थिति निर्धारित करें 8-9।
• (...)-i यह अंतर रखने के लिए दशमलव स्थानों की संख्या होगी, अगर हम डॉट के बाईं ओर घूम रहे होंगे।
• n.to_f.round ... फ्लोट में कनवर्ट करें और राउंडिंग करें।

Answer 3

जेली , 34 बाइट्स

;”.ḟ$µ»"”2e€⁽¡XṾ¤;1i1_i”.$_>¥0ɓVær

इसे ऑनलाइन आज़माएं!

-1 जोनाथन एलन को धन्यवाद ।

Comments

क्यों ŒV? मुझे लगता है कि Vकाम भी करेगा।

— जोनाथन एलन

@ जोनाथनअलन नोप। (मूल रूप से बैंकर के

— चक्कर लगाने वाले क्विरक्स

ओह, क्योंकि यह इनपुट पर अभिनय नहीं कर रहा है? _>¥0ɓVærमेरी तरह कोशिश करो (मैं जल्दी से बहुत जल्दी धन्यवाद का उपयोग याद किया!)

— योनातन एलन

@JonathanAllan आह, चेन का चतुर उपयोग, धन्यवाद।

— आउटगोल्फर

Answer 4

जेली ,  30  29 बाइट्स

-1 एरिक द आउटगोलर के लिए धन्यवाद ( ¥उनके उत्तर से त्वरित डायडिक का उपयोग )

O;0µ_8H1¦%8ỊTḢ_<48TḢƊ_>¥0ɓVær

एक मोनडिक लिंक जो पात्रों की एक सूची को स्वीकार करता है जो एक फ्लोट देता है।

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।

किस तरह

पहले ध्यान दें कि इनपुट स्ट्रिंग विशेष रूप से उन वर्णों से बनाई गई है 0123456789.जिनमें अध्यादेश हैं [48,49,50,51,52,53,54,55,56,57,46], जिनके पास आठ से विभाजित होने पर शेष रहता है [0,1,2,3,4,5,6,7,0,1,6]। केवल अक्षर जो के बीच हैं -1और 1शामिल हैं 0, 1, 8, और 9।

इसके अलावा अगर हम अध्यादेशों में से आठ घटाते हैं ( [40,41,42,43,44,45,46,47,48,49,38]) वही (काफी स्पष्ट रूप से) धारण करते हैं। यदि हम इन ( [20,20.5,21,21.5,22,22.5,23,23.5,24,24.5,19]) को हटाते हैं तो केवल वे पात्र जो आठ से विभाजित होने पर शेष रहते हैं -1और जिनके बीच 1समावेशी होते हैं 8और होते हैं 9।

O;0µ_8H1¦%8ỊTḢ_<48TḢƊ_>¥0ɓVær - Link: list of characters, S
O                             - ordinal (vectorises across S)
 ;0                           - concatenate a zero
                              - (to cater BOTH for no '0', '1', '8', or '9' AND for no '.')
   µ                          - start a new monadic link (call that X)
    _8                        - subtract eight (vectorises across X)
        ¦                     - sparse application...
       1                      - ...to: indices: one
      H                       - ...do: halve (i.e. halve first ordinal)
         %8                   - modulo by eight (vectorises)
           Ị                  - insignificant (abs(v)<=1?) (vectorises)
            T                 - truthy indices
             Ḣ                - head
                    Ɗ         - last three links as a monad (i.e. f(X)):
               <48            -   less than 48? (i.e. was it a '.' in S or the added 0?)
                  T           -   truthy indices
                   Ḣ          -   head
              _               - subtract
                       ¥      - last two links as a dyad
                      < 0     -   less than zero? (1 if so 0 otherwise)
                     _        -   subtract
                         ɓ    - start a new dyadic chain (i.e. f(S,X))
                          V   - evaluate S as Jelly code (i.e. get S as a float)
                           ær - round to the nearest multiple of 10^(-X)

Answer 5

रेटिना 0.8.2 , 75 बाइट्स

^[89]
10
T`d`0`(?<=.)[01].*|(?<=8|9).*
T`89d`0d`.\.?[89]
(\.|(\..+?))0+$
$2

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

^[89]
10

एक प्रमुख 8या के मामले को संभालें 9।

T`d`0`(?<=.)[01].*|(?<=8|9).*

यदि कोई गैर-अग्रणी 0या है 1, तो इसे शून्य करें और बाकी स्ट्रिंग बाहर। इसके अलावा, वहाँ है कि अगर एक 8या 9, तो यह स्ट्रिंग के बाकी बाहर छोड़ देते हैं, लेकिन शून्य। (लेकिन दोनों ही स्थिति में दशमलव बिंदु को अपरिवर्तित छोड़ दें।)

T`89d`0d`.\.?[89]

यदि इस बिंदु पर अभी भी एक 8या एक है 9, तो इसे शून्य करें, और पूर्ववर्ती अंक को बढ़ाएँ (संभवतः दशमलव बिंदु से पहले)।

(\.|(\..+?))0+$
$2

यदि वे दशमलव बिंदु के बाद हैं, तो ट्रेलिंग शून्य हटाएं, लेकिन बीच में कोई अन्य अंक नहीं होने पर केवल दशमलव बिंदु हटाएं।

Answer 6

सी (जीसीसी) , 111 102 बाइट्स

g(_,i,j,k)char*_;{for(i=*_<56?*_++:48,j=3;j;j&=k%8>1|(i=*_++)/48*2)putchar(j&1?i+(k=_[*_<48])/56:48);}

इसे ऑनलाइन आज़माएं!

//_: input, as string
//i: current digit, rounded if applicable
//j: tracks whether number is rounded, and whether \0 or '.' has been encountered
//k: digit to test rounding (round if k is one of 0,1,8,9)
//'0'==48, '8'==56
g(_,i,j,k)char*_;{
    for(i=*_<56?*_++:48,j=3;                //special case: if first digit is 8 or 9, use a
                                            //placeholder digit with value 0. initialize j.
        j;                                  //only stop execution when number is rounded and
                                            //'.' or \0 has been encountered.
        j&=k%8>1|(i=*_++)/48*2)             //check if execution should stop.
        putchar(j&1?i+(k=_[*_<48])/56:48);  //print '0' if rounding had already been done;
                                            //otherwise, print digit. round up as needed.
}

Answer 7

C # (विजुअल C # इंटरएक्टिव कंपाइलर) , 280 बाइट्स

c=>{int d=c.IndexOf('.');int t=c.IndexOfAny(new char[]{'8','9','0','1'},1);var m=c[0]=='8'||c[0]=='9'?1>0:0>1;var z=decimal.Parse(c);Func<decimal>q=()=>(decimal)Math.Pow(10,m?d<0?c.Length:d:d<0?c.Length-t:d>t?d-t:d-t+1);return m?Math.Round(z/q())*q():t<0?z:Math.Round(z/q())*q();}

इसे ऑनलाइन आज़माएं!

यह कम हो सकता है अगर मैं दशमलव के बजाय युगल का उपयोग करता हूं, लेकिन मैंने सटीकता को संरक्षित करने के लिए दशमलव का उपयोग किया, या 547.4726 जैसी संख्या 547.472595214844 होगी।

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 268 बाइट्स

c=>{int d=c.IndexOf('.');int t=c.IndexOfAny(new char[]{'8','9','0','1'},1);var m=c[0]=='8'||c[0]=='9'?1>0:0>1;var z=float.Parse(c);Func<double>q=()=>Math.Pow(10,m?d<0?c.Length:d:d<0?c.Length-t:d>t?d-t:d-t+1);return m?Math.Round(z/q())*q():t<0?z:Math.Round(z/q())*q();}

इसे ऑनलाइन आज़माएं! (कम सटीक संस्करण)