Dile a mis amigos a qué "club de coma" pertenecen

16

Inspirado en las escenas del "club de tres comas" de Silicon Valley, como esta , en este desafío le contarás a diez personas el "club de comas" al que pertenecen.

Si no está familiarizado con el término "club de coma", permítame explicarle: está en el club de una coma si el dinero que tiene está en el rango inclusivo de $ 1,000.00 a $ 999,999.99; estás en el club de dos comas si está en el rango de $ 1,000,000.00 a $ 999,999,999.99; estos "clubes" se repiten a través del club de tres comas, ya que ningún individuo en la Tierra (AFAIK) posee más de un billón de dólares estadounidenses (el yen japonés sería una historia diferente muy rápidamente). Entonces, la cantidad de comas que tiene su cuenta bancaria, de acuerdo con los estándares de notación más comunes en los Estados Unidos y Gran Bretaña, denota el club de comas al que pertenece. Las mismas reglas de "coma" se aplican a los números negativos (aunque no querría estar en el club de coma negativo): cantidades negativas en el rango inclusivo [-0.01, -999.

Los casos de prueba

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

Las respuestas correctas:

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.

Cualquier configuración de matriz que necesite para obtener una friendsmatriz y una amountsmatriz no cuenta para su puntaje. Entonces, para Python, el siguiente código no cuenta:

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: consulte los casos de prueba revisados

Eliminé las comas de cadena reales de los casos de prueba para hacer las cosas un poco más difíciles, en lugar de contar las comas.

code-golf 
— sitio negro
fuente
2
No creo que haya dejado muy claro el formato de salida. ¿Es algo como "Name number,Name number,..."aceptable?
— FryAmTheEggman
2
¿Se garantiza que las entradas en f sean positivas, o -$1,234.56también estarían en el club de 1 coma?
— Jonathan Allan
2
@not_a_robot ¿Podrías abordar el comentario de Fry? ¿Es suficiente generar pares de nombre y número en cualquier formato?
— Martin Ender
1
@FryAmTheEggman No, la salida debe estar en el formato"<name> is in the <number of commas>-club."
— blacksite el
1
Los casos de prueba no son especificaciones. E incluso si lo fueran, no hay un caso de prueba que cubra el tema de los grandes negativos planteados por Jonathan Allan anteriormente.
— Peter Taylor

Respuestas:

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

Toma una matriz de matrices [amigo, cantidad] y devuelve una matriz de "amigo está en el club n-coma". instrumentos de cuerda. Funciona agregando ceros finales adicionales para que la longitud sea 6-8 para el club de 0 comas, 9-11 para el club de 1 coma, 12-15 para el club de 2 comas, etc.

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

— Neil
fuente
No creo que esto funcione para números negativos. Por ejemplo, pondría a Nelly (-123.45) en el club de 1 coma. Sugeriría el más corto Math.log10(n*n)/6|0.
— Arnauld
@Arnauld Ah, sí, me había olvidado de |0truncar a cero, por lo que da la respuesta correcta para Jamie.
— Neil
8

PostgreSQL, 61 bytes

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

@xes el valor absoluto de x, log(x)es el logaritmo de base 10 y div(y, x)calcula el cociente entero de y / x.

Preparar:

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)

Salida:

            ?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
fuente
Es agradable ver una respuesta SQL competitiva, ¡bien hecho!
— Toby Speight
6

Jalea , 34  32 bytes

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

Un enlace diádico (función) que toma una lista de saldos bancarios como números (decimales / enteros) y una lista de nombres como cadenas y devuelve una lista de cadenas.

Pruébalo en línea! - el pie de páginaçYsimplemente llama a la función y se une a la lista resultante con avances de línea para que tenga un buen resultado cuando se ejecuta como un programa completo.

¿Cómo?

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

Afortunadamente no tengo que enviar a int (como tendría que hacer en C); PHP lo hace implícitamente para %d.

— Titus
fuente
¡Caramba! ¿Soy el primero en calcular en lugar de contar caracteres?
— Titus
4

Mathematica (86 bytes)

La configuración (con nombres como cadenas, dinero 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}

El intento:

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

Todas las funciones de cadena de Mathematica incluyen "Cadena" en el nombre, por lo que creo que los registros son más cortos. El Max[...,0]es tratar con los molestos números negativos o el infinito negativo para las personas que poseen entre -1 y 1 dólares. El registro de un número negativo incluye cosas imaginarias, pero Mathematica lo ignora cuando toma un Floor!

— No un arbol
fuente
4

Japt , 36 bytes

Esto toma la cantidad como la primera entrada, el nombre como la segunda.

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

Explicación

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 la biblioteca shoco para la compresión de cadenas.

Inspirado en la solución de @ Neil .

Guardado 7 bytes gracias a @ETHproductions

Pruébalo en línea!

— Oliver
fuente
1
Creo que puedes hacerlo Vw0 x4 l /3-2|0en la sección central, ahorrando 6 bytes :-)
— ETHproductions
1
Creo que puede guardar un byte tomando la entrada en el orden opuesto:V+`...{w0...
— ETHproductions
3

MATL, 50 48 43 bytes

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

Pruébalo en MATL Online

Explicación

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

R, 68 bytes

La puesta en marcha:

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 solución:

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

Tome el registro de base 10 del valor absoluto de la cuenta, redondee hacia abajo e imprima con los nombres.

No estoy seguro de si podría ser más pequeño si afuera un vector de caracteres ...

— Joe
fuente
1
¿Qué pasa con el caso de Nelly, que tiene -123.45 dólares? Esa log10llamada producirá NaNs para negativos. Parece log10(abs(a))que funcionaría.
— blacksite
Vaya, tienes razón, la muestra anterior no incluía a Nelly. Y leí mal la especificación ... Comprendí que el valor negativo debería ser 0 club de coma.
— Joe
En lugar de abs(x)usar pmax(a,1), esto tomará menos de 1 y lo convertirá en 1, dando buenos resultados para números negativos. Y, en lugar de floor(log10(...)/3)que pueda usar log10(...)%/%3. Creo que eso lo reduce a 66 bytes (y lo corrige para los negativos).
— Gregor
1
También vale la pena señalar que 7 bytes completos de eso son cat()y \n... imprimir el vector con las cadenas en la consola podría considerarse lo suficientemente bueno (* ejem * como las respuestas de Python).
— Gregor
Esto tiene un paréntesis adicional después de 3. También genera el -1 club para Jamie. El uso de pmax (a, 1) corrige eso.
— BLT
3

JavaScript, 59 bytes

Guardado 3 bytes gracias a @ETHproductions

Guardado 2 bytes gracias a @Cyoce

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

Manifestación

Mostrar fragmento de código

— Oliver
fuente
1
Guarde un byte con `${}`y puede curry la función en n=>m=>...lugar de(n,m)=>...
— Cyoce
2

Vim, 72 bytes

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

De alguna manera debería mostrar que hay un retorno final, pero no estoy seguro de cómo. Esta es solo una respuesta básica de expresiones regulares, que estoy seguro podría ser superada por cualquier lenguaje de expresiones regulares. Hubiera usado V, pero creo que los comandos sustitutos en V usan/ como separador por defecto, y no pude encontrar la manera de que no se queje de la división.

Toma datos como la tabla de OP y devuelve valores como la tabla, pero con la información financiera reemplazada por "está en el club de coma X"

Pruébalo en línea!

— nmjcman101
fuente
No creo que \-=agregue nada. Además, si elimina los espacios adicionales en su entrada y también cambia la expresión regular \v (\d*).*;, podría ahorrar 4 bytes
— DJMcMayhem
2

05AB1E , 32 bytes

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

Pruébalo en línea!

Explicación

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

Python 2, 69 bytes

Configura nuestras matrices:

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]

Y nuestra función puede ser:

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

Dándonos:

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

Si la matriz necesita ser idéntica a la proporcionada en la pregunta, entonces la solución cuesta 76 bytes:

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

Powershell, 82 bytes

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

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

La salida es 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.

— Colina
fuente
2

Haskell, 71 bytes

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

Define un operador '#' que proporciona la respuesta correcta. P.ej:

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

Desafortunadamente, Haskell no tiene una log10función compacta como muchos otros idiomas, pero tiene una logBasefunción útil , lo que significa que no necesitamos dividir nuestra respuesta entre 3. Desafortunadamente, logBase 1000 0.05es un número negativo, por lo que debemos usar el más largo truncatequefloor redondearlo.

Programa completo que incluye casos de prueba:

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

Da los siguientes 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
fuente
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
fuente
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.'

Pruébalo en línea!

Programa completo que toma una tupla de dos listas: nombres como cadenas, saldos bancarios como números e imprime las cadenas resultantes.

— Jonathan Allan
fuente
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");};

Función anónima que imprime el resultado en el formato del OP.

Programa completo con casos de prueba:

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

Python 3 ( 207 159 110 95 86 bytes, gracias a @iwaseatenbyagrue)

Un poco de configuración:

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]

Mi intento:

['%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: convertir todo a valores absolutos me ahorró 15 bytes.

— sitio negro
fuente
1
Lo más importante, este es un fragmento de código. Por lo general, solo permitimos funciones o programas completos. En cuanto al golf, puede eliminar muchos espacios. Intente: ["%s is in the %d-comma club."%(p,v.count(','))for p,v in zip(f,a)]Además, debe incluir un recuento de bytes.
— Conor O'Brien
Puede hacer print'\n'.join([your array])e imprimir realmente la salida.
— Elronnd
2
Bienvenido al sitio! Los negativos (por ejemplo -123.45) están apagados por uno (ya que cuenta el -). Pero, ¿por qué no tomar una lista de números y guardar (¿he malinterpretado?). Debería agregar declaraciones de importación, y tal como está, este es un fragmento, no un programa o función (como son los valores predeterminados, y se desaconseja cambiarlos a menos que haya una buena razón).
— Jonathan Allan
1
Gracias, @JonathanAllan. Actualmente estoy tratando de mejorar esto para no tener que contar las importaciones. Me doy cuenta de que la math.ceilfunción de Python probablemente agrega un poco de sobrecarga a mi puntaje.
— blacksite el
2
Puede guardar 9 bytes reemplazando (-len(str(abs(v)).split('.')[0])con len(str(int(float(v)))). En su conjunto de prueba, no hay números negativos (en los ejemplos, hay uno). Si quisieras ser completista, gasta 5 bytes para hacer len(str(abs(int(float(v))))), lo que solo te ahorra 4 bytes.
— iwaseatenbyagrue
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;}

No es mi trabajo más orgulloso, avísenme si he olvidado alguna técnica de golf. EDITAR: -12 bytes gracias a @Ven

— Håvard Nygård
fuente
¿Por qué parens alrededor ^@f.elems? por cierto no necesitas eso .elems, for ^@ffunciona. No necesita nombrar su $x, use $_en su lugar. Y no use printf, use "{"interpolation"}".
— Ven
Ni siquiera entiendo por qué necesitas eso. ¿Por qué no ir a por for @f? Puede usarlo $++como índice para acompañarlo (e indexarlo @a).
— Ven
editaré tan pronto como esté en la PC :)
— Håvard Nygård
1
@Ven gracias por el aviso sobre los $ ++. Me ahorra muchos problemas en mis programas "reales". Acabo de recoger Perl 6.
— Håvard Nygård
¿Estás seguro de que las interpolaciones no guardan 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(',')

Un poco más antiguo (90 bytes):

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

Toma la entrada como una lista de tuplas (nombre, cantidad).

Estoy haciendo esto en mi teléfono en la escuela, así que lo probaré más tarde.

— Daniel
fuente
1

dc, 56 54 bytes

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

Esto toma la entrada de la pila, que debe cargarse previamente con el primer nombre en la parte superior de la pila, el primer número, el segundo nombre, el segundo número, etc.

Aquí hay un ejemplo de cómo cargar la pila y ejecutar la 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 produce la salida habitual,

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.

Aquí hay una exégesis del 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

Tenga en cuenta que en la edición 1 reemplacé dZrX-(d = dup, Z = longitud del número, r = intercambio, X = fracción, - = restar) con 1/Z(dividir el número por 1, que con la escala predeterminada de cero se trunca a entero; luego Z = número longitud), ahorrando dos bytes.

— James Waldby - jwpat7
fuente
1

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

Y aquí está el diccionario:

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
]

Pruébalo aquí!

— Sr. Xcoder
fuente
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)

No estoy seguro si la operación en flotadores se acortaría que en secuencias de caracteres. No estoy seguro si la respuesta sin función está bien, lo que devuelve una secuencia de respuestas.

— NikoNyrh
fuente
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."]]

Ungolfed con declaración 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."]
]

Salida:

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

Sin golf

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
fuente
1
Puede eliminar String.valueOfy usar (((""+Math.abs(m.get(k).longValue())).length()-1)/3)en su lugar.
— Kevin Cruijssen
1
Y también puedes eliminar el paréntesis k->.
— Kevin Cruijssen
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.