Deskripsi singkat dan manis dari tantangan:
Didasarkan pada ETAOIN SHRDLU , tantangan Anda adalah menulis program atau fungsi terpendek dalam bahasa apa pun yang menghasilkan 26 huruf alfabet Inggris berdasarkan frekuensi mereka dalam input.

Spesifikasi sangat panjang, kering dan menyeluruh:

• Program / fungsi Anda akan menerima sebagai input string teks, yang akan berisi satu atau lebih huruf besar dan / atau huruf kecil dan mungkin juga mengandung tanda baca, angka, simbol, dan karakter non-alfabet lainnya.
• Program / fungsi harus hanya menampilkan 26 huruf UNDANG huruf alfabet Inggris, termasuk yang tidak muncul dalam input, dipesan dari yang paling sering ke yang paling tidak berdasarkan berapa kali mereka muncul di input.
• Sunting: Frekuensi dihitung case-insensitive, tetapi output harus dalam huruf besar.
• Jika dua atau lebih huruf memiliki frekuensi yang sama, mereka mungkin dalam urutan apa pun.
• Tidak ada output lain, seperti spasi, diizinkan.
• Sunting 7/1/2014: Berdasarkan umpan balik, saya mengubah aturan ini. Satu-satunya output lain yang diperbolehkan adalah spasi spasial memimpin dan / atau tambahan, seperti baris baru tambahan. Tidak ada output lain yang diizinkan.
• Perilaku tidak terdefinisi diizinkan untuk input yang tidak mengandung huruf apa pun.

Pemenang akan dipilih 7 hari dari sekarang, jadi ketikkan jari itu!

Input contoh:

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.

Contoh output:

EITUSALNROMCDPVGQBFHJKWXYZ

Catatan: ada hubungan 5 arah antara KWXYZinput tersebut.

Edit:

Persaingan berakhir! Terima kasih untuk semua yang berpartisipasi. Dan sekarang untuk pemenang: jawaban Dennis CJam dan isthac Pyth masuk dengan 19 karakter. (Maaf, tapi saya tidak akan menerima salah satu jawaban karena saya pikir itu tidak adil bagi yang lain.) Sunting: Mengambil saran Dennis, saya akan menandai jawabannya sebagai diterima karena itu adalah yang pertama untuk mencapai 19 karakter. Disebutkan terhormat pergi ke jawaban Golfscript tempat ketiga Ilmari Karonen di 22 karakter serta jawaban 75-char Python undergroundmonorail yang mendapat upvotes paling banyak. Sekali lagi, terima kasih untuk semua yang berpartisipasi!

CJam, 21 19 byte

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

Cobalah online.

Contoh

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

(tidak ada baris baru)

Bagaimana itu bekerja

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.                                               ";
}$     "                                                                              ";

Semakin banyak kejadian berarti semakin banyak karakter dihilangkan, sehingga karakter yang paling sering muncul di awal array.

Python 2 atau 3 - 77 75 byte

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

Saya punya jawaban sebelum itu mendapat masukan dari STDIN, tetapi saya menyadari itu secara teknis tidak valid. Saya menggunakan input()yang hanya mendapat satu baris, tetapi input contoh pertanyaan menyiratkan bahwa ia harus menangani beberapa baris sekaligus. Untuk memenuhi spesifikasi, saya mengubah jawaban saya menjadi fungsi yang mengambil argumen string. Yang mengejutkan saya, itu dua byte lebih kecil! Ini tidak terjadi kepada saya bahwa print(...)dan input()yang lebih lama dari f=lambda s:dan s.

Ini juga membuat jawaban tersebut kompatibel dengan Python 2 dan Python 3. Awalnya hanya Python 3, karena digunakan input()(yang disebut raw_input()dalam 2). Sekarang ini berfungsi, keduanya berfungsi baik.

Dijelaskan

                                  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 byte

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

Contoh

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

Bagaimana itu bekerja

(              #
  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

Coba di sini: http://ideone.com/fork/YlWpEJ

Pelajari lebih lanjut tentang Pyth di sini: http://esolangs.org/wiki/Pyth

Contoh:

Didasarkan pada ETAOIN SHRDLU, tantangan Anda adalah menulis program atau fungsi terpendek dalam bahasa apa pun yang menghasilkan 26 huruf alfabet Inggris berdasarkan frekuensi mereka dalam input.

Memberi:

TENOHARSIULGFPYDCBWQMZXVKJ

Penjelasan:

=ZUw: Konversikan input ke huruf besar dan simpan di Z.

sV: Cetak jumlah kebalikan dari

m;d: Entri terakhir dari

S: Diurutkan berdasarkan entri pertama mereka, dalam urutan yang meningkat

m[cZkk): Daftar [hitungan k dalam Z, k]

UG: Untuk k dalam huruf besar.

Setara dengan Python:

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

Ini bukan entri, saya hanya berpikir orang mungkin ingin melihatnya. Dalam Pyth 1.0.4, program berikut adalah solusi dalam 10 karakter:

JUwo_cJNUG

Penjelasan:

JUw: Konversikan input ke huruf besar dan simpan di J.

o: (Cetak) Urutkan berdasar

_cJN: -1 * (hitungan N dalam J)

UG: Over N dalam huruf besar.

Ini bukan solusi hukum karena beberapa perubahan dari Pyth 1.0.2 ke 1.0.4, termasuk penambahan o, urutkan berdasarkan, fungsi, dalam menanggapi masalah ini.

Javascript ( ES6 ) 119 117

Sunting: (-2) Menghapus kebutuhan untuk toUpperCasemenggunakan RegEx case-insensitive dalam splitpanggilan.

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

Alternatif (panjang yang sama): Mengompensasi pengurutan dan karakter menjadi satu fungsi.

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

Sebagai fungsi: 105 104

Sunting: (-1) Menyingkat jenis dan penghitungan karakter ke dalam satu fungsi.

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+]?\-,}$

Cobalah online.

Penjelasan:

• :?menetapkan string input ke simbol ?. (Saya menggunakan simbol tanda baca sehingga nomor berikut 91tidak diuraikan sebagai bagian dari nama simbol.)
• 91,membuat daftar angka dari 0 hingga 90 (kode ASCII Z).
• + menambahkan daftar ini ke string input, sehingga mengubahnya dari array kode ASCII ke string (dan juga menghapus string input dari stack).
• -26>mengambil 26 karakter terakhir dari string ini, menghasilkan string yang berisi huruf ASCII huruf besar dari Ahingga Z.
• The { }$menerapkan blok kode untuk semua karakter dalam string input, dan mengurutkan karakter tersebut sesuai dengan hasilnya.
• Di dalam blok kode, .duplikat karakter dan 32+konversi salinan dari huruf besar ke huruf kecil. The ]mengumpulkan dua karakter tersebut ke dalam sebuah array, ?\-mengambil input string disimpan dalam ?dan menghapus semua kejadian dari karakter dalam array dari itu, dan ,jumlah panjang string yang tersisa, yang akan menjadi kunci semacam. Karakter akan diurutkan dalam urutan menaik dengan kunci ini, dan dengan demikian dalam urutan menurun berdasarkan jumlah kemunculan.

Haskell, 110 byte

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

Contoh penggunaan:

λ> 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 : Tetap berfungsi dengan benar dengan string multiline, terima kasih @ durron597!

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

Membuat fungsi yang disebut fyang dapat digunakan sebagai berikut:

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

Mencetak ke STDOUT:

AZOSICGHEJKLMBFPQRDTUVWXYN

Perl, 54 46 byte

UPDATE: setelah optimasi lebih lanjut dapat diperas hingga 46 byte: (thx dennis for -n/ {}hack; perl Cina goth for <=>-> -hack)

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

Itu harus dijalankan dengan dijalankan dengan perl -nE

Solusi asli (tidak perlu opsi Perl khusus):

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

Diverifikasi dalam Perl 5.8.3, 5.14.2

Jika Anda mendapat peringatan, pisahkan egdan fordengan spasi (karakter +1), jika Anda keberatan

contoh penggunaan:

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

PENJELASAN: Pada masing-masing karakter ( .) dari setiap baris input ( for<>), menerapkan substitusi "pola", yang sebenarnya dievaluasi sebagai ungkapan ( ebendera s///), yang increment sebuah upcased ( uc) karakter ( ./ $&lebih pendek dari lebih jelas (.)/ $1) hitung dalam hash (tidak diinisialisasi) ( %h). Kemudian, hash frekuensi huruf digunakan dalam fungsi perbandingan semacam untuk mencetak alfabet huruf besar dengan urutan yang benar.

R, 123 byte

Kode ditingkatkan berkat saran dari @RichieCotton.

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)

Keluaran:

> f(text)
[1] "ETNAHORISULFGPBCDYMQWJKVXZ"

C ++, 185 183 179 177 bytes

Tidak diharapkan untuk menang, tentu saja (bisakah C ++ pernah menang?) Tetapi tetap merupakan latihan yang menyenangkan.

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

Penjelasan:

#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

Diperbarui untuk menggunakan algoritma yang sama sekali berbeda. Mengalahkan JavaScript!

Cantik:

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)

Golf:

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 Bytes

(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

Penjelasan:

(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

Kuncinya adalah menambahkan array kiri, sehingga semua huruf tersedia, dan sudah dalam urutan. Konsekuensi lucu menggunakan kata benda sebagai tine ketiga ke fork adalah ia berfungsi sebagai kata kerja dan juga frase.

Groovy - 130 123 115 112 98 92

Sesuai saran @ cfrick (dua kali!):

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

Tes kecil (tanpa malu-malu dicuri dari @jpjacobs):

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

Dan tes yang diusulkan juga lulus

SAS - 217 (saya pikir)

Input harus ditempatkan pada saluran setelah pernyataan cards4, atau pada kartu punch yang sesuai untuk sistem Anda. Saya pikir pendekatan ini menghemat beberapa karakter vs berusaha mengutip input.

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;

Saya menyadari bahwa ini tidak memenuhi spesifikasi lengkap, karena hanya mengembalikan karakter yang muncul dalam string input. Saya mungkin perlu memikirkan kembali ini sedikit.

AppleScript, 278

aku tahu itu "a" = "A" benar di AppleScript. Saya bisa menggunakan ini dalam kode golf, tetapi skrip lainnya terlalu bertele-tele. Saya menggunakan AppleScript 1.8.3.

Ini mendefinisikan suatu fungsi f. Jika Anda menambahkan f("a string")di bagian bawah skrip dan menjalankannya di Editor Skrip, itu akan menunjukkan hasilnya.

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

Diformat dan dikomentari:

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

Edit: ubah kotak pesan (p) ke kotak pesan hal

Lebih mudah dibaca:

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 carriage return)

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

Saya memilikinya di 171 sebelumnya dengan kode yang saya temukan lebih menarik, tetapi metode pengurutan nyamandrei lebih pendek dan memerlukan len (s), yang membuat "untuk" lebih pendek dari "sementara" untuk loop pertama. (menguap)

'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 char

Fungsi mengambil input di sebelah kanan sebagai string. Bukan pemenang, tapi menyenangkan untuk menulis.

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

Dijelaskan:

• toupperadalah kata kerja di perpustakaan standar yang mengangkat string. Itu kemudian menjadi argumen yang benar dari kata kerja, sedangkan argumen kiri adalah alfabet: ASCII codepoints 65-90.

• [dan ,e.~#])memilih ( #) huruf-huruf di arg kanan ( ]) yang merupakan elemen ( e.~) kiri, dan kemudian prepends ( ,) arg kiri ( [). Intinya, kita hanya menyimpan karakter huruf besar, dan menambahkan satu salinan alfabet sampai akhir, untuk memastikan kita menangkap semuanya.

• #/.~@lalu berikan frekuensi masing-masing karakter. Kebetulan ini diberikan dalam urutan abjad, jadi setelah itu kita bisa menurunkan ( \:) abjad (argumen kiri [).

Contoh malas cepat di bawah ini. Jangan ragu untuk mencobanya sendiri di tryj.tk .

   (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

Pada dasarnya, ini adalah solusi VBScript saya tetapi diimplementasikan dalam SQL.

Ini adalah penyalahgunaan hasil XML untuk menyatukan kolom. Dalam penggunaan praktis, ini dapat digabungkan ke tabel luar untuk ditiruGROUP_CONCAT fungsi di MySQL dan lainnya.

Mendeklarasikan @variabel:

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

Kode:

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 byte

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

• Hanya 26 huruf ASCII huruf besar tanpa spasi putih yang dihasilkan dalam urutan frekuensi.
• Karakter yang diikat diberikan dalam urutan abjad.

Hasil untuk contoh dalam pertanyaan:

EITUSALNROMCDPVGQBFHJKWXYZ

Tidak Disatukan:

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

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

Inilah hexdump, penyebab karakter khusus:

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

Dan versi yang sedikit kurang golf:

<?
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

Contoh:

 $ 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

C # dalam LINQPad - 203 Bytes

Saya mengambil pendekatan berbeda untuk jawaban Dam Logan. Saya memastikan terlebih dahulu bahwa setiap karakter dalam string input diurutkan berdasarkan penampilannya dan hanya ada satu kali dalam string output. Setelah itu saya menambahkan setiap karakter yang hilang dari alfabet ke string output.

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

Sayangnya itu tidak akan mengalahkan jawaban Logan Dam jika saya membuat di Visual Studio.

Versi yang lebih mudah dibaca:

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 # (dan LINQ) 255 226 210 Bytes

Menggunakan saran Patrick Huizinga, sintaks kueri sekarang lebih pendek:

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

Penjelasan:

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

Sintaks metode kesetaraan (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());}}}

Pos asli:

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

Ini adalah pengajuan pertama saya dan saya harus melakukan hal-hal di tempat kerja tetapi ini hanya tampak sangat menyenangkan karena saya merasa seperti saya benar-benar dapat berpartisipasi untuk sekali.

Penjelasan:

(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

Saya tidak pernah menggunakan sintaks metode untuk LINQ jadi ini adalah pengalaman belajar bagi saya :) juga memikirkannya sekarang saya bisa menghemat 2 byte dengan mengganti karakter literal dengan rekan integer mereka, tapi, meh.

Dipersingkat berkat tips dari ProgramFOX dan Num Lock :)

Sintaks kueri yang setara (sedikit lebih lama):

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

Versi 701 byte pertama (penggunaan STL idiomatik)

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

Versi bersih yang diperluas:

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

Idenya adalah untuk menunjukkan program C ++ yang "tepat" tanpa peretasan. Abaikan boilerplate dan fakta bahwa ini hanya dikompilasi pada VC ++

Penjelasan:

Kami mengisi A hingga Z menjadi string dengan iota () , ini memastikan bahwa ketika kami menghitung kejadian, setiap karakter muncul bahkan jika itu tidak ada dalam input.

mengubah () menyalin karakter demi karakter dari input standar dan memasukkannya ke akhir s setelah memanggil toupper () pada masing-masing

Hitungan masing-masing karakter dikurangi dalam peta (dengan mempertahankan penghitungan negatif, kita dapat memiliki urutan menurun tanpa kode tambahan)

Entri peta hitungan disalin ke satu set pasangan, bertukar (char, count) ke (count, char). Karena set dipesan, kami mengurutkannya dengan mengurangi jumlah frekuensi

Akhirnya kami menyalin konten set ke standar keluar, menggunakan transformasi, dan menggunakan select2nd () untuk memilih hanya anggota kedua dari pasangan.

Kode ini cukup mudah dibaca. Solusi C ++ 11 akan terlihat jauh lebih cantik, karena kita dapat menggunakan lambdas

Versi C ++ 11 - tidak perlu lambdas, tetapi berbasis otomatis dan jangkauan untuk membuat semuanya sangat bersih (kalau dipikir-pikir itu dapat Anda lakukan sangat mirip dengan C ++ 98 biasa)

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

Versi yang diperluas:

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

Iterasi berikutnya (mengapa membaca dari stdin ketika kita memiliki argv):

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

Versi yang diperluas:

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

Jelly , 9 byte (tidak bersaing)

ØAŒuċ¥@ÞU

Penjelasan

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

Ini berbunyi "mengurutkan alfabet huruf besar dengan jumlah kemunculan dalam input yang ditulis dengan huruf besar, terbalik", yang merupakan terjemahan tantangan yang agak literal: P

Cobalah online!

Tantangan ini dikaitkan dengan Jelly HyperTraining tempat kami menyelesaikan tantangan. Saya memposting ini karena saya adalah orang pertama yang mencapai 10 byte.

-1 byte berkat Erik the Outgolfer (guru JHT)

C ++ 377

Menerapkan qsort menggunakan jumlah huruf dalam array n untuk mengurutkan alfabet dalam array A. Jalankan melalui baris perintah: 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) byte

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

• Beberapa input yang mengandung kode ASCII> = 128 akan secara tidak benar meningkatkan frekuensi huruf. Untuk mengatasinya, ganti konstanta 95dengan 223, dengan biaya 1 byte tambahan.
• Ini akan berakhir lebih awal pada input yang mengandung karakter dengan kode ASCII 255. Untuk memperbaikinya dengan biaya 1 byte tambahan, ubah char c;ke just c;and ++cto c=c+1%255.

PowerShell - 139 karakter

Pertama, saya bukan ahli PowerShell. Cukup yakin ada yang lebih pendek dari ini. Tetapi senang dengan itu dan memutuskan untuk berbagi.

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

Bagaimana itu bekerja:

$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. 

Ceylon , 98 byte

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

Terima kasih kepada Adam.