Lấy cảm hứng từ những cảnh "câu lạc bộ ba dấu phẩy" của Thung lũng Silicon, như thế này , trong thử thách này, bạn sẽ nói với mười người "câu lạc bộ dấu phẩy" mà mỗi người thuộc về họ.

Nếu bạn không quen thuộc với cụm từ "câu lạc bộ dấu phẩy", hãy để tôi giải thích: bạn đang ở trong câu lạc bộ một dấu phẩy nếu số tiền bạn có trong phạm vi bao gồm $ 1.000,00 đến $ 999.999,99; bạn đang ở trong câu lạc bộ hai dấu phẩy nếu trong phạm vi $ 1.000.000,00 đến $ 999.999.999,99; những "câu lạc bộ" này lặp lại thông qua câu lạc bộ ba dấu phẩy, vì không có cá nhân nào trên Trái đất (AFAIK) sở hữu hơn một nghìn tỷ đô la Mỹ (Yên Nhật sẽ là một câu chuyện khác rất nhanh). Vì vậy, số dấu phẩy mà tài khoản ngân hàng của bạn có, theo các tiêu chuẩn ký hiệu phổ biến nhất ở Hoa Kỳ và Vương quốc Anh, biểu thị câu lạc bộ dấu phẩy mà bạn thuộc về. Các quy tắc "dấu phẩy" tương tự áp dụng cho các số âm (mặc dù bạn không muốn ở trong câu lạc bộ dấu phẩy âm): số âm trong phạm vi bao gồm [-0,01, -999.

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

Friend    Amount
John      100000
Jamie     0.05
Kylie     1549001.10
Laura     999999999.99
Russ      986000000
Karla     1
Reid      99.99
Mark      999.99
Manson    1000.01
Lonnie    999999999999.00
Nelly     -123.45

Câu trả lời đúng:

John is in the 1-comma club.
Jamie is in the 0-comma club.
Kylie is in the 2-comma club.
Laura is in the 2-comma club.
Russ is in the 2-comma club.
Karla is in the 0-comma club.
Reid is in the 0-comma club.
Mark is in the 0-comma club.
Manson is in the 1-comma club.
Lonnie is in the 3-comma club.
Nelly is in the 0-comma club.

Bất kỳ thiết lập mảng nào bạn cần để có được một friendsmảng và amountsmảng không được tính vào điểm số của bạn. Vì vậy, đối với Python, đoạn mã sau không được tính:

f = ['John', 'Jamie', 'Kylie', 'Laura', 'Russ', 'Karla', 'Reid', 'Mark', 'Manson', 'Lonnie']
a = ['100000', '0.05', '1549001.10', '999999999.99', '986000000', '1', '99.99', '999.99', '1000.01', '999999999999.00']

Chỉnh sửa: Vui lòng xem các trường hợp thử nghiệm sửa đổi

Tôi đã xóa các dấu phẩy chuỗi thực tế khỏi các trường hợp thử nghiệm để làm cho mọi thứ khó khăn hơn một chút, trái ngược với việc chỉ đếm các dấu phẩy.

JavaScript (ES6), 80 byte

a=>a.map(([s,n])=>s+` is in the ${n.toFixed(n<0?3:4).length/3-2|0}-comma club.`)

Lấy một mảng các mảng [friend, lượng] và trả về một mảng "friend nằm trong câu lạc bộ n-comma". dây. Hoạt động bằng cách thêm các số 0 ở cuối để độ dài là 6-8 cho câu lạc bộ 0 dấu phẩy, 9-11 cho câu lạc bộ 1 dấu phẩy, 12-15 cho câu lạc bộ 2 dấu phẩy, v.v.

https://jsfiddle.net/cau40vmk/1/

PostgreSQL, 61 byte

SELECT f||' is in the '||div(log(@a),3)||'-comma club.'FROM p

@xlà giá trị tuyệt đối của x, log(x)là logarit cơ số 10 và div(y, x)tính thương số nguyên của y / x.

Thiết lập:

CREATE TEMP TABLE p AS
SELECT * FROM (VALUES
    ('John', 100000),
    ('Jamie', 0.05),
    ('Kylie', 1549001.10),
    ('Laura', 999999999.99),
    ('Russ', 986000000),
    ('Karla', 1),
    ('Reid', 99.99),
    ('Mark', 999.99),
    ('Manson', 1000.01),
    ('Lonnie', 999999999999.00),
    ('Nelly', -123.45)
) AS p (f, a)

Đầu ra:

            ?column?            
--------------------------------
 John is in the 1-comma club.
 Jamie is in the 0-comma club.
 Kylie is in the 2-comma club.
 Laura is in the 2-comma club.
 Russ is in the 2-comma club.
 Karla is in the 0-comma club.
 Reid is in the 0-comma club.
 Mark is in the 0-comma club.
 Manson is in the 1-comma club.
 Lonnie is in the 3-comma club.
 Nelly is in the 0-comma club.
(11 rows)

Thạch , 34  32 byte

AḞbȷL’⁶;“£ṙƬs⁾`¬ụṂ“¢<ỴȦ8£l»jµ€⁹żY

Một liên kết dyadic (hàm) lấy danh sách số dư ngân hàng dưới dạng số (số thập phân / số nguyên) và danh sách tên dưới dạng chuỗi và trả về danh sách chuỗi.

Hãy thử trực tuyến! - chân trangçYchỉ đơn giản gọi hàm và tham gia danh sách kết quả với nguồn cấp dữ liệu để nó có đầu ra đẹp khi chạy dưới dạng chương trình đầy đủ.

Làm sao?

AḞbȷL’⁶;“£ṙƬs⁾`¬ụṂ“¢<ỴȦ8£l»jµ€⁹żY - Main link: bankBalances, names
                             €    - for each bankBalance:
A                                 - absolute value (treat negatives and positives the same)
 Ḟ                                - floor (get rid of any pennies)
  bȷ                              - convert to base 1000
    L                             - length (number of digits in base 1000)
     ’                            - decrement by one
      ⁶;                          - concatenate a space with that   ...because -------.
        “         “       »       - compressed list of strings:                       ↓
         £ṙƬs⁾`¬ụṂ                -     " is in the"  ← cannot compress a trailing space :(
                   ¢<ỴȦ8£l        -     "-comma club."
                           j      - join that list of strings with the "number plus space"
                            µ     - monadic chain separation (call that result L)
                              ⁹   - right argument (names)
                               ż  - zip with L

PHP, 76 74 byte

// data as associative array
$d=[Poorman=>-1234,John=>100000,Jamie=>0.05,Kylie=>1549001.10,Laura=>999999999.99,Russ=>1000000000,Karla=>1,Reid=>99.99,Mark=>999.99,Manson=>1000.01,Lonnie=>999999999999.00];
// code
foreach($d as$n=>$a)printf("$n is in the %d-comma club.
",log($a*$a,1e6));

May mắn thay, tôi không thể chuyển sang int (như tôi sẽ phải làm trong C); PHP làm điều đó ngầm cho %d.

Toán học (86 byte)

Thiết lập (với tên là chuỗi, tiền là số):

n = {"John", "Jamie", "Kylie", "Laura", "Russ", "Karla", "Reid", "Mark", "Manson", "Lonnie", "Nelly"};
m = {100000, 0.05, 1549001.10, 999999999.99, 1000000000, 1, 99.99, 999.99, 1000.01, 999999999999.00, -123.45}

Nỗ lực:

MapThread[#~~" is in the "~~ToString@Max[Floor@Log[10^3,#2],0]~~"-comma club."&,{n,m}]

Tất cả các hàm chuỗi của Mathicala bao gồm "Chuỗi" trong tên, vì vậy tôi nghĩ rằng các bản ghi ngắn hơn. Các Max[...,0]là để đối phó với những con số pesky tiêu cực hay tiêu cực vô cùng cho những người sở hữu giữa -1 và 1 đô la. Nhật ký của một số âm bao gồm các công cụ tưởng tượng, nhưng Mathicala hữu ích bỏ qua điều đó khi lấy a Floor!

Japt , 36 byte

Điều này có số lượng là đầu vào đầu tiên, tên là thứ hai.

V+`   e {w0 x4 l /3-2|0}-¬mµ club

Giải trình

V+`   e {w0 x4 l /3-2|0}-¬mµ club
V+                                   // Second input +
  `                                  // compressed string:
      e                              // " is in the " 
        {              }             // Insert here:
         w0                          //   The larger of 0 and the first input
            x4                       //   Rounded to the 4th decimal
               l                     //   Length
                        -¬mµ club    // "-comma club"
                                     // A closing backtick is auto-inserted at the end of the program

Japt sử dụng thư viện shoco để nén chuỗi.

Lấy cảm hứng từ giải pháp của @ Neil .

Đã lưu 7 byte nhờ @ETHproductions

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

MATL, 50 48 43 byte

`j' is in the 'i|kVn3/XkqV'-comma club'&hDT

Dùng thử tại MATL Online

Giải trình

`                   % Do...While loop
  j                 % Explicitly grab the next input as a string
  ' is in the the ' % Push this string literal to the stack
  i                 % Grab the next input as a number
  |                 % Compute the absolute value
  k                 % Round towards zero
  V                 % Convert to a string
  n3/Xk             % Divide the length of the string by 3 and round up
  q                 % Subtract one
  V                 % Convert to a string
  '-comma club'     % Push this string literal to the stack
  &h                % Horizontally concatenate the entire stack
  D                 % Display the resulting string
  T                 % Push TRUE to the stack, causing an infinite loop which automatically
                    % terminates when we run out of inputs
                    % Implicit end of do...while loop

R, 68 byte

Các thiết lập:

f <- c('John', 'Jamie', 'Kylie', 'Laura', 'Russ', 'Karla', 'Reid', 'Mark', 'Manson', 'Lonnie', 'Nelly')
a <- c(100000, 0.05, 1549001.10, 999999999.99, 986000000, 1, 99.99, 999.99, 1000.01, 999999999999.00, -123.45)

Giải pháp:

cat(paste0(f, " is in the ",floor(log10(abs(a))/3)),"-comma club.\n"))

Lấy nhật ký cơ sở 10 của giá trị tuyệt đối của tài khoản, làm tròn xuống sau đó in với tên.

Tôi không chắc nó có thể nhỏ hơn nếu alà vectơ nhân vật ...

JavaScript, 59 byte

Đã lưu 3 byte nhờ @ETHproductions

Đã lưu 2 byte nhờ @Cyoce

n=>m=>n+` is in the ${m>1?Math.log10(m)/3|0:0}-comma club.`

Bản giới thiệu

f=n=>m=>n+` is in the ${m>1?Math.log10(m)/3|0:0}-comma club.`

console.log((f("John")(100000)))
console.log((f("Jamie")(0.05)))
console.log((f("Kylie")(1549001.10)))
console.log((f("Laura")(999999999.99)))
console.log((f("Russ")(986000000)))
console.log((f("Karla")(1)))
console.log((f("Reid")(99.99)))
console.log((f("Mark")(999.99)))
console.log((f("Manson")(1000.01)))
console.log((f("Lonnie")(999999999999.00)))
console.log((f("Nelly")(-123.45)))

Vim, 72 byte

:%s;\v +\-=(\d+).*;\=' is in the '.(len(submatch(1))-1)/3.' comma club'

Bằng cách nào đó tôi nên cho thấy rằng có một sự trở lại kéo dài, nhưng không chắc chắn làm thế nào. Đây chỉ là một câu trả lời regex cơ bản, mà tôi chắc chắn có thể bị đánh bại bởi bất kỳ ngôn ngữ regex nào. Tôi đã sử dụng V, nhưng tôi nghĩ rằng các lệnh thay thế trong V sử dụng /như một dấu phân tách theo mặc định và tôi không thể tìm ra cách làm cho nó không phàn nàn về sự phân chia.

Lấy đầu vào dưới dạng bảng của OP và trả về các giá trị dưới dạng bảng, nhưng với thông tin tài chính được thay thế bằng "nằm trong câu lạc bộ dấu phẩy X"

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

05AB1E , 32 byte

Äï€g3/î<“-comma†Ú“«“€ˆ€†€€ “ì‚ø»

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

Giải trình

Ä                                 # absolute value of input
 ï                                # convert to int
  €g                              # length of each
    3/                            # divided by 3
      î                           # round up
       <                          # decrement
        “-comma†Ú“«               # append string "-comma club" to each number
                   “€ˆ€†€€ “ì     # prepend string "is in the " to each number
                             ‚    # pair with second input
                              ø   # zip
                               »  # join by spaces and newlines

Python 2, 69 byte

Thiết lập mảng của chúng tôi:

n = ['John', 'Jamie', 'Kylie', 'Laura', 'Russ', 'Karla', 'Reid', 'Mark', 'Manson', 'Lonnie']
a = [100000, 0.05, 1549001.10, 999999999.99, 1000000000, 1, 99.99, 999.99, 1000.01, 999999999999.00]

Và chức năng của chúng ta có thể là:

f=lambda n,a:'%s is in %s comma club'%(n,min(3,(len(str(int(a)))/3)))

Cho chúng tôi:

>>> [f(x,y) for x,y in zip(n,a)]
['John is in 2 comma club', 'Jamie is in 0 comma club', 'Kylie is in 2 comma club', 'Laura is in 3 comma club', 'Russ is in 3 comma club', 'Karla is in 0 comma club', 'Reid is in 0 comma club', 'Mark is in 1 comma club', 'Manson is in 1 comma club', 'Lonnie is in 3 comma club']

Nếu mảng cần giống hệt với mảng được cung cấp trong câu hỏi, thì giải pháp có giá 76 byte:

f=lambda n,a:'%s is in %s comma club'%(n,min(3,(len(str(int(float(a))))/3)))

Powershell, 82 byte

$args[0]|%{$_[0]+" is in the "+(('{0:N}'-f$_[1]-split',').Count-1)+"-comma club."}

Giả sử đầu vào mảng 2D của

cc.ps1 @(@("John",100000),@("Jamie",0.05),@("Kylie",1549001.10),@("Laura",999999999.99),@("Russ",986000000),@("Karla",1),@("Reid",99.99),@("Mark",999.99),@("Manson",1000.01),@("Lonnie",999999999999.00),@("Nelly",-123.45))

Đầu ra là John is in the 1-comma club. Jamie is in the 0-comma club. Kylie is in the 2-comma club. Laura is in the 2-comma club. Russ is in the 2-comma club. Karla is in the 0-comma club. Reid is in the 0-comma club. Mark is in the 0-comma club. Manson is in the 1-comma club. Lonnie is in the 3-comma club. Nelly is in the 0-comma club.

Haskell, 71 byte

n#a=n++" is in the "++(show.truncate.logBase 1e3.abs$a)++"-comma club."

Xác định toán tử '#' cung cấp câu trả lời đúng. Ví dụ:

*Main> "John"#100000
"John is in the 1-comma club."

Thật không may, Haskell không có log10chức năng nhỏ gọn như nhiều ngôn ngữ khác, nhưng nó có logBasechức năng hữu ích , điều đó có nghĩa là chúng ta không cần chia câu trả lời của mình cho 3. Thật không may, logBase 1000 0.05là một số âm, vì vậy chúng ta cần sử dụng lâu hơntruncate hơn là floorđể làm tròn nó.

Chương trình đầy đủ bao gồm các trường hợp thử nghiệm:

(#) :: (RealFrac n, Floating n) => [Char] -> n -> [Char]
n#a=n++" is in the "++(show.truncate.logBase 1e3.abs$a)++"-comma club."

testCases = [
 ("John",      100000),
 ("Jamie",     0.05),
 ("Kylie",     1549001.10),
 ("Laura",     999999999.99),
 ("Russ",      986000000),
 ("Karla",     1),
 ("Reid",      99.99),
 ("Mark",      999.99),
 ("Manson",    1000.01),
 ("Lonnie",    999999999999.00),
 ("Nelly",     -123.45)]

main = putStrLn $ unlines $ map (uncurry (#)) testCases

Cho kết quả như sau:

John is in the 1-comma club.
Jamie is in the 0-comma club.
Kylie is in the 2-comma club.
Laura is in the 2-comma club.
Russ is in the 2-comma club.
Karla is in the 0-comma club.
Reid is in the 0-comma club.
Mark is in the 0-comma club.
Manson is in the 1-comma club.
Lonnie is in the 3-comma club.
Nelly is in the 0-comma club.

K, 66 byte

    /n is names and a is amounts
    n
    ("John";"Jamie";"Kylie";"Laura";"Russ";"Karla";"Reid";"Mark";"Manson";"Lonnie")
    a
    ("100000";"0.05";"1549001.10";"999999999.99";"1000000000";,"1";"99.99";"999.99";"1000.01";"999999999999.00")
    /the function
    {x," is in the ",($(#.q.cut[3;*"."\:y])-1)," comma club"}./:+(n;a)
    /output
    ("John is in the 1 comma club";"Jamie is in the 0 comma club";"Kylie is in the 2 comma club";"Laura is in the 2 comma club";"Russ is in the 3 comma club";"Karla is in the 0 comma club";"Reid is in the 0 comma club";"Mark is in the 0 comma club";"Manson is in the 1 comma club";"Lonnie is in the 3 comma club")

Python 2.7 , 89 86 84 byte

for g,b in zip(*input()):print g,'is in the',`(len('%d'%b)+~(b<0))/3`+'-comma club.'

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

Chương trình đầy đủ có một bộ gồm hai danh sách - tên dưới dạng chuỗi, số dư ngân hàng dưới dạng số - và in chuỗi kết quả.

C #, 125 byte

(p,n)=>{for(int x=0;x<p.Length;x++)Console.Write(p[x]+" is in the "+(n[x]<1e3?0:n[x]<1e6?1:n[x]<1e9?2:3)+"-comma club.\n");};

Hàm ẩn danh in kết quả theo định dạng của OP.

Chương trình đầy đủ với các trường hợp thử nghiệm:

using System;

class CommaClub
{
    static void Main()
    {
        Action<string[], double[]> f =
        (p,n)=>{for(int x=0;x<p.Length;x++)Console.Write(p[x]+" is in the "+(n[x]<1e3?0:n[x]<1e6?1:n[x]<1e9?2:3)+"-comma club.\n");};

        // test cases:
        string[] personArr = new[] {"John", "Jamie", "Kylie", "Laura", "Russ", "Karla", "Reid", "Mark", "Manson", "Lonnie", "Nelly"};
        double[] amountArr = new[] {100000, 0.05, 1549001.10, 999999999.99, 1000000000, 1, 99.99, 999.99, 1000.01, 999999999999.00, -123.45};
        f(personArr, amountArr);
    }
}

Python 3 ( 207 159 110 95 86 byte, nhờ @iwaseatenbyagrue)

Một chút thiết lập:

f = ['John', 'Jamie', 'Kylie', 'Laura', 'Russ', 'Karla', 'Reid', 'Mark', 'Manson', 'Lonnie', 'Nelly']
a = [100000, 0.05, 1549001.10, 999999999.99, 986000000, 1, 99.99, 999.99, 1000.01, 999999999999.00, -123.45]

Nỗ lực của tôi:

['%s is in the %d-comma club.'%(p,-(-len(str(int(abs(v))))//3)-1) for p,v in zip(f,a)]

Các kết quả:

['John is in the 1-comma club.', 'Jamie is in the 0-comma club.', 'Kylie is in the 2-comma club.', 'Laura is in the 2-comma club.', 'Russ is in the 2-comma club.', 'Karla is in the 0-comma club.', 'Reid is in the 0-comma club.', 'Mark is in the 0-comma club.', 'Manson is in the 1-comma club.', 'Lonnie is in the 3-comma club.', 'Nelly is in the 0-comma club.']

Chỉnh sửa: chuyển đổi mọi thứ thành giá trị tuyệt đối giúp tôi tiết kiệm 15 byte.

Perl 6, 107 95 byte

for @f {printf "%s is in the %d-comma club.\n",@f[$++],(abs(@a[$++].split(".")[0]).chars-1)/3;}

Không phải là công việc đáng tự hào nhất của tôi, hãy cho tôi ngẩng cao đầu nếu tôi quên bất kỳ kỹ thuật chơi gôn nào. EDIT: -12 byte nhờ @Ven

Python 2, 87 byte

for n,a in input():print n+' is in the %dd-comma club.'%'{:20,.2f}'.format(a).count(',')

Hơi cũ hơn (90 byte):

for n,a in input():print n+' is in the '+`'{:20,.2f}'.format(a).count(',')`+'-comma club.'

Đưa đầu vào dưới dạng danh sách các bộ dữ liệu (tên, số tiền).

Tôi đang làm điều này trên điện thoại của tôi ở trường nên tôi sẽ kiểm tra nó sau.

dc, 56 54 byte

[P[ is in the ]Pd*vdZrX-1-3/n[-comma club.]pstz0<g]sglgx

Cái này lấy đầu vào từ ngăn xếp, nên được tải sẵn tên đầu tiên ở đầu ngăn xếp, số thứ nhất, tên thứ hai, số thứ hai, v.v.

Dưới đây là một ví dụ về việc tải ngăn xếp và chạy macro, g:

#!/usr/bin/dc
_123.45         [Nelly]
999999999999.00 [Lonnie]
1000.01         [Manson]
999.99          [Mark]
99.99           [Reid]
1               [Karla]
986000000       [Russ]
999999999.99    [Laura]
1549001.10      [Kylie]
0.05            [Jamie]
100000          [John]
[P[ is in the ]Pd*v1/Z1-3/n[-comma club.]pstz0<g]sglgx

tạo ra đầu ra thông thường,

John is in the 1-comma club.
Jamie is in the 0-comma club.
Kylie is in the 2-comma club.
Laura is in the 2-comma club.
Russ is in the 2-comma club.
Karla is in the 0-comma club.
Reid is in the 0-comma club.
Mark is in the 0-comma club.
Manson is in the 1-comma club.
Lonnie is in the 3-comma club.
Nelly is in the 0-comma club.

Đây là một đoạn trích của mã:

[P[ is in the ]Pd*v1/Z-1-3/n[-comma club.]pstz0<g]sglgx

[                    # begin macro string
P                    # print and pop person name
[ is in the ]P       # print and pop ' is in the '
# Get absolute value of number by squaring and square root
d*v                  # d=dup, *=multiply, v=root
1/                   # 1/ truncates to integer since scale is 0
Z                    # Z=number length
1-3/n                # n=print and pop (#digits - 1)//3
[-comma club.]p      # print '-comma club.' and newline
st                   # pop '-comma club.' off stack into register t
z0<g                 # Do macro g if 0 is less than z=stack height
]                    # end macro string
sg                   # Save macro g
lgx                  # Load g and do its initial execution

Lưu ý, trong chỉnh sửa 1 tôi đã thay thế dZrX-(d = dup, Z = chiều dài số, r = hoán đổi, X = phân số, - = trừ) bằng 1/Z(chia số cho 1, với tỷ lệ mặc định là 0 cắt thành số nguyên; sau đó Z = số chiều dài), tiết kiệm hai byte.

Swift , 166 158 145 byte

var c="comma club",i=0
f.map{k,v in var a=abs(v);print(k,(1000..<1000000~=a ?1:1000000..<1000000000~=a ?2:1000000000..<1000000000000~=a ?3:0),c)}

Và đây là từ điển:

var f = [
    "John": 100000, "Jamie": 0.05, "Kylie" : 1549001.10,
    "Laura": 999999999.99,"Russ":1000000000,"Karla": 1,
    "Reid": 99.99,"Mark": 999.99, "Manson": 1000.01,
    "Lonnie": 999999999999.00, "Nelly": -123.45
]

Hãy thử nó ở đây!

Clojure, 108 byte

(def f ["John", "Jamie", "Kylie", "Laura", "Russ", "Karla", "Reid", "Mark", "Manson", "Lonnie", "Nelly"])
(def a ["100000", "0.05", "1549001.10", "999999999.99", "986000000", "1", "99.99", "999.99", "1000.01", "999999999999.00", "-123.45"])

(map #(str %" is in the "(quot(-(count(nth(partition-by #{\.}(drop-while #{\-}%2))0))1)3)"-comma club.")f a)

Không chắc chắn nếu hoạt động trên phao sẽ bị rút ngắn hơn so với các chuỗi ký tự. Không chắc chắn nếu câu trả lời không chức năng là tốt mà trả về một chuỗi các câu trả lời.

Rebol, 118 byte

d: charset"0123456789"forskip s 2[c: 0 parse s/2[opt"-"any[3 d and d(++ c)]]print[s/1"is in the"join c"-comma club."]]

Ungolfed với khai báo mảng:

s: [
    {John} {100000}
    {Jamie} {0.05}
    {Kylie} {1549001.10}
    {Laura} {999999999.99}
    {Russ} {986000000}
    {Karla} {1}
    {Reid} {99.99}
    {Mark} {999.99}
    {Manson} {1000.01}
    {Lonnie} {999999999999.00}
    {Nelly} {-123.45}
    {Baz} {1.12345678}     ;; added extra Baz test case
]

d: charset "0123456789"
forskip s 2 [
    c: 0
    parse s/2 [
        opt "-"
        any [3 d and d (++ c)]
    ]
    print [s/1 "is in the" join c "-comma club."]
]

Đầu ra:

John is in the 1-comma club.
Jamie is in the 0-comma club.
Kylie is in the 2-comma club.
Laura is in the 2-comma club.
Russ is in the 2-comma club.
Karla is in the 0-comma club.
Reid is in the 0-comma club.
Mark is in the 0-comma club.
Manson is in the 1-comma club.
Lonnie is in the 3-comma club.
Nelly is in the 0-comma club.
Baz is in the 0-comma club.

Java 8 154 141 byte

m.keySet().stream().map(k->k+" is in the "+(((""+Math.abs(m.get(k).longValue()))).length()-1)/3+"-comma club.").forEach(System.out::println);

Bị đánh cắp

public static void main(String[] args) {
    Map<String, Number> m = new LinkedHashMap<String, Number>(){{
        put("John", 100000);
        put("Jamie", 0.05);
        put("Kylie", 1549001.10);
        put("Laura", 999999999.99);
        put("Russ", 1000000000);
        put("Karla", 1);
        put("Reid", 99.99);
        put("Mark", 999.99);
        put("Manson", 1000.01);
        put("Lonnie", 999999999999.00);
        put("Nelly", -123.45);
    }};
    m.keySet().stream().map(k->k+" is in the "+(((""+Math.abs(m.get(k).longValue()))).length()-1)/3+"-comma club.").forEach(System.out::println);
}