दशमलव को ट्रिम और काउंट करें

Question

इस चुनौती में, आप आउटपुट स्ट्रिंग में कितने दशमलव स्थान हैं, आउटपुट के लिए एक प्रोग्राम लिखेंगे और ज़रूरत पड़ने पर इनपुट ट्रिम कर सकते हैं।

उदाहरण

-12.32
2

32
0

3231.432
3

-34.0
0 -34

023
0 23

00324.230
2 324.23

10
0

00.3
1 0.3

0
0

-04.8330
3 -4.833

नियम

• इनपुट एक स्ट्रिंग होगी जिसे STDIN, फ़ंक्शन आर्ग्यूमेंट्स या निकटतम समकक्ष के माध्यम से लिया जा सकता है
• आउटपुट फ़ंक्शन रिटर्न, STDOUT, या निकटतम समकक्ष के माध्यम से हो सकता है।
• आपकी भाषाओं की अधिकतम स्ट्रिंग लंबाई को छोड़कर इनपुट पूर्णांक के लिए आकार की कोई सीमा नहीं है ।
• यदि इनपुट में कोई अनावश्यक (प्रमुख या अनुगामी) शून्य है:
  1. आपको उन्हें बाहर निकालना चाहिए
  2. नई संख्या में दशमलव स्थान की मात्रा को आउटपुट करें
  3. एक विभाजक द्वारा अलग किए गए नए नंबर को आउटपुट करें (जैसे स्पेस, न्यूलाइन, अल्पविराम)
• इनपुट हमेशा इस RegEx से मेल खाएगा: -?\d+(\.\d+)?या यदि आप RegEx नहीं बोलते हैं :
  • वहाँ सकता है एक हो -शुरुआत एक ऋणात्मक संख्या जिसका अर्थ में। फिर कम से कम एक अंक होगा। फिर हो सकता है ... a .और कुछ और अंक।
  • यह देखने के लिए कि क्या कोई इनपुट वैध है, यहां देखें
• रेगेक्स नहीं

---

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

Comments

शायद माइनस साइन और अग्रणी शून्य के साथ एक परीक्षण मामला जोड़ें?

— लुइस मेंडो

क्या इसकी परवाह किए बिना अंतिम संख्या को आउटपुट करने की अनुमति है कि क्या इसे छंटनी की गई थी या नहीं?

— 22

@insertusernamehere नहीं, आप केवल दूसरी संख्या को आउटपुट कर सकते हैं यदि इसे ट्रिम कर दिया गया हो

— डाउनगैट

आप एकल के लिए एक परीक्षण मामले / उदाहरण जोड़ना चाह सकते हैं 0।

— सम्मिलित

निरर्थक रेगेक्स प्रतिबंध के लिए -1।

— कॉनर ओ'ब्रायन

Answer 1

PHP 7, 142 बाइट्स

मैं किसी भी तरह एक ही प्रिंट स्टेटमेंट में सब कुछ निचोड़ने में कामयाब रहा:

<?=strlen((explode('.',$t=trim('-'==($_=$argv[1])[0]?$n=$_=trim($_,'-'):$_,0)))[1]).($t!==$_?($n?' -':' ').('.'==$t[0]?0:'').trim($t,'.'):'');

कमांड लाइन से चलती है, जैसे:

$ php trimandcount.php "-04833.010"

डेमो

सभी परीक्षण मामलों को देखें जिसमें एक बहुत लंबा (62 अक्षर) शामिल हैं:

¹ खरीदने से पहले कोशिश करें

_{¹ "नीचे दिए गए बॉक्स के ऊपर होवर 7.0.0 के लिए आउटपुट सभी परिणाम देखने के लिए"।}

Answer 2

पायथन 2, 165 180 बाइट्स

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

def t(i):
 o,a='',i
 while a[-1]=='0':
  a=a[:-1]
 while a[0]=='0':
  a=a[1:]
 if a[-1]=='.':a=a[:-1]
 if'.'in a:o=str(len(a)-a.index('.')-1)
 else:o='0'
 if a!=i:o+=" "+a
 print o

यदि कोई पाइथ में मेरे काम का निर्माण करना चाहता है ~b@+cz"."" "1Wq@b_1"0"~b<b_1)plrb6, तो यह देखने के लिए कि आप कहाँ पर हैं, आप एपी के बीच डालना चाहते हैं @+।

Answer 3

05AB1E , 23 बाइट्स (गैर-प्रतिस्पर्धी)

अरे, मैं बहुत करीब था। पायथन वैज्ञानिक संकेतन का उपयोग करके बहुत बड़ी तैरता है, इसलिए मैंने दुभाषिया में इस बग को तय किया। हालाँकि, यह चुनौती के बाद किया गया था और मेरा प्रस्तुतिकरण गैर-प्रतिस्पर्धी है।

कोड:

DÞ'.¡0Üg,\DÞ0Ü'.ÜDrQ_i,

स्पष्टीकरण:

D                       # Duplicate top of the stack, or input when empty
 Þ                      # Convert to float
  '.¡                   # Split on '.' (decimal point)
     0Ü                 # Remove trailing zeroes
       g                # Get the length
        ,               # Output top of the stack (the length)
         \              # Discard the top item
          D             # Duplicate top of the stack
           Þ            # Convert to float
            0Ü          # Remove trailing zeroes
              '.Ü       # Remove trailing dots
                 D      # Duplicate top of the stack
                  r     # Reverse the stack
                   Q_i, # If not equal, print top of the stack

आईएसओ 8859-1 एन्कोडिंग का उपयोग करता है ।

Answer 4

जावास्क्रिप्ट (ईएस 6), 156 162

'-0' के लिए फिक्स्ड बग को संपादित करें - thx @Fez Vrasta संपादित करें 2 6 बाइट्स ने thx @Neil को बचाया

यह एक गड़बड़ है, लेकिन यह 100% स्ट्रिंग आधारित है - संख्यात्मक प्रकारों के कारण कोई सीमा नहीं है

s=>(l=k=p=t=0,[...s].map(c=>++t&&c=='.'?p=t:+c&&(l=t,k=k||t)),m=p>l?p-1:p?l:t,k=k>p&&p?p-2:k-1,r=(s<'0'?'-':'')+s.slice(k,m),(p&&m>p?m-p:0)+(r!=s?' '+r:''))

कम गोल्फ वाला

f=s=>
(
  // All values are position base 1, so that 0 means 'missing'
  // k position of first nonzero digit
  // l position of last non zero digit
  // p position of decimal point
  // t string length
  l=k=p=t=0,
  // Analyze input string
  [...s].map((c,i)=>c=>++t&&c=='.'?p=t:+c&&(l=t,k=k||t)),
  // m position of last digits in output
  // if the point is after the last nz digit, must keep the digits up to before the point
  // else if point found, keep  up to l, else it's a integer: keep all
  m=p>l?p-1:p?l:t,
  // the start is the first nonzero digit for an integer
  // but if there is a point must be at least 1 char before the point
  k=k>p&&p?p-2:k-1,
  // almost found result : original string from k to m
  r=(s<'0'?'-':'')+s.slice(k,m), // but eventually prepend a minus
  (p&&m>p?m-p:0) // number of decimal digits
  +(r!=s?' '+r:'') // append the result if it's different from input
)

परीक्षा

F=s=>(l=k=p=t=0,[...s].map(c=>++t&&c=='.'?p=t:+c&&(l=t,k=k||t)),m=p>l?p-1:p?l:t,k=k>p&&p?p-2:k-1,r=(s<'0'?'-':'')+s.slice(k,m),(p&&m>p?m-p:0)+(r!=s?' '+r:''))

console.log=x=>O.textContent+=x+'\n';
// Test cases  
;[['-12.32','2'],['32','0'],['3231.432','3'],['-34.0','0 -34']
 ,['023','0 23'],['00324.230','2 324.23'],['10','0'],['00.3','1 0.3']
 ,['0','0'],['-0','0'],['-04.8330','3 -4.833']]
.forEach(t=>{
  var i=t[0],k=t[1],r=F(i);
  console.log((k==r?'OK ':'KO ')+i+' -> '+r)})

function test(){var i=I.value,r=F(i);R.textContent=r;}
test()

input { width:90% }
input,span { font-family: sans-serif; font-size:14px }

Input: <input id=I oninput='test()' value='-000000098765432112345.67898765432100000'>
Output: <span id=R></span><br>
Test cases<br>
<pre id=O></pre>

Comments

मेरा और आपके उत्तर दोनों की तरह -0इनपुट के साथ समस्याएँ हैं .. हमें आउटपुट चाहिए 0, नहीं0 0

— Fez Vrasta

हां, इंगित करने के लिए धन्यवाद

— edc65

@FezVrasta ने तय किया

— edc65

क्या c=='.'?p=t:+c&&(l=t,k=k||t)आप एक बाइट को बचाने के लिए काम करता है ?

— नील १

मुझे लगता है कि आप का उपयोग करके कुछ अधिक को बचाने के लिए सक्षम हो सकता है t=l=k=p=0और ++t&&c=='.'आदि

— नील

Answer 5

ईएस 6, 102 180 177 बाइट्स

s=>(t=s.replace(/(-?)0*(\d+(.\d*[1-9])?).*/,"$1$2"),d=t.length,d-=1+t.indexOf('.')||d,t!=s?d+' '+t:d)

s=>{t=[...s];for(m=t[0]<'0';t[+m]==0&&t[m+1]>'.';)t[m++]='';r=l=t.length;for(r-=1+t.indexOf('.')||l;t[--l]<1&&r;r--)t[l]='';t[l]<'0'?t[l]='':0;t=t.join``;return t!=s?r+' '+t:r}

संपादित करें: सहेजे गए 3 बाइट्स @ edc65 के लिए धन्यवाद; सम्मिलन के लिए धन्यवाद 1 बाइट बचाया।

Comments

विभाजन के बजाय प्रसार की कोशिश करेंt=[...s]

— edc65

@ edc65 मैं इसे फिर से लिखने के बाद इसे वापस गोल्फ के लिए कोशिश कर रहा उम्र बिताता हूं और आप एक फ्लैश में 3 बाइट बचाने के लिए जाते हैं ...

— नील

मुझे लगता है कि आप 1 बाइट बचा सकते हैं : t[--l]==0साथ बदलें t[--l]<1।

— २०:४here में

@insertusernamehere धन्यवाद!

— नील

Answer 6

सी ++, 180 बाइट्स

int f(char*s,char*&p){int m=*s=='-',n=0;for(p=s+m;*p=='0';++p);for(;*++s-'.'&&*s;);p-=p==s;if(*s){for(;*++s;)++n;for(;*--s=='0';--n)*s=0;*s*=n>0;}if(m&&*p-'0'|n)*--p='-';return n;}

यह पोर्टेबल C ++ है, जो चरित्र एन्कोडिंग की कोई धारणा नहीं बनाता है, और इसमें कोई लाइब्रेरी (मानक लाइब्रेरी भी नहीं) शामिल है।

इनपुट में पारित हो जाता है s। दशमलव स्थानों की संख्या वापस आ गई है; स्ट्रिंग को जगह में संशोधित किया गया है और नई शुरुआत को वापस लौटा दिया गया है p।

अधिकारों से, मुझे वापस लौट जाना चाहिए size_t, लेकिन इसके बजाय मैं यह दावा करने जा रहा हूं कि आपको इसे एक ओएस के लिए संकलित करना चाहिए जो स्ट्रिंग्स के आकार को आधा की सीमा तक सीमित करता है int। मुझे लगता है कि यह उचित है; यह 32-बिट आर्किटेक्चर पर 2 बिलियन से अधिक दशमलव स्थानों की गणना करता है।

व्याख्या

int f(char*s, char*&p){
    int m=*s=='-', n=0;
    for(p=s+m;*p=='0';++p);     // trim leading zeros
    for(;*++s-'.'&&*s;);        // advance to decimal point
    p-=p==s;                    // back up if all zeros before point
    if(*s){
        for(;*++s;)++n;          // count decimal places
        for(;*--s=='0';--n)*s=0; // back up and null out trailing zeros
        *s*=n>0;                 // don't end with a decimal point
    }
    if(m&&*p-'0'|n)*--p='-';    // reinstate negative sign
    return n;
}

परीक्षण कार्यक्रम

#include <cstring>
#include <cstdio>
int main(int argc, char **argv)
{
    for (int i = 1;  i < argc;  ++i) {
        char buf[200];
        strcpy(buf, argv[i]);
        char *s;
        int n = f(buf, s);
        printf("%10s ==> %-10s (%d dp)\n", argv[i], s, n);
    }
}

परीक्षण उत्पादन

    -12.32 ==> -12.32     (2 dp)
        32 ==> 32         (0 dp)
  3231.432 ==> 3231.432   (3 dp)
     -34.0 ==> -34        (0 dp)
       023 ==> 23         (0 dp)
 00324.230 ==> 324.23     (2 dp)
        10 ==> 10         (0 dp)
      00.3 ==> 0.3        (1 dp)
  -04.8330 ==> -4.833     (3 dp)
    -00.00 ==> 0          (0 dp)
       -00 ==> 0          (0 dp)
       000 ==> 0          (0 dp)
      0.00 ==> 0          (0 dp)
      -0.3 ==> -0.3       (1 dp)
         5 ==> 5          (0 dp)
        -5 ==> -5         (0 dp)