Di 'ai miei amici a quale "club di virgola" appartengono

16

Ispirato alle scene del "club delle tre virgole" della Silicon Valley, come questo , in questa sfida dirai a dieci persone il "club delle virgole" a cui ciascuna appartiene.

Se non hai familiarità con il termine "club virgola", lasciami spiegare: sei nel club una virgola se il denaro che hai è compreso nell'intervallo compreso tra $ 1.000,00 e $ 999.999,99; sei nel club con due virgole se è compreso tra $ 1.000.000,00 e $ 999.999.999,99; questi "club" si ripetono attraverso il club di tre virgole, poiché nessun individuo sulla Terra (AFAIK) possiede più di un trilione di dollari USA (lo yen giapponese sarebbe una storia diversa molto rapidamente). Pertanto, il numero di virgole che il tuo conto bancario ha, secondo gli standard di notazione più comuni negli Stati Uniti e in Gran Bretagna, indica il club virgola a cui appartieni. Le stesse regole "virgola" si applicano ai numeri negativi (anche se non si vorrebbe essere nel club virgola negativo): importi negativi nell'intervallo compreso [-0,01, -999.

I casi di test

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

Le risposte giuste:

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.

Qualunque configurazione dell'array sia necessaria per ottenere un friendsarray e l' amountsarray non conta ai fini del punteggio. Quindi per Python, il seguente codice non conta:

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

Modifica: consultare i casi di test rivisti

Ho rimosso le virgole di stringa effettive dai casi di test per rendere le cose un po 'più difficili, invece di contare solo le virgole.

code-golf 
— Blacksite
fonte
2
Non credo che tu abbia reso molto chiaro il formato di output. Qualcosa di simile è "Name number,Name number,..."accettabile?
— FryAmTheEggman
2
Le voci in f sono garantite come positive o sarebbero -$1,234.56anche nel club da 1 virgola?
— Jonathan Allan
2
@not_a_robot Potresti rispondere al commento di Fry? È sufficiente produrre coppie di nome e numero in qualsiasi formato?
— Martin Ender
1
@FryAmTheEggman No, l'output deve essere nel formato"<name> is in the <number of commas>-club."
— blacksite
1
I casi di test non sono spec. E anche se lo fossero, non esiste un caso di prova che copra la questione dei grandi negativi sollevati da Jonathan Allan sopra.
— Peter Taylor,

Risposte:

10

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

Accetta una matrice di matrici [amico, importo] e restituisce una matrice di "amico è nel club n-virgola". stringhe. Funziona aggiungendo ulteriori zeri finali in modo che la lunghezza sia 6-8 per il club con 0 virgola, 9-11 per il club con 1 virgola, 12-15 per il club con 2 virgola ecc.

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

— Neil
fonte
Non penso che questo funzioni per numeri negativi. Ad esempio, metterebbe Nelly (-123.45) nel club da 1 virgola. Suggerirei il più corto Math.log10(n*n)/6|0.
— Arnauld
@Arnauld Ah sì, avevo dimenticato il |0troncamento a zero, quindi dà la risposta giusta per Jamie.
— Neil
8

PostgreSQL, 61 byte

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

@xè il valore assoluto di x,log(x) è logaritmo in base 10 e div(y, x)calcola il quoziente intero di y / x.

Impostare:

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)

Produzione:

            ?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
fonte
È bello vedere una risposta SQL competitiva - ben fatto!
— Toby Speight
6

Gelatina , 34  32 byte

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

Un collegamento diadico (funzione) che accetta un elenco di saldi bancari come numeri (decimali / numeri interi) e un elenco di nomi come stringhe e restituisce un elenco di stringhe.

Provalo online! - il piè di paginaçY chiama semplicemente la funzione e unisce l'elenco risultante con i feed di linea in modo che abbia un buon output quando viene eseguito come programma completo.

Come?

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
fonte
4

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

Fortunatamente non devo lanciare in int (come avrei dovuto in C); PHP lo fa implicitamente per %d.

— Titus
fonte
Gee! Sono il primo qui a calcolare invece di contare i caratteri?
— Tito
4

Mathematica (86 byte)

Il set-up (con nomi come stringhe, denaro come numeri):

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}

Il tentativo:

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

Tutte le funzioni di stringa di Mathematica includono "String" nel nome, quindi penso che i log siano più brevi. Il Max[...,0]problema è gestire i fastidiosi numeri negativi o l'infinito negativo per le persone che possiedono tra -1 e 1 dollari. Il registro di un numero negativo include materiale immaginario, ma Mathematica lo ignora utilmente quando lo prende Floor!

— Non un albero
fonte
4

Japt , 36 byte

Questo prende la quantità come primo input, il nome come secondo.

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

Spiegazione

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 utilizza la libreria shoco per la compressione delle stringhe.

Ispirato dalla soluzione di @ Neil .

Risparmiato 7 byte grazie a @ETHproductions

Provalo online!

— Oliver
fonte
1
Penso che puoi fare solo Vw0 x4 l /3-2|0nella sezione centrale, risparmiando 6 byte :-)
— ETHproductions
1
Penso che puoi salvare un byte prendendo input nell'ordine opposto:V+`...{w0...
— ETHproductions
3

MATL, 50 48 43 byte

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

Provalo su MATL Online

Spiegazione

`                   % 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
fonte
3

R, 68 byte

Il set up:

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)

La soluzione:

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

Prendi il registro di base 10 del valore assoluto dell'account, arrotondare per difetto quindi stampare con i nomi.

Non sono sicuro che potrebbe essere più piccolo se afosse un vettore di caratteri ...

— Joe
fonte
1
E il caso di Nelly, che ha -123,45 dollari? Quella log10chiamata produrrà messaggi NaNnegativi. Sembra log10(abs(a))che funzionerebbe.
— nero
Oops, hai ragione, l'esempio sopra non includeva Nelly. E ho letto male le specifiche ... Ho capito che il valore negativo dovrebbe essere 0 virgola club.
— Joe
Invece di abs(x), usa pmax(a,1)- questo richiederà qualcosa di meno di 1 e lo farà 1, dando buoni risultati per numeri negativi. E invece di floor(log10(...)/3)te puoi usare log10(...)%/%3. Penso che arriva a 66 byte (e corretto per i negativi).
— Gregor --state Monica -
1
Vale anche la pena notare che ben 7 byte di questi sono il cat()e \n... stampare il vettore con le stringhe in esso sulla console potrebbe essere considerato abbastanza buono (* ahem * come le risposte di Python).
— Gregor --state Monica -
Questa ha una parentesi extra dopo 3. Emette anche il club -1 per Jamie. L'uso di pmax (a, 1) risolve questo problema.
— BLT
3

JavaScript, 59 byte

Salvato 3 byte grazie a @ETHproductions

Salvato 2 byte grazie a @Cyoce

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

dimostrazione

Mostra snippet di codice

— Oliver
fonte
1
Salvare un byte con `${}`e puoi curry la funzione n=>m=>...invece di(n,m)=>...
— Cyoce
2

Vim, 72 byte

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

In qualche modo dovrei mostrare che c'è un ritorno finale, ma non so come. Questa è solo una risposta regex di base, che sono sicuro che potrebbe essere battuta da qualsiasi linguaggio regex. Avrei usato V, ma penso che i comandi sostitutivi in ​​V usino/ come separatore di default, e non sono riuscito a capire come farlo non lamentarsi della divisione.

Accetta input come tabella OP e restituisce valori come tabella, ma con le informazioni finanziarie sostituite da "è nel club X virgola"

Provalo online!

— nmjcman101
fonte
Non credo che \-=aggiunge nulla. Inoltre, se rimuovi gli spazi extra nel tuo input e cambi anche la regex \v (\d*).*;potresti risparmiare 4 byte
— DJMcMayhem
2

05AB1E , 32 byte

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

Provalo online!

Spiegazione

Ä                                 # 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
fonte
2

Python 2, 69 byte

Imposta i nostri array:

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]

E la nostra funzione può quindi essere:

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

Dandoci:

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

Se l'array deve essere identico a quello fornito nella domanda, la soluzione costa 76 byte:

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

Powershell, 82 byte

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

Supponendo un input di array 2D di

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

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

— Tor
fonte
2

Haskell, 71 byte

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

Definisce un '#' operatore che fornisce la risposta corretta. Per esempio:

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

Sfortunatamente, Haskell non ha una log10funzione compatta come molte altre lingue, ma ha una logBasefunzione utile , il che significa che non abbiamo bisogno di dividere la nostra risposta per 3. Sfortunatamente, logBase 1000 0.05è un numero negativo, quindi dobbiamo usare il più a lungo truncatepiuttosto chefloor arrotondarlo.

Programma completo inclusi casi di test:

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

Fornisce i seguenti risultati:

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
fonte
1

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")
— Chromozorz
fonte
1

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

Provalo online!

Programma completo che prende una tupla di due elenchi - nomi come stringhe, saldi bancari come numeri - e stampa le stringhe risultanti.

— Jonathan Allan
fonte
1

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

Funzione anonima che stampa il risultato nel formato del PO.

Programma completo con casi di test:

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
fonte
1

Python 3 ( 207 159 110 95 86 byte, grazie a @iwaseatenbyagrue)

Un po 'di installazione:

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]

Il mio tentativo:

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

risultati: 

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

Modifica: convertire tutto in valori assoluti mi ha salvato 15 byte.

— Blacksite
fonte
1
Ancora più importante, questo è uno snippet di codice, in genere consentiamo solo funzioni o programmi completi. Per quanto riguarda il golf, puoi rimuovere molti spazi. Prova: ["%s is in the %d-comma club."%(p,v.count(','))for p,v in zip(f,a)]inoltre, è necessario includere un conteggio di byte.
— Conor O'Brien,
Puoi fare print'\n'.join([your array])e effettivamente stampare l'output.
— Elronnd
2
Benvenuti nel sito! I negativi (ad es. -123.45) Sono disattivati ​​di uno (poiché si conta il -). Ma perché non prendere un elenco di numeri e salvare (ho interpretato male?). Dovresti aggiungere dichiarazioni di importazione, e allo stato attuale si tratta di uno snippet non di un programma o di una funzione (come lo sono le impostazioni predefinite, e il cambiamento da esse è scoraggiato a meno che non ci siano buone ragioni).
— Jonathan Allan
1
Grazie, @JonathanAllan. Attualmente sto cercando di migliorarlo, quindi non devo contare le importazioni. Mi rendo conto che la math.ceilfunzione di Python probabilmente aggiunge un po 'di sovraccarico al mio punteggio.
— nero
2
È possibile salvare 9 byte sostituendoli (-len(str(abs(v)).split('.')[0])con len(str(int(float(v)))). Nel tuo set di test non ci sono numeri negativi (negli esempi ce n'è uno). Se vuoi essere completo, spendi 5 byte da fare len(str(abs(int(float(v))))), il che ti salva solo 4 byte.
— Iwaseatenbyagrue
1

Perl 6, 107 95 byte

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

Non il mio lavoro più orgoglioso, dammi un avvertimento se dimentico qualsiasi tecnica di golf. MODIFICA: -12 byte grazie a @Ven

— Håvard Nygård
fonte
perché parens in giro ^@f.elems? ma non ne hai bisogno .elems, for ^@ffunziona. Non è necessario nominare il tuo $x, utilizzare $_invece. E non usare printf, usa "{"interpolation"}".
— Ven
Non capisco nemmeno perché ne hai bisogno. Perché non andare per for @f? Puoi usarlo $++come indice per seguirlo (e indicizzarlo @a).
— Ven
non posso modificarlo appena sono sul pc :)
— Håvard Nygård
1
@Ven grazie per il testa a testa su $ ++. Mi salva un sacco di problemi nei miei programmi "reali". Appena raccolto Perl 6.
— Håvard Nygård
Sei sicuro che le interpolazioni non salvino i byte?
— Ven
1

Python 2, 87 byte

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

Leggermente più vecchio (90 byte):

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

Accetta input come un elenco di tuple (nome, quantità).

Lo sto facendo sul telefono a scuola, quindi lo proverò più tardi.

— Daniel
fonte
1

dc, 56 54 byte

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

Questo prende input dallo stack, che dovrebbe essere precaricato con il nome in cima allo stack, il primo numero, il secondo nome, il secondo numero, ecc.

Ecco un esempio di caricamento dello stack e di esecuzione della 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

che produce il solito 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 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.

Ecco un'esegesi del codice:

[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

Nota, nella modifica 1 ho sostituito dZrX-(d = dup, Z = lunghezza del numero, r = swap, X = frazione, - = sottrarre) con 1/Z(dividi il numero per 1, che con la scala predefinita di zero tronca all'intero; quindi Z = numero lunghezza), salvando due byte.

— James Waldby - jwpat7
fonte
1

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

Ed ecco il dizionario:

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
]

Provalo qui!

— Mr. Xcoder
fonte
0

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)

Non sono sicuro se il funzionamento su float sarebbe in cortocircuito rispetto alle sequenze di caratteri. Non sono sicuro se la risposta non funzionale va bene che restituisce una sequenza di risposte.

— NikoNyrh
fonte
0

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 con dichiarazione array:

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

Produzione:

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
fonte
0

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

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);
}
— anacron
fonte
1
È possibile rimuovere String.valueOfe utilizzare (((""+Math.abs(m.get(k).longValue())).length()-1)/3)invece.
— Kevin Cruijssen
1
E puoi anche rimuovere la parentesi in giro k->.
— Kevin Cruijssen,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.