Vous savez probablement que les différents niveaux de réputation sur Stack Exchange sont formatés différemment lorsqu'ils sont vus à partir de la page de questions / d'un article. Il y a toutes les règles de formatage des représentants:

• si un utilisateur a 1 à 999 (un à trois chiffres) représentant, il est laissé tel quel.
• si un utilisateur a entre 1 000 et 9 999 répétitions (quatre chiffres), il reçoit la virgule comme séparateur: 9,999

• si un utilisateur dispose de 10000 à 99999 rep (cinq chiffres), il est raccourci et arrondi. C'est-à-dire, 16741 rep est formaté comme 16.7k, notez le séparateur de points contrairement à la virgule pour le représentant inférieur (point précédent).

  1. 16750 résultera déjà 16.8k(puisque cela semble être corrigé )

  2. 16941 donne 16950 16.9karrondis à 17k, ainsi que 17014, par exemple.

  3. 99941 arrondit à 99.9k, 99950 arrondit à 100k(c'est quelque chose que je déteste en fait avec l'arrondi de répétition sur SE, car 100 000 est un tel jalon et 99950 est loin d'être le cas).

• Si un utilisateur a 100000 à 999999 représentants, il est arrondi de cette façon:

  1. 100100 100karrondis à , 100500 arrondis à 101k. Le fait est que l'arrondi est fait, mais la partie décimale est supprimée (contrairement au représentant à quatre chiffres).

  2. 100450 arrondit à 100k, pas de pas pour arrondir 450 à 500. 100499 non plus - c'est toujours 100k.

  3. 279843 arrondit à 280ket 399999 arrondit à 400k.

En entrée, vous obtenez la réputation brute et la sortez sous forme formatée.

Vous pouvez considérer que l'entrée ne recevra pas de nombres / non-nombres invalides, ou des nombres avec des zéros en tête, c'est-à-dire 0001234.

Parce que Jon Skeet ne semble pas atteindre 1 000 000 bientôt, votre code doit être aussi court que possible, vous n'avez pas besoin de gérer le représentant supérieur à un million (c'est-à-dire pas de cas particuliers pour 999500 et plus).

Japt, 50 48 octets

Premier essai; il peut y avoir une meilleure méthode.

U<A³?U:U<L²?Us i1', :(U<1e5?Ue2n)r /A:Ue3n)r)+'k

Essayez-le en ligne!

Comment ça fonctionne

          // Implicit: U = input integer, A = 10, L = 100
U<A³?U    // If U is less than A³ (10³ = 1000), return U.
:U<L²?    // Else, if U is less than L² (100² = 10000), return:
Us i1',   //  U.toString, with a comma inserted at position 1.
:(        // Else, return:
U<1e5?    //  If U is less than 1e5:
Ue2n)     //   U * (10 to the power of -2), 
r /A      //   rounded and divided by 10.
:Ue3n)r)  //  Else: U * (10 to the power of -3), rounded.
+'k       //  Either way, add a "k" to the end.
          // Implicit: output last expression

JavaScript (ES6), 76 68 octets

x=>x<1e4?x.toLocaleString():(x<1e5?(x/1e2+.5|0)/10:(x/1e3+.5|0))+"k"

Encore une première tentative. Dieu merci pour cette pratique .toLocaleString(), l'alternative la plus courte que j'ai pu trouver est 21 octets de plus ...

Cela sépare des milliers par ,ou ., selon le pays dans lequel vous vivez. Pour cinq deux octets de plus, vous pouvez toujours utiliser une virgule:

x=>x<1e4?x.toLocaleString`en`:(x<1e5?(x/1e2+.5|0)/10:(x/1e3+.5|0))+"k"

JavaScript (ES6), 71

Battre @ETHProductions alors qu'il ne voit pas mon indice. Il l'a vu.

x=>x<1e3?x:x<1e4?(x+='')[0]+','+x.slice(1):(x/1e3).toFixed(x<99950)+'k'

Tester

f=x=>x<1e3?x:x<1e4?(x+='')[0]+','+x.slice(1):(x/1e3).toFixed(x<99950)+'k'

function test() { n=+I.value, O.textContent = n + ' -> ' + f(n) }

test()

<input id=I type=number value=19557 oninput=test()>
<pre id=O></pre>

Tester

ES6, 68 62 octets

x=>x<1e4?`${x}`.split(/(?=...)/)+"":x.toPrecision(3)/1e3+"k"

Edit: sauvé 6 octets quand je me suis rendu compte que se ["1", "001"]stringifiait "1,001".

Edit: enregistré 2 octets pour corriger le commentaire de @ Mwr247!

Python 2.7, 58 octets

lambda x:['%.3g'%((x+.5)/1e3)+'k','{:,}'.format(x)][x<1e4]

Je devais utiliser (x+.5) pour faire face à l' 16950->17kaffaire ..