Probablemente sepa que los diferentes niveles de reputación en Stack Exchange tienen un formato diferente cuando se ven desde la página de preguntas / una publicación. Existen todas las reglas de formateo de repeticiones:

• si un usuario tiene 1 a 999 (uno a tres dígitos) rep, se deja como está.
• Si un usuario tiene 1000 a 9999 repeticiones (cuatro dígitos), recibe la coma como separador: 9,999

• si un usuario tiene de 10000 a 99999 repeticiones (cinco dígitos), se acorta y se redondea. Es decir, 16741 rep está formateado como 16.7k, observe el separador de puntos a diferencia de la coma para el rep inferior (punto anterior).

  1. 16750 ya resultará 16.8k(ya que esto parece estar solucionado )

  2. 16941 da como resultado 16.9k, 16950 redondea hasta 17k, al igual que 17014, por ejemplo.

  3. 99941 redondea a 99.9k, 99950 redondea a 100k(esto es algo que realmente odio con el redondeo de repeticiones en SE, porque 100,000 es un hito y 99950 no está cerca).

• Si un usuario tiene 100000 a 999999 repeticiones, se redondea de esta manera:

  1. 100100 redondea hacia abajo 100k, 100500 redondea hasta 101k. La cuestión es que el redondeo está hecho, pero la parte decimal se elimina (a diferencia del representante de cuatro dígitos).

  2. 100450 se redondea hacia abajo 100k, no hay paso para redondear 450 a 500. Tampoco 100499, sigue siendo 100k.

  3. 279843 redondea hacia arriba 280ky 399999 redondea hacia 400k.

Como entrada, se le da la reputación bruta y la emite como formateada.

Puede considerar que la entrada no recibirá números / no números no válidos, o números con ceros a la izquierda, es decir 0001234.

Debido a que Jon Skeet no parece llegar a 1,000,000 pronto, su código debe ser lo más breve posible , no necesita manejar el representante mayor de un millón (es decir, no hay casos especiales para 999500 y superiores).

Japt, 50 48 bytes

Primer intento; Puede haber un mejor método.

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

Pruébalo en línea!

Cómo funciona

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

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

Otro primer intento. Gracias a Dios por eso .toLocaleString(), la alternativa más corta que pude encontrar es 21 bytes más larga ...

Esto separa miles entre uno ,u otro ., según el país en el que viva. Para cinco dos bytes más, puede hacer que siempre use una coma:

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

JavaScript (ES6), 71

Vencer a @ETHProductions mientras no ve mi pista. El lo vió.

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

Prueba

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>

Prueba

ES6, 68 62 bytes

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

Editar: guardado 6 bytes cuando me di cuenta de que ["1", "001"]stringifica a "1,001".

Editar: ¡Se guardaron 2 bytes para arreglar el comentario de @ Mwr247!

Python 2.7, 58 bytes

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

Tuve que usar (x+.5)para lidiar con el 16950->17kcaso ...