Trong thử thách này, bạn sẽ viết một chương trình để xuất ra bao nhiêu vị trí thập phân trong chuỗi đầu vào và cắt đầu vào nếu cần.

Ví dụ

-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

Quy tắc

• Đầu vào sẽ là một chuỗi có thể được đưa qua, STDIN, đối số hàm hoặc tương đương gần nhất
• Đầu ra có thể thông qua trả về hàm, STDOUT hoặc tương đương gần nhất.
• Không có giới hạn về kích thước cho số nguyên đầu vào ngoại trừ độ dài chuỗi tối đa của ngôn ngữ của bạn .
• Nếu đầu vào có bất kỳ số không cần thiết (dẫn hoặc theo dõi) nào:
  1. Bạn nên đưa họ ra ngoài
  2. Xuất số lượng vị trí thập phân trong số mới
  3. Xuất số mới được phân tách bằng dấu phân cách (ví dụ: dấu cách, dòng mới, dấu phẩy)
• Đầu vào sẽ luôn khớp với RegEx này: -?\d+(\.\d+)?hoặc nếu bạn không nói RegEx :
  • Có thể có một -lúc đầu ngụ ý một số âm. Sau đó sẽ có ít nhất một chữ số. Sau đó, có thể có ... một .và một số chữ số nữa.
  • Để kiểm tra xem đầu vào có hợp lệ không, kiểm tra tại đây
• Không có chính quy

Đây là mã golf để mã ngắn nhất tính theo byte thắng

PHP 7, 142 byte

Tôi bằng cách nào đó đã xoay sở để ép mọi thứ vào một câu lệnh in duy nhất:

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

Chạy từ dòng lệnh, như:

$ php trimandcount.php "-04833.010"

Bản giới thiệu

Xem tất cả các trường hợp thử nghiệm bao gồm một trường hợp rất dài (62 ký tự) đang hoạt động:

Hãy thử trước khi mua ¹

_{¹ Di chuột qua hộp bên dưới " Đầu ra cho 7.0.0 " để xem tất cả kết quả.}

Python 2, 165 180 byte

Lúc đầu, tôi đã suy nghĩ về việc viết chương trình Pyth đầu tiên của mình, để nó đếm các chữ số sau dấu phẩy tiềm năng. Nhưng sau đó tôi khá bực mình, tôi không biết bạn thích ngôn ngữ đó như thế nào, đoán nó chỉ nhằm mục đích chiến thắng. Dù sao đây là giải pháp của tôi (được chỉnh sửa vì nó không hoạt động với số lượng lớn):

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

Trong trường hợp bất kỳ ai muốn xây dựng công việc của tôi ở Pyth: ~b@+cz"."" "1Wq@b_1"0"~b<b_1)plrb6Để xem bạn đang ở đâu, bạn có thể muốn chèn ap giữa @+.

05AB1E , 23 byte (không cạnh tranh)

Chết tiệt, tôi đã rất gần. Python phân tích các float rất lớn bằng cách sử dụng ký hiệu khoa học, vì vậy tôi đã sửa lỗi này trong trình thông dịch. Tuy nhiên, điều này đã được thực hiện sau thử thách và do đó trình của tôi là không cạnh tranh.

Mã số:

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

Giải trình:

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

Sử dụng mã hóa ISO 8859-1 .

JavaScript (ES6), 156 162

Chỉnh sửa lỗi đã sửa cho '-0' - thx @Fez Vrasta Chỉnh sửa 2 6 byte đã lưu thx @Neil

Đó là một mớ hỗn độn, nhưng nó dựa trên chuỗi 100% - không giới hạn do các loại số

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

Ít chơi gôn

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
)

Kiểm tra

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}

Chỉnh sửa: Đã lưu 3 byte nhờ @ edc65; đã lưu 1 byte nhờ insertusernamehere.

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

Đây là C ++ di động, không giả định mã hóa ký tự và không bao gồm các thư viện (thậm chí không phải Thư viện chuẩn).

Đầu vào được thông qua s. Số lượng vị trí thập phân được trả về; chuỗi được sửa đổi tại chỗ và bắt đầu mới được trả lại p.

Theo quyền, tôi nên trả lại một size_t, nhưng thay vào đó tôi sẽ tuyên bố rằng bạn nên biên dịch điều này cho một hệ điều hành giới hạn kích thước của chuỗi xuống một nửa phạm vi int. Tôi nghĩ đó là hợp lý; nó đếm hơn 2 tỷ vị trí thập phân trên các kiến ​​trúc 32 bit.

Giải trình

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

Chương trình kiểm tra

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

Kiểm tra đầu ra

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