Description succincte du défi:
Sur la base d' ETAOIN SHRDLU , votre défi consiste à écrire le programme ou la fonction le plus court dans n'importe quelle langue contenant les 26 lettres de l'alphabet anglais en fonction de leur fréquence de saisie.

Spécifications vraiment longues, sèches et complètes:

• Votre programme / fonction recevra en entrée une chaîne de texte contenant une ou plusieurs lettres majuscules et / ou minuscules, ainsi que des signes de ponctuation, des chiffres, des symboles et d’autres caractères non alphabétiques.
• Le programme / la fonction ne doit sortir que les 26 lettres MAJUSCULES de l'alphabet anglais, y compris celles qui n'apparaissent pas dans l'entrée, classées du plus au moins fréquentes en fonction du nombre de fois où elles apparaissent dans l'entrée.
• Edit: la fréquence est calculée sans distinction de casse, mais la sortie doit être en majuscule.
• Si deux lettres ou plus ont la même fréquence, elles peuvent être dans n'importe quel ordre.
• Aucune autre sortie, telle qu'un espace, n'est autorisée.
• Éditer 01/07/2014: Sur la base des commentaires, je modifie cette règle. Les seuls autres résultats autorisés sont les espaces de début et / ou de fin facultatifs, tels que les retours à la ligne. Aucune autre sortie n'est autorisée.
• Le comportement indéfini est autorisé pour une entrée ne contenant aucune lettre.

Le gagnant sera choisi dans 7 jours, alors faites taper vos doigts!

Exemple d'entrée:

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.

Exemple de sortie:

EITUSALNROMCDPVGQBFHJKWXYZ

Remarque: il existe un lien à 5 sens KWXYZpour cette entrée.

Modifier:

La compétition est terminée! Merci à tous ceux qui ont participé. Et maintenant, pour le (s) gagnant (s): Les réponses de CJam de Dennis et d’ Iaacg en python ont été composées de 19 caractères. (Désolé, mais je n'accepterai aucune des réponses car je pense que ce serait injuste pour l'autre.) Edit: Sur le conseil de Dennis, je vais marquer sa réponse comme acceptée car il a été le premier à atteindre 19 caractères. Des mentions honorables vont à la troisième place de Golfscript, Ilmari Karonen, avec 22 caractères, ainsi qu'à la réponse Python de undergroundmonorail, 75 caractères, qui a obtenu le plus grand nombre de votes positifs. Encore une fois, merci à tous ceux qui ont participé!

CJam, 21 19 octets

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

Essayez-le en ligne.

Exemple

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

(pas de nouvelle ligne)

Comment ça marche

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

Plus d'occurrences signifie plus de caractères sont supprimés, donc les caractères les plus fréquents apparaissent au début du tableau.

Python 2 ou 3 - 77 75 octets

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

J'avais une réponse avant qui a attrapé l'entrée de STDIN, mais j'ai réalisé que c'était techniquement invalide. J'ai utilisé input()ce qui n'obtient qu'une seule ligne, mais l'exemple de saisie de la question implique qu'il doit gérer plusieurs lignes à la fois. Pour répondre aux spécifications, j'ai transformé ma réponse en une fonction qui prend un argument de chaîne. À ma grande surprise, c'était deux octets plus petit! Cela ne m'est pas venu à l'esprit print(...)et input()était plus long que f=lambda s:et s.

Cela rend également la réponse compatible avec Python 2 et Python 3. À l’origine, il s’agissait uniquement de Python 3, car il l’utilisait input()(ce qui était appelé raw_input()dans 2). Maintenant que c'est une fonction, ça marche dans les deux cas.

A expliqué

                                  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 octets

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

Exemple

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

Comment ça marche

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

Essayez-le ici: http://ideone.com/fork/YlWpEJ

En savoir plus sur Pyth ici: http://esolangs.org/wiki/Pyth

Exemple:

Sur la base de ETAOIN SHRDLU, votre défi consiste à écrire le programme ou la fonction le plus court dans n’importe quelle langue qui génère les 26 lettres de l’alphabet anglais en fonction de leur fréquence dans l’entrée.

Donne:

TENOHARSIULGFPYDCBWQMZXVKJ

Explication:

=ZUw: Convertir les entrées en majuscules et les stocker dans Z.

sV: Imprimer la somme du revers de

m;d: Les dernières entrées de

S: Triés par leur première entrée, par ordre croissant

m[cZkk): Les listes [nombre de k dans Z, k]

UG: Pour k en majuscules.

Équivalent Python brut:

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

Ce n'est pas une entrée, je pensais juste que les gens aimeraient le voir. Dans Pyth 1.0.4, le programme suivant est une solution à 10 caractères:

JUwo_cJNUG

Explication:

JUw: Convertir les entrées en majuscules et les stocker dans J.

o: (Imprimer) Trier par

_cJN: -1 * (nombre de N dans J)

UG: Plus de N en majuscules.

Ce n'est pas une solution légale car plusieurs des modifications apportées de Pyth 1.0.2 à 1.0.4, y compris l'ajout de la fonction o, trier par, ont été apportées à ce problème.

Javascript ( ES6 ) 119 117

Edit: (-2) Suppression de la nécessité d' toUpperCaseutiliser un RegEx respectant la casse dans l' splitappel.

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

Alternative (même longueur): condensez le tri et le décompte des caractères en une seule fonction.

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

En fonction: 105 104

Edit: (-1) Condenser le tri et le décompte des caractères en une seule fonction.

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

GolfScript, 22 caractères

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

Essayez-le en ligne.

Explication:

• :?assigne la chaîne d'entrée au symbole ?. (J'utilise un symbole de ponctuation pour que le nombre suivant 91ne soit pas analysé dans le nom du symbole.)
• 91,construit une liste des nombres de 0 à 90 (code ASCII de Z).
• + ajoute cette liste à la chaîne d'entrée, la convertissant ainsi d'un tableau de codes ASCII en une chaîne (et supprimant également la chaîne d'entrée de la pile).
• -26>prend les 26 derniers caractères de cette chaîne, produisant une chaîne contenant les lettres ASCII majuscules de Aà Z.
• Le { }$applique le bloc de code à tous les caractères de la chaîne d'entrée et trie ces caractères en fonction du résultat.
• À l'intérieur du bloc de code, .duplique le caractère et 32+convertit la copie en majuscule en minuscule. Le ]récupère ces deux caractères dans un tableau, en extrait ?\-la chaîne d'entrée stockée, en ?supprime toutes les occurrences des caractères du tableau et ,compte la longueur de la chaîne restante, qui constituera la clé de tri. Les caractères seront triés en ordre croissant par cette touche, et donc en ordre décroissant par nombre d'occurrences.

Haskell, 110 octets

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

Exemple d'utilisation:

λ> 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 caractères

EDIT : Corrigé pour fonctionner correctement avec des chaînes multilignes, merci @ durron597!

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

Crée une fonction appelée fqui peut être utilisée comme suit:

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

Imprime sur STDOUT:

AZOSICGHEJKLMBFPQRDTUVWXYN

Perl, 54 46 octets

UPDATE: après d’autres optimisations, il pourrait être réduit à 46 octets: (merci dennis pour -n/ {}bidouille; chinois perl goth pour <=>-> -bidouille)

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

Il faut courir avec courir avec perl -nE

Solution originale (ne nécessite pas d'options Perl spéciales):

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

Vérifié en Perl 5.8.3, 5.14.2

Si vous recevez un avertissement, séparez eg-le en forlaissant un espace (+1 caractère), si vous le voulez bien.

exemple d'utilisation:

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

EXPLICATION: Sur chaque caractère ( .) de chaque ligne d'entrée ( for<>), appliquez un "motif" de substitution, qui est en fait évalué en tant qu'expression ( eindicateur du s///), qui incrémente un caractère upcased ( uc) ( ./ $&est plus court que plus évident (.)/ $1) compte dans le hash (non initialisé) ( %h). Ensuite, le hachage de la fréquence des lettres est utilisé dans une fonction de comparaison de tri pour imprimer les lettres majuscules dans le bon ordre.

R, 123 octets

Le code est amélioré grâce aux suggestions de @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)

Sortie:

> f(text)
[1] "ETNAHORISULFGPBCDYMQWJKVXZ"

C ++, 185 183 179 177 octets

Pas prévu de gagner, bien sûr (le C ++ peut-il jamais gagner?), Mais un exercice amusant néanmoins.

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

Explication:

#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

Mise à jour pour utiliser un algorithme complètement différent. Beats JavaScript!

Joli:

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

Golfé:

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

J 41 35 octets

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

Démo:

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

Explication:

(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

La clé consiste à ajouter le tableau de gauche, de sorte que toutes les lettres soient disponibles et déjà en ordre. Une conséquence amusante de l’utilisation d’un nom comme troisième phrase de la fourche est que cela fonctionne aussi bien comme verbe que comme expression.

Groovy - 130 123 115 112 98 92

Selon le conseil de @ cfrick (deux fois!):

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

Un petit test (volé sans vergogne à @jpjacobs):

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

Et le test proposé passe également

SAS - 217 (je pense)

Les entrées doivent être placées sur la ligne après la déclaration de cards4 ou sur les cartes perforées appropriées pour votre système. Je pense que cette approche enregistre quelques caractères plutôt que d'essayer de citer l'entrée.

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;

Je suis conscient que cela ne répond pas à la spécification complète, car il ne renvoie que les caractères qui apparaissent dans la chaîne d'entrée. Je pourrais avoir besoin de repenser cela un peu.

AppleScript, 278

J'ai remarqué que "a" = "A"c'est vrai dans AppleScript. Je peux l'utiliser dans le code de golf, mais le reste du script est trop verbeux. J'ai utilisé AppleScript 1.8.3.

Ceci définit une fonction f. Si vous ajoutez f("a string")au bas du script et l'exécutez dans l'éditeur de script, le résultat s'affiche.

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

Formaté et commenté:

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

Edit: changé msgbox (p) en msgbox p

Plus lisible:

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 caractères + 1 retour de voiture)

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

Je l'avais trouvé plus tôt avec le code 171 que je trouvais plus intéressant, mais la méthode de tri de comfortablydrei est plus courte et nécessite un ou plusieurs noms, ce qui fait un "pour" plus court que le "tant que" pour la première boucle. (bâillement)

'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 caractères

Une fonction prenant l'entrée à droite sous forme de chaîne. Pas un gagnant, mais c'était amusant d'écrire.

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

A expliqué:

• toupperest un verbe dans la bibliothèque standard qui met en valeur une chaîne. Cela devient alors l’argument droit du verbe, tandis que l’argument gauche est l’alphabet: points de code ASCII 65 à 90.

• [et ,e.~#])sélectionne ( #) les lettres dans l'argument de droite ( ]) qui sont des éléments de ( e.~) la gauche, et ajoute ensuite ( ,) l'argument de gauche ( [). En fait, nous ne conservons que les caractères majuscules et ajoutons une seule copie de l'alphabet à la fin pour nous assurer de les saisir tous.

• #/.~@donne ensuite les fréquences de chaque caractère. Il se trouve que ceci est donné par ordre alphabétique, alors juste après on peut downsort ( \:) l'alphabet (l'argument de gauche [).

Un exemple paresseux rapide ci-dessous. Ne hésitez pas à l' essayer pour vous - même à 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

Fondamentalement, ceci est ma solution VBScript mais implémentée en SQL.

Ceci est un abus de sortie XML pour concaténer une colonne. En pratique, il peut être associé à une table externe pour émuler des GROUP_CONCATfonctions dans MySQL et autres.

Déclarant la @variable:

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 octets

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

• Seules les 26 lettres ASCII majuscules sans espace sont sorties en ordre de fréquence.
• Les caractères liés sont donnés dans l'ordre alphabétique.

Résultat pour l'exemple dans la question:

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 octets

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

Voici un hexdump, à cause des caractères spéciaux:

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

Et une version légèrement moins golfée:

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

Exemple:

 $ 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 # dans LINQPad - 203 octets

J'ai adopté une approche différente de la réponse de Logan Dam. Je me suis d'abord assuré que tous les caractères de la chaîne d'entrée sont triés en fonction de leur apparence et n'existent qu'une seule fois dans la chaîne de sortie. Après cela, j'ai ajouté chaque caractère manquant de l'alphabet à la chaîne de sortie.

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

Malheureusement, la réponse de Logan Dam n’aurait pas été battue si j’avais procédé dans Visual Studio.

Version plus lisible:

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 # (et LINQ) 255 226 210 octets

Suivant les conseils de Patrick Huizinga, la syntaxe de la requête est maintenant plus courte:

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

Explication:

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

Syntaxe de méthode équivalente (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());}}}

Message original:

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

C’est ma toute première soumission et je devrais faire des choses au travail, mais c’était tellement amusant parce que j’avais l’impression de pouvoir participer pour une fois.

Explication:

(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

Je n’utilise jamais la syntaxe de méthode pour LINQ, c’est donc une expérience d’apprentissage pour moi :) en y réfléchissant aussi, je pourrais maintenant économiser 2 octets en remplaçant les littéraux de caractères par leurs équivalents entiers, mais, euh.

Raccourci grâce aux conseils de ProgramFOX et Num Lock :)

La syntaxe de requête équivalente (légèrement plus longue):

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

Première version 701 octets (utilisation idiomatique de la 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>());}

Version propre étendue:

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

L'idée est de démontrer un programme "correct" C ++ sans aucun piratage. Ignorer le passe-partout et le fait que cela compile uniquement sur VC ++

Explication:

Nous remplissons de A à Z une chaîne avec iota () , ce qui garantit que lorsque nous comptons les occurrences, chaque caractère apparaît même s'il ne figure pas dans l'entrée.

transform () copie caractère par caractère de l'entrée standard et le met à la fin de s après l'appel de toupper () sur chaque entrée

Le compte de chaque caractère est décrémenté dans la carte (en maintenant les comptes négatifs, nous pouvons avoir un tri décroissant sans code supplémentaire)

Les entrées de la carte de comptage sont copiées dans un ensemble de paires, en permutant (char, count) à (count, char). Puisque les ensembles sont commandés, nous les obtenons triés par décroissance du nombre de fréquences

Enfin, nous copions le contenu de l'ensemble vers la sortie standard, en utilisant transform, et en sélectionnant select2nd () pour ne sélectionner que le deuxième membre de la paire.

Le code est assez lisible. Une solution C ++ 11 serait beaucoup plus jolie, car nous pouvons utiliser lambdas

Version C ++ 11 - pas besoin de lambdas, mais les options auto et plage rendent les choses très propres (à bien y penser, vous pouvez faire très similaire avec le C ++ 98 standard)

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

Version étendue:

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

Prochaine itération (pourquoi lire depuis stdin quand on a 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;}}

Version étendue:

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

Gelée , 9 octets (non concurrente)

ØAŒuċ¥@ÞU

Explication

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

Cela se lit comme "trier l'alphabet majuscule par le nombre d'occurrences dans l'entrée majuscule, inversée", ce qui est une traduction assez littérale du défi: P

Essayez-le en ligne!

Ce défi était lié à Jelly HyperTraining, où nous avons résolu le problème. J'ai posté ceci parce que j'étais le premier à atteindre 10 octets.

-1 octet grâce à Erik the Outgolfer (enseignant JHT)

C ++ 377

Implémente qsort en utilisant le nombre de lettres du tableau n pour trier l'alphabet du tableau A. Exécuté en ligne de commande: 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) octets

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

• Certaines entrées contenant des codes ASCII> = 128 augmentent incorrectement les fréquences des lettres. Pour résoudre ce problème, remplacez la constante 95par 223, pour un coût d'un octet supplémentaire.
• Cela mettra fin tôt aux entrées contenant le caractère avec le code ASCII 255. Pour résoudre ce problème au prix d'un octet supplémentaire, passez char c;à juste c;et ++cà c=c+1%255.

PowerShell - 139 caractères

Premièrement, je ne suis pas un expert de PowerShell. Bien sûr, il y en a plus court que ça. Mais était heureux avec cela et a décidé de partager.

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

Comment ça marche:

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

Ceylan , 98 octets

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

APL, 26 à 20 caractères

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

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

-6 merci à Adam.