Mô tả ngắn gọn và ngọt ngào về thử thách:
Dựa trên ETAOIN SHRDLU , thử thách của bạn là viết chương trình hoặc chức năng ngắn nhất bằng bất kỳ ngôn ngữ nào tạo ra 26 chữ cái của bảng chữ cái tiếng Anh dựa trên tần số của chúng trong đầu vào.

Đặc điểm kỹ thuật thực sự dài, khô và kỹ lưỡng:

• Chương trình / chức năng của bạn sẽ nhận được dưới dạng một chuỗi văn bản, trong đó sẽ chứa một hoặc nhiều chữ cái viết hoa và / hoặc chữ thường và cũng có thể chứa dấu câu, chữ số, ký hiệu và các ký tự không phải là chữ cái khác.
• Chương trình / chức năng phải chỉ xuất ra 26 chữ cái UPPERCASE của bảng chữ cái tiếng Anh, bao gồm cả các chữ cái không xuất hiện trong đầu vào, được sắp xếp theo thứ tự từ ít nhất đến thường xuyên nhất dựa trên số lần chúng xuất hiện trong đầu vào.
• Chỉnh sửa: Tần suất được tính không phân biệt chữ hoa chữ thường, nhưng đầu ra phải được viết hoa.
• Nếu hai hoặc nhiều chữ cái có cùng tần số, chúng có thể theo bất kỳ thứ tự nào.
• Không có đầu ra khác, như khoảng trắng, được cho phép.
• Chỉnh sửa 7/1/2014: Dựa trên phản hồi, tôi đang sửa đổi quy tắc này. Đầu ra duy nhất khác được phép là khoảng trắng hàng đầu và / hoặc dấu tùy chọn, chẳng hạn như một dòng mới. Không có đầu ra khác được cho phép.
• Hành vi không xác định được phép cho đầu vào không chứa bất kỳ chữ cái nào.

Người chiến thắng sẽ được chọn 7 ngày kể từ bây giờ, vì vậy hãy gõ những ngón tay đó!

Ví dụ đầu vào:

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.

Ví dụ đầu ra:

EITUSALNROMCDPVGQBFHJKWXYZ

Lưu ý: có một ràng buộc 5 cách giữa KWXYZcho đầu vào đó.

Biên tập:

Cuộc thi đã kết thúc! Cảm ơn tất cả những người tham gia. Và bây giờ cho người chiến thắng (s!): Cả hai câu trả lời Pyth của Dennis 'CJam và isaacg đều xuất hiện với 19 ký tự. (Xin lỗi, nhưng tôi sẽ không chấp nhận một trong hai câu trả lời vì tôi nghĩ nó sẽ không công bằng cho người khác.) Chỉnh sửa: Nhận lời khuyên của Dennis, tôi sẽ đánh dấu câu trả lời của anh ấy là chấp nhận vì anh ấy là người đầu tiên đạt 19 ký tự. Những đề cập đáng trân trọng dành cho câu trả lời Golfscript ở vị trí thứ ba của Ilmari Karonen ở 22 ký tự cũng như câu trả lời Python 75-char của câu lạc bộ được nhiều người ủng hộ nhất. Một lần nữa, cảm ơn mọi người đã tham gia!

CJam, 21 19 byte

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

Hãy thử trực tuyến.

Thí dụ

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

(không có dòng mới)

Làm thế nào nó hoạt động

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

Xuất hiện nhiều hơn có nghĩa là nhiều ký tự bị xóa hơn, vì vậy các ký tự thường xuyên nhất xuất hiện ở đầu mảng.

Python 2 hoặc 3 - 77 75 byte

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

Tôi đã có câu trả lời trước khi lấy dữ liệu đầu vào từ STDIN, nhưng tôi nhận ra rằng nó không hợp lệ về mặt kỹ thuật. Tôi đã sử dụng input()chỉ nhận được một dòng duy nhất, nhưng đầu vào ví dụ của câu hỏi ngụ ý rằng nó sẽ xử lý nhiều dòng cùng một lúc. Để đáp ứng thông số kỹ thuật, tôi đã biến câu trả lời của mình thành một hàm lấy đối số chuỗi. Thật ngạc nhiên, nó nhỏ hơn hai byte! Nó đã không xảy ra với tôi print(...)và input()lâu hơn f=lambda s:và s.

Điều này cũng làm cho câu trả lời tương thích với cả Python 2 và Python 3. Ban đầu nó chỉ là Python 3, vì nó được sử dụng input()(được gọi là raw_input()2). Bây giờ nó là một chức năng, nó hoạt động trong cả hai.

Giải thích

                                  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

Thí dụ

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

Làm thế nào nó hoạt động

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

Dùng thử tại đây: http://ideone.com/fork/YlWpEJ

Tìm hiểu thêm về Pyth tại đây: http://esolangs.org/wiki/Pyth

Thí dụ:

Dựa trên ETAOIN SHRDLU, thử thách của bạn là viết chương trình hoặc chức năng ngắn nhất bằng bất kỳ ngôn ngữ nào xuất ra 26 chữ cái của bảng chữ cái tiếng Anh dựa trên tần số của chúng trong đầu vào.

Cung cấp:

TENOHARSIULGFPYDCBWQMZXVKJ

Giải trình:

=ZUw: Chuyển đổi đầu vào thành chữ hoa và lưu trữ trong Z.

sV: In tổng số đảo ngược của

m;d: Các mục cuối cùng của

S: Sắp xếp theo mục đầu tiên của họ, theo thứ tự tăng dần

m[cZkk): Danh sách [số k trong Z, k]

UG: Cho k trong các chữ cái viết hoa.

Tương đương Python thô sơ:

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

Đây không phải là mục, tôi chỉ nghĩ mọi người có thể muốn xem nó. Trong Pyth 1.0.4, chương trình sau đây là một giải pháp trong 10 ký tự:

JUwo_cJNUG

Giải trình:

JUw: Chuyển đổi đầu vào thành chữ hoa và lưu trữ trong J.

o: (In) Sắp xếp theo

_cJN: -1 * (số N trong J)

UG: Trên N trong các chữ cái viết hoa.

Đây không phải là một giải pháp hợp pháp vì một số thay đổi từ Pyth 1.0.2 đến 1.0.4, bao gồm cả việc bổ sung ochức năng, sắp xếp theo, đã đáp ứng với vấn đề này.

Javascript ( ES6 ) 119 117

Chỉnh sửa: (-2) Đã xóa nhu cầu toUpperCasesử dụng RegEx không phân biệt chữ hoa chữ thường trong splitcuộc gọi.

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

Thay thế (cùng độ dài): Ngưng tụ sắp xếp và ký tự vào một chức năng.

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

Là một chức năng: 105 104

Chỉnh sửa: (-1) Cô đặc cách sắp xếp và ký tự thành một hàm duy nhất.

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

GolfScript, 22 ký tự

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

Hãy thử trực tuyến.

Giải trình:

• :?gán chuỗi đầu vào cho ký hiệu ?. (Tôi sử dụng ký hiệu dấu chấm câu để số sau 91không được phân tích cú pháp như một phần của tên biểu tượng.)
• 91,xây dựng một danh sách các số từ 0 đến 90 (mã ASCII của Z).
• + nối thêm danh sách này vào chuỗi đầu vào, do đó chuyển đổi nó từ một mảng mã ASCII thành chuỗi (và cũng thuận tiện loại bỏ chuỗi đầu vào khỏi ngăn xếp).
• -26>lấy 26 ký tự cuối cùng của chuỗi này, tạo ra một chuỗi chứa các chữ cái ASCII viết hoa từ Ađến Z.
• Áp { }$dụng khối mã cho tất cả các ký tự trong chuỗi đầu vào và sắp xếp các ký tự đó theo kết quả.
• Bên trong khối mã, .sao chép ký tự và 32+chuyển đổi bản sao từ chữ hoa sang chữ thường. Bộ ]sưu tập hai ký tự này thành một mảng, ?\-lấy chuỗi đầu vào được lưu trữ ?và loại bỏ tất cả các lần xuất hiện của các ký tự trong mảng đó và ,đếm độ dài của chuỗi còn lại, sẽ là khóa sắp xếp. Các ký tự sẽ được sắp xếp theo thứ tự tăng dần theo phím này, và do đó theo thứ tự giảm dần theo số lần xuất hiện.

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

Ví dụ sử dụng:

λ> 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 ký tự

EDIT : Đã sửa lỗi để hoạt động chính xác với các chuỗi đa dòng, cảm ơn @ durron597!

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

Tạo một hàm được gọi là fcó thể được sử dụng như sau:

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

In sang STDOUT:

AZOSICGHEJKLMBFPQRDTUVWXYN

Perl, 54 46 byte

CẬP NHẬT: sau khi tối ưu hóa hơn nữa, nó có thể được nén thành 46 byte: (thx dennis cho -n/ {}hack; tiếng Trung perl goth cho <=>-> -hack)

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

Nó được chạy với chạy với perl -nE

Giải pháp gốc (không cần tùy chọn Perl đặc biệt):

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

Được xác minh trong Perl 5.8.3, 5.14.2

Nếu bạn nhận được cảnh báo, hãy tách biệt egvà forcó dấu cách (+1 char), nếu bạn thấy phiền

sử dụng ví dụ:

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

GIẢI THÍCH: Trên mỗi ký tự ( .) của mỗi dòng đầu vào ( for<>), áp dụng một "mẫu" thay thế, trên thực tế được đánh giá là một biểu thức ( ecờ của s///), làm tăng ucký tự ( .) $&ngắn hơn ( / ngắn hơn rõ ràng hơn (.)/ $1) được tính trong hàm băm (chưa được khởi tạo) ( %h). Sau đó, hàm băm tần số được sử dụng trong hàm so sánh sắp xếp để in ra bảng chữ cái in hoa theo đúng thứ tự.

R, 123 byte

Mã được cải thiện nhờ các đề xuất của @RichieC Bông.

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)

Đầu ra:

> f(text)
[1] "ETNAHORISULFGPBCDYMQWJKVXZ"

C ++, 185 183 179 177 byte

Tất nhiên, không mong đợi chiến thắng (C ++ có thể giành chiến thắng không?) Nhưng dù sao cũng là một bài tập thú vị.

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

Giải trình:

#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

Cập nhật để sử dụng một thuật toán hoàn toàn khác nhau. Đánh bại JavaScript!

Đẹp:

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)

Chơi gôn

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 byte

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

Bản giới thiệu:

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

Giải trình:

(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

Điều quan trọng là nối thêm mảng bên trái, sao cho tất cả các chữ cái đều có sẵn và đã theo thứ tự. Một hậu quả buồn cười của việc sử dụng một danh từ làm tine thứ ba cho ngã ba là nó hoạt động như động từ cũng như cụm từ.

Groovy - 130 123 115 112 98 92

Theo lời khuyên của @ cfrick (hai lần!):

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

Một thử nghiệm nhỏ (bị đánh cắp một cách đáng xấu hổ từ @jpjacobs):

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

Và bài kiểm tra đề xuất cũng đang trôi qua

SAS - 217 (tôi nghĩ)

Đầu vào phải được đặt trên dòng sau câu lệnh card4 hoặc trên thẻ đục lỗ thích hợp cho hệ thống của bạn. Tôi nghĩ rằng phương pháp này tiết kiệm một vài ký tự so với cố gắng trích dẫn đầu vào.

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;

Tôi biết rằng điều này không đáp ứng đầy đủ thông số kỹ thuật, vì nó chỉ trả về các ký tự xuất hiện trong chuỗi đầu vào. Tôi có thể cần phải suy nghĩ lại về điều này một chút.

AppleScript, 278

Tôi nhận thấy điều đó "a" = "A"đúng trong AppleScript. Tôi có thể sử dụng điều này trong mã golf, nhưng phần còn lại của kịch bản quá dài dòng. Tôi đã sử dụng AppleScript 1.8.3.

Điều này xác định một chức năng f. Nếu bạn thêm f("a string")ở dưới cùng của tập lệnh và chạy nó trong Trình chỉnh sửa tập lệnh, nó sẽ hiển thị kết quả.

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

Định dạng và nhận xét:

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

Chỉnh sửa: đã thay đổi hộp thư (p) thành hộp thư

Dễ đọc hơn:

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

Chơi gôn: (155 ký tự + 1 xe trở về)

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

Tôi đã có nó ở mức 171 trước đó với mã mà tôi thấy thú vị hơn, nhưng phương pháp sắp xếp thoải mái của tôi lại ngắn hơn và yêu cầu len (s), làm cho "for" ngắn hơn "while" cho vòng lặp đầu tiên. (ngáp)

'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

Một hàm lấy đầu vào bên phải dưới dạng một chuỗi. Không phải là một người chiến thắng, nhưng đó là niềm vui để viết.

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

Giải thích:

• toupperlà một động từ trong thư viện chuẩn bao gồm một chuỗi. Điều đó sau đó trở thành đối số bên phải của động từ, trong khi đối số bên trái là bảng chữ cái: ASCII mã hóa từ 65 đến 90.

• [và ,e.~#])chọn ( #) các chữ cái ở bên phải arg ( ]) là các phần tử của ( e.~) bên trái, và sau đó thêm vào ( ,) bên trái arg ( [). Để dí dỏm, chúng tôi chỉ giữ các ký tự viết hoa và thêm một bản sao của bảng chữ cái vào cuối, để đảm bảo chúng tôi bắt được tất cả.

• #/.~@sau đó đưa ra tần số của từng ký tự. Điều đó xảy ra rằng điều này được đưa ra theo thứ tự bảng chữ cái, vì vậy ngay sau đó chúng ta có thể downsort ( \:) bảng chữ cái (đối số bên trái [).

Một ví dụ lười biếng nhanh chóng dưới đây. Cảm thấy tự do để thử nó cho chính mình tại 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

Về cơ bản, đây là giải pháp VBScript của tôi nhưng được triển khai bằng SQL.

Đây là lạm dụng đầu ra XML để nối một cột. Trong sử dụng thực tế, nó có thể được nối với một bảng bên ngoài để mô phỏng các GROUP_CONCATchức năng trong MySQL và các chức năng khác.

Khai báo @biến:

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

Mã số:

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

• Chỉ có 26 chữ cái ASCII viết hoa mà không có bất kỳ khoảng trắng nào được xuất theo thứ tự tần số.
• Các ký tự buộc được đưa ra theo thứ tự chữ cái.

Kết quả cho ví dụ trong câu hỏi:

EITUSALNROMCDPVGQBFHJKWXYZ

Ung dung:

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

Đây là một hexdump, nguyên nhân của các ký tự đặc biệt:

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

Và một phiên bản ít chơi gôn hơn:

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

Thí dụ:

 $ 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 # trong LINQPad - 203 byte

Tôi đã thực hiện một cách tiếp cận khác nhau cho câu trả lời của Logan Dam. Trước tiên tôi đã đảm bảo rằng mọi ký tự trong chuỗi đầu vào được sắp xếp theo sự xuất hiện của nó và chỉ tồn tại một lần trong chuỗi đầu ra. Sau đó tôi đã thêm mọi ký tự bị thiếu từ bảng chữ cái vào chuỗi đầu ra.

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

Đáng buồn thay, nó sẽ không đánh bại câu trả lời của Logan Dam nếu tôi đã thực hiện trong Visual Studio.

Phiên bản dễ đọc hơn:

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 # (và LINQ) 255 226 210 byte

Sử dụng lời khuyên của Patrick Huizinga, cú pháp truy vấn hiện ngắn hơn:

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

Giải trình:

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

Cú pháp phương thức tương đương (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());}}}

Bài gốc:

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

Đây là lần gửi đầu tiên của tôi và tôi nên làm việc tại nơi làm việc nhưng điều này trông giống như rất nhiều niềm vui bởi vì tôi cảm thấy như tôi thực sự có thể tham gia một lần.

Giải trình:

(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

Tôi không bao giờ sử dụng cú pháp phương thức cho LINQ vì vậy đây là một kinh nghiệm học tập đối với tôi :) cũng nghĩ về nó bây giờ tôi có thể tiết kiệm 2 byte bằng cách thay thế các ký tự bằng các số nguyên của chúng, nhưng, meh.

Rút ngắn nhờ các mẹo từ Chương trìnhFOX và Num Lock :)

Cú pháp truy vấn tương đương (dài hơn một chút):

(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

Phiên bản đầu tiên 701 byte (sử dụng STL thành ngữ)

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

Phiên bản sạch mở rộng:

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

Ý tưởng là để chứng minh một chương trình C ++ "phù hợp" mà không có bất kỳ hack nào. Bỏ qua các mẫu soạn sẵn và thực tế là cái này chỉ biên dịch trên VC ++

Giải trình :

Chúng tôi điền từ A đến Z vào một chuỗi bằng iota () , điều này đảm bảo rằng khi chúng tôi đếm số lần xuất hiện, mỗi ký tự sẽ xuất hiện ngay cả khi nó không có trong đầu vào.

biến đổi () sao chép ký tự theo ký tự từ đầu vào tiêu chuẩn và đặt nó vào cuối s sau khi gọi toupper () trên mỗi một

Số lượng của mỗi ký tự được giảm dần trên bản đồ (bằng cách duy trì số lượng âm, chúng ta có thể sắp xếp giảm dần mà không cần thêm mã)

Các mục nhập bản đồ đếm được sao chép thành một tập hợp các cặp, hoán đổi (char, đếm) thành (đếm, char). Vì các bộ được đặt hàng, chúng tôi sẽ sắp xếp chúng bằng cách giảm số lượng tần số

Cuối cùng, chúng tôi sao chép nội dung của tập hợp thành tiêu chuẩn, sử dụng biến đổi và sử dụng select2nd () để chọn ra thành viên thứ hai của cặp.

Mã này khá dễ đọc. Một giải pháp C ++ 11 sẽ trông đẹp hơn nhiều, vì chúng ta có thể sử dụng lambdas

Phiên bản C ++ 11 - không cần lambdas, nhưng tự động và phạm vi dựa trên để làm cho mọi thứ rất sạch sẽ (hãy nghĩ về nó bạn có thể làm rất giống với C ++ 98 thông thường)

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

Phiên bản mở rộng:

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

Lặp lại tiếp theo (tại sao đọc từ stdin khi chúng ta có 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;}}

Phiên bản mở rộng:

#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 (không cạnh tranh)

ØAŒuċ¥@ÞU

Giải trình

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

Điều này đọc là "sắp xếp bảng chữ cái viết hoa theo số lần xuất hiện trong đầu vào chữ hoa, đảo ngược", đây là một bản dịch khá đúng nghĩa của thách thức: P

Hãy thử trực tuyến!

Thử thách này được liên kết với Jelly HyperTraining nơi chúng tôi đã giải quyết thử thách. Tôi đã đăng bài này vì tôi là người đầu tiên đạt 10 byte.

-1 byte nhờ Erik the Outgolfer (giáo viên JHT)

C ++ 377

Triển khai qsort bằng cách sử dụng số lượng chữ cái trong mảng n để sắp xếp bảng chữ cái trong mảng A. Chạy qua dòng lệnh: 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);}

• Một số đầu vào chứa mã ASCII> = 128 sẽ tăng tần số chữ không chính xác. Để sửa lỗi này, thay thế hằng số 95bằng 223, với chi phí thêm 1 byte.
• Điều này sẽ chấm dứt sớm trên các đầu vào có chứa ký tự với mã ASCII 255. Để sửa lỗi này với chi phí thêm 1 byte, hãy thay đổi char c;thành chỉ c;và ++cthành c=c+1%255.

PowerShell - 139 ký tự

Đầu tiên, tôi không phải là chuyên gia về PowerShell. Khá chắc chắn có ngắn hơn này. Nhưng đã hài lòng với nó và quyết định chia sẻ.

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

Làm thế nào nó hoạt động:

$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 ký tự

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

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

-6 cảm ơn Adam.