Cho một câu đầu vào bao gồm một hoặc nhiều từ [a-z]+và không hoặc nhiều khoảng trắng , xuất ra biểu đồ nghệ thuật ASCII (biểu đồ thanh) của phân phối chữ cái của câu đầu vào.

Biểu đồ phải được đặt theo chiều ngang, tức là với phím chữ dọc phía dưới theo thứ tự bảng chữ cái từ trái sang phải, với trục Y được dán nhãn 1-và cứ sau 5 đơn vị. Trục Y phải là bội số nhỏ nhất trong năm, ít nhất cao bằng thanh cao nhất và phải được căn phải. Trục X được gắn nhãn với các chữ cái đầu vào, không có khoảng trống giữa. Ví dụ, đầu vào a bb ddnên có nhãn abdvà không ab d, bỏ qua c. Các thanh có thể được tạo từ bất kỳ ký tự ASCII nhất quán nào - tôi sẽ sử dụng Xở đây trong các ví dụ của mình.

test example

5-

   X
   X   X
1-XXXXXXXX
  aelmpstx

Vì có ba e, hai tvà một almsx.

Ví dụ khác:

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 và Nội quy

• Đầu vào có thể được thực hiện trong bất kỳ định dạng hợp lý và bằng bất kỳ phương pháp thuận tiện . Điều này cũng có nghĩa là bạn có thể lấy đầu vào bằng chữ hoa, nếu điều đó có ý nghĩa hơn đối với mã của bạn.
• Dòng mới hàng đầu / dấu hoặc khoảng trắng khác là tùy chọn, miễn là các ký tự xếp hàng một cách thích hợp.
• Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Đầu ra có thể là bàn điều khiển, được trả về dưới dạng danh sách các chuỗi, được trả về dưới dạng một chuỗi, v.v.
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

Stax , 37 byte

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

Chạy và gỡ lỗi nó

R , 239 230 byte

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

Hãy thử trực tuyến!

table thực hiện việc nâng vật nặng ở đây, duy nhất các ký tự, sắp xếp chúng và trả lại số đếm của chúng.

Mọi thứ khác chỉ là đảm bảo các bản in phù hợp để in, đó là công việc "thực sự" của một thách thức nghệ thuật.

Cảm ơn @dylnan đã chỉ ra một lỗi.

Cảm ơn @rturnbull cho scancách tiếp cận, giảm 2 byte.

gnu sed -r, 516 490 278 249 + 1 byte

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

Hãy thử trực tuyến!

Tôi chắc chắn rằng điều này có thể được cải thiện , nhưng hiện tại, điều này nên được xem xét tốt khi nó được thực hiện trong sed, nơi bạn không có số học hoặc sắp xếp bản địa. Vì vậy, tôi đã nói dối, điều này không đủ tốt, vì vậy tôi đã cải thiện (viết lại) nó bằng 212 byte khác, với một mẹo liên quan đến thuật toán sắp xếp từ quẻ bò , điều này cho tôi một ý tưởng để chuyển đổi đơn phương sang thập phân ngắn hơn.
Mô tả hoạt động bên trong:

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

Điều này sắp xếp đầu vào và phân tách các nhóm với không gian. Điều này hoạt động bằng cách đầu tiên nối thêm một bảng chữ cái viết hoa cộng với không gian được phân tách bằng dấu hai chấm đến cuối. Sau đó, nó di chuyển mỗi ký tự ở phía trước dấu hai chấm thành một ký tự khớp phía sau dấu hai chấm bằng cách sử dụng thay thế không phân biệt chữ hoa chữ thường trong một vòng lặp. Các chữ cái in hoa sau đó được thay thế bằng khoảng trắng và chuỗi được sao chép vào không gian giữ.

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

Vòng lặp này hoạt động bằng cách giảm từng kích thước nhóm ký tự, nối thêm dòng gốc đã sắp xếp và tăng bộ đếm đơn nguyên sau dấu hai chấm còn lại từ sắp xếp. Nó lặp cho đến khi đạt được một dòng trống với số lượng 5 * n + 1 (vì dòng cuối cùng cuối cùng dẫn đến khoảng trắng). Không gian mẫu trông giống như thế này sau vòng lặp:

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

Sau đó, định dạng sau:

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

Và cuối cùng, trình chuyển đổi unary sang thập phân vẫn còn:

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

Về cơ bản, nó nối thêm một chuỗi trong đó kiến ​​thức về chuyển đổi. Bạn có thể hiểu nó là: dấu cách: -> 1 và 0-> 1-> 2-> 3-> 4-> 5-> 6-> 7-> 8-> 9-> I0. Biểu thức thay thế s/(.)I(.*\1(I?.))|;.*/\3\2/hoạt động tương tự như cách sắp xếp, thay thế các ký tự phía trước tôi [ (.)I] bằng ký tự bên cạnh ký tự ở phía trước của chuỗi I trong chuỗi chuyển đổi [ (.*\1(I?.))] và nếu không còn tôi, nó sẽ xóa chuỗi được nối thêm [ |;.*]. Sự thay thế [ /\nI/s/^/ /Mg] thêm phần đệm nếu cần.

Cảm ơn quẻ bò đã giảm kích thước 26 byte và cho thuật toán sắp xếp ngắn hơn.

Thuốc nhuộm APL , 109 97 96 95 93 88 byte

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

Hãy thử trực tuyến!

Đòi hỏi ⎕IO←0

Cách lưu quá nhiều byte nhờ Adám và bò lang băm !

05AB1E , 58 47 byte

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

Hãy thử trực tuyến!

-11 byte nhờ @Emigna

Python 2 , 192 byte

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

Hãy thử trực tuyến!

Giải trình

Dòng 2 tính toán các giá trị biểu đồ theo cách khá đơn giản, loại bỏ ' '.

Dòng 3 sử dụng thủ thuật tính toán ceil(x/5)như -(-x/5)sau: chúng ta làm tròn tần số tối đa lên tới bội số tiếp theo của 5 bằng công thức -x/5*-5. Đây là h.

Dòng 4 là một vòng lặp đếm từ hxuống đến 0bao gồm, in mỗi hàng:

• Nếu y%5==2>>ychúng tôi in một nhãn. Đây là khi y∈ {1, 5, 10, 15, 20, Mua}

  (Công thức này có lẽ có thể ngắn hơn. Chúng tôi chỉ cần cái gì đó là 1 hoặc Đúng cho {1, 5, 10, ...}, và 0 hoặc False hoặc thậm chí là một số nguyên âm cho tất cả các giá trị khác của y.)

• Chúng tôi xác nhận đúng nhãn (hoặc không gian trống) vào len(`-h`)khoảng trắng: đây là cách tiết kiệm một byte gọn gàng hơn len(`h`)+1!

• Sau đó, chúng tôi in một trong hai Xvà khoảng trắng cho hàng này (nếu y≥ 1) hoặc các chữ cái (if y= 0), chạy qua các cặp giá trị khóa dtheo thứ tự tăng dần.

Than , 62 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

≔Ｅ²⁷⟦⟧η

Tạo một danh sách 27 danh sách.

Ｆθ⊞§η⌕βιι

Đẩy từng ký tự đầu vào vào danh sách tương ứng với vị trí của nó trong bảng chữ cái viết thường. Các ký tự không phải chữ thường được đẩy đến danh sách thứ 27.

≔⊟ηθ

Hủy phần tử thứ 27 của danh sách.

≦Ｌη

Lấy độ dài của tất cả các yếu tố của danh sách.

Ｐ⭆β⎇§ηκιω

In các chữ cái viết thường tương ứng với các yếu tố danh sách khác không.

↑↑Φηι

In các phần tử danh sách khác không lên trên. Vì đây là một mảng các số nguyên, mỗi số nguyên in dưới dạng một dòng (bây giờ là dọc), mỗi số trong một cột riêng biệt.

Ｆ÷⁺⁹⌈η⁵«

Tính số lượng dấu tick trên trục Y và lặp qua chúng.

≔∨×⁵ι¹ι

Tính vị trí của dấu tick tiếp theo.

Ｊ±¹±ι

Nhảy đến dấu tích tiếp theo.

←⮌⁺ι-

In dấu tick đảo ngược và quay lại phía trước, căn chỉnh nó một cách hiệu quả.

Thạch , 48 byte

^{Thật là một mỏ khai thác để đi qua!}

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

Một chương trình in đầy đủ kết quả (dưới dạng một liên kết đơn, nó sẽ trả về một danh sách chứa các ký tự và số nguyên từ đó [0,9])

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm

Làm sao?

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 byte

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

Hãy thử trực tuyến!

Ruby , 250 248 234 188 173 157 153 byte

->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*''}

Hãy thử trực tuyến!

Nhờ vào:

• Đông Nam cho -16 byte với phần đệm ít nghiêm ngặt hơn
• Lynn cho -2 byte bằng cách làm tròn với-x/5*-5
• Kirill L. cho -2 byte bằng cách lấy các phần tử mảng duy nhất với|[]

Java (JDK 10) , 296 byte

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

Hãy thử trực tuyến!

Tín dụng

• -3 byte nhờ Kevin Cruijssen

Bình thường, 65 byte

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

Hãy thử nó ở đây

Giải trình

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.

JavaScript (Node.js) , 262 256 byte

* Cảm ơn @Shaggy vì đã giảm 2 byte

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

Hãy thử trực tuyến!

Python 2 , 249 224 219 215 205 197 187 188 182 176 byte

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]

Hãy thử trực tuyến!

Trả về một danh sách các danh sách các ký tự đại diện cho các dòng.

• Đã lưu một số byte bằng cách bao gồm rất nhiều khoảng trắng.
• Có một thứ không cần thiết map(list,yticks) trong đó.
• Thay đổi không gian đệm để lưu một số byte.
• Tôi nghĩ rằng tôi đã sắp xếp nhưng tôi không: +2 byte. Nhưng tôi đã lưu một cách độc lập cùng một lúc. y==1thay thế bằng y<2.
• -6 byte nhờ Lynn bằng cách sử dụng '%d-'%y*(y%5==2>>y)thay vì (`y`+'-')*(not y%5or y<2).

Hơi vô dụng:

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 # (Lõi .NET) , 344 340 338 + 18 byte

Bao gồm 18 byte cho using System.Linq;

Đã lưu 6 byte nhờ @KevinCruijssen.

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

Hãy thử trực tuyến!

Bash + coreutils, 332 324 323 318 312 302 298 296 293 291 byte

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

Hãy thử trực tuyến!

Chú thích:

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

Cảm ơn @IanM_Matrix vì đã lưu 3 byte.

C, 201 byte

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

Đầu vào được lấy từ dòng lệnh (đối số đầu tiên). Sử dụng dấu chấm than thay vì dấu X để tiếp tục giảm kích thước mã. Số lượt truy cập bên trái luôn dài ba ký tự.

Đã thử nghiệm với GCC và tiếng kêu.

VBA Excel, 316 byte

Một chức năng cửa sổ ngay lập tức VBE ẩn danh lấy đầu vào từ ô [A1]và xuất ra cửa sổ ngay lập tức 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

Phiên bản Ungolfed

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 , 198 168 byte

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

Hãy thử trực tuyến!

Python 3 , 177 byte

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]

Hãy thử trực tuyến!

Đây có thể không phải là cách tiếp cận hiệu quả nhất trong Python, nhưng tôi thực sự muốn giải quyết vấn đề này bằng lambda "đúng một lớp".

Xuất ra một danh sách các danh sách nhân vật. Lạm dụng nhiều dòng mới và không gian hàng đầu giống như mọi người khác. Nó thực sự có thể được giảm xuống còn 174 byte nếu có thể chấp nhận bọc kết quả trong một danh sách khác, để chúng tôi có thể chuyển [0]chỉ mục cuối cùng sang chân trang.

JavaScript (ES8), 200 byte

Đưa đầu vào như một mảng các ký tự. Trả về một chuỗi.

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)

Hãy thử trực tuyến!

Đã bình luận

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