Krótki i słodki opis wyzwania:
Opierając się na ETAOIN SHRDLU , Twoim zadaniem jest napisanie najkrótszego programu lub funkcji w dowolnym języku, który wypisuje 26 liter alfabetu angielskiego na podstawie ich częstotliwości na wejściu.

Naprawdę długa, sucha i dokładna specyfikacja:

• Twój program / funkcja otrzyma jako wejście ciąg tekstu, który będzie zawierał jedną lub więcej wielkich i / lub małych liter, a także może zawierać znaki interpunkcyjne, cyfry, symbole i inne znaki niealfabetyczne.
• Program / funkcja musi wyprowadzać tylko 26 wielkich liter alfabetu angielskiego, w tym te, które nie pojawiają się na wejściu, uporządkowane od największej do najmniejszej w zależności od tego, ile razy pojawiają się na wejściu.
• Edycja: Częstotliwość jest obliczana bez rozróżniania wielkości liter, ale dane wyjściowe muszą być pisane wielkimi literami.
• Jeśli dwie lub więcej liter ma tę samą częstotliwość, mogą być w dowolnej kolejności.
• Żadne inne dane wyjściowe, takie jak białe znaki, nie są dozwolone.
• Edytuj 7/1/2014: W oparciu o informacje zwrotne zmieniam tę zasadę. Jedynym dozwolonym wyjściem jest opcjonalne początkowe i / lub końcowe białe znaki, takie jak końcowy znak nowej linii. Żadne inne dane wyjściowe nie są dozwolone.
• Niezdefiniowane zachowanie jest dozwolone dla danych wejściowych, które nie zawierają żadnych liter.

Zwycięzca zostanie wybrany za 7 dni, więc zacznij pisać!

Przykładowe dane wejściowe:

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.

Przykładowe dane wyjściowe:

EITUSALNROMCDPVGQBFHJKWXYZ

Uwaga: KWXYZdla tego wejścia istnieje 5-krotny remis .

Edytować:

Konkurs się skończył! Dziękujemy wszystkim, którzy wzięli udział. A teraz zwycięzca (zwycięzcy!): Zarówno CJam Dennisa, jak i Pyta Isaacga otrzymały 19 ogromnych postaci. (Przepraszam, ale nie zamierzam przyjąć żadnej z odpowiedzi, ponieważ uważam, że byłoby to niesprawiedliwe w stosunku do drugiej.) Edytuj: Biorąc radę Dennisa, oznaczę jego odpowiedź jako zaakceptowaną, ponieważ to on jako pierwszy osiągnąć 19 znaków. Wyróżnienia należą do odpowiedzi Ilmari Karonen na trzecie miejsce w Golfscript przy 22 znakach, a także 75- znakowej odpowiedzi Python podziemnego kolejki, która uzyskała najwięcej pozytywnych opinii. Jeszcze raz dziękuję wszystkim, którzy wzięli udział!

CJam, 21 19 bajtów

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

Wypróbuj online.

Przykład

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

(bez nowej linii)

Jak to działa

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

Więcej wystąpień oznacza, że ​​więcej znaków zostanie usuniętych, więc najczęściej pojawiają się na początku tablicy.

Python 2 lub 3 - 77 75 bajtów

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

Miałem odpowiedź przed tym pobranym wkładem ze STDIN, ale zdałem sobie sprawę, że jest to technicznie nieprawidłowe. Użyłem, input()który pobiera tylko jedną linię, ale przykładowe dane wejściowe pytania sugerują, że powinien on obsługiwać wiele linii jednocześnie. Aby spełnić specyfikację, zmieniłem moją odpowiedź w funkcję, która pobiera argument ciągu. Ku mojemu zaskoczeniu było to dwa bajty mniejsze! Nie przyszło mi to do głowy print(...)i input()były dłuższe niż f=lambda s:is .

Dzięki temu odpowiedź jest kompatybilna zarówno z Python 2, jak i Python 3. Początkowo był to tylko Python 3, ponieważ był używany input()(który został wywołany raw_input()w 2). Teraz, gdy jest to funkcja, działa w obu przypadkach.

Wyjaśniono

                                  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 bajtów

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

Przykład

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

Jak to działa

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

Wypróbuj tutaj: http://ideone.com/fork/YlWpEJ

Dowiedz się więcej o Pyth tutaj: http://esolangs.org/wiki/Pyth

Przykład:

Na podstawie ETAOIN SHRDLU Twoim zadaniem jest napisanie najkrótszego programu lub funkcji w dowolnym języku, który wypisze 26 liter alfabetu angielskiego na podstawie ich częstotliwości na wejściu.

Daje:

TENOHARSIULGFPYDCBWQMZXVKJ

Wyjaśnienie:

=ZUw: Konwertuj tekst na wielkie litery i zapisz w Z.

sV: Wydrukuj sumę rewersu

m;d: Ostatnie wpisy z

S: Posortowane według pierwszego wpisu, w porządku rosnącym

m[cZkk): Listy [liczba k w Z, k]

UG: Dla k wielkimi literami.

Szorstki odpowiednik Pythona:

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

To nie jest wpis, pomyślałem, że ludzie mogą go zobaczyć. W Pyth 1.0.4 następujący program jest rozwiązaniem składającym się z 10 znaków:

JUwo_cJNUG

Wyjaśnienie:

JUw: Konwertuj tekst na wielkie litery i zapisz w J.

o: (Drukuj) Sortuj według

_cJN: -1 * (liczba N w J)

UG: Powyżej N wielkimi literami.

Nie jest to legalne rozwiązanie, ponieważ kilka zmian z Pyth 1.0.2 na 1.0.4, w tym dodanie funkcji osortowania według, było odpowiedzią na ten problem.

JavaScript ( ES6 ) 119 117

Edycja: (-2) Usunięto potrzebę toUpperCaseużywania w splitwywołaniu RegEx bez rozróżniania wielkości liter .

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

Alternatywa (ta sama długość): Skondensowano sortowanie i liczenie znaków w jedną funkcję.

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

W funkcji: 105 104

Edycja: (-1) Skondensowano sortowanie i liczenie znaków w jedną funkcję.

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

GolfScript, 22 znaki

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

Wypróbuj online.

Wyjaśnienie:

• :?przypisuje ciąg wejściowy do symbolu ?. (Używam symbolu interpunkcyjnego, aby następujący numer 91nie był analizowany jako część nazwy symbolu).
• 91,konstruuje listę liczb od 0 do 90 (kod ASCII Z).
• + dołącza tę listę do ciągu wejściowego, tym samym konwertując go z tablicy kodów ASCII na ciąg (i wygodnie usuwając również ciąg wejściowy ze stosu).
• -26>pobiera ostatnie 26 znaków tego ciągu, tworząc ciąg zawierający wielkie litery ASCII od AdoZ .
• { }$Stosuje blok kodu do wszystkich znaków w ciągu wejściowego i sortuje te znaki, w zależności od wyniku.
• Wewnątrz bloku kodu .duplikuje znak i 32+konwertuje kopię z wielkich na małe. ]Zbiera te dwa znaki do tablicy, ?\-wykonuje ciąg wejściowy przechowywane w ?i usuwa wszystkie wystąpienia znaków w tablicy z nim, a ,liczy się długość pozostałego ciąg, który będzie kluczem sortowania. Znaki będą sortowane w kolejności rosnącej według tego klucza, a zatem w kolejności malejącej według liczby wystąpień.

Haskell, 110 bajtów

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

Przykładowe użycie:

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

EDYCJA : Naprawiono do poprawnego działania z ciągami wielowierszowymi, dzięki @ durron597!

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

Tworzy wywoływaną funkcję, fktórej można użyć w następujący sposób:

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

Drukuje do STDOUT:

AZOSICGHEJKLMBFPQRDTUVWXYN

Perl, 54 46 bajtów

AKTUALIZACJA: po dalszych optymalizacjach może zostać zmniejszona do 46 bajtów: (thx dennis for -n/ {}hack; chinese perl goth for <=>-> -hack)

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

Ma być uruchamiany z biegiem z perl -nE

Oryginalne rozwiązanie (nie wymaga specjalnych opcji Perla):

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

Zweryfikowane w Perl 5.8.3, 5.14.2

Jeśli pojawi się ostrzeżenie, oddzielną egi forspacją (+1 char), jeśli przeszkadza

przykładowe użycie:

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

OBJAŚNIENIE: Do każdego znaku ( .) w każdym wierszu wejściowym ( for<>) zastosuj „wzór” podstawienia, który w rzeczywistości jest oceniany jako wyrażenie ( eflaga s///), które inkrementuje znak w górę ( uc) ( ./ $&jest krótszy niż bardziej oczywiste (.)/ $1) liczą się w (niezainicjowanym) haszu ( %h). Następnie skrót literowy częstotliwości jest używany w funkcji porównania sortowania w celu wydrukowania wielkich liter alfabetu we właściwej kolejności.

R, 123 bajty

Kod został ulepszony dzięki sugestiom @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)

Wynik:

> f(text)
[1] "ETNAHORISULFGPBCDYMQWJKVXZ"

C ++, 185 183 179 177 bajtów

Oczywiście nie oczekuje się wygranej (czy C ++ może kiedykolwiek wygrać?), Ale mimo to jest to zabawne ćwiczenie.

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

Wyjaśnienie:

#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

Zaktualizowano, aby używać zupełnie innego algorytmu. Wygrywa JavaScript!

Ładny:

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)

Gra w golfa:

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 bajtów

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

Próbny:

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

Wyjaśnienie:

(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

Kluczem jest dodanie lewej tablicy, aby wszystkie litery były dostępne i już w kolejności. Zabawną konsekwencją użycia rzeczownika jako trzeciego palca widelca jest to, że działa on zarówno jako czasownik, jak i fraza.

Groovy - 130 123 115 112 98 92

Zgodnie z radą @ cfrick (dwa razy!):

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

Mały test (bezwstydnie skradziony z @jpjacobs):

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

I proponowany test również przechodzi

SAS - 217 (myślę)

Dane wejściowe należy umieścić w wierszu po wyciągu cards4 lub na odpowiednich kartach dziurkowanych dla twojego systemu. Myślę, że takie podejście pozwala zaoszczędzić kilka znaków w porównaniu z próbą zacytowania danych wejściowych.

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;

Wiem, że nie jest to pełna specyfikacja, ponieważ zwraca tylko znaki pojawiające się w ciągu wejściowym. Być może będę musiał przemyśleć to trochę.

AppleScript, 278

Zauważyłem, że tak "a" = "A"jest w AppleScript. Mogę użyć tego w golfie kodu, ale reszta skryptu jest zbyt trudna. Użyłem AppleScript 1.8.3.

To definiuje funkcję f. Jeśli dodasz f("a string")na dole skryptu i uruchomisz go w edytorze skryptów, wyświetli wynik.

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

Sformatowane i skomentowane:

-- 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 bajtów

Edytuj: zmieniono msgbox (p) na msgbox p

Bardziej czytelny:

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

Gra w golfa: (155 znaków + 1 powrót karetki)

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

Miałem go wcześniej w 171 z kodem, który uznałem za bardziej interesujący, ale metoda sortowania drei jest wygodniejsza i krótsza i wymaga len (s), co powoduje, że „dla” jest krótsze niż „while” dla pierwszej pętli. (ziewać)

'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 znaków

Funkcja pobierająca dane po prawej jako ciąg znaków. Nie jestem zwycięzcą, ale pisanie było fajne.

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

Wyjaśniono:

• toupperto czasownik w standardowej bibliotece, który zwiększa ciąg. To staje się właściwym argumentem czasownika, a lewym argumentem jest alfabet: punkty kodowe ASCII od 65 do 90.

• [i ,e.~#])wybiera ( #) te litery w prawym arg ( ]), które są elementami ( e.~) po lewej, a następnie wstawia ( ,) lewy arg ( [). To znaczy, trzymamy tylko wielkie litery i dodajemy jedną kopię alfabetu na końcu, aby upewnić się, że złapiemy je wszystkie.

• #/.~@następnie podaje częstotliwości każdego znaku. Zdarza się, że jest to podane w kolejności alfabetycznej, więc zaraz potem możemy downsortować ( \:) alfabet (lewy argument [).

Szybki, leniwy przykład poniżej. Nie krępuj się go wypróbować na 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

Zasadniczo jest to moje rozwiązanie VBScript, ale zaimplementowane w SQL.

Jest to nadużycie wyjściowe XML w celu konkatenacji kolumny. W praktyce można go połączyć z zewnętrznym stołem w celu emulacjiGROUP_CONCAT funkcje w MySQL i innych.

Deklarowanie @zmiennej:

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 bajtów

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

• Tylko 26 wielkich liter ASCII bez spacji jest wyprowadzanych w kolejności częstotliwości.
• Związane znaki są podawane w kolejności alfabetycznej.

Wynik dla przykładu w pytaniu:

EITUSALNROMCDPVGQBFHJKWXYZ

Nie golfowany:

# 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 bajtów

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

Oto zrzut heksowy, przyczyna znaków specjalnych:

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

I nieco mniej golfowa wersja:

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

Przykład:

 $ 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 # w LINQPad - 203 bajtów

Przyjąłem inne podejście do odpowiedzi Logana Dam. Najpierw upewniłem się, że każdy znak w ciągu wejściowym jest posortowany według wyglądu i istnieje tylko raz w ciągu wyjściowym. Następnie dodałem każdy brakujący znak z alfabetu do ciągu wyjściowego.

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

Niestety, nie wybiłbym odpowiedzi Logana Dama, gdybym zrobił to w Visual Studio.

Bardziej czytelna wersja:

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 # (i LINQ) 255 226 210 bajtów

Korzystając z porady Patricka Huizingi, składnia zapytania jest teraz krótsza:

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

Wyjaśnienie:

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

Równoważna składnia metody (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());}}}

Oryginalny post:

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

To jest moje pierwsze zgłoszenie i powinienem robić rzeczy w pracy, ale wyglądało to na tak dobrą zabawę, ponieważ czułem, że mogę chociaż raz wziąć udział.

Wyjaśnienie:

(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

Nigdy nie używam składni metody dla LINQ, więc było to dla mnie doświadczenie uczenia się :) również zastanawiałem się nad tym teraz, mogłem zaoszczędzić 2 bajty, zastępując literały znakowe ich odpowiednikami liczb całkowitych, ale, meh.

Skrócone dzięki poradom ProgramFOX i Num Lock :)

Równoważna składnia zapytania (nieco dłużej):

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

Pierwsza wersja 701 bajtów (idiomatyczne użycie STL)

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

Rozszerzona czysta wersja:

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

Chodzi o to, aby zademonstrować „właściwy” program C ++ bez żadnych włamań. Zignoruj ​​płytę kotłową i fakt, że kompiluje się ona tylko w VC ++

Objaśnienie:

Wypełniamy A do Z ciągiem znaków za pomocą iota () , co zapewnia, że ​​kiedy policzymy wystąpienia, każdy znak pojawi się, nawet jeśli nie ma go na wejściu.

transform () kopiuje znak po znaku ze standardowego wejścia i umieszcza go na końcu s po wywołaniu toupper () na każdym

Liczba każdego znaku jest zmniejszana na mapie (utrzymując liczby ujemne, możemy sortować malejąco bez dodatkowego kodu)

Wpisy mapy zliczania są kopiowane do zestawu par, zamieniając (char, count) na (count, char). Ponieważ zestawy są uporządkowane, sortujemy je według malejącej liczby częstotliwości

Na koniec kopiujemy zawartość zestawu do standardu, używając transformacji i używając select2nd (), aby wybrać tylko drugiego członka pary.

Kod jest dość czytelny. Rozwiązanie C ++ 11 wyglądałoby o wiele ładniej, ponieważ możemy używać lambd

Wersja C ++ 11 - nie potrzeba lambda, ale auto i zakres oparte na sprawiają, że wszystko jest bardzo czyste (pomyśl o tym, możesz zrobić bardzo podobnie ze zwykłym C ++ 98)

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

Wersja rozszerzona:

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

Następna iteracja (po co czytać ze stdin, skoro mamy 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;}}

Wersja rozszerzona:

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

Galaretka , 9 bajtów (niekonkurencyjna)

ØAŒuċ¥@ÞU

Wyjaśnienie

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

Odczytuje się to jako „posortuj wielkie litery według liczby wystąpień w danych wejściowych pisanych wielkimi literami, odwróconych”, co jest dość dosłownym tłumaczeniem wyzwania: P

Wypróbuj online!

To wyzwanie było powiązane z Jelly HyperTraining, w którym rozwiązaliśmy to wyzwanie. Wysłałem to, ponieważ jako pierwszy osiągnąłem 10 bajtów.

-1 bajt dzięki Erik the Outgolfer (nauczyciel JHT)

C ++ 377

Implementuje qsort przy użyciu liczby liter w tablicy n, aby posortować alfabet w tablicy A. Uruchom za pomocą wiersza poleceń: 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) bajtów

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

• Niektóre wejścia zawierające kody ASCII> = 128 niepoprawnie zwiększają częstotliwości liter. Aby rozwiązać ten problem, należy wymienić stałą 95z 223kosztem 1 dodatkowym bajt.
• To zakończy się wcześnie na wejściach zawierających znak z kodem ASCII 255. Aby to naprawić kosztem 1 dodatkowego bajtu, zmień char c;na just c;i ++cto c=c+1%255.

PowerShell - 139 znaków

Po pierwsze, nie jestem ekspertem od PowerShell. Jestem pewien, że są krótsze niż to. Ale był z tego zadowolony i postanowił się podzielić.

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

Jak to działa:

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

Cejlon , 98 bajtów

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

APL, 26 20 znaków

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

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

-6 dzięki Adamowi.