Probabilmente sai che i diversi livelli di reputazione su Stack Exchange sono formattati in modo diverso se visti dalla pagina delle domande / un post. Ci sono tutte le regole di formattazione di rep:

• se un utente ha da 1 a 999 (da una a tre cifre), viene lasciato così com'è.
• se un utente ha una ripetizione da 1000 a 9999 (quattro cifre), riceve la virgola come separatore: 9,999

• se un utente ha da 10000 a 99999 rappresentanti (cinque cifre), viene accorciato e arrotondato. Vale a dire, 16741 rappresentante è formattato come 16.7k, notare il punto separatore a differenza della virgola per il rappresentante inferiore (punto precedente).

  1. 16750 risulterà già 16.8k(poiché questo sembra essere stato risolto )

  2. 16941 risultati 16.9k, 16950 arrotondati a 17k, così come 17014, per esempio.

  3. 99941 round a 99.9k, 99950 round a 100k(questo è qualcosa che odio in realtà con il rep-rounding su SE, perché 100.000 è una pietra miliare e 99950 non è affatto vicino).

• Se un utente ha una ripetizione da 100000 a 999999, viene arrotondato in questo modo:

  1. 100100 arrotondati fino a 100k, 100500 arrotondati fino a 101k. Il fatto è che l'arrotondamento viene eseguito, ma la parte decimale viene eliminata (a differenza del rappresentante a quattro cifre).

  2. 100450 arrotondano per difetto a 100k, nessun passo per arrotondare da 450 a 500. Neanche 100499 - è ancora 100k.

  3. 279843 arrotondamenti per 280keccesso e 399999 arrotondamenti per 400k.

Come input, ti viene data la reputazione grezza e l'output è formattato.

Puoi considerare che l'input non riceverà numeri / non numeri non validi o numeri con zeri iniziali, ad es 0001234.

Poiché Jon Skeet non sembra raggiungere presto 1.000.000, il tuo codice deve essere il più breve possibile e non è necessario gestire un rappresentante superiore a un milione (ovvero nessun caso speciale per 999500 e oltre).

Japt, 50 48 byte

Primo tentativo; potrebbe esserci un metodo migliore.

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

Provalo online!

Come funziona

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

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

Un altro primo tentativo. Grazie al cielo .toLocaleString(), l'alternativa più breve che ho trovato è di 21 byte in più ...

Questo separa migliaia di uno ,o ., a seconda del paese in cui vivi. Per altri cinque byte, puoi farlo sempre usando una virgola:

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

JavaScript (ES6), 71

Battere @ETHProductions mentre non vede il mio suggerimento. L'ha visto.

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

Test

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>

Test

ES6, 68 62 byte

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

Modifica: salvato 6 byte quando mi sono reso conto che si ["1", "001"]restringe a "1,001".

Modifica: salvato 2 byte per correggere il commento di @ Mwr247!

Python 2.7, 58 byte

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

Ho dovuto usare (x+.5)per affrontare il 16950->17kcaso ..