Zorluğun kısa ve tatlı açıklaması: ETAOIN SHRDLU'ya
dayanarak , zorluğunuz, giriş sırasındaki sıklıklarına bağlı olarak İngilizce alfabenin 26 harfini çıkaran herhangi bir dilde en kısa programı veya işlevi yazmaktır.

Gerçekten uzun, kuru ve ayrıntılı şartname:

• Programınız / işleviniz bir veya daha fazla büyük harf ve / veya küçük harf içerecek ve ayrıca noktalama işaretleri, sayılar, semboller ve diğer alfabetik olmayan karakterler de içerebilecek bir metin dizisi olarak alınacaktır.
• Program / işlev , girişte görünmediklerine bağlı olarak, girişte görünmeyenler de dahil olmak üzere, ingilizce alfabenin yalnızca 26 ÜSTÜNCÜ harfini yazmalıdır.
• Düzenleme: Frekans büyük / küçük harfe duyarsız olarak hesaplanır, ancak çıktının büyük harf olması gerekir.
• İki veya daha fazla harf aynı sıklığa sahipse, herhangi bir sırayla olabilirler.
• Boşluk gibi başka hiçbir çıktıya izin verilmez.
• Düzenleme 07.01.2014: Geri bildirime dayanarak, bu kuralı değiştiriyorum. İzin verilen diğer çıktı, izleyen bir yeni satır gibi isteğe bağlı öncü ve / veya izleyen bir boşluktur. Başka bir çıkışa izin verilmez.
• Tanımlanmamış davranış, harf içermeyen giriş için izin verilir.

Kazanan, bundan 7 gün sonra alınacak, bu yüzden parmaklarınızı yazmaya başlayın!

Örnek giriş:

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent vitae erat velit. Mauris gravida euismod libero ut tincidunt. Phasellus elit dui, consectetur et egestas in, aliquam vitae diam. Donec eget varius ante. Vestibulum cursus diam aliquet, egestas orci quis, placerat dolor. Proin vel nisi lectus. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Aliquam erat volutpat. Etiam libero tortor, ornare id dui eget, posuere dignissim libero. Pellentesque commodo consequat volutpat. Integer hendrerit sapien libero, vel viverra augue facilisis sit amet. Quisque consectetur eget nisl quis dignissim. Ut lacinia pretium quam a placerat.
Morbi sed interdum risus, nec pretium lectus. Morbi imperdiet est id accumsan molestie. Duis sed fermentum nisl. Nunc vitae augue mattis, dictum lectus vel, accumsan nisl. Sed ultricies adipiscing rhoncus. Vivamus eu lacus a enim venenatis eleifend. Praesent consectetur tortor non eleifend ultricies. Mauris et odio posuere, auctor erat at, fringilla est. Proin in vestibulum erat. Maecenas congue commodo ante vel varius. Sed tempus mi ut metus gravida, nec dictum libero dapibus. Morbi quis viverra elit. Ut pharetra neque eget lacus tincidunt dictum. Fusce scelerisque viverra tellus et pretium.
Fusce varius adipiscing odio. Nulla imperdiet faucibus sem, at rhoncus ipsum adipiscing vitae. Phasellus imperdiet congue lacus et mollis. Nullam egestas mauris magna, et mollis lectus varius ut. Sed sollicitudin adipiscing dolor, vel elementum elit laoreet molestie. Aliquam nec nulla vel sem ultrices ullamcorper. Nullam nec felis magna. Duis sodales orci non justo aliquam tempus. Integer mi diam, tempor sed vulputate et, varius et nunc. Vestibulum sodales ipsum id mi pharetra, ut convallis mi accumsan. Sed dictum volutpat vestibulum.
Quisque ac dolor sagittis, aliquam libero at, euismod enim. Nulla ullamcorper posuere nulla vitae varius. Nam at dolor non libero elementum pellentesque in in lorem. Fusce porttitor turpis in quam placerat varius. Donec lorem orci, condimentum eu sapien sit amet, aliquet commodo magna. Quisque sed lectus sit amet arcu euismod accumsan et non nunc. Phasellus placerat congue metus, feugiat posuere leo dictum quis. Sed ultricies feugiat eros dignissim bibendum.
Mauris scelerisque consectetur libero eget varius. Aenean neque nunc, ullamcorper vitae orci in, auctor ornare sapien. Nam lacinia molestie imperdiet. Nam vitae mattis nibh. Vestibulum consequat tellus ac nisi sagittis pulvinar. Nullam mollis ornare quam, et venenatis leo porttitor sit amet. Nulla urna neque, dignissim non orci ut, volutpat ultrices erat. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Pellentesque vestibulum tellus nec eros faucibus porta.

Örnek çıktı:

EITUSALNROMCDPVGQBFHJKWXYZ

Not: KWXYZBu giriş için 5 yönlü bir bağ vardır.

Düzenle:

Yarışma bitti! Katılan herkese teşekkürler. Ve şimdi kazanan (lar!) İçin: Hem Dennis'in CJam'ı hem de isaacg'in Pyth cevapları, 19 karakterden oluşuyordu . (Üzgünüm, ama cevapların hiçbirini kabul etmeyeceğim çünkü diğerine haksızlık olacağını düşünüyorum.) Düzenleme: Dennis'in tavsiyesine göre, cevabını ilk olduğu için kabul edildi olarak işaretleyeceğim. 19 karaktere ulaş. Onurlu sözler Ilmari Karonen'in 22 karakterlik üçüncü sıradaki Golfscript cevabı ve en fazla puan alan undermonmonorail'in 75 kişilik Python cevabına gider. Bir kez daha, katılan herkese teşekkürler!

CJam, 21 19 bayt

qeu:A;'[,65>{A\-,}$

Çevrimiçi deneyin.

Örnek

$ cjam etaoin.cjam <<< "~XyxY YyxZ"
YXZABCDEFGHIJKLMNOPQRSTUVW

(yeni satır yok)

Nasıl çalışır

qeu:A; " Read from STDIN, convert to uppercase, save in the variable “A” and discard, ";
'[,    " Push an array of all ASCII characters before “[” (NUL to “Z”).               ";
65>    " Remove the first 64 characters (NUL to “@”).                                 ";
{      " Sort the array of characters by the following mapping:                       ";
  A\   " Swap the character with the string saved in variable “A”.                    ";
  -    " Remove all occurrences of the character from the string.                     ";
  ,    " Push the length of the string.                                               ";
}$     "                                                                              ";

Daha fazla örnek daha fazla karakterin kaldırılması anlamına gelir, bu nedenle en sık kullanılan karakterler dizinin başında görünür.

Python 2 veya 3 - 77 75 bayt

f=lambda s:''.join(sorted(map(chr,range(65,91)),key=s.upper().count))[::-1]

Daha önce STDIN'den alınan bir cevabı aldım, ancak teknik olarak geçersiz olduğunu anladım. Ben kullanılan input()yalnızca tek bir satırını aldığı, ancak Sorunun örnek girişi aynı anda birden fazla satır işlemesi gerektiğini ima etmektedir. Spec ile tanışmak için cevabımı string argümanı alan bir işleve çevirdim. Benim için sürpriz, iki bayt daha küçüktü! Bana hiç ortaya çıkmayan print(...)ve input()daha uzun idi f=lambda s:ve s.

Bu aynı zamanda cevabı hem Python 2 hem de Python 3 ile uyumlu hale getirir. Aslında sadece Python 3'tü, çünkü kullanıldı input()( raw_input()2 olarak adlandırıldı ). Şimdi bu bir fonksiyon, ikisinde de çalışıyor.

Açıklaması

                                  range(65,91)                              # The numbers 65 to 90
                          map(chr,range(65,91))                             # Convert to ASCII

                                                    s                       # The input string
                                                    s.upper()               # Convert to uppercase
                                                    s.upper().count         # Function literal for 'how many times the argument appears in the string'

                   sorted(map(chr,range(65,91)),key=s.upper().count)        # Sort by that function
           ''.join(sorted(map(chr,range(65,91)),key=s.upper().count))       # Concatenate to string
           ''.join(sorted(map(chr,range(65,91)),key=s.upper().count))[::-1] # Step through by -1 (i.e. reverse string)

  lambda s:''.join(sorted(map(chr,range(65,91)),key=s.upper().count))[::-1] # Make it a function (`return` is implicit for lambdas)
f=lambda s:''.join(sorted(map(chr,range(65,91)),key=s.upper().count))[::-1] # Give it a name

Bash, 65 bayt

(tr a-z A-Z;echo {A..Z})|fold -1|sort|uniq -c|sort -nr|tr -dc A-Z

Örnek

$ bash etaoin.sh <<< "~AbaB BbaC"
BACZYXWVUTSRQPONMLKJIHGFED

Nasıl çalışır

(              #
  tr a-z A-Z   # Turn lowercase into uppercase letters.
  echo {A..Z}  # Print all uppercase letters.
) |            #
fold -1 |      # Split into lines of length 1.
sort |         # Sort those lines (required for piping to uniq).
uniq -c |      # Print the frequencies of all lines.
sort -nr |     # Sort by frequency (reversed).
tr -dc A-Z     # Remove everything that's not an uppercase letter.

Pyth 1.0.2 , 19 20

=ZUwsVm;dSm[cZkk)UG

Burada deneyin: http://ideone.com/fork/YlWpEJ

Burada Pyth hakkında daha fazla bilgi edinin: http://esolangs.org/wiki/Pyth

Örnek:

ETAOIN SHRDLU'ya dayanarak, girdiğiniz sıklığa göre İngilizce alfabenin 26 harfini çıkaran herhangi bir dilde en kısa programı veya işlevi yazmak zor olacaktır.

verir:

TENOHARSIULGFPYDCBWQMZXVKJ

Açıklama:

=ZUw: Girişi büyük harfe dönüştürün ve Z'de saklayın.

sV: Tersinin toplamını yazdır

m;dSon girişleri

S: İlk giriş sırasına göre artan sırada sıralandı

m[cZkk): Listeler [Z'deki k sayısı, k]

UG: Büyük harflerle k için.

Pürüzlü Python eşdeğeri:

G='abcdefghijklmnopqrstuvwxyz'
Z=copy(upper(input()))
print(_sum(rev(_map(lambda d:d.pop(),sorted(_map(lambda k:_list(count(Z,k),k),upper(G)))))))

Bu giriş değil, insanların görmek isteyebileceğini düşündüm. Pyth 1.0.4'te, aşağıdaki program 10 karakterlik bir çözümdür:

JUwo_cJNUG

Açıklama:

JUw: Girişi büyük harfe dönüştürün ve J'de saklayın.

o: (Yazdır) Sırala

_cJN: -1 * (J'deki N sayısı)

UG: Büyük harflerde N'den büyük.

Bu yasal bir çözüm değildir çünkü Pyth 1.0.2 ile 1.0.4 arasındaki değişikliklerin birçoğu o, sıralama işlevinin eklenmesi de dahil olmak üzere bu soruna yanıt olarak görülmüştür.

Javascript ( ES6 ) 119 117

Düzenleme: (-2) Çağrıda büyük / toUpperCaseküçük harf duyarlı olmayan bir RegEx kullanma gereksinimi kaldırıldı split.

a=prompt(f=x=>a.split(RegExp(x,'i')).length)
alert([...'ABCDEFGHIJKLMNOPQRSTUVWXYZ'].sort((b,c)=>f(c)-f(b)).join(''))

Alternatif (aynı uzunluk): Sıralama ve karakter sayma işlemlerini tek bir işlevde yoğunlaştırdı.

a=prompt()
alert([...'ABCDEFGHIJKLMNOPQRSTUVWXYZ'].sort(f=(b,c)=>c?f(c)-f(b):a.split(RegExp(b,'i')).length).join(''))

İşlev olarak: 105 104

Düzenleme: (-1) Sıralama ve karakter sayma işlemlerini tek bir işleve yoğunlaştırır.

F=a=>[...'ABCDEFGHIJKLMNOPQRSTUVWXYZ'].sort(f=(b,c)=>c?f(c)-f(b):a.split(RegExp(b,'i')).length).join('')

GolfScript, 22 karakter

:?91,+-26>{.32+]?\-,}$

Çevrimiçi deneyin.

Açıklama:

• :?giriş dizesini sembole atar ?. (Bir noktalama işareti kullanıyorum, böylece aşağıdaki numara 91sembol adının bir parçası olarak ayrıştırılmaz.)
• 91,0'dan 90'a kadar olan sayıların bir listesini yapar (ASCII kodu Z).
• + bu listeyi giriş dizgisine ekler, böylece bir ASCII kod dizisinden bir dizgeye dönüştürür (ve ayrıca giriş dizgisini yığından da rahatça kaldırır).
• -26>dan büyük ASCII harf içeren bir dize üreten bu dizenin son 26 karakter alır Aiçin Z.
• { }$Giriş dizesi tüm karakterleri kod bloğunu geçerlidir ve sonucuna göre bu karakterleri sıralar.
• Kod bloğunun içinde, .karakteri çoğaltır ve 32+kopyayı büyük harften küçük harfe dönüştürür. ]Bir diziye bu iki karakter toplar, ?\-saklanan giriş dizesi alır ?ve ondan dizideki karakterlerin tüm oluşumları kaldırır ve ,sayımlar sıralama anahtarı olacaktır kalan dize uzunluğunu,. Karakterler bu tuşa göre artan sırada ve dolayısıyla oluşum sayısına göre azalan sırada sıralanacaktır.

Haskell, 110 bayt

import Data.List
import Data.Char
a%f=compare(f a).f
f t=sortBy(% \c->length$filter((/=c).toUpper)t)['A'..'Z']

Örnek kullanım:

λ> f "Based off ETAOIN SHRDLU, your challenge is to write the shortest program or function in any language that outputs the 26 letters of the English alphabet based on their frequency in the input."
"ETNAHORISULFGPBCDYMQWJKVXZ"

Ruby 2.0, 53 karakter

EDIT : Çok satırlı dizelerle düzgün çalışması düzeltildi, teşekkürler @ durron597!

f=->s{$><<(?A..?Z).sort_by{|c|-s.upcase.count(c)}*''}

fAşağıdaki gibi kullanılabilecek bir fonksiyon yaratır :

f['jackdaws love my big sphinx of quartzzz']

STDOUT'a yazdırır:

AZOSICGHEJKLMBFPQRDTUVWXYN

Perl, 54 46 bayt

GÜNCELLEME: daha fazla optimizasyondan sonra 46 bayta sıkılabilir : ( / hack için thx dennis ; çince perl goth için -> hack)-n{}<=>-

s/./$h{uc$&}++/eg}{say sort{$h{$b}-$h{$a}}A..Z

İle çalıştırılacak olan perl -nE

Orijinal çözüm (özel Perl seçeneklerine ihtiyaç duymaz):

s/./$h{uc$&}++/egfor<>;print sort{$h{$b}<=>$h{$a}}A..Z

Perl tarafından doğrulandı 5.8.3, 5.14.2

Bir uyarı alırsanız, ayırın egve forboşlukla (+1 char), sakıncası varsa

örnek kullanım:

$ python -c 'import this' | perl -le 's/./$h{uc$&}++/egfor<>;print sort{$h{$b}<=>$h{$a}}A..Z' 2>/dev/null
ETAISONLRHPBUCDYMFGXVWKZJQ

Her karakter olarak (: AÇIKLAMA .her bir giriş hattı (arasında) for<>aslında bir ifade olarak değerlendirilir), "yol" bir ikame uygulanır ( ebayrak s///, bir upcased (artışlarla olduğu), uc) karakteri ( ./ $&daha belirgin daha kısadır (.)/ ' $1) (başlatılmamış) hash ( %h) cinsinden sayılır . Ardından, harf sıklığı karması, büyük harfli alfabeyi doğru sırada yazdırmak için bir sıralama karşılaştırma işlevinde kullanılır.

R, 123 bayt

@RichieCotton önerileri sayesinde kod geliştirildi.

text <- "Based off ETAOIN SHRDLU, your challenge is to write the shortest program or function in any language that outputs the 26 letters of the English alphabet based on their frequency in the input."

f=function(x){b=plyr::count(toupper(strsplit(x,"")[[1]]));c=merge(LETTERS,b,all.x=T);paste(c[order(-c$freq),1],collapse="")}

f(text)

Çıktı:

> f(text)
[1] "ETNAHORISULFGPBCDYMQWJKVXZ"

C ++, 185 183 179 177 bayt

Kazanması beklenmiyor, elbette (C ++ hiç kazanabilir mi?) Ama yine de eğlenceli bir egzersiz.

#include <algorithm>
#include <stdio.h>
int f[256],p;main(){for(p=65;p<91;p++)f[p]=p;while(~(p=getchar()))f[p&95]+=256;p=256;std::sort(f,f+p);while(p--)f[p]&95&&putchar(f[p]);}

Açıklama:

#include <algorithm>         // for std::sort
#include <stdio.h>           // for getchar, putchar
int f[256],p;                // declare an array of count-prefixed chars, and a counter
main(){
    for(p=65;p<91;p++)       // 65 == 'A', 91 == the character after 'Z'
        f[p]=p;              // set the character for the slot
    while(~(p=getchar()))    // read characters until EOF
        f[p&95]+=256;        // increment the packed count for the character stripped of the 'lowercase bit'
    p=256;                   // start a countdown
    std::sort(f,f+p);        // sort the array
    while(p--)               // do the countdown
        f[p]&95 &&           // if the masked-off character is set...
          putchar(f[p]);     // print it
}

VBScript 181 109

Tamamen farklı bir algoritma kullanmak için güncellendi. JavaScript'i yeniyor!

Güzel:

dim b(99):i=ucase(inputbox(k))
for y=65to 90
    c=chr(y)
    a=len(replace(i,c,k))
    b(a)=c+b(a)
next
msgbox join(b,k)

golfed:

dim b(99):i=ucase(inputbox(k)):for y=65to 90:c=chr(y):a=len(replace(i,c,k)):b(a)=c+b(a):next:msgbox join(b,k)

J 41 35 Bayt

(u:65+i.26)([\:[#/.~@,e.~#])toupper

Demo:

i=: 'This is a test to see whether this is still working'
(u:65+i.26)([\:[#/.~@,e.~#])toupper i
STIEHLORWAGKNBCDFJMPQUVXYZ

Açıklama:

(u:65+i.26) & ( [ \: [ #/.~@,e.~#]) toupper) )
ABCDE...          |    |    |   |      uppercase the right argument
                  |    |    |   \copy from right only member from left
                  |    |     \append the left argument
                  |    \ Afterwards Count apperances of each letter
                  \ Sort the left according to the appearances

Anahtar, soldaki diziyi eklemek, böylece tüm harfler kullanılabilir ve sırayla. Çatalı olarak üçüncü isim olarak bir isim kullanmanın komik bir sonucu, cümlenin yanı sıra fiil olarak da çalışmasıdır.

Harika - 130 123 115 112 98 92

@ Cfrick'in tavsiyesine göre (iki kere!):

f={('A'..'Z').collectEntries{c->[c,it.grep(~/(?i)$c/).size()]}.sort{-it.value}*.key.join()}

Küçük bir test (utanmadan jpjacobs'tan çalınmış):

assert f('This is a test to see whether this is still working') == 
    'STIEHLORWAGKNBCDFJMPQUVXYZ'

Ve önerilen test de geçiyor

SAS - 217 (Sanırım)

Girdi, card4 ifadesinden sonraki satıra veya sisteminiz için uygun delikli kartlara yerleştirilmelidir. Bence bu yaklaşım girdilerden alıntı yapmaya çalışırken birkaç karakterden tasarruf sağlıyor.

data a;
input;
S = upcase(compress(_INFILE_,,'ak'));
do i=1 to length(S);
l=substr(S,i,1);
output;
end;
cards4;
;;;;
run;
proc sql;
select l into :o separated by '' from
(select l, 1/count(l) as f from a group by l) order by f;
quit;

Bunun sadece giriş dizgisinde görünen karakterleri döndürdüğü için tam özelliklere uymadığını biliyorum. Bunu biraz düşünmem gerekebilir.

AppleScript, 278

Bunun "a" = "A"AppleScript'te doğru olduğunu fark ettim . Bunu kod golfünde kullanabilirim, ancak betiğin geri kalanı çok endişe verici. AppleScript 1.8.3 kullandım.

Bu bir işlevi tanımlar f. f("a string")Komut dosyasının altına ekler ve Komut Dosyası Düzenleyicide çalıştırırsanız, sonucu gösterir.

on c(n)
ASCII character(64+n)
end
on f(s)
set{a,r}to{{},""}
repeat with i from 1 to 26
set j to 0
repeat with b in s
if b&""=c(i)then set j to j+1
end
set a to a&j
end
repeat with j from 0 to(count s)
repeat with i from 1 to 26
if a's item i=j then set r to c(i)&r
end
end
r
end

Biçimlendi ve yorumlandı:

-- Returns nth letter of alphabet.
on c(n)
    ASCII character (64 + n)
end c

-- Returns letters in s sorted by frequency.
on f(s)
    -- a: list of letter counts
    -- r: resulting string
    set {a, r} to {{}, ""}

    -- For each letter from A to Z,
    -- count letters in string s.
    repeat with i from 1 to 26
        set j to 0
        repeat with b in s
            -- Can't use b = c(i), because
            -- b is a reference to a string
            -- and = never dereferences its
            -- operands. Get contents of b,
            -- here by coercing b to string.
            if b & "" = c(i) then set j to j + 1
        end repeat
        -- Set item i of a to count j.
        set a to a & j
    end repeat

    -- Sort letters by frequency.  Do a counting sort
    -- because AppleScript lacks a sort command.
    repeat with j from 0 to (count s)
        repeat with i from 1 to 26
            if a's item i = j then set r to c(i) & r
        end repeat
    end repeat
    r
end f

-- Example call:
f("Now is the time for all good men to come to the aid of their country.")
-- Result: "OTEIRNMHLFDCAYWUSGZXVQPKJB"

VBScript 157 156 bayt

Düzenleme: msgbox (p) değiştirildi msgbox p

Daha okunabilir:

s=ucase(InputBox(z))    'z is empty.
L=len(s)
Dim a(255)
for i=1to L
    x=asc(mid(s,i))
    a(x)=a(x)+1
next
for t=0to L
    For i=65To 90
        If a(i)=t then p=chr(i)&p
    next
next
msgbox p

Golf: (155 karakter + 1 satır başı)

s=ucase(InputBox(z)):L=len(s):Dim a(255):for i=1to L:x=asc(mid(s,i)):a(x)=a(x)+1:next:for t=0to L:For i=65To 90:If a(i)=t then p=chr(i)&p
next:next:msgbox p

Daha ilginç bulduğum kodla 171'de daha önce bulmuştum, ama rahatça drei'nin sıralama yöntemi daha kısa ve len (ler) i gerektiriyor; (esneme)

's=UCase(InputBox(Z))&8 'just need any extra character.  0-7 don't work because &7 is octal

s=UCase(InputBox(Z)) 'nevermind
Dim a(999)
While Len(s)
    x=Asc(s) 'returns ascii of first char
    a(x)=a(x)-1 'going negative saves a character later...
    s=Mid(s,2) 'doesn't care if you run out of string
Wend
for j=1 to 26 'this used to be   While Len(p)<26
    For i=65To 90
        If a(i)<a(y) Then y=i 'it is barely not worth it to do a(i)+a(i+32)>a(y) here to skip the ucase() above
    Next
    p=p&Chr(y)
    a(y)=1 'if I didn't go negative this would have to be -1.  arrays default to 0.
Next
MsgBox(p)

J - 38 35 karakter

Dize olarak sağdaki girişi alan bir işlev. Kazanan değil, ama yazmak eğlenceliydi.

(u:65+i.26)([\:[#/.~@,e.~#])toupper

Açıklaması:

• toupperstandart kütüphanede bir dizgiyi geçersiz kılan bir fiildir. Bu daha sonra fiilin doğru argümanı olur, sol argüman ise alfabedir: ASCII 65 ila 90 kod noktalarına sahiptir.

• [ve ,e.~#])( #) sol arg'in ( ) solundaki ]( e.~) elementleri olan harfleri seçer ( ) ve sonra sol arg'ini ( ,) hazırlar [. Görmek için, sadece büyük harfleri tutarız ve hepsini yakaladığımızdan emin olmak için sonuna kadar alfabenin tek bir kopyasını ekleriz.

• #/.~@sonra her karakterin frekanslarını verir. Öyleyse, bunun alfabetik sıraya göre yapılması gerekir, bu yüzden hemen sonra \:alfabeyi (sol argüman [) aşağı doğru ( ) daraltabiliriz .

Aşağıda hızlı tembel bir örnek. Tryj.tk adresinde kendiniz denemek için çekinmeyin .

   (u:65+i.26)([\:[#/.~@,e.~#])toupper 'Based off ETAOIN SHRDLU, your challenge is to write the shortest program or function in any language that outputs the 26 letters of the English alphabet based on their frequency in the input.'
ETNAHORISULFGPBCDYMQWJKVXZ

T-SQL 178

Temel olarak, bu benim VBScript çözümüm ama SQL'de uygulandı.

Bu, bir sütunu birleştirmek için XML çıktısının kötüye kullanılmasıdır. Pratik kullanımda, GROUP_CONCATMySQL ve diğerlerinde işlevleri taklit etmek için dış bir masaya birleştirilebilir .

@Değişkeni bildirmek :

DECLARE @ CHAR(1024)= 'enter your text here';

Kod:

with y AS(
    SELECT UPPER(@)i,0l,91y
    UNION ALL
    SELECT i,len(replace(i,char(y-1),'')),y-1
    FROM y
    WHERE y>65
)
SELECT LTRIM(
(
    SELECT char(y)
    FROM y
    WHERE y<91
    ORDER BY l
    FOR XML PATH(''))
)

Perl, 78 bayt

undef$/;$i=<>;$r{$i=~s/$_//gi}.=$_ for A..Z;print$r{$_}for sort{$b<=>$a}keys%r

• Yalnızca beyaz boşluk olmayan 26 büyük ASCII harfi, frekans sırasına göre verilir.
• Bağlı karakterler alfabetik sıraya göre verilmiştir.

Sorudaki örneğin sonucu:

EITUSALNROMCDPVGQBFHJKWXYZ

Ungolfed:

# read input
# ----------
undef $/; # disable input separator
$i = <>;  # $i holds the complete input as one string

# analyze
# -------
# For each uppercase letter (A upto Z) its occurences are counted
# via the number of substitutions made by s/$_//gi. The lowercase
# letter is included via modifier "i".
# 
# The occurrence count is then used as key for hash %r.
# The uppercase letter is appended to the value of that hash entry.
$r{$i =~ s/$_//gi} .= $_ for A..Z;

# output
# ------
# The hash keys are sorted numerically in reverse order by
# the specified sort function.
print $r{$_} for sort {$b<=>$a} keys %r

PHP - 105 bayt

<?preg_filter(~‹§æ“Ö¢‹ö,'$f[$0&fl]++',join('',range(a,z)).$argv[1]);arsort($f);foreach($f as$l=>$F)echo$l;

İşte özel karakterlerin nedeni, bir hexdump:

0000000 3c 3f 70 72 65 67 5f 66 69 6c 74 65 72 28 7e dc
0000010 a4 be d2 85 a2 dc 9a 2c 27 24 66 5b 24 30 26 df
0000020 5d 2b 2b 27 2c 6a 6f 69 6e 28 27 27 2c 72 61 6e
0000030 67 65 28 61 2c 7a 29 29 2e 24 61 72 67 76 5b 31
0000040 5d 29 3b 61 72 73 6f 72 74 28 24 66 29 3b 66 6f
0000050 72 65 61 63 68 28 24 66 20 61 73 24 6c 3d 3e 24
0000060 46 29 65 63 68 6f 24 6c 3b                     
0000069

Ve biraz daha az golflü versiyonu:

<?
preg_filter(           // regular expression
  "#[A-z]#e",          // matches every letter + 'eval' flag
  '$f[$0&fl]++',        // so this code runs for every letter
                       // $f is an array whose indices are uppercase letters
                       //   and whose values represent the number of occurences
                       // lowercase is converted to uc with the bitwise and
                       //   fl is 11011111 in binary, every bit except for 32's is set
  join('', range(a,z)) // adding abcdefghijklmnopqrstuvwxyz to the input
    .$argv[1]);        //   because not all letters have to appear in the input
arsort($f);            // sort $f in reverse, maintaining indices
foreach($f as$l=>$F)   //
  echo$l;              // print each index in order

Örnek:

 $ php etaoin_shrdlu.php "This function sorts an array such that array indices maintain their correlation with the array elements they are associated with."
 ATIRESHNOCYUWMDLFXZBVGPQKJ

LINQPad'deki C # - 203 Bayt

Logan Barajı'nın cevabına farklı bir yaklaşım benimsedim. Öncelikle giriş dizesindeki her karakterin görünümüne göre sıralandığından ve yalnızca çıkış dizesinde bir kez bulunduğundan emin oldum. Bundan sonra alfabedeki her eksik karakteri çıktı dizgisine ekledim.

void e(string i){var a="";foreach(var d in i.ToUpper().GroupBy(x=>x).OrderByDescending(u=>u.Count()))if(d.Key<91&&d.Key>64){a+=d.Key;}for(int x=65;x<91;x++)if(!a.Contains((char)x)){a+=(char)x;}a.Dump();}

Ne yazık ki Visual Studio'da yapsaydım Logan Dam'ın cevabını geçemezdi.

Daha okunabilir sürüm:

void e(string i)
    {
        var a = "";
        foreach (var d in i.ToUpper().GroupBy(x => x).OrderByDescending(u => u.Count()))
        {
            if (d.Key < 91 && d.Key > 64)
            {
                a += d.Key;
            }
        }
        for (int x = 65; x < 91; x++)
        {
            if (!a.Contains((char)x))
            {
                a += (char)x;
            }
        }
        a.Dump();
    }

C # (ve LINQ) 255 226 210 Bayt

Patrick Huizinga'nın tavsiyesini kullanarak, sorgu sözdizimi şimdi daha kısa:

namespace System.Linq{class P{static void Main(string[]a){Console.Write((from c in(a[0]+"ABCDEFGHIJKLMNOPQRSTUVWXYZ").ToUpper()where c>'@'&&c<'['group c by c into g orderby-g.Count()select g.Key).ToArray());}}}

Açıklama:

Console.Write(
    (from c //declare our range variable
       in (a[0] + "ABCDEFGHIJKLMNOPQRSTUVWXYZ").ToUpper() //declare the datasource
     where c > '@' && c < '[' //include only letters
     group c by c into g //run of the mill group by
     orderby -g.Count() //order by descending
     select g.Key //we only want the actual letters
     ).ToArray() //mash it all into an array
  );

Eşdeğer yöntem sözdizimi (217):

namespace System.Linq{class P{static void Main(string[]a){Console.Write((a[0]+"ABCDEFGHIJKLMNOPQRSTUVWXYZ").ToUpper().GroupBy(c=>c).OrderBy(c=>-c.Count()).Where(c=>c.Key>'@'&&c.Key<'[').Select(c=>c.Key).ToArray());}}}

Orijinal yayın:

namespace System.Linq{class P{static void Main(string[]a){(a[0]+"ABCDEFGHIJKLMNOPQRSTUVWXYZ").ToUpper().GroupBy(c=>c).OrderByDescending(c=>c.Count()).Where(c=>c.Key>'@'&&c.Key<'[').ToList().ForEach(c=>Console.Write(c.Key));}}}

Bu benim ilk gönderim ve iş yerinde işler yapmam gerekiyor, ama bu çok eğlenceli görünüyordu çünkü bir kez katılabileceğimi hissettim.

Açıklama:

(a[0] + "ABCDEFGHIJKLMNOPQRSTUVWXYZ") //ensure each character appears once
  .ToUpper()
  .GroupBy(c => c) //get access to .Count()
  .OrderByDescending(c => c.Count())
  .Where(c => c.Key > '@' && c.Key < '[') //exclude anything other than letters
  .ToList() //Only lists have a .ForEach() :(
  .ForEach(c => Console.Write(c.Key)); //print output

LINQ için metod sözdizimini asla kullanmıyorum, bu yüzden bu benim için bir öğrenme deneyimi oldu :) aynı zamanda şimdi düşününce, karakter değişmezlerini tamsayı meslektaşları ile değiştirerek 2 bayt tasarruf edebilirim, ama, meh.

ProgramFOX ve Num Lock'tan gelen ipuçları sayesinde kısaltıldı :)

Eşdeğer sorgu sözdizimi (biraz daha uzun):

(from c in (a[0]+"ABCDEFGHIJKLMNOPQRSTUVWXYZ").ToUpper() where c>'@'&&c<'[' group c by c into g orderby g.Count() descending select g.Key).ToList().ForEach(c=>Console.Write(c));

C ++ 701 322 232 bayt

İlk sürüm 701 bayt (deyimsel STL kullanımı)

#define _HAS_TRADITIONAL_STL 1
#include <numeric>
#include <iostream>
#include <iterator>
#include <string>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#define ALL(x) x.begin(), x.end()
using namespace std;
typedef istream_iterator<char> iic;typedef pair<int, char> pic;map<char, int> c;set<pic> d;
void f1(char x) {c[x]--;}
void f2(const pic &p) {d.insert(make_pair(p.second, p.first));}
int main(){string s(26, 0);stdext::iota(ALL(s), 65);copy(ALL(s), ostream_iterator<char>(cout));transform(iic(cin), iic(), back_inserter(s), toupper);for_each(ALL(s), f1);for_each(ALL(c), f2);transform(ALL(c2), ostream_iterator<char>(cout), select2nd<pic>());}

Genişletilmiş temiz sürüm:

#define _HAS_TRADITIONAL_STL 1
#include <numeric>
#include <iostream>
#include <iterator>
#include <string>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
using namespace std;

typedef istream_iterator<char> iic;
map<char, int> counts;
set<pair<int, char> > counts2;

void docount(char ch) { counts[ch]--; }
void toCounts2(const pair<char, int> &p) { counts2.insert(make_pair(p.second, p.first)); }

int main()
{
    string s(26, 0);
    stdext::iota(s.begin(), s.end(), 65);
    transform(iic(cin), iic(), back_inserter(s), toupper);
    for_each(s.begin(), s.end(), docount);
    for_each(counts.begin(), counts.end(), toCounts2);
    transform(counts2.begin(), counts2.end(), ostream_iterator<char>(cout), select2nd< pair<int, char> >());
}

Fikir, herhangi bir hack olmadan "uygun" bir C ++ programı göstermektir. Kazan plakasını ve bunun sadece VC ++ ile derlendiğini göz ardı edin.

Açıklama:

A'dan Z'ye bir dizgeye iota () ile dolduruyoruz , bu da olayları saydığımızda her karakter girişte olmasa bile görünmesini sağlıyor.

transform () karakteri standart girdiden karakter karakterine kopyalar ve her birini toupper () işlevini çağırdıktan sonra s komutunun sonuna yerleştirir.

Haritadaki her karakterin sayısı azalır (negatif sayım korunarak fazladan kod olmadan azalan sıralama yapabiliriz)

Sayım haritası girişleri bir çift gruba kopyalanır, (char, count) ile (count, char) değiştirilir. Setler sipariş edildiğinden, onları sıklık sayısını azaltarak sıralıyoruz

Sonunda setin içeriğini standart çıktıya dönüştürürüz, dönüşümü ve sadece çiftin ikinci üyesini seçmek için select2nd () kullanarak .

Kod oldukça okunabilir. C ++ 11 çözümü çok daha güzel gözüküyor, çünkü lambda kullanabiliyoruz

C ++ 11 sürümü - lambdaya gerek yok, ancak otomatik ve aralık tabanlı işler işleri çok temiz yapıyor (normal C ++ 98 ile çok benzer şeyler yapabileceğinizi düşünün)

#include<iostream>
#include<iterator>
#include<map>
#include<set>
using namespace std;int main(){istream_iterator<char> b(cin),e;map<char,int> c;set<pair<int,char>> d;for(char i='A';i<='Z';++i){--c[i];}for(auto i=b;i!=e;++i){c[toupper(*i)]--;}for(auto p:c){d.insert(make_pair(p.second,p.first));}for(auto p:d){cout<<p.second;}}

Genişletilmiş sürüm:

#include <iostream>
#include <iterator>
#include <map>
#include <set>
using namespace std;
int main()
{
    istream_iterator<char> b(cin), e;
    map<char, int> c;
    set<pair<int, char>> d;
    for(char i = 'A'; i <= 'Z'; ++i) {--c[i];}
    for(auto i = b; i != e; ++i) {c[toupper(*i)]--;}
    for(auto p : c) { d.insert(make_pair(p.second, p.first)); }
    for(auto p : d) { cout << p.second; }
}

Sonraki yineleme (neden argv olduğunda stdin'den okunur):

#include <set>
#include <iostream>
int c[256];int main(int n, char **s){std::set<std::pair<int,char>> d;while(*s[1]){c[toupper(*s[1]++)]--;}for(n=65;n<92;++n){d.insert(std::make_pair(--c[n],n));}for(auto p:d){std::cout<<p.second;}}

Genişletilmiş sürüm:

#include <set>
#include <iostream>
int c[256];
int main(int n, char **s)
{
    std::set<std::pair<int, char>> d;
    while (*s[1])
    {
        c[toupper(*s[1]++)]--;
    }
    for (n = 65; n < 92; n++)
    {
        d.insert(std::make_pair(--c[n], n));
    }
    for (auto p : d)
    {
        std::cout << p.second;
    }
}

Jöle , 9 bayt (yarışmaz)

ØAŒuċ¥@ÞU

açıklama

ØAŒuċ¥@ÞU  Main Link
       Þ   Sort
ØA         The uppercase alphabet by
  Œuċ¥@    number of occurrences in the input:
  Œu       Uppercase
    ċ      Count occurrences
     ¥     Grammar: Last two links as a dyad
      @    Swap arguments
        U  Reverse (because sort sorts up)

Bu, "büyük harfli alfabeyi, girişin üst kısmına yerleştirilmiş, ters çevrilmiş girişindeki oluşum sayısına göre sıralayın" şeklinde yazılmıştır;

Çevrimiçi deneyin!

Bu zorluk, mücadeleyi çözdüğümüz Jelly HyperTraining ile bağlantılıydı . Bunu gönderdim çünkü ilk 10 byte'a ulaşan bendim.

-1 Outgolfer (JHT öğretmeni) sayesinde bayt

C ++ 377

A dizisindeki alfabeyi sıralamak için n dizgesindeki harf sayılarını kullanarak qsort uygular. golf.exe < in.txt

int n[26],c,k,N;
char A[26];
int C(const void*a,const void*b)
{
int i=(int)(*(char*)a -'A');
int j=(int)(*(char*)b -'A');
return n[j]-n[i];
}
int main()
{
for(;k<26;k++)
{
A[k]=k+'A';
}
N=sizeof(A);
c=getchar();
while(c>0)
{
c=toupper(c);
c=c-'A';
if(c>=0&&c<26)n[c]++;
c=getchar();
}
qsort(A,N,1,C);
for(k=0;k<N;k++)
{
putchar(A[k]);
}
return 0;
}

C, 117 (119) bayt

x[256];m=1;char c;main(){while(c=getchar()+1)++x[c-1&95];for(;m=x[++c]<x[m]?m:c;x[m<65|m>90||c?m*!c:putchar(m)]=-1);}

• ASCII kodları> = 128 içeren bazı girişler harf frekanslarını hatalı şekilde artıracaktır. Bunu düzeltmek için, sabit değiştirmek 95ile 2231 ilave byte bir maliyetle.
• Bu 1 ilave byte, değişim pahasına Bunu düzeltmek için ASCII kodu 255 ile karakterini içeren girdiler erken sona erer char c;lazım c;ve ++ckarşı c=c+1%255.

PowerShell - 139 karakter

İlk önce, bir PowerShell uzmanı değilim. Bundan daha kısa olduğuna eminim. Ancak ondan memnun kaldı ve paylaşmaya karar verdi.

$a = Read-host
$b = ($a.ToUpper() -replace '[^A-Z]','').ToCharArray() + (65..90|%{[char[]]$_})|Group|sort Count -desc|%{$_.Name}
-join $b

Nasıl çalışır:

$a = Read-host            # read from stdin and save into a string var $a
$a.ToUpper()              # Convert the string to UPPERCASE
-replace'[^A-Z]',''       # Remove all non A-Z characters from the str
(...).ToCharArray()       # Convert the inner object (string) to a Char Array
+  (65..90|%{[char[]]$_}) # Create another char array with A-Z chars expanded, 
                          #  and append it to the previous one.
|Group                    # Group the char array by value for each element, 
                          #  consolidates them and count each char occurrence. Example:
                          #  Count | Name
                          #  ----- | -----
                          #      4 | B
                          #      1 | F
                          #      2 | C 
                          #     .. | ..
                          # 
|sort Count -desc         # Sorts the previous hash-table by the 'Count' column 
                          #   in desc ordering
|%{$_.Name}               # Grab only the 'Name' column from the previous sorted hash-table. 
                          # The retuslt obj will be a simple char array again, 
                          #   with the letters in the desired order
$b = (...)                # Saves the resulting char array into a new variable $b
-join $b                  # join the resulting char array elements into a single 
                          #   string, and print it to stdout. 

Seylan , 98 bayt

String f(String s)=>String(('A':26).sort(byDecreasing((Object c)=>s.uppercased.count(c.equals))));

APL, 26 20 karakter

⎕a[⍒+/⎕a∘.=('\w'⎕r'\u0')⍞]

⎕a[⍒+/⎕a∘.=1(819⌶)⍞]

-6 Adam için teşekkürler.