Dites à mes amis à quel «club de virgule» ils appartiennent

16

Inspiré par les scènes du "club des trois virgules" de la Silicon Valley, comme celle-ci , dans ce défi, vous direz à dix personnes le "club des virgules" auquel ils appartiennent chacun.

Si vous n'êtes pas familier avec le terme «club de virgule», laissez-moi vous expliquer: vous êtes dans le club à une virgule si l'argent que vous avez est compris entre 1 000,00 $ et 999 999,99 $; vous êtes dans le club à deux virgules s'il se situe entre 1 000 000,00 $ et 999 999 999,99 $; ces "clubs" se répètent à travers le club des trois virgules, car aucun individu sur Terre (AFAIK) ne possède plus d'un billion de dollars américains (le yen japonais serait une histoire différente très rapidement). Ainsi, le nombre de virgules que possède votre compte bancaire, selon les normes de notation les plus courantes aux États-Unis et en Grande-Bretagne, indique le club de virgules auquel vous appartenez. Les mêmes règles de "virgule" s'appliquent pour les nombres négatifs (bien que vous ne souhaitiez pas être dans le club de virgule négatif): des montants négatifs dans la plage inclusive [-0.01, -999.

Les cas de 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

Les bonnes réponses:

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.

Quelle que soit la configuration du tableau dont vous avez besoin pour obtenir un friendstableau, le amountstableau ne compte pas dans votre score. Donc, pour Python, le code suivant ne compte pas:

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

Modifier: veuillez consulter les cas de test révisés

J'ai supprimé les virgules de chaîne réelles des cas de test pour rendre les choses un peu plus difficiles, au lieu de simplement compter les virgules.

code-golf 
— blacksite
source
2
Je ne pense pas que vous ayez rendu le format de sortie très clair. Est-ce que quelque chose est "Name number,Name number,..."acceptable?
— FryAmTheEggman
2
Les entrées en f sont-elles garanties positives ou le seraient -$1,234.56également dans le club à 1 virgule?
— Jonathan Allan
2
@not_a_robot Pourriez-vous répondre au commentaire de Fry? Est-il suffisant de sortir des paires de nom et de numéro dans n'importe quel format?
— Martin Ender
1
@FryAmTheEggman Non, la sortie doit être au format"<name> is in the <number of commas>-club."
— blacksite
1
Les cas de test ne sont pas spécifiés. Et même s'ils l'étaient, il n'y a pas de cas test couvrant la question des gros négatifs soulevée par Jonathan Allan ci-dessus.
— Peter Taylor

Réponses:

10

JavaScript (ES6), 80 octets

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

Prend un tableau de tableaux [ami, montant] et renvoie un tableau "ami est dans le club n-virgule". cordes. Fonctionne en ajoutant des zéros de fin supplémentaires pour que la longueur soit de 6-8 pour le club à 0 virgule, de 9 à 11 pour le club à 1 virgule, de 12 à 15 pour le club à 2 virgules, etc.

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

— Neil
source
Je ne pense pas que cela fonctionne pour les nombres négatifs. Par exemple, cela placerait Nelly (-123,45) dans le club à 1 virgule. Je suggère le plus court Math.log10(n*n)/6|0.
— Arnauld
@Arnauld Ah oui, j'avais oublié de |0tronquer à zéro, donc ça donne la bonne réponse pour Jamie.
— Neil
8

PostgreSQL, 61 octets

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

@xest la valeur absolue de x, log(x)est un logarithme en base 10 et div(y, x)calcule le quotient entier de y / x.

Installer:

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)

Production:

            ?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
source
C'est agréable de voir une réponse SQL compétitive - bravo!
— Toby Speight
6

Gelée , 34  32 octets

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

Un lien dyadique (fonction) qui prend une liste de soldes bancaires sous forme de nombres (décimales / entiers) et une liste de noms sous forme de chaînes et renvoie une liste de chaînes.

Essayez-le en ligne! - le pied de pageçYappelle simplement la fonction et rejoint la liste résultante avec des sauts de ligne afin qu'elle ait une sortie agréable lorsqu'elle est exécutée en tant que programme complet.

Comment?

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

PHP, 76 74 octets

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

Heureusement, je n'ai pas besoin de transtyper en int (comme je le ferais en C); PHP le fait implicitement pour %d.

— Titus
source
Gee! Suis-je le premier ici à calculer au lieu de compter les caractères?
— Titus
4

Mathematica (86 octets)

La configuration (avec des noms sous forme de chaînes, de l'argent sous forme de nombres):

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}

La tentative:

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

Toutes les fonctions de chaîne de Mathematica incluent "String" dans le nom, donc je pense que les journaux sont plus courts. Il Max[...,0]s'agit de gérer les nombres négatifs embêtants ou l'infini négatif pour les personnes qui possèdent entre -1 et 1 dollar. Le journal d'un nombre négatif comprend des éléments imaginaires, mais Mathematica ignore utilement cela lors de la prise d'un Floor!

— Pas un arbre
source
4

Japt , 36 octets

Cela prend le montant comme première entrée, le nom comme deuxième.

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

Explication

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 utilise la bibliothèque shoco pour la compression de chaînes.

Inspiré par la solution de @ Neil .

7 octets enregistrés grâce à @ETHproductions

Essayez-le en ligne!

— Oliver
source
1
Je pense que vous pouvez le faire Vw0 x4 l /3-2|0dans la section du milieu, en économisant 6 octets :-)
— ETHproductions
1
Je pense que vous pouvez enregistrer un octet en prenant l'entrée dans l'ordre inverse:V+`...{w0...
— ETHproductions
3

MATL, 50 48 43 octets

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

Essayez-le sur MATL Online

Explication

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

R, 68 octets

La mise en place:

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 solution:

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

Prenez le journal de base 10 de la valeur absolue du compte, arrondissez puis imprimez avec les noms.

Je ne sais pas s'il pourrait être plus petit s'il as'agissait d'un vecteur de caractères ...

— Joe
source
1
Qu'en est-il du cas de Nelly, qui a -123,45 dollars? Cet log10appel produira des NaNs pour les négatifs. On dirait que ça log10(abs(a))marcherait.
— blacksite
Oups, vous avez raison, l'échantillon ci-dessus n'inclut pas Nelly. Et j'ai mal lu la spécification ... J'ai compris que la valeur négative devrait être 0 virgule club.
— Joe
Au lieu de abs(x), utilisez pmax(a,1)- cela prendra moins de 1 et le rendra 1, donnant de bons résultats pour les nombres négatifs. Et, au lieu de floor(log10(...)/3)vous pouvez utiliser log10(...)%/%3. Je pense que cela réduit à 66 octets (et corrige les points négatifs).
— Gregor --reinstate Monica--
1
Il convient également de noter que 7 octets complets sont le cat()et \n... l'impression du vecteur avec les chaînes dans la console peut être considérée comme assez bonne (* ahem * comme les réponses Python).
— Gregor --reinstate Monica--
Cela a une parenthèse supplémentaire après 3. Il produit également le club -1 pour Jamie. L'utilisation de pmax (a, 1) corrige cela.
— BLT
3

JavaScript, 59 octets

3 octets enregistrés grâce à @ETHproductions

Sauvegardé 2 octets grâce à @Cyoce

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

Démo

Afficher l'extrait de code

— Oliver
source
1
Enregistrez un octet avec `${}`et vous pouvez utiliser la fonction au n=>m=>...lieu de(n,m)=>...
— Cyoce
2

Vim, 72 octets

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

D'une manière ou d'une autre, je devrais montrer qu'il y a un retour de fuite, mais je ne sais pas comment. Ceci est juste une réponse regex de base, qui, je suis sûr, pourrait être battue par n'importe quel langage regex. J'aurais utilisé V, mais je pense que les commandes de substitution dans V utilisent/ comme séparateur par défaut, et je ne pouvais pas comprendre comment faire en sorte de ne pas se plaindre de la division.

Prend l'entrée en tant que table OP et renvoie des valeurs en tant que table, mais avec les informations financières remplacées par "est dans le club de virgule X"

Essayez-le en ligne!

— nmjcman101
source
Je ne pense pas que l' \-=ajoute quoi que ce soit. De plus, si vous supprimez les espaces supplémentaires dans votre entrée et modifiez également l'expression \v (\d*).*;
— régulière,
2

05AB1E , 32 octets

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

Essayez-le en ligne!

Explication

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

Python 2, 69 octets

Configurez nos tableaux:

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]

Et notre fonction peut alors être:

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

Nous donnant:

>>> [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 baie doit être identique à celle fournie dans la question, la solution coûte 76 octets:

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

Powershell, 82 octets

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

En supposant une entrée de tableau 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 sortie est 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
source
2

Haskell, 71 octets

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

Définit un opérateur '#' qui fournit la bonne réponse. Par exemple:

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

Malheureusement, Haskell n'a pas de log10fonction compacte comme beaucoup d'autres langages, mais il a une logBasefonction utile , ce qui signifie que nous n'avons pas besoin de diviser notre réponse par 3. Malheureusement, logBase 1000 0.05c'est un nombre négatif, nous devons donc utiliser le plus truncateplutôt que floorde la contourner.

Programme complet comprenant des cas de 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

Donne les résultats suivants:

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

K, 66 octets

    /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
source
1

Python 2.7 , 89 86 84 octets

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

Essayez-le en ligne!

Programme complet qui prend un tuple de deux listes - les noms sous forme de chaînes, les soldes bancaires sous forme de nombres - et imprime les chaînes résultantes.

— Jonathan Allan
source
1

C #, 125 octets

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

Fonction anonyme qui imprime le résultat au format OP.

Programme complet avec cas de 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
source
1

Python 3 ( 207159110110 95 207159110110 86 octets, merci à @iwaseatenbyagrue)

Un peu de configuration:

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]

Ma tentative:

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

Résultats: 

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

Edit: tout convertir en valeurs absolues m'a fait gagner 15 octets.

— blacksite
source
1
Plus important encore, il s'agit d'un extrait de code. En règle générale, nous n'autorisons que les fonctions ou les programmes complets. Quant au golf, vous pouvez supprimer de nombreux espaces. Essayez: ["%s is in the %d-comma club."%(p,v.count(','))for p,v in zip(f,a)]vous devez également inclure un nombre d'octets.
— Conor O'Brien
Vous pouvez faire print'\n'.join([your array])et imprimer la sortie.
— Elronnd
2
Bienvenue sur le site! Les négatifs (par exemple -123.45) sont décalés d'un (puisque vous comptez le -). Mais pourquoi ne pas prendre une liste de numéros et enregistrer (ai-je mal interprété?). Vous auriez besoin d'ajouter des instructions d'importation, et en l'état, il s'agit d'un extrait et non d'un programme ou d'une fonction (comme les valeurs par défaut, et leur changement est déconseillé sauf si il y a une bonne raison).
— Jonathan Allan
1
Merci, @JonathanAllan. J'essaie actuellement d'améliorer cela, donc je n'ai pas à compter les importations. Je me rends compte que la math.ceilfonction de Python ajoute probablement un peu de surcharge à mon score.
— blacksite
2
Vous pouvez économiser 9 octets en remplaçant (-len(str(abs(v)).split('.')[0])par len(str(int(float(v)))). Dans votre test, il n'y a pas de nombres négatifs (dans les exemples, il y en a un). Si vous vouliez être completiste, dépensez 5 octets à faire len(str(abs(int(float(v)))))- ce qui ne vous fait économiser que 4 octets.
— iwaseatenbyagrue
1

Perl 6, 107 95 octets

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

Ce n'est pas mon travail le plus fier, donnez-moi une note si j'ai oublié des techniques de golf. EDIT: -12 octets grâce à @Ven

— Håvard Nygård
source
pourquoi parens autour ^@f.elems? btw vous n'avez pas besoin de ça .elems, ça for ^@fmarche. Vous n'avez pas besoin de nommer votre $x, utilisez $_plutôt. Et n'utilisez pas printf, utilisez "{"interpolation"}".
— Ven
Je ne comprends même pas pourquoi vous en avez besoin. Pourquoi ne pas y aller for @f? Vous pouvez l'utiliser $++comme index pour l'accompagner (et indexer @a).
— Ven
mauvais montage dès que je suis sur le pc :)
— Håvard Nygård
1
@Ven merci pour les informations sur $ ++. Me sauve beaucoup de problèmes dans mes "vrais" programmes. Je viens de prendre Perl 6.
— Håvard Nygård
Êtes-vous sûr que les interpolations n'enregistrent pas d'octets?
— Ven
1

Python 2, 87 octets

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

Légèrement plus ancien (90 octets):

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

Prend l'entrée comme une liste de tuples (nom, montant).

Je fais ça sur mon téléphone à l'école donc je vais le tester plus tard.

— Daniel
source
1

dc, 56 54 octets

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

Cela prend l'entrée de la pile, qui doit être préchargée avec le prénom en haut de la pile, le premier numéro, le deuxième nom, le deuxième numéro, etc.

Voici un exemple de chargement de la pile et d'exécution de 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

qui produit la sortie habituelle,

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.

Voici une exégèse du code:

[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

Remarque, dans l'édition 1, j'ai remplacé dZrX-(d = dup, Z = longueur du nombre, r = swap, X = fraction, - = soustraire) par 1/Z(diviser le nombre par 1, qui avec l'échelle par défaut de zéro tronque en entier; puis Z = nombre longueur), économisant deux octets.

— James Waldby - jwpat7
source
1

Swift , 166 158 145 octets

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

Et voici le dictionnaire:

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
]

Essayez-le ici!

— M. Xcoder
source
0

Clojure, 108 octets

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

Je ne sais pas si le fonctionnement sur des flotteurs serait court-circuité que sur des séquences de caractères. Je ne sais pas si la réponse non fonctionnelle est correcte, ce qui renvoie une séquence de réponses.

— NikoNyrh
source
0

Rebol, 118 octets

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 avec déclaration de tableau:

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

Production:

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

Java 8 154 141 octets

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

Non 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
source
1
Vous pouvez supprimer String.valueOfet utiliser à la (((""+Math.abs(m.get(k).longValue())).length()-1)/3)place.
— Kevin Cruijssen
1
Et vous pouvez également supprimer les parenthèses autour k->.
— Kevin Cruijssen
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.