Gibi Silikon Vadisi'nin "üç virgül kulübü" sahneleri esinlenerek bu bir , on insanlara hangi onlar her aittir "virgül kulübü" söylüyorum olacak bu mücadelede.

"Virgül kulübü" terimine aşina değilseniz, açıklamama izin verin: elinizde bulunan para 1.000,00 ila 999,999,99 $ aralığındaysa, tek-virgül kulübündesiniz; 1,000,000,00 ila 999,999,999,99 $ aralığındaysa iki virgül kulübündesiniz; Bu "kulüpler" üç virgül kulübü aracılığıyla tekrarlanır, çünkü Dünya'daki hiçbir kişi (AFAIK) bir trilyon ABD dolarından fazla değildir (Japon Yeni çok hızlı bir şekilde farklı bir hikaye olurdu). Bu nedenle, ABD ve Büyük Britanya'da en yaygın gösterim standartlarına göre, banka hesabınızın virgül sayısı ait olduğunuz virgül kulübünü gösterir. Negatif sayılar için aynı "virgül" kuralları geçerlidir (negatif virgül kulübünde olmak istemezsiniz): kapsayıcı aralıktaki negatif miktarlar [-0.01, -999.

Test senaryoları

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

Doğru cevaplar:

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.

Bir friendsdizi ve amountsdizi almak için gereken dizi kurulumu ne olursa olsun puanınıza dahil değildir. Python için aşağıdaki kod sayılmaz:

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

Düzenleme: Lütfen gözden geçirilmiş test senaryolarına bakın

Virgülleri saymak yerine işleri biraz daha zorlaştırmak için test dizelerinden gerçek dize virgüllerini kaldırdım.

JavaScript (ES6), 80 bayt

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

Bir dizi [arkadaş, miktar] dizisi alır ve "arkadaş n-virgül kulübünde" dizisini döndürür. Teller. 0-virgül kulübü için uzunluk 6-8, 1-virgül kulübü için 9-11, 2-virgül kulübü için 12-15 olacak şekilde ekstra sondaki sıfırlar ekleyerek çalışır.

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

PostgreSQL, 61 bayt

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

@xmutlak değeri x, log(x)baz-10 logaritmasıdır ve div(y, x)y / x tamsayı olan hesaplar.

Kurmak:

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)

Çıktı:

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

Jöle , 34  32 bayt

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

Banka bakiyeleri listesini sayılar (ondalık sayılar / tamsayılar) ve isimlerin listesini dize olarak alan ve dizelerin listesini döndüren ikili bağlantı (işlev).

Çevrimiçi deneyin! - altbilgiçYsadece işlevi çağırır ve sonuç listesi ile satır beslemeleri birleştirir, böylece tam bir program olarak çalıştırıldığında güzel bir çıktı olur.

Nasıl?

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 bayt

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

Neyse ki int için döküm yapmak zorunda değilim (C için olduğu gibi); PHP bunu örtük olarak yapar %d.

Mathematica (86 bayt)

Kurulum (isimler dizgiler, paralar sayılar olarak):

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}

Girişim:

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

Tüm Mathematica dize işlevleri adında "Dize" içerir, bu yüzden günlükleri daha kısa olduğunu düşünüyorum. Max[...,0]Arasında -1 ile 1 dolar sahibi insanlar için sinir bozucu negatif sayılar veya negatif sonsuza başa etmektir. Negatif bir sayının günlüğü hayali şeyler içerir, ancak Mathematica bir Floor!

Japt , 36 bayt

Bu, miktarı ilk girdi, ikinci olarak ad alır.

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

açıklama

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, string sıkıştırması için shoco kütüphanesini kullanır .

@ Neil'in çözümünden ilham aldı .

@ETHproductions sayesinde 7 bayt tasarruf edildi

Çevrimiçi deneyin!

MATL, 50 48 43 bayt

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

MATL Online'da deneyin

açıklama

`                   % 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 bayt

Kurulum:

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)

Çözüm:

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

Hesabın mutlak değerinin temel 10 günlüğünü alın, aşağı yuvarlayın ve adlarla yazdırın.

aBir karakter vektörü olmanın daha küçük olabileceğinden emin değilim ...

JavaScript, 59 bayt

@ETHproductions sayesinde 3 bayt tasarruf edildi

@Cyoce sayesinde 2 bayt kaydedildi

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

gösteri

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 bayt

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

Her nasılsa, sonunda bir dönüş olduğunu göstermeliyim, ama nasıl olduğundan emin değilim. Bu sadece temel bir normal ifade cevabı, eminim herhangi bir normal ifade dili tarafından yenilebilir. V'yi kullanırdım, ama V'deki ikame komutlarının /varsayılan olarak bir ayırıcı olarak kullandığını ve bölünmeden şikayet etmemeyi nasıl anlayamadığımı düşünüyorum.

OP'nin tablosu olarak girdi alır ve değerleri tablo olarak döndürür, ancak finansal bilgiler "X virgül kulübünde" ile değiştirilir

Çevrimiçi deneyin!

05AB1E , 32 bayt

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

Çevrimiçi deneyin!

açıklama

Ä                                 # 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 bayt

Dizilerimizi ayarlayın:

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]

Ve bizim fonksiyonumuz şu şekilde olabilir:

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

Bize ver:

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

Dizinin soruda verilenle aynı olması gerekiyorsa, çözümün 76 bayt maliyeti:

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

Powershell, 82 bayt

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

2D-dizi girişinin

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

Çıktı 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 bayt

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

Doğru cevabı veren bir '#' operatörü tanımlar. Örneğin:

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

Ne yazık ki, Haskell'in log10diğer birçok dil gibi kompakt bir işlevi yoktur, ancak kullanışlı bir logBaseişlevi vardır, bu da cevabımızı 3'e bölmemiz gerekmediği anlamına gelir. Ne yazık ki, logBase 1000 0.05negatif bir sayıdır, bu yüzden daha uzun truncatedeğil floor.

Test senaryolarını içeren tam program:

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

Aşağıdaki sonuçları verir:

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 bayt

    /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 bayt

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

Çevrimiçi deneyin!

Tam olarak iki listeden oluşan bir grup alır - dizeler olarak adlar, banka sayılar olarak dengeler - ve ortaya çıkan dizeleri yazdırır.

C #, 125 bayt

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

Sonucu OP biçiminde yazdıran anonim işlev.

Test senaryolarıyla birlikte tam program:

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 ( 207159110 95 86 bayt, @iwaseatenbyagrue sayesinde)

Biraz kurulum:

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]

Girişimim:

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

Sonuçlar:

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

Düzenleme: her şeyi mutlak değerlere dönüştürmek beni 15 bayt kurtardı.

Perl 6, 107 95 bayt

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

Gururlu çalışmam değil, golf tekniklerini unutursam bana kulak ver. EDIT: @Ven sayesinde -12 bayt

Python 2, 87 bayt

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

Biraz daha eski (90 bayt):

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

Girişi bir grup listesi (isim, miktar) olarak alır.

Bunu okuldaki telefonumda yapıyorum, bu yüzden daha sonra test edeceğim.

dc, 56 54 bayt

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

Bu, yığının üstündeki ilk ad, ilk sayı, ikinci ad, ikinci sayı vb. İle önceden yüklenmiş olması gereken yığıntan girdi alır.

Aşağıda, yığının yüklenmesi ve makroyu çalıştırmanın bir örneği, 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

ki bu da normal çıktıyı üretir,

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.

İşte kodun bir tefsiri:

[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

Not 1, düzenleme 1'de dZrX-(d = dup, Z = sayı uzunluğu, r = takas, X = kesir, - = çıkarma) yerine 1/Z(varsayılan olarak sıfır ölçeği ile tamsayıya kesilen sayı 1'e bölün; sonra Z = sayı uzunluk), iki bayt tasarrufu.

Swift , 166 158 145 bayt

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

İşte sözlük:

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
]

Burada deneyin!

Clojure, 108 bayt

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

Şamandıralar üzerinde çalışmanın karakter dizilerinden daha kısa olup olmayacağından emin değilim. Bir cevap dizisi döndüren işlevsiz yanıtın iyi olup olmadığından emin değilim.

Rebol, 118 bayt

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

Dizi bildirimi ile yönlendirilmedi:

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

Çıktı:

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 bayt

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

Ungolfed

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