Diga aos meus amigos a que "clube de vírgulas" eles pertencem

16

Inspirado nas cenas do "clube das três vírgulas" do Vale do Silício, como este , neste desafio, você estará dizendo a dez pessoas o "clube das vírgulas" ao qual cada um pertence.

Se você não estiver familiarizado com o termo "clube de vírgulas", deixe-me explicar: você está no clube de uma vírgula se o dinheiro que você possui estiver no intervalo inclusivo de US $ 1.000,00 a US $ 999.999,99; você está no clube de duas vírgulas se estiver no intervalo de US $ 1.000.000,00 a US $ 999.999.999,99; esses "clubes" se repetem no clube de três vírgulas, já que nenhum indivíduo na Terra (AFAIK) possui mais de um trilhão de dólares (o iene japonês seria uma história diferente muito rapidamente). Portanto, o número de vírgulas que sua conta bancária possui, de acordo com os padrões de notação mais comuns nos Estados Unidos e na Grã-Bretanha, denota o clube de vírgulas ao qual você pertence. As mesmas regras de "vírgula" se aplicam a números negativos (embora você não queira estar no clube de vírgulas negativas): valores negativos no intervalo inclusivo [-0,01, -999.

Os casos de teste

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

As respostas certas:

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.

Qualquer que seja a configuração da matriz que você precise para obter uma friendsmatriz e uma amountsmatriz, não conta para sua pontuação. Portanto, para Python, o seguinte código não 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']

Editar: veja os casos de teste revisados

Eu removi as vírgulas reais dos casos de teste para tornar as coisas um pouco mais difíceis, em vez de apenas contar vírgulas.

code-golf 
— Zona de Perigo
fonte
2
Não acho que você tenha deixado o formato de saída muito claro. É algo como "Name number,Name number,..."aceitável?
— FryAmTheEggman #
2
As inscrições em f são garantidas como positivas ou -$1,234.56também no clube com 1 vírgula?
— Jonathan Allan
2
@not_a_robot Você poderia abordar o comentário de Fry? É suficiente gerar pares de nome e número em qualquer formato?
— Martin Ender
1
@FryAmTheEggman Não, as necessidades de saída para estar no formato"<name> is in the <number of commas>-club."
— BlackSite
1
Os casos de teste não são específicos. E mesmo se fossem, não há caso de teste que cubra a questão dos grandes negativos levantados por Jonathan Allan acima.
— Peter Taylor

Respostas:

10

JavaScript (ES6), 80 bytes

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

Pega uma matriz de [amigo, quantidade] e retorna uma matriz de "amigo está no clube n-vírgula". cordas. Funciona adicionando zeros à direita extras para que o comprimento seja de 6-8 para o clube com 0 vírgula, 9-11 para o clube com 1 vírgula, 12-15 para o clube com 2 vírgulas etc.

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

— Neil
fonte
Eu não acho que isso funcione para números negativos. Por exemplo, colocaria Nelly (-123,45) no clube de 1 vírgula. Eu sugeriria o mais curto Math.log10(n*n)/6|0.
— Arnauld
@ Arnauld Ah, sim, eu esqueci o valor |0de zero, por isso dá a resposta certa para Jamie.
— Neil
8

PostgreSQL, 61 bytes

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

@xé o valor absoluto de x, log(x)é logaritmo de base 10 e div(y, x)calcula o quociente inteiro de y / x.

Configuração:

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)

Resultado:

            ?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
É bom ver uma resposta SQL competitiva - muito bem!
— Toby Speight
6

Geléia , 34  32 bytes

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

Um link diádico (função) que pega uma lista de saldos bancários como números (decimais / números inteiros) e uma lista de nomes como cadeias de caracteres e retorna uma lista de cadeias de caracteres.

Experimente online! - o rodapéçYsimplesmente chama a função e junta a lista resultante aos feeds de linha, para que tenha uma saída agradável quando executado como um programa completo.

Quão?

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 bytes

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

Felizmente, não preciso converter para int (como em C); PHP faz isso implicitamente para %d.

— Titus
fonte
Gee! Eu sou o primeiro aqui a calcular em vez de contar caracteres?
— Titus
4

Mathematica (86 bytes)

A configuração (com nomes como seqüências de caracteres, dinheiro como números):

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}

A tentativa:

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

Todas as funções de string do Mathematica incluem "String" no nome, então acho que os logs são mais curtos. O Max[...,0]objetivo é lidar com os números negativos incômodos ou o infinito negativo para pessoas que possuem entre -1 e 1 dólar. O log de um número negativo inclui coisas imaginárias, mas o Mathematica ignora isso útil ao tirar uma Floor!

— Não é uma árvore
fonte
4

Japonês , 36 bytes

Isso leva a quantidade como a primeira entrada e o nome como a segunda.

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

Explicação

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 usa a biblioteca shoco para compactação de strings.

Inspirado na solução da @ Neil .

Economizou 7 bytes graças a @ETHproductions

Experimente online!

— Oliver
fonte
1
Eu acho que você pode apenas fazer Vw0 x4 l /3-2|0na seção do meio, poupando 6 bytes :-)
— ETHproductions
1
Eu acho que você pode salvar um byte tomando entrada na ordem inversa:V+`...{w0...
— ETHproductions
3

MATL, 50 48 43 bytes

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

Experimente no MATL Online

Explicação

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

A configuração:

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)

A solução:

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

Pegue o log base 10 do valor absoluto da conta, arredonde para baixo e imprima com os nomes.

Não tenho certeza se poderia ser menor se afosse um vetor de caractere ...

— Joe
fonte
1
E o caso de Nelly, que tem -123,45 dólares? Essa log10chamada produzirá NaNs para negativos. Parece que log10(abs(a))iria funcionar.
— BlackSite
Opa, você está certo, a amostra acima não incluiu Nelly. E eu interpretei errado a especificação ... Entendi que o valor negativo deveria ser 0 clube de vírgulas.
— 315 Joe Joe
Em vez de abs(x), use pmax(a,1)- isso levará menos de 1 e o tornará 1, fornecendo bons resultados para números negativos. E, em vez de floor(log10(...)/3)você pode usar log10(...)%/%3. Eu acho que reduz para 66 bytes (e corrige os negativos).
— Gregor
1
Também vale a pena notar que 7 bytes completos são cat()e \n... imprimir o vetor com as strings nele no console pode ser considerado bom o suficiente (* ahem * como as respostas do Python).
— Gregor
Isso tem um parêntese extra após 3. Ele também gera o clube -1 para Jamie. Usar pmax (a, 1) corrige isso.
— BLT
3

JavaScript, 59 bytes

Economizou 3 bytes graças a @ETHproductions

Guardado 2 bytes graças a @Cyoce

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

Demo

Mostrar snippet de código

— Oliver
fonte
1
Salve um byte com `${}`e você pode curry a função para em n=>m=>...vez de(n,m)=>...
— Cyoce 1/17/17
2

Vim, 72 bytes

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

De alguma forma, devo mostrar que há um retorno final, mas sem saber como. Esta é apenas uma resposta básica de regex, que eu tenho certeza que poderia ser derrotada por qualquer idioma de regex. Eu teria usado V, mas acho que os comandos substitutos em V usam /como separador por padrão, e não consegui descobrir como fazê-lo não reclamar sobre a divisão.

Recebe entrada como tabela do OP e retorna valores como a tabela, mas com as informações financeiras substituídas por "está no clube de vírgulas X"

Experimente online!

— nmjcman101
fonte
Eu não acho que o \-= acrescenta nada. Além disso, se você remover os espaços extras na sua entrada e alterar o regex também, \v (\d*).*;poderá salvar 4 bytes
— DJMcMayhem
2

05AB1E , 32 bytes

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

Experimente online!

Explicação

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

Configure nossas matrizes:

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 nossa função pode ser:

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

Dando-nos:

>>> [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 a matriz precisar ser idêntica à fornecida na pergunta, a solução custará 76 bytes:

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

Powershell, 82 bytes

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

Supondo uma entrada de matriz 2D de

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

A saída é 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 bytes

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

Define um operador '#' que fornece a resposta correta. Por exemplo:

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

Infelizmente, Haskell não possui uma log10função compacta como muitas outras línguas, mas possui uma logBasefunção útil , o que significa que não precisamos dividir nossa resposta por 3. Infelizmente, como logBase 1000 0.05é um número negativo, precisamos usar o mais truncatedo que floorarredondá-lo.

Programa completo, incluindo casos de teste:

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

Fornece os seguintes resultados:

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 bytes

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

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

Experimente online!

Programa completo que utiliza uma tupla de duas listas - nomes como cadeias, saldos bancários como números - e imprime as cadeias resultantes.

— Jonathan Allan
fonte
1

C #, 125 bytes

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

Função anônima que imprime o resultado no formato do OP.

Programa completo com casos de teste:

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 110 95 86 bytes, graças a @iwaseatenbyagrue)

Um pouco de configuração:

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]

Minha tentativa:

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

Resultados: 

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

Editar: converter tudo em valores absolutos me salvou 15 bytes.

— Zona de Perigo
fonte
1
Mais importante, esse é um trecho de código. Normalmente, permitimos apenas funções ou programas completos. Quanto ao golfe, você pode remover muitos espaços. Tente: ["%s is in the %d-comma club."%(p,v.count(','))for p,v in zip(f,a)]Além disso, você deve incluir uma contagem de bytes.
— Conor O'Brien
Você pode fazer print'\n'.join([your array])e realmente imprimir a saída.
— Elronnd
2
Bem vindo ao site! Os negativos (por exemplo -123.45) são desativados em um (desde que você conte -). Mas por que não pegar uma lista de números e salvar (eu interpretei mal?). Você precisaria adicionar instruções de importação e, como está, esse trecho não é um programa ou função (como são os padrões, e a alteração deles é desencorajada, a menos que haja um bom motivo).
— Jonathan Allan
1
Obrigado, @ JonathanAllan. Atualmente, estou tentando melhorar isso, para não precisar contar as importações. Percebo que a math.ceilfunção do Python provavelmente adiciona um pouco de sobrecarga à minha pontuação.
— precisa saber é o seguinte
2
Você pode salvar 9 bytes substituindo (-len(str(abs(v)).split('.')[0])por len(str(int(float(v)))). No seu conjunto de testes, não há números negativos (nos exemplos, há um). Se você quiser ser completo, gaste 5 bytes para fazer len(str(abs(int(float(v)))))- o que economiza apenas 4 bytes.
— precisa saber é o seguinte
1

Perl 6, 107 95 bytes

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

Não é o meu trabalho mais orgulhoso, me avise se tiver esquecido alguma técnica de golfe. EDIT: -12 bytes graças a @Ven

— Håvard Nygård
fonte
por que parens por aí ^@f.elems? btw você não precisa disso .elems, for ^@ffunciona. Você não precisa nomear seu nome $x, use-o $_. E não use printf, use "{"interpolation"}".
— Ven
Eu nem entendo por que você precisa disso. Por que não escolher for @f? Você pode usar $++como um índice para acompanhá-lo (e indexar em @a).
— Ven
vou editar assim que estiver no pc :)
— Håvard Nygård
1
@ Ven, obrigado pelo aviso sobre os $ ++. Economiza muitos problemas em meus programas "reais". Acabei de pegar o Perl 6.
— Håvard Nygård
Você tem certeza de que as interpolações não salvam bytes?
— Ven
1

Python 2, 87 bytes

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

Um pouco mais antigo (90 bytes):

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

Recebe a entrada como uma lista de tuplas (nome, quantidade).

Estou fazendo isso no meu telefone na escola, então testarei mais tarde.

— Daniel
fonte
1

dc, 56 54 bytes

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

Isso recebe a entrada da pilha, que deve ser pré-carregada com o primeiro nome no topo da pilha, o primeiro número, o segundo nome, o segundo número, etc.

Aqui está um exemplo de carregamento da pilha e execução da 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

que produz a saída usual,

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.

Aqui está uma exegese do código:

[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

Observe que, na edição 1, substituí dZrX-(d = dup, Z = comprimento do número, r = troca, X = fração, - = subtrair) por 1/Z(divida o número por 1, que com a escala padrão de zero trunca o número inteiro; depois Z = número comprimento), economizando dois bytes.

— James Waldby - jwpat7
fonte
1

Rápido , 166 158 145 bytes

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

E aqui está o dicionário:

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
]

Experimente aqui!

— Mr. Xcoder
fonte
0

Clojure, 108 bytes

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

Não tenho certeza se a operação em carros alegóricos seria em curto do que nas seqüências de caracteres. Não tenho certeza se a resposta que não funciona é boa, o que retorna uma sequência de respostas.

— NikoNyrh
fonte
0

Rebol, 118 bytes

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

Sem jogar com declaração de matriz:

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

Resultado:

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 bytes

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
Você pode remover o String.valueOfe usar em seu (((""+Math.abs(m.get(k).longValue())).length()-1)/3)lugar.
— 21713 Kevin Kevin Kurtzleren
1
E você também pode remover os parênteses k->.
— Kevin Cruijssen
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.