Dizelerin bir listesi verildiğinde, hangi tabanın kullanıldığını bilmeden listeyi sayılar olarak sıralayın. Basamak değerleri de bilinmiyor ( '1'> olabilir '2').

Rakamların değerleri bilinmediğinden, rakamların göreceli değerini belirlemek için Benford Yasası'nı (veya Birinci Basamak Yasası'nı) kullanın. Benford Yasasını izleyen dağıtımlar için, daha düşük değerli rakamlar, daha yüksek değerli rakamlardan daha sık öncü rakam olarak görünür.

kurallar

• Bu kod golfü
• Dizelerin listesi seçtiğiniz bir kaynaktan gelebilir (stdin, değişken, dosya, kullanıcı, vb.)
• Dizeler ASCII karakterleriyle sınırlıdır.
• Baş karakter olarak görünmeyen karakterler en yüksek değerlere sahiptir. (sıfır olmadığını varsayalım ve kesinlikle önde gelen frekansa göre sıralayın.)
• Önde gelen rakamlar olarak görünen karakterler, diğer karakterlerle aynı sayıda tartılır.

Misal

Sınıflandırılmamış

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

Sıralama

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

Not: Örnek olarak, 'cz', 'cy've 'cx'5, 6 ve basamak beri herhangi bir sırayla 7. elemanları olarak görünebilir 'x', 'y've 'z'eşit bir ağırlığa sahiptir.

Python, 59 108 112

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

Giriş liste olarak sağlanır ave bu ifade sıralı listeyi (bir değişkene atamak için +2 karakter) oluşturur. Bu, listeyi negatif uzunluk ve ardından frekansa göre tersine sıralar .

Yakut, 65

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

Dizginin boyutuna göre sözlükbilimsel olarak sıralar, ardından her karakterin sıklığı baştaki basamak değildir.

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

Yöntemler bir dizi dizeyi alır ve diziyi yerinde sıralar. Uygulama hakkında süslü bir şey yok, ancak Java 8'e eklenen lambda ifadelerinden faydalanıyor.

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

limit

1000000000'e kadar frekans değerleri: sıralama için frekans değerleri büyük bir yastıklı dizede birleştirilir

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-~ orijinal sayı X, tanımlanmamış ya da NaN bile 1 ile artım

kullanım

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

Çıktı: ["c", "a", "cc", "ca", "cx", "cz", "cy", "ac", "ccc"]