Dato un elenco di stringhe, ordina l'elenco come numeri senza sapere quale base viene utilizzata. Anche i valori delle cifre sono sconosciuti (è possibile che '1'> '2').

Poiché i valori delle cifre sono sconosciuti, utilizzare la Legge di Benford (o Legge della prima cifra) per determinare il valore relativo delle cifre. Per le distribuzioni che seguono la Legge di Benford, le cifre con valori più bassi appaiono come cifre iniziali più frequentemente rispetto alle cifre con valori più alti.

Regole

• Questo è code-golf
• L'elenco delle stringhe può provenire da una fonte di tua scelta (stdin, variabile, file, utente, ecc.)
• Le stringhe sono limitate ai caratteri ASCII.
• I personaggi che non compaiono come protagonisti hanno i valori più alti. (supponi che non ci siano zeri e ordina rigorosamente in base alla frequenza principale.)
• I personaggi che appaiono come cifre iniziali lo stesso numero di volte degli altri personaggi sono ponderati allo stesso modo.

Esempio

Unsorted

['c','ca','ac','cc','a','ccc','cx','cz','cy']

smistato

['c','a','cc','ca','cz','cy','cx','ac','ccc']

Nota: Nell'esempio 'cz', 'cy'e 'cx'può apparire come il 5 °, 6 ° e 7 ° elementi in qualsiasi ordine poiché le cifre 'x', 'y'e 'z'sono ugualmente ponderati.

Python, 59 108 112

sorted(a,None,lambda x:(-len(x),map(zip(*a)[0].count,x)),1)

L'input è fornito come elenco a e questa espressione produce l'elenco ordinato (+2 caratteri da assegnare a una variabile). Questo ordina l'elenco al contrario per lunghezza negata e poi per frequenza.

Ruby, 65 anni

f=->a{a.sort_by{|s|[s.size,s.chars.map{|c|a.count{|t|t[0]!=c}}]}}

Ordina lessicograficamente in base alla dimensione della stringa, quindi la frequenza di ciascun personaggio come non la cifra iniziale.

Java (261)

void s(String[]s){int[]a=new int[128];for(String t:s)a[t.charAt(0)]++;java.util.Arrays.sort(s,(o,p)->{int j=o.length()-p.length();if(j!=0)return j;for(int i=0;i<Math.min(o.length(),p.length());i++){j=a[p.charAt(i)]-a[o.charAt(i)];if(j!=0)return j;}return 0;});}

void s(String[] s) {
    int[] a = new int[128];
    for (String t : s) {
        a[t.charAt(0)]++;
    }
    java.util.Arrays.sort(s, (o, p) -> {
        int j = o.length() - p.length();
        if (j != 0) {
            return j;
        }
        for (int i = 0; i < Math.min(o.length(), p.length()); i++) {
            j = a[p.charAt(i)] - a[o.charAt(i)];
            if (j != 0) {
                return j;
            }
        }
        return 0;
    });
}

Il metodo accetta una matrice di stringhe e ordina la matrice in posizione. Niente di speciale per l'implementazione, ma fa uso delle espressioni lambda aggiunte a Java 8.

Javascript (E6) 147

F=i=>(f={},i.map(x=>(f[x[0]]=-~f[x[0]])),i.map(x=>[x,[...x].map(y=>1e9-~f[y]+'')]).sort((a,b,d=a[0].length-b[0].length)=>d||a[1]<b[1]).map(x=>x[0]))

Limite

Valori di frequenza fino a 1000000000: per l'ordinamento, i valori di frequenza vengono uniti in una grande stringa imbottita

Ungolfed

F=i=>(
  f={}, //init frequency map
  i.map(x => (f[x[0]]=-~f[x[0]])), // build frequency map
  i.map(x => [x, [...x].map(y=>1e9-~f[y]+'')]) // add frequency info to each element of input list
 .sort((a,b,d=a[0].length-b[0].length)=>d || a[1]<b[1]) // then sort by lenght and frequency
 .map( x => x[0]) // throw away frequency info
)

Sidenote X-~ incrementa di 1 anche se il numero originale X non è definito o NaN

uso

F(['c','ca','ac','cc','a','ccc','cx','cz','cy'])

Produzione: ["c", "a", "cc", "ca", "cx", "cz", "cy", "ac", "ccc"]