Breve e dolce descrizione della sfida: sulla
base di ETAOIN SHRDLU , la tua sfida è quella di scrivere il programma o la funzione più breve in qualsiasi lingua che emetta le 26 lettere dell'alfabeto inglese in base alla loro frequenza nell'input.

Specifiche davvero lunghe, asciutte e approfondite:

• Il tuo programma / funzione riceverà come input una stringa di testo, che conterrà una o più lettere maiuscole e / o minuscole e può contenere anche punteggiatura, numeri, simboli e altri caratteri non alfabetici.
• Il programma / funzione deve generare solo le 26 lettere MAIUSCOLE dell'alfabeto inglese, comprese quelle che non compaiono nell'input, ordinate dalla più alla meno frequente in base al numero di volte che compaiono nell'input.
• Modifica: la frequenza viene calcolata senza distinzione tra maiuscole e minuscole, ma l'output deve essere in maiuscolo.
• Se due o più lettere hanno la stessa frequenza, possono essere in qualsiasi ordine.
• Nessun altro output, come gli spazi bianchi, è consentito.
• Modifica 1/7/2014: in base al feedback, sto modificando questa regola. L'unico altro output consentito è lo spazio bianco iniziale e / o finale facoltativo, come una nuova riga finale. Nessun altro output è consentito.
• È consentito un comportamento indefinito per l'input che non contiene lettere.

Il vincitore verrà scelto tra 7 giorni, quindi digita quelle dita!

Esempio di input:

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.

Esempio di output:

EITUSALNROMCDPVGQBFHJKWXYZ

Nota: esiste un legame a 5 vie tra KWXYZquesti input.

Modificare:

La competizione è finita! Grazie a tutti coloro che hanno partecipato. E ora per il / i vincitore / i: sia la risposta di Dennis 'CJam che quella di Pyth di isaacg sono arrivate a ben 19 personaggi. (Mi dispiace, ma non accetterò nessuna delle risposte perché penso che non sarebbe giusto per l'altra.) Modifica: seguendo il consiglio di Dennis, segnerò la sua risposta come accettata perché la sua è stata la prima a raggiungere 19 caratteri. Le menzioni d'onore vanno alla risposta Golfscript al terzo posto di Ilmari Karonen a 22 caratteri e alla risposta Python a 75 caratteri di undergroundmonorail che ha ottenuto il maggior numero di voti. Ancora una volta, grazie a tutti coloro che hanno partecipato!

CJam, 21 19 byte

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

Provalo online.

Esempio

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

(nessuna nuova riga)

Come funziona

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

Più occorrenze indicano che vengono rimossi più caratteri, quindi i caratteri più frequenti vengono visualizzati all'inizio dell'array.

Python 2 o 3 - 77 75 byte

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

Prima ho ricevuto una risposta che ha afferrato l'input di STDIN, ma mi sono reso conto che tecnicamente non era valido. Ho usato input()che ottiene solo una singola riga, ma l'input di esempio della domanda implica che dovrebbe gestire più righe contemporaneamente. Per soddisfare le specifiche, ho trasformato la mia risposta in una funzione che accetta un argomento stringa. Con mia sorpresa, era di due byte più piccolo! Non mi è venuto in mente questo print(...)ed input()erano più lunghi di f=lambda s:e s.

Questo rende anche la risposta compatibile con Python 2 e Python 3. Inizialmente era solo Python 3, perché usato input()(che era chiamato raw_input()in 2). Ora che è una funzione, funziona in entrambi.

spiegato

                                  range(65,91)                              # The numbers 65 to 90
                          map(chr,range(65,91))                             # Convert to ASCII

                                                    s                       # The input string
                                                    s.upper()               # Convert to uppercase
                                                    s.upper().count         # Function literal for 'how many times the argument appears in the string'

                   sorted(map(chr,range(65,91)),key=s.upper().count)        # Sort by that function
           ''.join(sorted(map(chr,range(65,91)),key=s.upper().count))       # Concatenate to string
           ''.join(sorted(map(chr,range(65,91)),key=s.upper().count))[::-1] # Step through by -1 (i.e. reverse string)

  lambda s:''.join(sorted(map(chr,range(65,91)),key=s.upper().count))[::-1] # Make it a function (`return` is implicit for lambdas)
f=lambda s:''.join(sorted(map(chr,range(65,91)),key=s.upper().count))[::-1] # Give it a name

Bash, 65 byte

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

Esempio

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

Come funziona

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

Provalo qui: http://ideone.com/fork/YlWpEJ

Ulteriori informazioni su Pyth qui: http://esolangs.org/wiki/Pyth

Esempio:

Basato su ETAOIN SHRDLU, la tua sfida è quella di scrivere il programma o la funzione più breve in qualsiasi lingua che emetta le 26 lettere dell'alfabeto inglese in base alla loro frequenza nell'input.

dà:

TENOHARSIULGFPYDCBWQMZXVKJ

Spiegazione:

=ZUw: Converte l'input in maiuscolo e lo memorizza in Z.

sV: Stampa la somma del retro di

m;d: Le ultime voci di

S: Ordinati per prima voce, in ordine crescente

m[cZkk): Le liste [conteggio di k in Z, k]

UG: Per k nelle lettere maiuscole.

Equivalente di Python approssimativo:

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

Questa non è una voce, pensavo solo che alla gente potesse piacere vederla. In Pyth 1.0.4, il seguente programma è una soluzione in 10 caratteri:

JUwo_cJNUG

Spiegazione:

JUw: Converte l'input in maiuscolo e lo memorizza in J.

o: (Stampa) Ordina per

_cJN: -1 * (conteggio di N in J)

UG: Sopra N nelle lettere maiuscole.

Non è una soluzione legale perché molte delle modifiche da Pyth 1.0.2 a 1.0.4, inclusa l'aggiunta della funzione o, ordina per, erano in risposta a questo problema.

Javascript ( ES6 ) 119 117

Modifica: (-2) Rimossa la necessità di toUpperCaseutilizzare un RegEx senza distinzione tra maiuscole e minuscole nella splitchiamata.

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

Alternativa (stessa lunghezza): ha condensato l'ordinamento e il conteggio dei caratteri in un'unica funzione.

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

In funzione: 105 104

Modifica: (-1) Condensato l'ordinamento e il conteggio dei caratteri in una singola funzione.

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

GolfScript, 22 caratteri

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

Provalo online.

Spiegazione:

• :?assegna la stringa di input al simbolo ?. (Uso un simbolo di punteggiatura in modo che il seguente numero 91non venga analizzato come parte del nome del simbolo.)
• 91,costruisce un elenco di numeri da 0 a 90 (codice ASCII di Z).
• + aggiunge questo elenco alla stringa di input, convertendolo così da una matrice di codici ASCII in una stringa (e rimuovendo convenientemente anche la stringa di input dallo stack).
• -26>accetta gli ultimi 26 caratteri di questa stringa, producendo una stringa contenente le lettere ASCII maiuscole da Aa Z.
• Il { }$applica il blocco di codice di tutti i caratteri nella stringa di input e ordina i caratteri in base al risultato.
• All'interno del blocco di codice, .duplica il carattere e 32+converte la copia da maiuscola a minuscola. Il ]raccoglie questi due caratteri in una matrice, ?\-prende la stringa di ingresso memorizzata in ?e rimuove tutte le occorrenze dei caratteri nella matrice da esso, e ,conta la lunghezza della stringa rimanente, che sarà la chiave di ordinamento. I caratteri saranno ordinati in ordine crescente da questa chiave, e quindi in ordine decrescente per numero di occorrenze.

Haskell, 110 byte

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

Esempio di utilizzo:

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

EDIT : risolto per funzionare correttamente con stringhe multilinea, grazie @ durron597!

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

Crea una funzione chiamata fche può essere utilizzata come segue:

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

Stampa su STDOUT:

AZOSICGHEJKLMBFPQRDTUVWXYN

Perl, 54 46 byte

AGGIORNAMENTO: dopo ulteriori ottimizzazioni potrebbe essere compresso a 46 byte: (grazie dennis per -n/ {}hack; cinese perl goth per <=>-> -hack)

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

Deve essere eseguito con run with perl -nE

Soluzione originale (non richiede opzioni speciali Perl):

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

Verificato in Perl 5.8.3, 5.14.2

Se ricevi un avviso, separalo ege forcon uno spazio (+1 carattere), se ti dispiace

esempio di utilizzo:

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

SPIEGAZIONE: su ogni carattere ( .) di ciascuna riga di input ( for<>), applicare un "modello" di sostituzione, che in effetti viene valutato come un'espressione ( ebandiera del s///), che incrementa un carattere ( uc) più elevato di ( ./ $&è più breve di più ovvio (.)/ $1) conta nell'hash (non inizializzato) ( %h). Quindi, l'hash della frequenza delle lettere viene utilizzato in una funzione di confronto di ordinamento per stampare l'alfabeto maiuscolo nell'ordine corretto.

R, 123 byte

Il codice è stato migliorato grazie ai suggerimenti di @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)

Produzione:

> f(text)
[1] "ETNAHORISULFGPBCDYMQWJKVXZ"

C ++, 185 183 179 177 byte

Non ci si aspetta che vinca, ovviamente (può mai vincere il C ++?) Ma comunque un esercizio divertente.

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

Spiegazione:

#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

Aggiornato per utilizzare un algoritmo completamente diverso. Batte JavaScript!

Bella:

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)

golfed:

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

J 41 35 byte

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

demo:

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

Spiegazione:

(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 chiave è aggiungere l'array di sinistra, in modo tale che tutte le lettere siano disponibili e già in ordine. Una divertente conseguenza dell'uso di un nome come terzo dente della forchetta è che funziona sia come verbo che come frase.

Groovy - 130 123 115 112 98 92

Come da consiglio di @ cfrick (due volte!):

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

Un piccolo test (rubato spudoratamente da @jpjacobs):

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

E anche il test proposto sta superando

SAS - 217 (penso)

L'input deve essere posizionato sulla riga dopo l'istruzione cards4 o sulle schede perforate appropriate per il proprio sistema. Penso che questo approccio salvi alcuni caratteri rispetto al tentativo di citare l'input.

data a;
input;
S = upcase(compress(_INFILE_,,'ak'));
do i=1 to length(S);
l=substr(S,i,1);
output;
end;
cards4;
;;;;
run;
proc sql;
select l into :o separated by '' from
(select l, 1/count(l) as f from a group by l) order by f;
quit;

Sono consapevole che questo non soddisfa le specifiche complete, in quanto restituisce solo caratteri che compaiono nella stringa di input. Potrei aver bisogno di ripensarci un po '.

AppleScript, 278

Ho notato che "a" = "A"è vero in AppleScript. Posso usarlo nel code golf, ma il resto dello script è troppo prolisso. Ho usato AppleScript 1.8.3.

Questo definisce una funzione f. Se aggiungi f("a string")in fondo allo script ed eseguilo nell'Editor degli script, mostrerà il risultato.

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

Formattato e commentato:

-- Returns nth letter of alphabet.
on c(n)
    ASCII character (64 + n)
end c

-- Returns letters in s sorted by frequency.
on f(s)
    -- a: list of letter counts
    -- r: resulting string
    set {a, r} to {{}, ""}

    -- For each letter from A to Z,
    -- count letters in string s.
    repeat with i from 1 to 26
        set j to 0
        repeat with b in s
            -- Can't use b = c(i), because
            -- b is a reference to a string
            -- and = never dereferences its
            -- operands. Get contents of b,
            -- here by coercing b to string.
            if b & "" = c(i) then set j to j + 1
        end repeat
        -- Set item i of a to count j.
        set a to a & j
    end repeat

    -- Sort letters by frequency.  Do a counting sort
    -- because AppleScript lacks a sort command.
    repeat with j from 0 to (count s)
        repeat with i from 1 to 26
            if a's item i = j then set r to c(i) & r
        end repeat
    end repeat
    r
end f

-- Example call:
f("Now is the time for all good men to come to the aid of their country.")
-- Result: "OTEIRNMHLFDCAYWUSGZXVQPKJB"

VBScript 157 156 byte

Modifica: modificato msgbox (p) in msgbox p

Più leggibile:

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 caratteri + 1 ritorno a capo)

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

L'ho avuto a 171 in precedenza con il codice che ho trovato più interessante, ma il metodo di ordinamento di drei è comodamente più breve e richiede len (s), il che rende un "for" più corto di "while" per il primo ciclo. (sbadiglio)

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

Una funzione che accetta input a destra come stringa. Non un vincitore, ma è stato divertente scrivere.

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

Ha spiegato:

• toupperè un verbo nella libreria standard che sostituisce una stringa. Questo diventa quindi l'argomento giusto del verbo, mentre l'argomento sinistro è l'alfabeto: codici ASCII da 65 a 90.

• [e ,e.~#])seleziona ( #) quelle lettere nell'arg destra ( ]) che sono elementi di ( e.~) la sinistra, e quindi antepone ( ,) l'arg sinistra ( [). Per intenderci, manteniamo solo i caratteri maiuscoli e aggiungiamo una singola copia dell'alfabeto alla fine, per assicurarci di catturarli tutti.

• #/.~@quindi fornisce le frequenze di ciascun personaggio. Accade così che questo sia dato in ordine alfabetico, quindi subito dopo possiamo declassare ( \:) l'alfabeto (l'argomento di sinistra [).

Un rapido esempio pigro di seguito. Sentitevi liberi di provare di persona a 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

Fondamentalmente, questa è la mia soluzione VBScript ma implementata in SQL.

Questo è un abuso dell'output XML per concatenare una colonna. Nell'uso pratico, può essere unito a una tabella esterna per emulare GROUP_CONCATfunzioni in MySQL e altri.

Dichiarazione della @variabile:

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

Codice:

with y AS(
    SELECT UPPER(@)i,0l,91y
    UNION ALL
    SELECT i,len(replace(i,char(y-1),'')),y-1
    FROM y
    WHERE y>65
)
SELECT LTRIM(
(
    SELECT char(y)
    FROM y
    WHERE y<91
    ORDER BY l
    FOR XML PATH(''))
)

Perl, 78 byte

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

• Solo le 26 lettere ASCII maiuscole senza spazi bianchi vengono emesse in ordine di frequenza.
• I personaggi legati sono indicati in ordine alfabetico.

Risultato per l'esempio nella domanda:

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 byte

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

Ecco un dump esadecimale, causa dei caratteri speciali:

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

E una versione leggermente meno giocata a golf:

<?
preg_filter(           // regular expression
  "#[A-z]#e",          // matches every letter + 'eval' flag
  '$f[$0&fl]++',        // so this code runs for every letter
                       // $f is an array whose indices are uppercase letters
                       //   and whose values represent the number of occurences
                       // lowercase is converted to uc with the bitwise and
                       //   fl is 11011111 in binary, every bit except for 32's is set
  join('', range(a,z)) // adding abcdefghijklmnopqrstuvwxyz to the input
    .$argv[1]);        //   because not all letters have to appear in the input
arsort($f);            // sort $f in reverse, maintaining indices
foreach($f as$l=>$F)   //
  echo$l;              // print each index in order

Esempio:

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

Ho adottato un approccio diverso alla risposta di Logan Dam. Mi sono assicurato innanzitutto che ogni carattere nella stringa di input sia ordinato in base al suo aspetto ed esista solo una volta nella stringa di output. Successivamente ho aggiunto tutti i caratteri mancanti dell'alfabeto alla stringa di output.

void e(string i){var a="";foreach(var d in i.ToUpper().GroupBy(x=>x).OrderByDescending(u=>u.Count()))if(d.Key<91&&d.Key>64){a+=d.Key;}for(int x=65;x<91;x++)if(!a.Contains((char)x)){a+=(char)x;}a.Dump();}

Purtroppo non avrebbe battuto la risposta di Logan Dam se avessi fatto Visual Studio.

Versione più leggibile:

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

Utilizzando i consigli di Patrick Huizinga, la sintassi della query è ora più breve:

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

Spiegazione:

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

Sintassi del metodo equivalente (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());}}}

Post originale:

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

Questa è la mia prima presentazione in assoluto e dovrei fare le cose al lavoro, ma mi è sembrato così divertente perché mi sentivo come se potessi davvero partecipare per una volta.

Spiegazione:

(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

Non ho mai usato la sintassi del metodo per LINQ, quindi questa è stata un'esperienza di apprendimento per me :) anche a pensarci ora ora potrei salvare 2 byte sostituendo i letterali dei caratteri con le loro controparti intere, ma, meh.

Abbreviato grazie ai suggerimenti di ProgramFOX e Num Lock :)

La sintassi della query equivalente (leggermente più lunga):

(from c in (a[0]+"ABCDEFGHIJKLMNOPQRSTUVWXYZ").ToUpper() where c>'@'&&c<'[' group c by c into g orderby g.Count() descending select g.Key).ToList().ForEach(c=>Console.Write(c));

C ++ 701 322 232 byte

Prima versione 701 byte (utilizzo idiomatico 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>());}

Versione pulita estesa:

#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'idea è quella di dimostrare un programma C ++ "corretto" senza alcun hack. Ignora il boilerplate e il fatto che questo compili solo su VC ++

Spiegazione :

Riempiamo dalla A alla Z in una stringa con iota () , questo assicura che quando contiamo le occorrenze, ogni carattere appare anche se non è nell'input.

transform () copia carattere per carattere dall'input standard e lo mette alla fine di s dopo aver chiamato toupper () su ciascuno

Il conteggio di ciascun personaggio è ridotto nella mappa (mantenendo i conteggi negativi possiamo avere un ordinamento decrescente senza codice aggiuntivo)

Le voci della mappa conteggi vengono copiate in un set di coppie, scambiando (carattere, conteggio) in (conteggio, carattere). Poiché i set sono ordinati, li ordiniamo diminuendo il conteggio delle frequenze

Infine, copiamo il contenuto dell'insieme allo standard out, usando transform e usando select2nd () per selezionare solo il secondo membro della coppia.

Il codice è abbastanza leggibile. Una soluzione C ++ 11 sembrerebbe molto più bella, dal momento che possiamo usare lambdas

Versione C ++ 11 - non c'è bisogno di lambda, ma auto e range based per rendere le cose molto pulite (vieni a pensarci bene puoi fare molto simile con il normale 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;}}

Versione estesa:

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

Prossima iterazione (perché leggi da stdin quando abbiamo 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;}}

Versione estesa:

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

Gelatina , 9 byte (non competitiva)

ØAŒuċ¥@ÞU

Spiegazione

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

Questo si legge come "ordina l'alfabeto maiuscolo in base al numero di occorrenze nell'input maiuscolo, invertito", che è una traduzione piuttosto letterale della sfida: P

Provalo online!

Questa sfida è stata collegata a Jelly HyperTraining dove abbiamo risolto la sfida. Ho pubblicato questo perché sono stato il primo a raggiungere i 10 byte.

-1 byte grazie a Erik the Outgolfer (insegnante JHT)

C ++ 377

Implementa qsort usando il conteggio delle lettere nell'array n per ordinare l'alfabeto nell'array A. Esegui dalla riga di comando: golf.exe < in.txt

int n[26],c,k,N;
char A[26];
int C(const void*a,const void*b)
{
int i=(int)(*(char*)a -'A');
int j=(int)(*(char*)b -'A');
return n[j]-n[i];
}
int main()
{
for(;k<26;k++)
{
A[k]=k+'A';
}
N=sizeof(A);
c=getchar();
while(c>0)
{
c=toupper(c);
c=c-'A';
if(c>=0&&c<26)n[c]++;
c=getchar();
}
qsort(A,N,1,C);
for(k=0;k<N;k++)
{
putchar(A[k]);
}
return 0;
}

C, 117 (119) byte

x[256];m=1;char c;main(){while(c=getchar()+1)++x[c-1&95];for(;m=x[++c]<x[m]?m:c;x[m<65|m>90||c?m*!c:putchar(m)]=-1);}

• Alcuni input contenenti codici ASCII> = 128 aumentano erroneamente le frequenze delle lettere. Per risolvere questo problema, sostituire la costante 95con 223, al costo di 1 byte extra.
• Questo terminerà presto sugli input contenenti il ​​carattere con codice ASCII 255. Per risolvere questo problema al costo di 1 byte aggiuntivo, passare char c;a just c;e ++cto c=c+1%255.

PowerShell - 139 caratteri

Innanzitutto, non sono un esperto di PowerShell. Abbastanza sicuro che ci siano più brevi di questo. Ma ne sono stato contento e ho deciso di condividere.

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

Come funziona:

$a = Read-host            # read from stdin and save into a string var $a
$a.ToUpper()              # Convert the string to UPPERCASE
-replace'[^A-Z]',''       # Remove all non A-Z characters from the str
(...).ToCharArray()       # Convert the inner object (string) to a Char Array
+  (65..90|%{[char[]]$_}) # Create another char array with A-Z chars expanded, 
                          #  and append it to the previous one.
|Group                    # Group the char array by value for each element, 
                          #  consolidates them and count each char occurrence. Example:
                          #  Count | Name
                          #  ----- | -----
                          #      4 | B
                          #      1 | F
                          #      2 | C 
                          #     .. | ..
                          # 
|sort Count -desc         # Sorts the previous hash-table by the 'Count' column 
                          #   in desc ordering
|%{$_.Name}               # Grab only the 'Name' column from the previous sorted hash-table. 
                          # The retuslt obj will be a simple char array again, 
                          #   with the letters in the desired order
$b = (...)                # Saves the resulting char array into a new variable $b
-join $b                  # join the resulting char array elements into a single 
                          #   string, and print it to stdout. 

Ceylon , 98 byte

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

APL, 26 20 caratteri

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

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

-6 grazie ad Adam.