도전에 대한 짧고 달콤한 설명 : ETAOIN SHRDLU에
기반을 둔 과제는 입력의 빈도에 따라 26 자의 영어 알파벳을 출력하는 모든 언어로 가장 짧은 프로그램이나 기능을 작성하는 것입니다.

길고 건조하며 철저한 사양 :

• 프로그램 / 함수는 하나 이상의 대문자 및 / 또는 소문자를 포함하고 문장 부호, 숫자, 기호 및 기타 비 알파벳 문자를 포함 할 수있는 텍스트 문자열을 입력으로받습니다.
• 프로그램 / 기능은 입력에 표시되지 않은 문자를 포함하여 영어 알파벳의 대문자 26 자만 입력에 표시되는 횟수에 따라 가장 빈번하거나 가장 적은 순서로 출력해야합니다.
• 편집 : 빈도는 대소 문자를 구분하지 않고 계산되지만 출력은 대문자 여야합니다.
• 둘 이상의 문자가 동일한 빈도를 가지면 순서는 상관 없습니다.
• 공백과 같은 다른 출력은 허용되지 않습니다.
• 2014 년 7 월 1 일 편집 : 피드백을 바탕 으로이 규칙을 개정하고 있습니다. 허용되는 다른 출력은 후행 줄 바꿈과 같은 선택적 선행 및 / 또는 후행 공백입니다. 다른 출력은 허용되지 않습니다.
• 문자가 포함되지 않은 입력에는 정의되지 않은 동작이 허용됩니다.

우승자는 지금부터 7 일 동안 선발되므로 손가락을 입력하십시오!

입력 예 :

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.

출력 예 :

EITUSALNROMCDPVGQBFHJKWXYZ

참고 : KWXYZ해당 입력 에는 5 가지 방법이 있습니다.

편집하다:

경쟁은 끝났습니다! 참여한 모든 분들께 감사드립니다. 그리고 이제 당첨자 : Dennis 'CJam 과 isaacg 's Pyth의 답변은 모두 19 자에 달했습니다 . (죄송하지만 다른 답변은 불공평하다고 생각하기 때문에 답변 중 하나를 받아들이지 않을 것입니다.) 편집 : Dennis의 조언을 받아, 그의 답변이 처음으로 받아 들여진 것으로 표시합니다. 19 자에 도달합니다. 존경은에 이동 언급 Ilmari 카로 넨의 3 위 Golfscript 응답을 22 개 문자뿐만 아니라에서 undergroundmonorail의 75 문자 파이썬 답변을 가장 upvotes을 얻었다. 다시 한 번 참여한 모든 분들께 감사드립니다!

CJam, 21 19 바이트

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

온라인으로 사용해보십시오.

예

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

(줄 바꿈 없음)

작동 원리

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

발생이 많을수록 더 많은 문자가 제거되므로 배열의 시작 부분에 가장 빈번한 문자가 나타납니다.

파이썬 2 또는 3- 77 75 바이트

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

STDIN의 입력을 받기 전에 답변이 있었지만 기술적으로 유효하지 않다는 것을 깨달았습니다. 나는 input()한 줄만 얻는 것을 사용 했지만 질문의 예제 입력은 한 번에 여러 줄을 처리해야 함을 의미합니다. 사양을 충족시키기 위해 대답을 문자열 인수를 취하는 함수로 바꿨습니다. 놀랍게도, 그것은 2 바이트 작았습니다! 나에게 발생하지 않았 print(...)및 input()이상했다 f=lambda s:및 s.

이것은 또한 답변이 Python 2와 Python 3 모두와 호환되도록합니다. 원래 는 2 input()에서 호출 되었기 때문에 Python 3 이었습니다 raw_input(). 이제는 함수이므로 둘 다 작동합니다.

설명

                                  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

배쉬, 65 바이트

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

예

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

작동 원리

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

여기에서보십시오 : http://ideone.com/fork/YlWpEJ

Pyth에 대한 자세한 내용은 여기 ( http://esolangs.org/wiki/Pyth)를 참조하십시오.

예:

ETAOIN SHRDLU를 기반으로하는 문제는 입력의 빈도에 따라 26 자의 영어 알파벳을 출력하는 모든 언어로 가장 짧은 프로그램이나 기능을 작성하는 것입니다.

제공합니다 :

TENOHARSIULGFPYDCBWQMZXVKJ

설명:

=ZUw: 입력을 대문자로 변환하고 Z에 저장합니다.

sV: 반대의 합계를 인쇄

m;d: 마지막 항목

S: 첫 번째 항목을 기준으로 오름차순으로 정렬

m[cZkk):리스트 [Z, k의 k 수]

UG: 대문자 인 경우 k입니다.

대략적인 파이썬 동등 물 :

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

이것은 입장이 아니며 사람들이 그것을보고 싶어 할 것이라고 생각했습니다. Pyth 1.0.4에서 다음 프로그램은 10 자로 된 솔루션입니다.

JUwo_cJNUG

설명:

JUw: 입력을 대문자로 변환하고 J에 저장합니다.

o: (인쇄) 정렬 기준

_cJN: -1 * (J의 N 개수)

UG: 대문자에서 N을 초과합니다.

o정렬 기준, 기능 추가를 포함하여 Pyth 1.0.2에서 1.0.4 로의 몇 가지 변경 사항 이이 문제에 대응 했기 때문에 합법적 인 솔루션 이 아닙니다.

자바 스크립트 ( ES6 ) 119 (117)

편집 : (-2) 통화 toUpperCase에서 대소 문자를 구분하지 않는 RegEx 를 사용할 필요가 없어 split졌습니다.

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

대안 (같은 길이) : 정렬 및 문자 수를 단일 함수로 요약했습니다.

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

함수로서 : 105 104

편집 : (-1) 정렬 및 문자 수를 단일 함수로 요약했습니다.

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

GolfScript, 22 자

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

온라인으로 사용해보십시오.

설명:

• :?입력 문자열을 기호에 할당합니다 ?. (다음 91기호가 기호 이름의 일부로 구문 분석되지 않도록 구두점 기호를 사용합니다 .)
• 91,0에서 90까지의 숫자 목록 (ASCII 코드 Z)을 구성합니다.
• + 이 목록을 입력 문자열에 추가하여 ASCII 코드 배열에서 문자열로 변환하고 스택에서 입력 문자열을 편리하게 제거합니다.
• -26>이 문자열의 마지막 26자를 가져와 대문자 ASCII 문자를 포함하는 문자열을에서 A로 Z만듭니다.
• 는 { }$입력 문자열에서 모든 문자 코드 블록을 적용하고, 그 결과에 따라 해당 문자를 정렬한다.
• 코드 블록 내에서 .문자를 복제 32+하고 사본을 대문자에서 소문자로 변환합니다. (가) ]배열로이 두 캐릭터를 수집, ?\-저장, 입력 문자열을 사용 ?하고 그것에서 배열의 문자의 모든 항목을 제거하고, ,카운트 정렬 열쇠가 될 것입니다 나머지 문자열의 길이를. 문자는이 키에 따라 오름차순으로 정렬되므로 발생 횟수에 따라 내림차순으로 정렬됩니다.

하스켈, 110 바이트

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

사용법 예 :

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

루비 2.0, 53 자

편집 : @ durron597 덕분에 여러 줄 문자열로 올바르게 작동하도록 수정되었습니다!

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

f다음과 같이 사용할 수 있는 함수를 만듭니다 .

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

STDOUT으로 인쇄합니다.

AZOSICGHEJKLMBFPQRDTUVWXYN

펄, 54 46 바이트

UPDATE : 이로 압착 될 수있어서 최적화 후 46 바이트 (THX 데니스 대 -n/ {}해킹, 중국어 펄 고스 위해 <=>-> -해킹)

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

다음과 함께 실행됩니다. perl -nE

독창적 인 솔루션 (특별한 Perl 옵션이 필요하지 않음) :

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

Perl 5.8.3, 5.14.2에서 확인 됨

경고가 표시되면 공백으로 분리 eg하고 for공백 (+1 문자)으로

사용법 예 :

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

설명 : .각 입력 행 ( )의 각 문자 ( )에 for<>대체 "패턴"을 적용하십시오. 대체 "패턴"은 실제로 표현식 ( e플래그)으로 평가되며 s///, 대문자 ( uc) 문자 를 증가시킵니다 ( ./ $&는보다 명백한 (.)/ $1)는 (초기화되지 않은) 해시 ( %h)로 계산합니다. 그런 다음 문자 빈도 해시는 정렬 비교 기능에서 대문자 알파벳을 올바른 순서로 인쇄하는 데 사용됩니다.

R, 123 바이트

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

산출:

> f(text)
[1] "ETNAHORISULFGPBCDYMQWJKVXZ"

C ++, 185 183 179 177 바이트

물론 이길 것으로 예상되지는 않지만 (C ++이 이길 수 있습니까?) 그렇지만 재미있는 운동입니다.

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

설명:

#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

완전히 다른 알고리즘을 사용하도록 업데이트되었습니다. JavaScript를 능가합니다!

예쁜:

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)

골프 :

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 바이트

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

데모:

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

설명:

(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

핵심은 모든 문자를 사용할 수 있고 이미 순서대로 왼쪽 배열을 추가하는 것입니다. 포크에 대한 세 번째 타인으로 명사를 사용하면 재미있는 결과는 동사뿐만 아니라 구문으로도 작동한다는 것입니다.

당연 - 130 123 115 112 98 92

@cfrick의 조언에 따라 (두 번!) :

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

작은 테스트 (@jpjacobs에서 부끄러운 도난) :

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

그리고 제안 된 테스트도 통과합니다

SAS-217 (제 생각에)

입력은 cards4 문 다음 줄이나 시스템에 적합한 펀치 카드에 입력해야합니다. 이 접근법은 입력을 인용하려고 시도하는 것과 비교하여 몇 문자를 절약한다고 생각합니다.

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;

입력 문자열에 나타나는 문자 만 반환하므로 전체 사양을 충족하지 못한다는 것을 알고 있습니다. 나는 이것을 조금 재고해야 할 수도 있습니다.

애플 스크립트, 278

나는 눈치 "a" = "A"애플 스크립트에 해당됩니다. 코드 골프에서 이것을 사용할 수 있지만 나머지 스크립트는 너무 장황합니다. AppleScript 1.8.3을 사용했습니다.

이것은 함수를 정의합니다 f. f("a string")스크립트 하단에 추가 하고 스크립트 편집기에서 실행하면 결과가 표시됩니다.

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

형식화 및 의견 :

-- 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 157156 바이트

편집 : msgbox (p)를 msgbox p로 변경했습니다.

더 읽기 쉬운 :

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

골프 : (155 자 + 1 개의 캐리지 리턴)

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

171에서 코드가 더 흥미 롭다는 것을 알았지 만 편안하게 drei의 정렬 방법 이 짧고 len이 필요하므로 첫 번째 루프의 "while"보다 "for"가 짧습니다. (입을 크게 벌림)

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

오른쪽에 입력을 문자열로받는 함수입니다. 승자는 아니지만 글쓰기가 즐거웠습니다.

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

설명 :

• toupper문자열을 대문자로하는 표준 라이브러리의 동사입니다. 그러면 동사의 오른쪽 인수가되고 왼쪽 인수는 알파벳입니다. ASCII 코드 포인트 65-90.

• [그리고 ,e.~#])선택 ( #오른쪽에서 ARG) 그 편지 ( ]요소 (하다) e.~) 왼쪽 앞에 추가하고 ( ,) 왼쪽 ARG ( [). 간단히 말해서, 우리는 대문자를 유지하고 끝에 하나의 알파벳 사본을 추가하여 모두 잡을 수 있도록합니다.

• #/.~@그런 다음 각 캐릭터의 빈도를 제공합니다. 알파벳 순서로 정렬되므로 알파벳 순서 \:(왼쪽 인수 [)를 바로 정렬 할 수 있습니다 .

아래의 간단한 게으른 예입니다. 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

기본적으로 이것은 내 VBScript 솔루션이지만 SQL로 구현되었습니다.

이것은 열을 연결하기위한 XML 출력 남용입니다. 실제로는 외부 테이블에 결합하여 GROUP_CONCATMySQL 및 기타 기능 을 에뮬레이션 할 수 있습니다 .

@변수 선언 :

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

암호:

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

펄, 78 바이트

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

• 공백이없는 26 개의 대문자 ASCII 문자 만 빈도 순서대로 출력됩니다.
• 묶인 문자는 알파벳 순서로 제공됩니다.

질문의 예에 대한 결과 :

EITUSALNROMCDPVGQBFHJKWXYZ

언 골프 드 :

# 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 바이트

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

다음은 특수 문자의 원인 인 16 진 덤프입니다.

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

그리고 약간 덜 골프 버전 :

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

예:

 $ 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

LINQPad의 C #-203 바이트

로건 댐의 대답에 다른 접근 방식을 취했습니다. 먼저 입력 문자열의 모든 문자가 모양에 따라 정렬되고 출력 문자열에 한 번만 존재하는지 확인했습니다. 그 후 알파벳에서 누락 된 모든 문자를 출력 문자열에 추가했습니다.

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

슬프게도 Visual Studio에서 만든 로건 댐의 대답을 이길 수는 없습니다.

더 읽기 쉬운 버전 :

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 번호 (및 LINQ) 255 226 210 바이트

Patrick Huizinga의 조언을 사용하여 쿼리 구문이 더 짧아졌습니다.

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

설명:

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

동등한 메소드 구문 (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());}}}

원본 게시물 :

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

이것은 첫 번째 제출물이며 직장에서해야 할 일이지만 실제로 한 번만 참여할 수 있다는 느낌이 들기 때문에 너무 재미있어 보였습니다.

설명:

(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

나는 LINQ에 대한 메소드 구문을 사용하지 않기 때문에 이것은 나를위한 학습 경험이었습니다.

ProgramFOX 및 Num Lock의 팁 덕분에 단축 :)

동등한 쿼리 구문 (약간 길다) :

(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 바이트

첫 번째 버전 701 바이트 (아이디 오 매틱 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>());}

클린 버전 확장 :

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

아이디어는 해킹없이 "적절한"C ++ 프로그램을 보여주는 것입니다. 상용구와 이것이 VC ++에서만 컴파일된다는 사실을 무시하십시오.

설명 :

iota () 를 사용하여 A ~ Z를 문자열로 채우면 발생 횟수를 계산할 때 각 문자가 입력에없는 경우에도 나타납니다.

transform () 은 표준 입력에서 문자별로 문자를 복사 하여 각각에 대해 toupper () 를 호출 한 후 s 끝에 넣습니다.

각 문자의 개수는 맵에서 감소합니다 (음수를 유지함으로써 추가 코드없이 내림차순 정렬 할 수 있음)

카운트 맵 항목은 (char, count)에서 (count, char)로 교체하여 한 쌍의 세트로 복사됩니다. 세트가 주문되었으므로 빈도수를 줄이면 정렬됩니다.

마지막으로, 변환을 사용하고 select2nd () 를 사용하여 세트의 내용을 표준 출력으로 복사 하여 쌍의 두 번째 멤버 만 선택합니다.

코드는 상당히 읽기 쉽다. 람다를 사용할 수 있기 때문에 C ++ 11 솔루션은 훨씬 더 예쁘게 보입니다.

C ++ 11 버전-람다가 필요하지 않지만 자동 및 범위 기반은 일을 매우 깨끗하게 만듭니다 (일반 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;}}

확장 버전 :

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

다음 반복 (arrgv가있을 때 stdin에서 읽은 이유) :

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

확장 버전 :

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

젤리 , 9 바이트 (비경쟁)

ØAŒuċ¥@ÞU

설명

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

이것은 "입력 된 대문자, 반전 된 입력의 발생 횟수에 따라 대문자 알파벳을 정렬합니다"라고 읽습니다.

온라인으로 사용해보십시오!

이 도전은 우리가 도전을 해결 한 Jelly HyperTraining 과 관련이있었습니다 . 10 바이트에 처음 도달했기 때문에 이것을 게시했습니다.

Outgolfer Erik (JHT 교사) 덕분에 -1 바이트

C ++ 377

배열 n에서 알파벳 수를 사용하여 배열 A에서 알파벳을 정렬하여 qsort를 구현합니다. 명령 행을 통해 실행하십시오. 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) 바이트

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

• ASCII 코드> = 128을 포함하는 일부 입력은 문자 주파수를 잘못 증가시킵니다. 이 문제를 해결하려면 1 바이트의 추가 비용으로 상수를 95로 223바꿉니다.
• 이것은 1 개의 여분 바이트, 변화의 비용으로이 문제를 해결하려면 ASCII 코드 255로 문자를 포함하는 입력에 조기 종료됩니다 char c;단지에 c;와 ++c에 c=c+1%255.

PowerShell-139 자

첫째, 저는 PowerShell 전문가가 아닙니다. 이보다 더 짧은 것이 확실합니다. 그러나 그것에 만족하고 공유하기로 결정했습니다.

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

작동 방식 :

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

실론 , 98 바이트

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

APL, 26 20 자

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

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

아담 덕분에 -6.