Dalam tantangan ini, Anda akan menulis sebuah program untuk menampilkan berapa banyak tempat desimal dalam string input dan memangkas input jika diperlukan.

Contohnya

-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

Aturan

• Input akan berupa string yang dapat diambil melalui, STDIN, argumen fungsi atau yang setara terdekat
• Output dapat melalui pengembalian fungsi, STDOUT, atau yang setara terdekat.
• Tidak ada batasan ukuran untuk bilangan bulat input kecuali untuk panjang string maksimum bahasa Anda .
• Jika input memiliki nol yang tidak perlu (memimpin atau mengikuti):
  1. Anda harus mengeluarkannya
  2. Keluarkan jumlah tempat desimal di angka baru
  3. Keluarkan nomor baru yang dipisahkan oleh pemisah (mis. Spasi, baris baru, koma)
• Input akan selalu cocok dengan RegEx ini:, -?\d+(\.\d+)?atau jika Anda tidak berbicara RegEx :
  • Ada bisa menjadi -di awal menyiratkan angka negatif. Maka akan ada setidaknya satu digit. Maka mungkin ada ... a .dan beberapa digit lagi.
  • Untuk memeriksa apakah input valid, periksa di sini
• Tidak Ada Regex

Ini adalah kode-golf sehingga kode terpendek dalam byte menang

PHP 7, 142 byte

Saya entah bagaimana berhasil memeras semuanya menjadi satu pernyataan cetak:

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

Berjalan dari baris perintah, seperti:

$ php trimandcount.php "-04833.010"

Demo

Lihat semua kasus uji termasuk yang sangat panjang (62 karakter) beraksi:

Coba sebelum membeli ¹

_{¹ Arahkan kursor ke kotak di bawah " Output for 7.0.0 " untuk melihat semua hasil.}

Python 2, 165 180 byte

Pada awalnya saya berpikir tentang menulis program Pyth pertama saya, mendapatkannya menghitung angka setelah koma potensial. Tapi kemudian saya merasa sangat kesal, saya tidak tahu bagaimana Anda akan menikmati bahasa itu, kira itu hanya untuk tujuan kemenangan. Bagaimanapun, inilah solusi saya (diedit karena tidak berfungsi untuk jumlah besar):

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

Seandainya ada orang yang ingin membangun karya saya di Pyth: ~b@+cz"."" "1Wq@b_1"0"~b<b_1)plrb6Untuk melihat di mana Anda berada, Anda mungkin ingin menyisipkan ap di antaranya @+.

05AB1E , 23 byte (tidak kompetitif)

Sial, aku sudah sangat dekat. Python mem-parsing pelampung yang sangat besar menggunakan notasi ilmiah, jadi saya memperbaiki bug ini pada interpreter. Namun, ini dilakukan setelah tantangan dan pengajuan saya karena itu tidak kompetitif.

Kode:

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

Penjelasan:

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

Menggunakan penyandian ISO 8859-1 .

JavaScript (ES6), 156 162

Sunting Fixed bug untuk '-0' - thx @Fez Vrasta Edit 2 6 byte disimpan thx @Neil

Ini berantakan, tetapi 100% berbasis string - tidak ada batasan karena tipe numerik

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:''))

Kurang golf

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
)

Uji

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>

ES6, 102 180 177 byte

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}

Sunting: Disimpan 3 byte berkat @ edc65; disimpan 1 byte berkat insertusername di sini.

C ++, 180 byte

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;}

Ini adalah C ++ portabel, yang tidak membuat asumsi pengkodean karakter, dan tidak menyertakan pustaka (bahkan Pustaka Standar).

Input diteruskan s. Jumlah tempat desimal dikembalikan; string dimodifikasi di tempat dan awal baru dikembalikan p.

Secara hak, saya harus mengembalikan a size_t, tetapi sebaliknya saya akan mengklaim bahwa Anda harus mengkompilasi ini untuk OS yang membatasi ukuran string hingga setengah kisaran int. Saya pikir itu masuk akal; itu menghitung lebih dari 2 miliar tempat desimal pada arsitektur 32-bit.

Penjelasan

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;
}

Program uji

#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);
    }
}

Uji keluaran

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