Mở đầu:

Tôi muốn đào tạo các trường hợp thử nghiệm, vì vậy tôi sẽ thử chúng trên một cái gì đó dễ dàng.

Thử thách:

Lấy bất kỳ đầu vào (chuỗi) đã cho nào (trong phạm vi ASCII có thể nhìn thấy) và suy luận nếu đó là một số và xuất ra thứ gì đó có thể được sử dụng để đánh giá.

Quy tắc:

• Một số sẽ chỉ chứa các ký tự -0123456789,.
• Câu trả lời chỉ được yêu cầu để nhận ra các số trong khoảng từ -1000000000 đến 1000000000 (độc quyền), nhưng có thể nhận ra các số lớn tùy ý.
• Bạn có thể viết một chương trình đầy đủ hoặc một chức năng.
• Nếu một số, trả về bất cứ thứ gì có thể được sử dụng để phân biệt nó và ghi lại đầu ra trong mô tả (ví dụ My program outputs T if a number, F if not.).
• Đầu vào sẽ là bất kỳ số lượng ký tự nào trong phạm vi ASCII hoặc trống (nếu trống trả về bất cứ thứ gì bạn xuất nếu không phải là số).
• Các số có thể bao gồm một dấu thập phân (ví dụ 3.14). Nếu họ làm như vậy, họ phải có ít nhất một chữ số trước dấu thập phân và ít nhất một chữ số sau nó.
• Các số có thể có các số 0 đứng đầu hoặc cuối (ví dụ 000001.00000).
• Phần nguyên của một số có thể được chia để dễ đọc thành các phần có ba chữ số bằng dấu phẩy (ví dụ 1,000.23456). Trong trường hợp này, họ phải được chia mỗi ba chữ số từ phải sang trái (ví dụ. 1,234,567, 10,000.202, 123,234.00, 0,123.293).
• Số âm được chỉ định bởi một hàng đầu -(ví dụ -1.23). +Không được phép dẫn đến số dương, và sẽ dẫn đến kết quả đầu ra sai lệch.
• Các ngoại lệ KHÔNG được tính là đầu ra hợp lệ và rõ ràng (trừ khi chúng có thể chuyển đầu ra cho luồng ra ngoài tiêu chuẩn (ví dụ: Exception on line N [...]có thể được đưa vào làm đầu ra cho một số / số không nếu chuỗi được đưa vào luồng ra ngoài tiêu chuẩn.

Các trường hợp thử nghiệm:

(giả sử My program outputs T if a number, F if not.phiên bản)

123 -> T [on integer]
-123 -> T [negative numbers need to be handled]
0 -> T [on zero]
123.456 -> T [on floating point]
123,456.789 -> T [on evenly divided by 3 digits with comas]
123456789 -> T [thousand separators are not required]
0000001.00000 -> T [on leading/trailing zeros]
00.00 -> T [on zero and leading/trailing zeros]
999999999.9999999999999999999999999999999999999999999999999999 -> T [on close to the maximum value]
-999999999.9999999999999999999999999999999999999999999999999999 -> T [on close to the minimum value]
 -> F [on empty]
lolz -> F [on non-number value]
n4melyh4xor -> F [on non-number with digits]
  1.2 -> F [on space-padded]
9.3 1.3 -> F [on anyhow separated multiple numbers]
1e5 -> F [no scientific notation]
50cl05e.buty3ts0f4r -> F [on input with letters obscuring the number]
1,2,3,4.5678 -> F [on badly readability-divided number]
1,234.5,678 -> F [on readability-divided floating point part]
.234 -> F [on no leading zero]
+1 -> F [no leading + sign]
1.234.3 -> F [only one decimal point]
12345,678 -> F [on separator stopping mid-way]

code-golf , ít nhân vật nhất là người chiến thắng.

Võng mạc , 28 29 31 40 34 byte

^-?\d{1,3}((,\d{3})*|\d*)(\.\d+)?$

Đầu ra 1nếu trung thực, 0nếu không. Theo tôi hiểu, trong trường hợp này, Retina xuất ra số lượng kết quả khớp với biểu thức chính quy trên đầu vào.

Hãy thử trực tuyến!

Phòng thử nghiệm

Chỉnh sửa

• Đã sửa lỗi tuân thủ quy tắc "nên có chữ số sau vị trí thập phân"
• Đã sửa lỗi tuân thủ quy tắc "xử lý phủ định"
• Đã sửa để tuân thủ các dấu phẩy tùy chọn
• Đã sửa lỗi với hàng ngàn dấu phân cách như ghi chú của @MartinEnder
• Chơi golf bằng cách loại bỏ cái nhìn có điều kiện

Lập kế hoạch

^-?\d{1,3}((,\d{3})*|\d*)(\.\d+)?$
^                                $  This marks the start and end of regex
 -?                                 Optional hyphen for negative number
   \d{1,3}                          Matches between 1 and 3 digits
          (             )           Capturing group
           (,\d{3})*                 Matches at least zero of comma and three numbers (in the case of separators)
                    |                OR
                     \d*             Matches at least zero digits (in the case of no separators)
                        (\.\d+)?    Matches an optional . and at least one digit (for decimal numbers)

JavaScript, 46 49 byte

Đây là một cổng trực tiếp của câu trả lời Retina của tôi. Lý do duy nhất tôi sử dụng JS là để có một cách dễ dàng để kiểm tra regex bằng cách sử dụng Đoạn trích bên dưới

f=s=>/^-?\d{1,3}((,\d{3})*|\d*)(\.\d+)?$/.test(s)

f=s=>/^-?\d{1,3}((,\d{3})*|\d*)(\.\d+)?$/.test(s)

<input oninput=p.innerText=f(value)><p id=p></p>

Perl 6 , 42 byte

{?/^\-?[\d**1..3[\,\d**3]+|\d+][\.\d+]?$/}

Thử nó

Mở rộng:

{  # bare block lambda with implicit parameter ｢$_｣

  ? # turn the following into a Bool result

  /  # match implicitly against ｢$_｣

    ^                 # beginning of string

    \- ?              # optional leading ｢-｣

    [

      \d ** 1..3      # 1 to 3 digits
      [
        \,            # comma
        \d ** 3       # three digits
      ]+              # repeat at least once

    |                 # or

      \d+             # at least one digit

    ]

    [ \. \d+ ]?       # ｢.｣ followed by at least one digit optionally

    $  # end of string

  /
}

PHP, 62 byte

<?=preg_match("#^-?(\d+|\d{1,3}(,\d{3})*)(\.\d+)?$",$argv[1]);

Nội dung không thể xử lý dấu phẩy và nó chấp nhận ký hiệu khoa học; Vì vậy, tôi đã phải đi bộ theo cách regex. <?=is_numeric($argv[1]);sẽ có 24 byte.

công cụ bash / Unix, 64 byte

egrep -c '^-?([0-9]+|[0-9]{1,3}(,[0-9]{3})+)(\.[0-9]+)?$'<<<"$1"

Lưu tệp này dưới dạng tệp và truyền chuỗi cần kiểm tra làm đối số đầu tiên cho lệnh.

Đầu ra là 0 cho một số không, 1 cho một số.

Nếu bạn sẵn sàng chấp nhận đầu vào từ stdin và nếu bạn có thể đảm bảo rằng đầu vào chỉ bao gồm một dòng, thì bạn có thể xóa <<< "$ 1" ở cuối, dẫn đến 57 byte .

Đối với bản thân mã, tùy chọn -c to egrep đếm số lượng các dòng khớp (sẽ là 0 hoặc 1).

Pyth, 25 ký tự

:zCiCM"૧򡊪񛨮򶟉񠫊򆻛񓰚祥񯯏󪬡򢝉񁘍񲲂쪤"^T6

Nén regex của Kritixi Lithos .

Hãy thử trực tuyến. Sử dụng các ký tự Unicode bên ngoài Mặt phẳng đa ngôn ngữ cơ bản, mà TIO dường như không thể xử lý? Ứng dụng nhỏ này báo cáo kích thước sai cho chuỗi, mặc dù. Bộ đếm ký tự / byte này làm cho nó đúng.

C89, 195 byte

b,d,c,i;f(char*s){b=*s;for(d=c=i=0;i++,*(s++),d+=*s=='.',c+=*s==',',b=c?i&(i%4!=3)&*s==','?0:b:b;)if(*s==45&!i);else if((*s==32)|(*s==46)|*s==43|!isdigit(*s)&*s!=46&*s!=44)||!(d-1))b=0;return b;}

Ung dung:

bool is_base10_number (const char* const str) {

  if(!str[0])return false;

  size_t
    dpts = 0,
    cmas = 0;

  for (size_t i = 0; i < strlen(str); i++) {

    if ((str[i] == '-') && (!i)){
      continue;
    }

    if (
      (str[i] == ' ')
      || (str[0] == '.')
      || (str[0] == '+')
      ||
      (
        (!isdigit(str[i]))
        && (str[i] != '.')
        && (str[i] != ',')
      )
    ) {
      return false;
    }

    dpts += str[i] == '.';
    cmas += str[i] == ',';

    if (cmas) {
      if (i & ((i % 4) != 3) & str[i] == ',') {
        return false;
      }
    }

  }

  if (dpts > 1) { return false; }

  return true;
}

Python 2, 79 byte

Giải pháp Regex

import re
lambda s:[s]==re.findall('-?(?:\d{1,3}(?:,\d{3}\d+)(?:\.?\d+)?',s)


-?                                          | Starts with 0-1 dashes
  (?:\d{1,3}(?:,\d{3})+                     | Have 1-3 digits and 1+ (comma followed by 3 digits)
                       |\d+)                | or 1+ digits
                            (?:\.?\d+)?     | Ends with dot and 1+ digits or nothing

Dùng thử trực tuyến

c #, 75 byte

bool t(string n){double v;return double.TryParse(n.Replace(",",""),out v);}