Powiedz moim znajomym, do którego „klubu przecinkowego” należą

16

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.

code-golf 
— blacksite
źródło
2
Nie sądzę, że format wyjściowy jest bardzo jasny. Czy coś jest do "Name number,Name number,..."zaakceptowania?
— FryAmTheEggman
2
Czy wpisy wf są gwarantowane jako pozytywne, czy -$1,234.56też będą w klubie z przecinkiem?
— Jonathan Allan
2
@not_a_robot Czy możesz odnieść się do komentarza Fry? Czy wystarczy wypisać pary nazw i numerów w dowolnym formacie?
— Martin Ender
1
@FryAmTheEggman Nie, dane wyjściowe muszą być w formacie"<name> is in the <number of commas>-club."
— blacksite
1
Przypadki testowe nie są spec. I nawet gdyby tak było, nie ma przypadku testowego obejmującego kwestię dużych negatywów podniesionych przez Jonathana Allana powyżej.
— Peter Taylor,

Odpowiedzi:

10

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/

— Neil
źródło
Nie sądzę, że to działa na liczby ujemne. Na przykład umieściłby Nelly (-123.45) w klubie z przecinkiem. Sugerowałbym krótszy Math.log10(n*n)/6|0.
— Arnauld
@Arnauld Ach tak, zapomniałem |0obciętych do zera, więc daje właściwą odpowiedź dla Jamiego.
— Neil
8

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)
— kennytm
źródło
Miło jest zobaczyć konkurencyjną odpowiedź SQL - dobra robota!
— Toby Speight
6

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
— Jonathan Allan
źródło
4

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.

— Tytus
źródło
Ojej! Czy jestem pierwszym, który obliczył zamiast liczyć znaki?
— Tytus
4

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!

— Nie drzewo
źródło
4

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!

— Oliver
źródło
1
Myślę, że możesz to zrobić Vw0 x4 l /3-2|0w środkowej części, oszczędzając 6 bajtów :-)
— ETHproductions
1
Myślę, że możesz zaoszczędzić bajt, wprowadzając dane w odwrotnej kolejności:V+`...{w0...
— ETHprodukcje
3

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
— Suever
źródło
3

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

— Joe
źródło
1
Co z przypadkiem Nelly, która ma -123,45 dolarów? To log10wywołanie wytworzy NaNs dla negatywów. Wygląda na to, log10(abs(a))że zadziała.
— blacksite
Ups, masz rację, powyższa próbka nie obejmowała Nelly. I źle odczytałem specyfikację ... Zrozumiałem, że wartość ujemna powinna wynosić 0 przecinek.
— Joe
Zamiast abs(x)używać pmax(a,1)- zajmie to mniej niż 1 i sprawi, że będzie 1, dając dobre wyniki dla liczb ujemnych. I zamiast floor(log10(...)/3)ciebie możesz użyć log10(...)%/%3. Myślę, że to sprowadza się do 66 bajtów (i poprawia na negatywy).
— Gregor - przywróć Monikę
1
Warto również zauważyć, że pełne 7 bajtów to cat()i \n… drukowanie wektora z ciągami w nim na konsoli może być uważane za wystarczająco dobre (* hmm * jak odpowiedzi w Pythonie).
— Gregor - przywróć Monikę
To ma dodatkowy nawias po 3. Wyprowadza także klub -1 dla Jamiego. Użycie pmax (a, 1) naprawia to.
— BLT
3

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

Pokaż fragment kodu

— Oliver
źródło
1
Zaoszczędź bajt, `${}`a n=>m=>...zamiast tego (n,m)=>...
— możesz wywołać
2

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!

— nmjcman101
źródło
Nie sądzę, żeby to \-=coś dodawało. Ponadto, jeśli usuniesz dodatkowe spacje na wejściu i zmienisz także wyrażenie regularne, \v (\d*).*;możesz zapisać 4 bajty
— DJMcMayhem
2

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
— Emigna
źródło
2

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)))
— iwaseatenbyagrue
źródło
2

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.

— Słup
źródło
2

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.
— Jules
źródło
1

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")
— Chromozorz
źródło
1

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.

— Jonathan Allan
źródło
1

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);
    }
}
— adrianmp
źródło
1

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.

— blacksite
źródło
1
Co najważniejsze, jest to fragment kodu. Zazwyczaj zezwalamy tylko na funkcje lub pełne programy. Jeśli chodzi o golfa, możesz usunąć wiele miejsc. Spróbuj: ["%s is in the %d-comma club."%(p,v.count(','))for p,v in zip(f,a)]Musisz także dołączyć liczbę bajtów.
— Conor O'Brien
Możesz zrobić print'\n'.join([your array])i faktycznie wydrukować.
— Elronnd
2
Witamy na stronie! Negatywne (np. -123.45) Są wyłączone o jeden (ponieważ się liczy -). Ale dlaczego nie wziąć listy numerów i zapisać (czy źle zinterpretowałem?). Trzeba by dodać instrukcje importu, a w obecnej postaci jest to fragment kodu, a nie program lub funkcja (jak to domyślnie, a zmiana z nich jest odradzana, chyba że jest ku temu dobry powód).
— Jonathan Allan
1
Dzięki, @JonathanAllan. Obecnie próbuję to poprawić, więc nie muszę liczyć importu. Zdaję sobie sprawę, że math.ceilfunkcja Pythona prawdopodobnie dodaje całkiem sporo do mojego wyniku.
— blacksite
2
Możesz zapisać 9 bajtów, zastępując (-len(str(abs(v)).split('.')[0])jelen(str(int(float(v)))) . W twoim zestawie testowym nie ma liczb ujemnych (w przykładach jest jedna). Jeśli chcesz być kompletnym, wydaj na to 5 bajtów, co pozwoli len(str(abs(int(float(v)))))Ci zaoszczędzić tylko 4 bajty.
— iwaseatenbyagrue
1

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

— Håvard Nygård
źródło
dlaczego się rozgląda ^@f.elems? btw, nie potrzebujesz tego .elems, for ^@fdziała. Nie musisz nazywać się $x, użyj $_zamiast tego. I nie używaj printf, używaj "{"interpolation"}".
— Ven
Nie rozumiem nawet, dlaczego tego potrzebujesz. Dlaczego nie wybrać for @f? Możesz użyć go $++jako indeksu, aby przejść razem z nim (i indeksować do @a).
— Ven
zła edycja, jak tylko będę na komputerze :)
— Håvard Nygård
1
@Ven dzięki za informacje o $ ++. Oszczędza mi dużo kłopotów w moich „prawdziwych” programach. Właśnie odebrałem Perl 6.
— Håvard Nygård
Czy na pewno interpolacje nie oszczędzają bajtów?
— Ven
1

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.

— Daniel
źródło
1

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.

— James Waldby - jwpat7
źródło
1

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!

— Pan Xcoder
źródło
0

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.

— NikoNyrh
źródło
0

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.
— draegtun
źródło
0

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);
}
— anakron
źródło
1
Możesz usunąć String.valueOfi użyj (((""+Math.abs(m.get(k).longValue())).length()-1)/3)zamiast tego.
— Kevin Cruijssen
1
Możesz także usunąć nawias wokół k->.
— Kevin Cruijssen
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.