Kurze und süße Beschreibung der Herausforderung:
Basierend auf ETAOIN SHRDLU besteht Ihre Herausforderung darin, das kürzeste Programm oder die kürzeste Funktion in einer beliebigen Sprache zu schreiben, die die 26 Buchstaben des englischen Alphabets basierend auf ihrer Häufigkeit in der Eingabe ausgibt.

Wirklich lange, trockene und gründliche Spezifikation:

• Ihr Programm / Ihre Funktion erhält als Eingabe eine Textzeichenfolge, die einen oder mehrere Groß- und / oder Kleinbuchstaben sowie Satzzeichen, Ziffern, Symbole und andere nicht alphabetische Zeichen enthält.
• Das Programm / die Funktion darf nur die 26 GROSSBUCHSTABEN des englischen Alphabets ausgeben , einschließlich derjenigen, die nicht in der Eingabe enthalten sind, geordnet nach der Häufigkeit, mit der sie in der Eingabe vorkommen.
• Bearbeiten: Die Frequenz wird unabhängig von Groß- und Kleinschreibung berechnet, die Ausgabe muss jedoch in Großbuchstaben erfolgen.
• Wenn zwei oder mehr Buchstaben dieselbe Häufigkeit haben, können sie in beliebiger Reihenfolge sein.
• Andere Ausgaben wie Leerzeichen sind nicht zulässig.
• Edit 01.07.2014: Aufgrund von Rückmeldungen ändere ich diese Regel. Die einzige andere Ausgabe, die zulässig ist, ist ein optionales führendes und / oder nachfolgendes Leerzeichen, z. B. ein nachfolgender Zeilenumbruch. Keine andere Ausgabe ist zulässig.
• Undefiniertes Verhalten ist für Eingaben zulässig, die keine Buchstaben enthalten.

Der Gewinner wird in 7 Tagen ermittelt, also lassen Sie die Finger tippen!

Beispiel Eingabe:

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.

Beispielausgabe:

EITUSALNROMCDPVGQBFHJKWXYZ

Hinweis: KWXYZFür diesen Eingang besteht eine 5-Wege-Verbindung .

Bearbeiten:

Der Wettbewerb ist vorbei! Vielen Dank an alle, die teilgenommen haben. Und jetzt zu den Gewinnern: Sowohl Dennis 'CJam- als auch isaacgs Pyth- Antworten kamen mit satten 19 Zeichen. (Tut mir leid, aber ich werde keine der Antworten akzeptieren, da ich denke, dass es für die anderen unfair wäre.) Bearbeiten: Ich nehme Dennis 'Rat an und markiere seine Antwort als akzeptiert, weil er die erste war erreichen 19 Zeichen. Lobende Erwähnungen gehen an Ilmari Karonens drittplatzierte Golfscript-Antwort mit 22 Zeichen sowie an die 75- Zeichen -Python-Antwort von undergroundmonorail mit den meisten positiven Stimmen. Nochmals vielen Dank an alle, die teilgenommen haben!

CJam, 21 19 Bytes

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

Probieren Sie es online aus.

Beispiel

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

(kein Zeilenumbruch)

Wie es funktioniert

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

Mehr Vorkommen bedeuten, dass mehr Zeichen entfernt werden, sodass die häufigsten Zeichen am Anfang des Arrays angezeigt werden.

Python 2 oder 3 - 77 75 Bytes

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

Ich hatte zuvor eine Antwort, die ich von STDIN erhalten hatte, aber mir wurde klar, dass dies technisch ungültig war. Ich habe verwendet, input()dass nur eine einzelne Zeile erhalten wird, aber die Beispieleingabe der Frage impliziert, dass mehrere Zeilen gleichzeitig behandelt werden sollen. Um die Spezifikation zu erfüllen, habe ich meine Antwort in eine Funktion umgewandelt, die ein String-Argument akzeptiert. Zu meiner Überraschung war es zwei Bytes kleiner! Mir ist das nicht eingefallen print(...)und input()waren länger als f=lambda s:und s.

Dies macht die Antwort auch mit Python 2 und Python 3 kompatibel. Ursprünglich war es nur Python 3, weil es verwendet wurde input()(was raw_input()in 2 aufgerufen wurde). Jetzt, da es eine Funktion ist, funktioniert es in beiden.

Erklärt

                                  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 Bytes

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

Beispiel

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

Wie es funktioniert

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

Versuchen Sie es hier: http://ideone.com/fork/YlWpEJ

Weitere Informationen zu Pyth finden Sie hier: http://esolangs.org/wiki/Pyth

Beispiel:

Basierend auf ETAOIN SHRDLU besteht Ihre Herausforderung darin, das kürzeste Programm oder die kürzeste Funktion in einer beliebigen Sprache zu schreiben, die die 26 Buchstaben des englischen Alphabets basierend auf ihrer Häufigkeit in der Eingabe ausgibt.

Gibt:

TENOHARSIULGFPYDCBWQMZXVKJ

Erläuterung:

=ZUw: Eingabe in Großbuchstaben konvertieren und in Z speichern.

sV: Gibt die Summe der Umkehrung von aus

m;d: Die letzten Einträge von

S: Sortiert nach dem ersten Eintrag in aufsteigender Reihenfolge

m[cZkk): Die Listen [Anzahl von k in Z, k]

UG: Für k in Großbuchstaben.

Grobes Python-Äquivalent:

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

Dies ist kein Eintrag, ich dachte nur, die Leute würden ihn gerne sehen. In Pyth 1.0.4 ist das folgende Programm eine Lösung mit 10 Zeichen:

JUwo_cJNUG

Erläuterung:

JUw: Eingabe in Großbuchstaben konvertieren und in J speichern

o: (Drucken) Sortieren nach

_cJN: -1 * (Anzahl von N in J)

UG: Über N in Großbuchstaben.

Es ist keine legale Lösung, da einige der Änderungen von Pyth 1.0.2 auf 1.0.4, einschließlich des Hinzufügens der oFunktion "Sortieren nach", auf dieses Problem reagiert haben.

Javascript ( ES6 ) 119 117

Bearbeiten: (-2) Die toUpperCaseVerwendung von RegEx, bei dem splitdie Groß- und Kleinschreibung nicht berücksichtigt werden muss , wurde entfernt.

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

Alternative (gleiche Länge): Die Sortierung und die Anzahl der Zeichen wurden zu einer einzigen Funktion zusammengefasst.

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

Als Funktion: 105 104

Bearbeiten: (-1) Die Sortierung und die Anzahl der Zeichen wurden zu einer einzigen Funktion zusammengefasst.

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

GolfScript, 22 Zeichen

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

Probieren Sie es online aus.

Erläuterung:

• :?Weist die Eingabezeichenfolge dem Symbol zu ?. (Ich verwende ein Interpunktionssymbol, damit die folgende Zahl 91nicht als Teil des Symbolnamens analysiert wird.)
• 91,erstellt eine Liste der Zahlen von 0 bis 90 (ASCII-Code von Z).
• + Hängt diese Liste an die Eingabezeichenfolge an und konvertiert sie dadurch von einem Array von ASCII-Codes in eine Zeichenfolge (und entfernt die Eingabezeichenfolge bequemerweise auch vom Stapel).
• -26>Nimmt die letzten 26 Zeichen dieser Zeichenfolge und erzeugt eine Zeichenfolge, die die ASCII-Großbuchstaben von Abis enthält Z.
• Das { }$wendet den Codeblock auf alle Zeichen in der Eingabezeichenfolge an und sortiert diese Zeichen gemäß dem Ergebnis.
• .Dupliziert das Zeichen im Codeblock und 32+konvertiert die Kopie von Groß- in Kleinbuchstaben. Der ]sammelt diese beiden Zeichen in einem Array, ?\-nimmt die in gespeicherte Eingabezeichenfolge ?und entfernt alle Vorkommen der Zeichen im Array daraus und ,zählt die Länge der verbleibenden Zeichenfolge, die der Sortierschlüssel sein wird. Die Zeichen werden mit diesem Schlüssel in aufsteigender Reihenfolge und damit in absteigender Reihenfolge nach Anzahl der Vorkommen sortiert.

Haskell, 110 Bytes

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

Anwendungsbeispiel:

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

BEARBEITEN : Behoben, dass es mit mehrzeiligen Strings korrekt funktioniert, danke @ durron597!

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

Erstellt eine aufgerufene Funktion, fdie wie folgt verwendet werden kann:

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

Druckt nach STDOUT:

AZOSICGHEJKLMBFPQRDTUVWXYN

Perl, 54 46 Bytes

UPDATE: nach weiteren Optimierungen konnte es auf 46 Bytes komprimiert werden: (thx dennis for -n/ {}hack; chinese perl goth for <=>-> -hack)

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

Es ist zu laufen mit laufen mit perl -nE

Originallösung (benötigt keine speziellen Perl-Optionen):

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

Verifiziert in Perl 5.8.3, 5.14.2

Wenn Sie eine Warnung erhalten, getrennt egund formit einem Raum (1 Zeichen), wenn Sie nichts dagegen

Beispielverwendung:

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

ERKLÄRUNG: Wenden Sie auf jedes Zeichen ( .) jeder Eingabezeile ( for<>) ein Substitutionsmuster an, das in der Tat als Ausdruck ( eFlag des s///) gewertet wird und ein hochgestelltes ( uc) Zeichen inkrementiert ( ./ $&ist kürzer als offensichtlich (.)/ $1) im (nicht initialisierten) Hash ( %h) zählen. Der Buchstabenhäufigkeits-Hash wird dann in einer Sortiervergleichsfunktion verwendet, um Großbuchstaben in der richtigen Reihenfolge auszudrucken.

R, 123 Bytes

Der Code wird dank der Vorschläge von @RichieCotton verbessert.

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)

Ausgabe:

> f(text)
[1] "ETNAHORISULFGPBCDYMQWJKVXZ"

C ++, 185 183 179 177 Bytes

Natürlich wird kein Sieg erwartet (kann C ++ jemals gewinnen?), Aber dennoch eine unterhaltsame Übung.

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

Erläuterung:

#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

Aktualisiert, um einen völlig anderen Algorithmus zu verwenden. Schlägt JavaScript!

Ziemlich:

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

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

Erläuterung:

(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

Der Schlüssel ist, das linke Array anzuhängen, so dass alle Buchstaben verfügbar und bereits in Ordnung sind. Eine lustige Konsequenz der Verwendung eines Substantivs als dritter Spruch für die Gabel ist, dass es sowohl als Verb als auch als Phrase funktioniert.

Groovy - 130 123 115 112 98 92

Nach @ cfricks Rat (zweimal!):

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

Ein kleiner Test (schamlos von @jpjacobs gestohlen):

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

Und der vorgeschlagene Test ist auch erfolgreich

SAS - 217 (glaube ich)

Die Eingabe sollte in der Zeile nach der Anweisung cards4 oder auf den entsprechenden Lochkarten für Ihr System erfolgen. Ich denke, dieser Ansatz spart ein paar Zeichen gegenüber dem Versuch, die Eingabe zu zitieren.

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;

Mir ist bewusst, dass dies nicht die vollständige Spezifikation erfüllt, da nur Zeichen zurückgegeben werden, die in der Eingabezeichenfolge enthalten sind. Ich muss das vielleicht ein bisschen überdenken.

AppleScript, 278

Mir ist aufgefallen, dass "a" = "A"dies in AppleScript zutrifft. Ich kann dies in Code Golf verwenden, aber der Rest des Skripts ist zu wortreich. Ich habe AppleScript 1.8.3 verwendet.

Dies definiert eine Funktion f. Wenn Sie f("a string")am unteren Rand des Skripts hinzufügen und es im Skript-Editor ausführen, wird das Ergebnis angezeigt.

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

Formatiert und kommentiert:

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

Bearbeiten: msgbox (p) in msgbox p geändert

Besser lesbar:

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 Zeichen + 1 Wagenrücklauf)

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

Ich hatte es bei 171 vorhin mit Code, den ich interessanter fand, aber die Sortiermethode von comfortablydrei ist kürzer und erfordert len ​​(s), was ein "for" kürzer macht als das "while" für die erste Schleife. (gähnen)

'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

Eine Funktion, die die Eingabe rechts als Zeichenfolge aufnimmt. Kein Gewinner, aber es hat Spaß gemacht zu schreiben.

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

Erklärt:

• toupperist ein Verb in der Standardbibliothek, das eine Zeichenfolge in den Vordergrund stellt. Das wird dann das rechte Argument des Verbs, während das linke Argument das Alphabet ist: ASCII-Codepunkte 65 bis 90.

• [und ,e.~#])wählt ( #) die Buchstaben im rechten arg ( ]) aus, die Elemente des e.~linken arg ( ) sind , und stellt dann ( ,) das linke arg ( [) voran . Wir behalten also nur die Großbuchstaben bei und fügen am Ende eine einzige Kopie des Alphabets hinzu, um sicherzustellen, dass alle gefunden werden.

• #/.~@gibt dann die Frequenzen der einzelnen Zeichen an. Es kommt also vor, dass dies in alphabetischer Reihenfolge angegeben wird, so dass wir gleich danach \:das Alphabet (das linke Argument [) heruntersortieren können .

Ein schnelles faules Beispiel unten. Probieren Sie es einfach auf tryj.tk aus .

   (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

Grundsätzlich ist dies meine VBScript-Lösung, die jedoch in SQL implementiert ist.

Dies ist ein Missbrauch der XML-Ausgabe, um eine Spalte zu verketten. In der Praxis kann es mit einer äußeren Tabelle verknüpft werden, um GROUP_CONCATFunktionen in MySQL und anderen zu emulieren .

Deklaration der @Variablen:

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

Code:

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 Bytes

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

• Es werden nur die 26 ASCII-Großbuchstaben ohne Leerzeichen in der Reihenfolge ihrer Häufigkeit ausgegeben.
• Gebundene Zeichen werden in alphabetischer Reihenfolge angegeben.

Ergebnis für das Beispiel in der Frage:

EITUSALNROMCDPVGQBFHJKWXYZ

Ungolfed:

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

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

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

PHP - 105 Bytes

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

Hier ist ein Hexdump, wegen der Sonderzeichen:

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

Und eine etwas weniger golfene Version:

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

Beispiel:

 $ 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 # in LINQPad - 203 Bytes

Ich habe eine andere Herangehensweise an die Antwort von Logan Dam gewählt. Ich habe zuerst sichergestellt, dass jedes Zeichen in der Eingabezeichenfolge nach seinem Aussehen sortiert ist und nur einmal in der Ausgabezeichenfolge vorhanden ist. Danach habe ich jedes fehlende Zeichen aus dem Alphabet in die Ausgabezeichenfolge eingefügt.

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

Leider würde es die Antwort von Logan Dam nicht übertreffen, wenn ich das in Visual Studio gemacht hätte.

Mehr lesbare Version:

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

Nach dem Rat von Patrick Huizinga ist die Abfragesyntax jetzt kürzer:

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

Erläuterung:

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

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

Ursprünglicher Beitrag:

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

Dies ist meine allererste Einreichung und ich sollte Dinge bei der Arbeit tun, aber das sah nach so viel Spaß aus, weil ich das Gefühl hatte, tatsächlich einmal teilnehmen zu können.

Erläuterung:

(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

Ich benutze nie die Methodensyntax für LINQ, also war dies eine Lernerfahrung für mich :) Ich denke auch darüber nach, jetzt könnte ich 2 Bytes einsparen, indem ich die Zeichenliterale durch ihre ganzzahligen Gegenstücke ersetze, aber, meh.

Verkürzt dank Tipps von ProgramFOX und Num Lock :)

Die äquivalente Abfragesyntax (etwas länger):

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

Erste Version 701 Bytes (idiomatische AWL-Verwendung)

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

Erweiterte saubere Version:

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

Die Idee ist, ein "richtiges" C ++ - Programm ohne irgendwelche Hacks zu demonstrieren. Ignorieren Sie das Boilerplate und die Tatsache, dass dies nur unter VC ++ kompiliert wird

Erklärung:

Wir füllen eine Zeichenfolge mit iota () von A bis Z. Dies stellt sicher, dass jedes Zeichen angezeigt wird, wenn wir die Vorkommen zählen, auch wenn es nicht in der Eingabe enthalten ist.

transform () kopiert Zeichen für Zeichen aus der Standardeingabe und setzt es nach dem Aufruf von toupper () an das Ende von s

Die Anzahl der einzelnen Zeichen wird in der Karte verringert (durch Beibehalten negativer Zählwerte kann die Sortierung ohne zusätzlichen Code absteigend sein).

Die Einträge der Zählungszuordnung werden in eine Reihe von Paaren kopiert, wobei (char, count) zu (count, char) getauscht wird. Da die Sets geordnet sind, werden sie nach abnehmender Häufigkeit sortiert

Schließlich kopieren wir den Inhalt der Gruppe mit transform und select2nd () , um nur das zweite Mitglied des Paares auszuwählen.

Der Code ist ziemlich gut lesbar. Eine C ++ 11-Lösung würde viel schöner aussehen, da wir Lambdas verwenden können

C ++ 11-Version - keine Lambdas erforderlich, aber Auto- und Range-basiert macht die Dinge sehr sauber.

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

Erweiterte Version:

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

Nächste Iteration (warum von stdin lesen, wenn wir argv haben):

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

Erweiterte Version:

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

Gelee , 9 Bytes (nicht konkurrierend)

ØAŒuċ¥@ÞU

Erläuterung

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

Dies lautet wie folgt: "Sortieren Sie das Alphabet in Großbuchstaben nach der Anzahl der Vorkommen in der Eingabe in Großbuchstaben, in umgekehrter Reihenfolge", was eine ziemlich wörtliche Übersetzung der Herausforderung ist: P

Probieren Sie es online!

Diese Herausforderung stand im Zusammenhang mit Jelly HyperTraining, bei dem wir die Herausforderung gelöst haben. Ich gab dieses bekannt, weil ich das erste war, zum 10 Bytes zu erreichen.

-1 Byte dank Erik the Outgolfer (JHT Lehrer)

C ++ 377

Implementiert qsort unter Verwendung der Buchstabenanzahl in Array n, um das Alphabet in Array A zu sortieren. Führen Sie Folgendes über die Befehlszeile aus: 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) Bytes

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

• Einige Eingaben mit ASCII-Codes> = 128 erhöhen die Buchstabenfrequenzen fälschlicherweise. Um dies zu beheben, ersetzen Sie die Konstante 95mit 2231 zusätzlichen Byte.
• Dies wird bei Eingaben, die das Zeichen mit dem ASCII-Code 255 enthalten, vorzeitig beendet. Um dies auf Kosten von 1 zusätzlichen Byte zu beheben, wechseln Sie char c;zu nur c;und ++czu c=c+1%255.

PowerShell - 139 Zeichen

Erstens bin ich kein PowerShell-Experte. Ich bin mir ziemlich sicher, dass es kürzere gibt. War aber zufrieden damit und entschloss sich zu teilen.

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

Wie es funktioniert:

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

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

APL, 26 20 Zeichen

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

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

-6 danke an Adam.