하나 이상의 단어 [a-z]+와 0 개 이상의 공백 으로 구성된 입력 문장이 있으면 입력 문장 의 문자 분포에 대한 ASCII 아트 히스토그램 (막대 그래프)을 출력합니다.

히스토그램은 수평으로 배치해야합니다. 즉, 문자 키를 왼쪽에서 오른쪽으로 알파벳 순서로 왼쪽에서 오른쪽으로 Y 축 레이블이 붙고 1-5 단위마다 배치해야합니다. Y 축은 최소한 가장 높은 막대만큼 큰 5의 가장 작은 배수 여야하며 오른쪽 정렬이어야합니다. X 축은 입력 문자로 표시되며 간격이 없습니다. 예를 들어, 입력은 a bb dd라벨이 있어야 abd하지 ab d의를 건너 뛰는를 c. 막대 자체는 일관된 ASCII 문자로 만들 수 있습니다 X. 예에서는 여기를 사용 하겠습니다.

test example

5-

   X
   X   X
1-XXXXXXXX
  aelmpstx

셋 e, 둘 t, 그리고 하나 가 있기 때문에 almsx.

더 많은 예 :

the quick brown fox jumped over the lazy dogs

5-
      X         X
      X         X
     XX  X      X  X XX
1-XXXXXXXXXXXXXXXXXXXXXXXXXX
  abcdefghijklmnopqrstuvwxyz


now is the time for all good men to come to the aid of their country

10-
              X
              X
              X  X
      X       X  X
 5-   X       X  X
      X   X   X  X
      X  XX XXXX X
   XXXXX XXXXXXX X
 1-XXXXXXXXXXXXXXXXXX
   acdefghilmnorstuwy

a bb ccc dddddddddddd

15-


      X
      X
10-   X
      X
      X
      X
      X
 5-   X
      X
     XX
    XXX
 1-XXXX
   abcd

a bb ccccc

5-  X
    X
    X
   XX
1-XXX
  abc

I / O 및 규칙

• 적절한 형식과 편리한 방법 으로 입력 할 수 있습니다 . 이것은 또한 코드에 더 적합한 경우 대문자로 입력 할 수 있음을 의미합니다.
• 문자가 적절하게 정렬되는 경우 선행 / 후행 줄 바꿈 또는 기타 공백은 선택 사항입니다.
• 전체 프로그램 또는 기능이 허용됩니다. 함수 인 경우 출력하지 않고 출력을 반환 할 수 있습니다.
• 콘솔로 출력 할 수 있으며, 문자열 목록으로 반환되거나 단일 문자열로 반환됩니다.
• 표준 허점 은 금지되어 있습니다.
• 이것은 코드 골프 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

Stax , 37 바이트

ü╣úwóΓµ┐Wh0íJ▌Ñìs┤►ï╖öz<à↔/Ü@τ|:╢Ω$‼φ

실행 및 디버깅

R , 239230 바이트

K=table(el(strsplit(gsub(" ","",scan(,"")),"")));m=matrix(" ",L<-sum(K|1)+1,M<-(M=max(K))+-M%%5+1);m[2:L,M]=names(K);m[1,M-g]=paste0(g<-c(1,seq(5,M,5)),"-");m[1,]=format(m[1,],j="r");for(X in 2:L)m[X,M-1:K[X-1]]=0;write(m,1,L,,"")

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

table 여기서 캐릭터를 균등화하고, 정렬하고, 카운트를 반환하면서 무거운 리프팅을 수행합니다.

그 밖의 모든 것들은 오프셋이 인쇄에 적합한 지 확인하는 것입니다. 이것은 아스키 아트 도전의 "실제"작업입니다.

버그를 지적한 @dylnan 에게 감사합니다 .

접근 방식에 대한 @rturnbull 덕분에 scan2 바이트가 떨어졌습니다.

GNU가 나오지 , -r 516 490 278 249 + 1 바이트

s/$/:ABCDEFGHIJKLMNOPQRSTUVWXYZ /
:a
s/(.)(:.*\1)/\2\1/I
ta
s/[A-Z]+/ /g
h
z
:b
s/ \w/ /g
G
s/:/&I/g
/:II{5}+ *$/M!bb
s/[a-z]/X/g
G
s/:(I{5}+|I)\b/0\1-/g
s/:I*/  /g
s/ (\w)\1*/\1/g
s/$/; 10123456789I0/
:c
s/(.)I(.*\1(I?.))|;.*/\3\2/
/\nI/s/^/ /Mg
tc

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

나는 이것이 향상 될 수 있다고 확신 하지만, 지금은 네이티브 산술이나 정렬이없는 sed로 만들어 졌다는 것을 고려하면 좋을 것입니다. 그래서 나는 이것이 충분하지 않다고 거짓말 했으므로 Cows quack 의 정렬 알고리즘에 관한 팁과 함께 212 바이트 더 향상 시켰 습니다.
내부 작업에 대한 설명 :

s/$/:ABCDEFGHIJKLMNOPQRSTUVWXYZ /
:a
s/(.)(:.*\1)/\2\1/I
ta
s/[A-Z]+/ /g
h
z

입력을 정렬하고 그룹을 공백으로 구분합니다. 콜론으로 구분 된 대문자 알파벳과 공백을 끝에 추가하면됩니다. 그런 다음 루프에서 대소 문자를 구분하지 않는 대체를 사용하여 콜론 앞의 각 문자를 콜론 뒤의 일치하는 문자로 이동합니다. 대문자는 공백으로 대체되고 문자열은 홀딩 공간으로 복사됩니다.

:b
s/ \w/ /g
G
s/:/&I/g
/:II{5}+ *$/M!bb

이 루프는 각 문자 그룹 크기를 하나씩 줄이며 정렬 된 원래 줄을 추가하고 정렬에서 남은 콜론 다음에 단항 카운터를 증가시킵니다. 숫자가 5 * n + 1 인 빈 줄에 도달 할 때까지 반복됩니다 (마지막 줄은 궁극적으로 공백이 있기 때문에). 루프 후 패턴 공간은 다음과 같습니다.

:IIIIII           
:IIIII           
:IIII           
:III  e         
:II  ee     t    
:I a eee l m p s tt x   

그런 다음 형식이 다음과 같습니다.

s/[a-z]/X/g            # makes bars consistent
G                      # appends line that becomes x-axis
s/:(I{5}+|I)\b/0\1-/g  # moves zero in front of line 1 or 5-divisible
                       # lines for the decimal conversion and adds -
s/:I*/  /g             # removes numbers from other lines
s/ (\w)\1*/\1/g        # collapses groups of at least 1 into 1
                       # character, deleting the space before it
                       # so that only size-0-groups have spaces

마지막으로 단항에서 10 진수로의 변환기는 다음과 같습니다.

s/$/; 10123456789I0/
:c
s/(.)I(.*\1(I?.))|;.*/\3\2/
/\nI/s/^/ /Mg
tc

기본적으로 변환 지식이있는 문자열을 추가합니다. 이를 공백 :-> 1 및 0-> 1-> 2-> 3-> 4-> 5-> 6-> 7-> 8-> 9-> I0으로 해석 할 수 있습니다. 대체 표현식 s/(.)I(.*\1(I?.))|;.*/\3\2/은 정렬 문자열과 유사하게 작동하며, [ (.)I] 앞에 있는 문자를 변환 문자열 [ (.*\1(I?.))] 에서 I 앞에있는 문자 옆에 있는 문자로 대체 하고, 남아 있지 않은 경우 제거합니다. 추가 된 문자열 [ |;.*]. 대체 [ /\nI/s/^/ /Mg]는 필요한 경우 패딩을 추가합니다.

크기를 26 바이트 줄이고 정렬 알고리즘을 단축 한 Cows quack 덕분 입니다.

Dyalog APL , 109 97 96 95 93 88 바이트

{⊖(⍉r),⍨⍕↑(⊂'')@{1@0~⍵∊1,5×⍵}⍳≢⍉↑r←↑r,⍨⊂' -','   - '⍴⍨5×⌈5÷⍨≢1↓⍉↑r←↓{⍺,∊⍕¨0×⍵}⌸⍵[⍋⍵]∩⎕A}

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

필요 ⎕IO←0

방법은 너무 많은 바이트 덕분에 저장 아담 과 소 돌팔이 !

05AB1E , 58 47 바이트

áê©S¢Z5‰`Ā+L5*1¸ì'-«ð5×ý#À¦Áí.Bís'X×ζ‚ζJR»,®3ú,

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

@Emigna 덕분에 -11 바이트

파이썬 2 , 192 바이트

s=input()
d={c:s.count(c)for c in s if' '<c}
h=-max(d.values())/5*-5
for y in range(h,-1,-1):print('%d-'%y*(y%5==2>>y)).rjust(len(`-h`))+''.join(('X '[y>v],k)[y<1]for k,v in sorted(d.items()))

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

설명

2 행은 히스토그램 값을 매우 간단하게 계산하여을 버립니다 ' '.

3 행은 다음 ceil(x/5)과 같이 계산의 트릭을 -(-x/5)사용합니다 -x/5*-5. 공식을 사용하여 최대 주파수를 5의 다음 배수로 올림합니다 . 이것은입니다 h.

라인 4는 각 행을 인쇄 하여 h아래에서 0포함으로 계산되는 루프입니다 .

• 경우 y%5==2>>y우리는 라벨을 인쇄 할 수 있습니다. 이 때 y∈ {1, 5, 10, 15, 20,…}

  (이 공식은 더 짧을 수 있습니다. {1, 5, 10,…} 의 경우 1 또는 True 이고 0 또는 False 또는 다른 모든 값의 경우 음의 정수가 필요합니다 y.)

• 우리는 레이블 (또는 빈 공간)을 len(`-h`)공백 으로 오른쪽 정렬 합니다 : 이것은 1 바이트를 깔끔하게 절약합니다 len(`h`)+1!

• 그런 다음 키-값 쌍 을 오름차순으로 실행 X하여이 행 ( y≥ 1 인 경우 ) 또는 문자 (if y= 0 인 경우)의 공백과 공백을 인쇄합니다 d.

숯 , 62 바이트

≔Ｅ²⁷⟦⟧ηＦθ⊞§η⌕βιι≔⊟ηθ≦ＬηＰ⭆β⎇§ηκιω↑↑ΦηιＦ÷⁺⁹⌈η⁵«≔∨×⁵ι¹ιＪ±¹±ι←⮌⁺ι-

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

≔Ｅ²⁷⟦⟧η

27 개의 목록을 만듭니다.

Ｆθ⊞§η⌕βιι

각 입력 문자를 소문자 알파벳의 위치에 해당하는 목록으로 푸시하십시오. 소문자가 아닌 문자는 27 번째 목록으로 푸시됩니다.

≔⊟ηθ

목록의 27 번째 요소를 폐기하십시오.

≦Ｌη

목록의 모든 요소의 길이를 가져옵니다.

Ｐ⭆β⎇§ηκιω

0이 아닌 목록 요소에 해당하는 소문자를 인쇄하십시오.

↑↑Φηι

0이 아닌 목록 요소를 위쪽으로 인쇄하십시오. 이것은 정수의 배열이므로 각 정수는 각각 별도의 열에 (현재 세로) 줄로 인쇄됩니다.

Ｆ÷⁺⁹⌈η⁵«

Y 축의 눈금 수를 계산하고 반복합니다.

≔∨×⁵ι¹ι

다음 눈금의 위치를 ​​계산하십시오.

Ｊ±¹±ι

다음 눈금으로 이동하십시오.

←⮌⁺ι-

체크 표시를 반전하고 앞뒤로 인쇄하여 효과적으로 오른쪽 정렬합니다.

젤리 , 48 바이트

^{지나가는 지뢰밭!}

J’⁶D;”-Ɗ%5^ỊƲ?€Uz⁶ZU
ḟ⁶ṢµĠ¬;⁶$L%5Ɗ¿€;"@Qz⁶Ç;"$ṚY

결과를 인쇄 전체 프로그램 (모나드 링크로 그것은에서 문자와 정수를 포함하는 목록을 반환 [0,9])

온라인으로 사용해보십시오! 또는 시험 스위트를 참조하십시오

방법?

J’⁶D;”-Ɗ%5^ỊƲ?€Uz⁶ZU - Link 1, get y-axis: list of columns (including x-axis & top-spaces)
J                    - range of length  [1,2,3,4,5,6,...,height+1] (+1 for x-axis)
 ’                   - decrement        [0,1,2,3,4,5,...] (line it up with the content)
             ?€      - if for €ach...
            Ʋ        - ...condition: last four links as a monad:
        %5           -   modulo by five
           Ị         -   insignificant? (1 for 0 and 1, else 0)
          ^          -   XOR (0 for 1 or multiples of 5 greater than 0, else 0)
  ⁶                  - ...then: literal space character
       Ɗ             - ...else: last three links as a monad:
   D                 -   decimal list of the number, e.g. 10 -> [1,0]
     ”-              -   literal '-' character
    ;                -   concatenate, e.g. [1,0,'-']
               U     - upend (reverse each)
                z⁶   - transpose with a filler of space characters
                  Z  - transpose
                   U - upend (i.e. Uz⁶ZU pads the left with spaces as needed)

ḟ⁶ṢµĠ¬;⁶$L%5Ɗ¿€;"@Qz⁶Ç;"$ṚY - Main link: list of characters
ḟ⁶                          - filter out space characters
  Ṣ                         - sort
   µ                        - start a new monadic chain, call that S
    Ġ                       - group indices of S by their values
     ¬                      - logical NOT (vectorises) (getting 0 for the X "characters")
             ¿€             - while for €ach...
            Ɗ               - ...condition: last three links as a monad:
         L                  -   length
          %5                -   modulo by five
        $                   - ...do: last two links as a monad:
      ;⁶                    -   concatenate a space character
                  Q         - deduplicate S (get the x-axis)
               ;"@          - zip with (") concatenation (;) with swapped arguments (@)
                   z⁶       - transpose a with filler of space characters
                        $   - last two links as a monad:
                     Ç      -   call last link (1) as a monad (get y-axis)
                      ;"    -   zip with concatenation (complete the layout)
                         Ṛ  - reverse (otherwise it'll be upside-down)
                          Y - join with newlines
                            - implicit print

APL (Dyalog Classic) , 56 바이트

⊖h,⍨{∊⍺'-'/⍨~×5|⍵-⍵<2}⌸⍕⍪⍳≢h←(⊢↑⍨≢+5|1-≢)⍉(⊢,⌸⊣\)∊⍞∘∩¨⎕a

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

루비 , 250 248 234 188 173 157 153 바이트

->s{a=s.scan(/\w/).sort|[]
m=-(c=a.map{|l|s.count l}).max/5*-5
m.downto(1).map{|i|(i%5<1||i<2?"#{i}-":'').rjust(m)+c.map{|l|l<i ?' ':?X}*''}<<' '*m+a*''}

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

덕분에 :

• 덜 엄격한 패딩으로 -16 바이트에 대한 dylnan
• 반올림하여 -2 바이트의 Lynn-x/5*-5
• Kirill L.의 고유 한 배열 요소를 가져 와서 -2 바이트|[]

자바 (JDK 10) , 296 바이트

s->{int d[]=new int[26],m=0;char a;for(int c:s.getBytes())m=c>32&&++d[c-=65]>m?(d[c]+4)/5*5:m;String r=m+"-",z=r.replaceAll("."," ");for(;m>0;r+="\n"+(--m%5<1|m==1&&m>0?z.format("%"+~-z.length()+"s-",m):z))for(a=0;a<26;a++)r+=d[a]>0?m>d[a]?" ":"x":"";for(a=64;a++<90;)r+=d[a-65]>0?a:"";return r;}

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

크레딧

• Kevin Cruijssen 덕분에 -3 바이트

Pyth, 65 바이트

J.tm+ed*hd\Xr8S-Qd)=+J*]d%_tlJ5_.e+?q<k2%k5.F"{:{}d}-",klQ*dhlQbJ

여기 사용해보십시오

설명

J.tm+ed*hd\Xr8S-Qd)=+J*]d%_tlJ5_.e+?q<k2%k5.F"{:{}d}-",klQ*dhlQbJ
J.tm+ed*hd\Xr8S-Qd)
     Get the bars.
                   =+J*]d%_tlJ5
     Round up the height to the next number that's 1 mod 5.
                               _.e+?q<k2%k5.F"{:{}d}-",klQ*dhlQbJ
     Stick the axis labels on.

자바 스크립트 (Node.js를) , (262) 256 바이트

* 2 바이트 씩 줄인 @Shaggy에게 감사합니다

a=>[...a].map(x=>x>" "&&(d=c[x]=(c[x]||x)+"X")[m]?m=d.length-1:0,c={},m=i=0)&&Object.keys(c).sort().map(x=>[...c[x].padEnd(m)].map((l,j)=>A[m-j-1]+=l),A=[...Array(m+=6-m%5)].map(x=>(++i>=m||((D=m-i)%5&&m-i^1)?"":D+"-").padStart((m+" ").length)))&&A.join`
`

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

파이썬 (2) , 249 (224) 219 215 205 197 187 188 182 176 바이트

def f(s):S=sorted(set(s)^{' '});C=map(s.count,S);P=max(C)+4;return zip(*(zip(*[('%d-'%y*(y%5==2>>y)).rjust(P)for y in range(P,0,-1)])+[(n*'#').rjust(P)for n in C]))+[[' ']*P+S]

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

행을 나타내는 문자 목록을 리턴합니다.

• 많은 추가 공백을 포함하여 일부 바이트를 절약했습니다.
• 불필요 map(list,yticks)거기에 했습니다.
• 일부 바이트를 저장하기 위해 공간 패딩이 변경되었습니다.
• 정렬 중이라고 생각했지만 +2 바이트는 아닙니다. 그러나 나는 동시에 독립적으로 하나를 구했습니다. y==1~로 교체되다y<2 .
• Lynn'%d-'%y*(y%5==2>>y) 대신 -6 바이트 를 사용하여 감사합니다 (`y`+'-')*(not y%5or y<2).

약간 골퍼되지 않음 :

def f(s):
	S=sorted(set(s)^{' '})  # sorted list of unique letters (without ' ')
	C=map(s.count,S)        # count of each unique letter in the input
	P=max(C)+4              # used for padding and getting highest y tick
	B=[(n*'#').rjust(P)for n in C]     # create bars
	yticks = [('%d-'%y*(y%5==2>>y)).rjust(P)for y in range(P,0,-1)]  # create y ticks at 1 and multiples of 5
	yticks = zip(*yticks)                      # need y ticks as columns before combining with bars
	return zip(*(yticks+B))+[[' ']*P+S]        # zip ticks+bars then add row of sorted unique letters.

C # (.NET 코어) , 344 (340) 338 + 18 바이트

18 바이트 포함 using System.Linq;

@KevinCruijssen 덕분에 6 바이트를 절약했습니다.

n=>{var l=n.Where(c=>c!=32).GroupBy(c=>c).OrderBy(c=>c.Key).ToDictionary(k=>k.Key,c=>c.Count());int h=(l.Values.Max()/5+1)*5,o=(h+"").Length+1,m=l.Keys.Count+o,t=h+1,i=0,j;var a=new string[t];for(string p,q;i<t;a[i++]=q)for(q=(p=i>0&i%5<1|i==1?i+"-":"").PadLeft(j=o);j<m;){var c=l.ElementAt(j++-o).Key;q+=i<1?c:l[c]>=i?'X':' ';}return a;}

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

배시 +로 coreutils, 332 324 323 318 312 302 298 296 293 291 바이트

c()(cut -d\  -f$@)
p=printf
cd `mktemp -d`
grep -o [^\ ]<<<$@|sort|uniq -c|c 7->a
sort -k2<a>b
r=$[`c 1 <a|sort -n|tail -1`+5]
s=${#r}
t()($p \ ;((i++<s))&&t;i=)
for((;--r;));{
((r%5&&r>1))&&t||$p %${s}s- $r;IFS='
'
for l in `<b`;{ ((r<=`c 1 <<<$l`))&&$p X||$p \ ;}
echo
}
t
c 2 <b|tr -d \\n

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

주석 달기 :

c()(cut -d\  -f$@)
p=printf              # saving a few bytes

cd `mktemp -d`        # for temp files

grep -o [^\ ]<<<$@    # grabs all non-space characters
    |sort|uniq -c     # get character frequency
    |c 7->a           # slightly hacky way of stripping leading spaces;
                      #     uniq -c adds 6 spaces in front of each line

sort -k2<a>b          # store frequencies sorted alphabetically in b

r=$[`                 # r = highest frequency +5:
    c 1 <a            #     get frequencies
    |sort -n|tail -1  #     get maximum frequency
    `+5]              #     +4 so at least one multiple of 5 is
                      #     labeled, +1 because r gets pre-decremented

s=${#r}                    # s = length of r as a string
t()($p \ ;((i++<s))&&t;i=) # pad line with s+1 spaces

for((;--r;));{         # while (--r != 0)
    ((r%5&&r>1))&&     # if r isn't 1 or a multiple of 5
        t||            #     then indent line 
        $p %${s}s- $r; # otherwise print right-aligned "${r}-"
        IFS='
'                      # newline field separator
    for l in `<b`;{          # for all letters and their frequencies:
        ((r<=`c 1 <<<$l`))&& #     if frequency <= current height 
            $p X||           #         then print an X
            $p \ ;}          #     otherwise print a space
    echo
}
t # indent x-axis labels
c 2 <b|tr -d \\n # print alphabetically sorted characters

3 바이트를 절약 한 @IanM_Matrix에게 감사합니다.

C, 201 바이트

char c[256],*p,d;main(int a,char **b){for(p=b[1];*p;p++)++c[*p|32]>d&*p>64?d++:0;for(a=(d+4)/5*5;a+1;a--){printf(!a||a%5&&a!=1?"    ":"%3i-",a);for(d=96;++d>0;c[d]?putchar(a?32|c[d]>=a:d):0);puts(p);}}

입력은 명령 행에서 가져옵니다 (첫 번째 인수). X 대신 느낌표를 사용하여 코드 크기를 더 줄입니다. 왼쪽의 카운터는 항상 3 자입니다.

GCC 및 clang으로 테스트되었습니다.

Excel VBA, 316 바이트

셀에서 입력 [A1]을 받고 VBE 즉시 창으로 출력 하는 익명 VBE 즉시 창 기능 .

For i=1To 26:Cells(2,i)=Len(Replace([Upper(A1)],Chr(i+64),11))-[Len(A1)]:Next:m=-5*Int(-[Max(2:2)]/5):l=Len(m)+1:For i=-m To-1:?Right(Space(l) &IIf(i=-1Xor i Mod 5,"",-i &"-"),l);:For j=1To 26:?IIf(Cells(2,j),IIf(Cells(2, j) >= -i, "X", " "),"");:Next:?:Next:?Spc(l);:For i=1To 26:?IIf(Cells(2,i),Chr(i+96),"");:Next

언 골프 버전

Public Sub bar_graph()
    For i = 1 To 26
        ''  gather the count of the letter into cells
        Cells(2, i) = Len(Replace([Upper(A1)], Chr(i + 64), 11)) - [Len(A1)]
    Next
    m = -5 * Int(-[Max(2:2)] / 5)   ''  get max bar height
    l = Len(m) + 1                  ''  length of `m` + 1
    For i = -m To -1
        ''  print either a label or free space (y-axis)
        Debug.Print Right(Space(l) & IIf((i = -1) Xor i Mod 5, "", -i & "-"), l);
        For j = 1 To 26
            ''  print 'X' or ' ' IFF the count of the letter is positive
            If Cells(2, j) Then Debug.Print IIf(Cells(2, j) >= -i, "X", " ");
        Next
        Debug.Print                 ''  print a newline
    Next
    Debug.Print Spc(l);             ''  print spaces
    For i = 1 To 26
        ''  print the letters that were used (x-axis)
        Debug.Print IIf(Cells(2, i), Chr(i + 96), "");
    Next
End Sub

Perl 5 -n , 198168 바이트

s/[a-z]/$\<++${$&}?$\=${$&}:0/eg;$\++while$\%5;$;=1+length$\++;printf"%$;s".'%s'x26 .$/,$\%5&&$\-1?"":"$\-",map$$_>=$\?X:$$_&&$",a..z while--$\;say$"x$;,map$$_&&$_,a..z

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

파이썬 3 , 177 바이트

lambda s:[[list(("%d-"%i*(i%5==2>>i)).rjust(len(q)))+["* "[s.count(c)<i]for c in q]for i in range(max(map(s.count,q))+4,0,-1)]+[[" "]*len(q)+q]for q in[sorted(set(s)-{' '})]][0]

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

이것은 파이썬에서 가장 바이트 효율적인 방법은 아니지만 "진정한 한 줄짜리"람다 로이 문제를 해결하고 싶었습니다.

문자 목록을 출력합니다. 다른 모든 사람들과 마찬가지로 여러 개의 줄 바꿈과 공백을 남용합니다. 최종 목록 [0]을 바닥 글로 전송할 수 있도록 결과를 다른 목록으로 래핑하는 것이 허용되는 경우 실제로 174 바이트로 더 줄어들 수 있습니다.

자바 스크립트 (ES8), 200 바이트

문자 배열로 입력을받습니다. 문자열을 반환합니다.

s=>(s.sort().join``.replace(/(\w)\1*/g,s=>a.push(s[0]+'X'.repeat(l=s.length,h=h<l?l:h)),h=a=[]),g=y=>y--?(y<2^y%5?'':y+'-').padStart(`${h}_`.length)+a.map(r=>r[y]||' ').join``+`
`+g(y):'')(h+=5-~-h%5)

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

댓글

s => (                    // s[] = input array of characters (e.g. ['a','b','a','c','a'])
  s.sort()                // sort it in lexicographical order (--> ['a','a','a','b','c'])
  .join``                 // join it (--> 'aaabc')
  .replace(/(\w)\1*/g,    // for each run s of consecutive identical letters (e.g. 'aaa'):
    s => a.push(          //   push in a[]:
      s[0] +              //     the letter, which will appear on the X-axis
      'X'.repeat(         //     followed by 'X' repeated L times
        L = s.length,     //     where L is the length of the run (--> 'aXXX')
        h = h < L ? L : h //     keep track of h = highest value of L
    )),                   //   initialization:
    h = a = []            //     h = a = empty array (h is coerced to 0)
  ),                      // end of replace() (--> a = ['aXXX','bX','cX'] and h = 3)
  g = y =>                // g = recursive function taking y
    y-- ?                 //   decrement y; if there's still a row to process:
      (                   //     build the label for the Y-axis:
        y < 2 ^ y % 5 ?   //       if y != 1 and (y mod 5 != 0 or y = 0):
          ''              //         use an empty label
        :                 //       else:
          y + '-'         //         use a mark
      ).padStart(         //     pad the label with leading spaces,
        `${h}_`.length    //     using the length of the highest possible value of y
      ) +                 //     (padStart() is defined in ECMAScript 2017, aka ES8)
      a.map(r => r[y]     //     append the row,
                 || ' ')  //     padded with spaces when needed
      .join`` + `\n` +    //     join it and append a linefeed
      g(y)                //     append the result of a recursive call
    :                     //   else:
      ''                  //     stop recursion
)(h += 5 - ~-h % 5)       // call g() with h adjusted to the next multiple of 5 + 1