Zainspirowany scenami „klubu z trzema przecinkami” Doliny Krzemowej, takimi jak ten , w tym wyzwaniu opowiesz dziesięciu osobom o „klubie przecinka”, do którego należą.

Jeśli nie znasz terminu „klub z przecinkiem”, pozwól mi wyjaśnić: jesteś w klubie z przecinkiem, jeśli posiadane pieniądze mieszczą się w przedziale od 1 000,00 do 999,999,99 USD; jesteś w klubie z dwoma przecinkami, jeśli mieści się w przedziale od 1 000 000,00 do 999,999,999,99 USD; te „kluby” powtarzają się przez klub z trzema przecinkami, ponieważ żadna osoba na Ziemi (AFAIK) nie posiada więcej niż jeden bilion dolarów amerykańskich (japoński jen byłby inną historią bardzo szybko). Tak więc liczba przecinków na Twoim koncie bankowym, zgodnie ze standardami notacji najczęściej stosowanymi w Stanach Zjednoczonych i Wielkiej Brytanii, oznacza klub przecinków, do którego należysz. Te same zasady „przecinków” obowiązują w przypadku liczb ujemnych (choć nie chcesz być w klubie z przecinkami ujemnymi): kwoty ujemne w zakresie obejmującym [-0,01, -999.

Przypadki testowe

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

Właściwe odpowiedzi:

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.

Niezależnie od konfiguracji tablicy potrzebnej do uzyskania friendstablicy i amountstablicy nie liczy się do wyniku. W przypadku Pythona następujący kod się nie liczy:

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']

Edycja: Zobacz poprawione przypadki testowe

Usunąłem przecinki ciągów z przypadków testowych, aby uczynić je nieco trudniejszymi, niż tylko liczenie przecinków.

JavaScript (ES6), 80 bajtów

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

Pobiera tablicę [przyjaciel, ilość] tablic i zwraca tablicę „przyjaciel jest w klubie z przecinkiem”. smyczki. Działa poprzez dodanie dodatkowych zer końcowych, dzięki czemu długość wynosi 6-8 dla klubu z przecinkami, 9-11 dla klubu z przecinkami, 12-15 dla klubu z przecinkami itp.

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

PostgreSQL, 61 bajtów

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

@xjest wartością bezwzględną x, log(x)wynosi logarytm dziesiętny i div(y, x)oblicza iloraz liczby całkowitej y / x.

Ustawiać:

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)

Wynik:

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

Galaretka , 34  32 bajty

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

Diadadic link (funkcja), który pobiera listę sald bankowych jako liczby (dziesiętne / całkowite) oraz listę nazw jako ciągi znaków i zwraca listę ciągów.

Wypróbuj online! - stopkaçYpo prostu wywołuje tę funkcję i dołącza do wynikowej listy ze znakami linii, dzięki czemu jest ładna, gdy działa jako pełny program.

W jaki sposób?

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 bajtów

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

Na szczęście nie muszę rzucać na int (jak w C); PHP robi to domyślnie dla %d.

Mathematica (86 bajtów)

Konfiguracja (z nazwami jako ciągami, pieniędzmi jako liczbami):

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}

Próba:

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

Wszystkie funkcje ciągów Mathematica zawierają w nazwie „String”, więc myślę, że dzienniki są krótsze. Ma Max[...,0]to na celu radzenie sobie z nieznośnymi liczbami ujemnymi lub ujemną nieskończonością dla osób, które posiadają od -1 do 1 dolarów. Dziennik liczby ujemnej zawiera wyimaginowane rzeczy, ale Mathematica pomaga ignorować to podczas robienia Floor!

Japt , 36 bajtów

Pobiera to kwotę jako pierwsze wejście, a nazwę jako drugie.

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

Wyjaśnienie

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 używa biblioteki shoco do kompresji ciągów.

Zainspirowany rozwiązaniem @ Neil .

Zaoszczędź 7 bajtów dzięki @ETHproductions

Wypróbuj online!

MATL, 50 48 43 bajtów

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

Wypróbuj w MATL Online

Wyjaśnienie

`                   % 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 bajtów

Ustawić:

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)

Rozwiązanie:

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

Weź podstawowy dziennik 10 wartości bezwzględnej konta, zaokrągl w dół, a następnie wydrukuj z nazwiskami.

Nie jestem pewien, czy mógłby być mniejszy, gdyby abył wektorem postaci ...

JavaScript, 59 bajtów

Zaoszczędź 3 bajty dzięki produktom @ETH

Zaoszczędź 2 bajty dzięki @Cyoce

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

Próbny

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 bajty

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

Jakoś powinienem pokazać, że powraca zwrot, ale nie jestem pewien, jak to zrobić. To jest tylko podstawowa odpowiedź na wyrażenia regularne, na którą z pewnością można pobić dowolny język wyrażenia regularnego. Użyłbym V, ale myślę, że zastępcze polecenia w V /domyślnie używają jako separatora i nie mogłem wymyślić, jak sprawić, by nie narzekało na podział.

Pobiera dane wejściowe jako tabelę OP i zwraca wartości jako tabelę, ale informacje finansowe zastąpione przez „znajduje się w klubie przecinkowym X”

Wypróbuj online!

05AB1E , 32 bajty

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

Wypróbuj online!

Wyjaśnienie

Ä                                 # 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 bajtów

Skonfiguruj nasze tablice:

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]

A naszą funkcją może być:

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

Dając nam:

>>> [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']

Jeśli tablica musi być identyczna z podaną w pytaniu, rozwiązanie kosztuje 76 bajtów:

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

PowerShell, 82 bajty

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

Zakładając wejście tablicy 2D z

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

Dane wyjściowe to 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 bajtów

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

Definiuje operator „#”, który zapewnia poprawną odpowiedź. Na przykład:

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

Niestety, Haskell nie ma kompaktowej log10funkcji, jak wiele innych języków, ale ma przydatną logBasefunkcję, co oznacza, że ​​nie musimy dzielić naszej odpowiedzi przez 3. Niestety, logBase 1000 0.05jest to liczba ujemna, więc musimy użyć dłużej truncateniż floorzaokrąglić.

Pełny program zawierający przypadki testowe:

(#) :: (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

Daje następujące wyniki:

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 bajtów

    /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 bajtów

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

Wypróbuj online!

Pełny program, który pobiera krotkę dwóch list - nazwy jako ciągi, salda bankowe jako liczby - i drukuje powstałe ciągi.

C #, 125 bajtów

(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");};

Anonimowa funkcja, która drukuje wynik w formacie PO.

Pełny program z przypadkami testowymi:

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 bajtów, dzięki @iwaseatenbyagrue)

Trochę konfiguracji:

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]

Moja próba:

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

Wyniki:

['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.']

Edycja: konwersja wszystkiego na wartości bezwzględne pozwoliła mi zaoszczędzić 15 bajtów.

Perl 6, 107 95 bajtów

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

Nie jest to moja największa praca, daj mi głowę, jeśli zapomniałem o jakichkolwiek technikach golfowych. EDYCJA: -12 bajtów dzięki @Ven

Python 2, 87 bajtów

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

Nieco starszy (90 bajtów):

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

Pobiera dane wejściowe jako listę krotek (nazwa, ilość).

Robię to na swoim telefonie w szkole, więc przetestuję to później.

dc, 56 54 bajtów

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

Pobiera to dane wejściowe ze stosu, który powinien być wstępnie załadowany imieniem na górze stosu, pierwszym numerem, drugim imieniem, drugim numerem itp.

Oto przykład ładowania stosu i uruchamiania makra, 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

co daje zwykłą wydajność,

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.

Oto egzegeza kodu:

[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

Zauważ, że w edycji 1 zamieniłem dZrX-(d = dup, Z = długość liczb, r = zamień, X = ułamek, - = odejmij) z 1/Z(podziel liczbę przez 1, która przy domyślnej skali zero skraca liczbę całkowitą; następnie Z = liczba długość), oszczędzając dwa bajty.

Szybki , 166 158 145 bajtów

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

A oto słownik:

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
]

Wypróbuj tutaj!

Clojure, 108 bajtów

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

Nie jestem pewien, czy działanie na liczbach zmiennoprzecinkowych byłoby zwarte niż na sekwencjach znaków. Nie jestem pewien, czy odpowiedź niefunkcyjna jest dobra, co zwraca sekwencję odpowiedzi.

Rebol, 118 bajtów

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."]]

Niegolfowane z deklaracją tablicową:

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."]
]

Wynik:

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 bajtów

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

Nie golfił

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