Bảng chữ cái mưa

Nhiệm vụ:

Tiền đề cơ bản là in ra chuỗi đầu vào và sau đó lặp lại từng ký tự theo chiều dọc, dựa trên vị trí của nó (0-index) trong bảng chữ cái (không phân biệt chữ hoa chữ thường) A-Z. Aở vị trí 0 nên không lặp lại, eở vị trí 4 nên được lặp lại 4 lần, Pở vị trí 15 nên được lặp lại 15 lần, !không ở trong A-Znên được lặp lại 0 lần, v.v.

Để rõ ràng, bất cứ điều gì nằm ngoài phạm vi B-Zb-z, ví dụ chữ số hoặc ký tự đặc biệt, sẽ không được lặp lại, và do đó sẽ chỉ xuất hiện trên dòng đầu tiên.

Đây là môn đánh gôn , vì vậy giải pháp ngắn nhất trong mỗi ngôn ngữ là người chiến thắng.

Đầu vào:

• Đầu vào sẽ nằm trong bộ ký tự ASCII có thể in tiêu chuẩn, từ 32 đến 126 ~.
• Chuỗi đầu vào sẽ dài 1 ký tự hoặc dài hơn.
• Sẽ không có bất kỳ khoảng trắng hàng đầu hoặc dấu.
• Bạn có thể lấy đầu vào dưới dạng chuỗi ( "hello") hoặc danh sách các ký tự ( ["h", "e", "l", "l", "o"])

Ví dụ:

Đầu vào của aaaacho:

aaaa

Đầu vào của abcdacho:

abcda
 bcd
  cd
   d

Đầu vào của Programming Puzzles & Code Golf!, cho:

Programming Puzzles & Code Golf!
Progr mming Puzzles   Code Golf
Progr mming Puzzles   Code Golf
Progr mming Puzzles    ode Golf
Progr mming Puzzles    o e Golf
Progr mming Puzzl s    o   Golf
Progr mming Puzzl s    o   Gol
Pro r mmin  Puzzl s    o    ol
Pro r mmin  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzz  s    o    o
Pro r    n  Puzz  s    o    o
Pro r       Puzz  s    o    o
Pr  r       Puzz  s
 r  r        uzz  s
 r  r        uzz  s
             uzz  s
             uzz
             uzz
              zz
              zz
              zz
              zz
              zz

Đầu vào của ~|[abc<0>cba]|~, cho:

~|[abc<0>cba]|~
    bc   cb
     c   c

Ghi chú:

• sơ hở tiêu chuẩn áp dụng
• đầu ra có thể là một danh sách các chuỗi, nhưng:
• dòng mới bên ngoài không được phép (đơn \ntrên dòng cuối cùng là chấp nhận được)
• đầu ra có thể là một danh sách các danh sách các ký tự, miễn là có vẻ như đó là các ký tự đang mưa
• không có dòng mới
• đối với người dùng Bắc Âu của chúng tôi có thêm một vài chữ cái trong bảng chữ cái "AZ" của họ, vui lòng hỗ trợ họ, nhưng đó không phải là một phần của thách thức

Mã máy 6502 (C64), 113 byte

00 C0 20 FD AE 20 9E AD 85 FB 20 A3 B6 A0 00 84 FC B1 22 99 6F C1 C9 41 90 14 
C9 5B B0 04 E9 40 B0 0E C9 C1 90 08 C9 DB B0 04 E9 C0 B0 02 A9 00 99 6F C0 C5 
FC 30 02 85 FC C8 C4 FB D0 D3 A9 00 99 6F C1 A0 C1 A9 6F 20 1E AB A9 0D 20 D2 
FF A6 FC D0 01 60 C6 FC A0 00 B9 6F C1 F0 E6 BE 6F C0 D0 07 A9 20 99 6F C1 D0 
05 CA 8A 99 6F C0 C8 D0 E7

Bản demo trực tuyến

Cách sử dụng: sys49152,"[string]" vd sys49152,"Programming Puzzles & Code Golf!".

Quan trọng: Nếu chương trình được tải từ đĩa (như trong bản demo trực tuyến), newtrước tiên hãy ra lệnh! Điều này là cần thiết bởi vì tải một chương trình máy bỏ qua một số con trỏ C64 BASIC.

Lưu ý: C64 theo mặc định ở chế độ không có chữ thường - để có thể nhập chuỗi ký tự hỗn hợp, trước tiên hãy chuyển sang chế độ chữ thường bằng cách nhấn SHIFT+ CBM.

Giải trình

Dưới đây là danh sách tháo gỡ nhận xét:

         00 C0       .WORD $C000        ; load address
.C:c000  20 FD AE    JSR $AEFD          ; consume comma
.C:c003  20 9E AD    JSR $AD9E          ; evaluate expression
.C:c006  85 FB       STA $FB            ; store string length
.C:c008  20 A3 B6    JSR $B6A3          ; free string
.C:c00b  A0 00       LDY #$00           ; initialize counter
.C:c00d  84 FC       STY $FC            ; and number of "extra" lines
.C:c00f   .copyloop:                    
.C:c00f  B1 22       LDA ($22),Y        ; load next character
.C:c011  99 6F C1    STA .outbuf,Y      ; store to buffer
.C:c014  C9 41       CMP #$41           ; compare with 'a'
.C:c016  90 14       BCC .zerocount     ; smaller -> no repetition
.C:c018  C9 5B       CMP #$5B           ; compare with 'z'
.C:c01a  B0 04       BCS .checkupper    ; larger -> check for uppercase
.C:c01c  E9 40       SBC #$40           ; subtract 'a' ('a' - 1 and carry)
.C:c01e  B0 0E       BCS .cl_storecount ; and jump to store in repeat count
.C:c020   .checkupper:                  
.C:c020  C9 C1       CMP #$C1           ; compare with 'A'
.C:c022  90 08       BCC .zerocount     ; smaller -> no repetition
.C:c024  C9 DB       CMP #$DB           ; compare with 'Z'
.C:c026  B0 04       BCS .zerocount     ; larger -> no repetition
.C:c028  E9 C0       SBC #$C0           ; subtract 'A' ('A' - 1 and carry)
.C:c02a  B0 02       BCS .cl_storecount ; and jump to store in repeat count
.C:c02c   .zerocount:                   
.C:c02c  A9 00       LDA #$00           ; store 0 ...
.C:c02e   .cl_storecount:               
.C:c02e  99 6F C0    STA .repcount,Y    ; ... in repeat count
.C:c031  C5 FC       CMP $FC            ; compare with number of extra lines
.C:c033  30 02       BMI .cl_next       ; smaller -> go on with loop
.C:c035  85 FC       STA $FC            ; repeat count to number of extra lines
.C:c037   .cl_next:                     
.C:c037  C8          INY                ; next
.C:c038  C4 FB       CPY $FB            ; compare with string length
.C:c03a  D0 D3       BNE .copyloop      ; not yet reached? -> repeat
.C:c03c  A9 00       LDA #$00           ; terminate string in buffer
.C:c03e  99 6F C1    STA .outbuf,Y      ; with 0 byte
.C:c041   .outloop:                     
.C:c041  A0 C1       LDY #>.outbuf      ; output ...
.C:c043  A9 6F       LDA #<.outbuf      ; ...
.C:c045  20 1E AB    JSR $AB1E          ; ... string
.C:c048  A9 0D       LDA #$0D           ; and output ...
.C:c04a  20 D2 FF    JSR $FFD2          ; ... newline
.C:c04d  A6 FC       LDX $FC            ; load extra line count
.C:c04f  D0 01       BNE .ol_step       ; not zero -> go on
.C:c051  60          RTS                ; WE ARE DONE HERE ;)
.C:c052   .ol_step:                     
.C:c052  C6 FC       DEC $FC            ; decrease extra line count
.C:c054  A0 00       LDY #$00           ; initialize counter
.C:c056   .eraseloop:                   
.C:c056  B9 6F C1    LDA .outbuf,Y      ; load next character from buffer
.C:c059  F0 E6       BEQ .outloop       ; 0 byte? -> end of string, output
.C:c05b  BE 6F C0    LDX .repcount,Y    ; load repeat count for this characer
.C:c05e  D0 07       BNE .el_step       ; not 0 yet? -> jump to decrement
.C:c060  A9 20       LDA #$20           ; load code for space
.C:c062  99 6F C1    STA .outbuf,Y      ; store in current string position
.C:c065  D0 05       BNE .el_next       ; and jump to next loop iteration
.C:c067   .el_step:                     
.C:c067  CA          DEX                ; decrease repeat count ...
.C:c068  8A          TXA                ; ... and ...
.C:c069  99 6F C0    STA .repcount,Y    ; ... store back
.C:c06c   .el_next:                     
.C:c06c  C8          INY                ; increase counter ...
.C:c06d  D0 E7       BNE .eraseloop     ; and jump back to loop

.C:c06f   .repcount:
.C:c06f              .RES $100          ; 256 bytes for repeat count
.C:c16f   .outbuf:
.C:c16f              .RES $100          ; 256 bytes as buffer for output

05AB1E , 13 12 byte

,εDlAsk×}ζ»,

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

Giải trình

,             # print input
 ε      }     # apply to each char in input
  D           # duplicate
   l          # convert to lower case
    Ask       # get index of current char in the lower case alphabet
       ×      # repeat the char that many times
         ζ    # transpose with space as filler
          »,  # join on newlines and print

Bình thường, 12 10 9 byte

.tm+*xGr0

Bộ thử nghiệm.

Giải trình:

.tm+*xGr0dddQ   Expanded program with autofilled input variable
  m      dddQ    For each character d in the input:
       r0d     get its lowercase variant
     xG        and return its 0-based index in the alphabet 
                   (-1 if not found, for special chars)
                (empty string for A/a and special characters)
    *     d    that many of the corresponding character
   +       d   and one more for good measure (because x is 0-indexed)
.t             Transpose it and fill blanks with spaces

12 byte:

j.t*VmxGr0d

(với dòng mới)

Bộ thử nghiệm.

Giải trình:

j.t*VmxGr0d
QQ              Expanded program with autofilled input variable
Q               print the input verbatim
     m    dQ    For each character d in the input:
        r0      get its lowercase variant
      xG        and return its 0-based index in the alphabet 
                    (-1 if not found, for special chars)
   *V       Q   multiply the corresponding characters in (the second autofilled input)
                 by their alphabet indices we just calculated
                 (empty string for A/a and special characters)
 .t             Transpose it and fill blanks with spaces
j               Join the result on newlines

Python 3 , 83 byte

f=lambda s,k=65:[*{*s}-{' '}]and[s]+f([[' ',c][91>ord(c.upper())>k]for c in s],k+1)

Hãy thử trực tuyến! Đưa ra một danh sách các nhân vật. Trả về một danh sách các danh sách các nhân vật.

Python 2 , 90 byte

f=lambda s,k=65:s.strip()and s+'\n'+f(''.join([' ',c][91>ord(c.upper())>k]for c in s),k+1)

Hãy thử trực tuyến! Mất một chuỗi. Trả về một chuỗi.

Toán học, 115 89 byte

Nó lấy như inputmột danh sách các ký tự [{"a", "b", "c", "d", "a"}] và đưa ra một danh sách các danh sách các ký tự

Thread[PadRight[Table[#,Max@Position[Alphabet[]/."a"->#,#|ToLowerCase@#]]&/@#]/. 0->" "]&

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

-26 byte từ Misha Lavrov

-5 byte từ user202729

nhưng nếu bạn muốn xem đầu ra như trong trường hợp thử nghiệm, hãy thử mã (128 byte) này
Hãy thử trực tuyến!

APL Dyalog , 27 22 byte

5 byte được lưu nhờ vào @ Adám

⍉∘↑⊢⍴¨⍨1⌈27|⎕A⍳819⌶⍨∘1

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

Làm sao?

⍴¨⍨ - định hình mỗi char theo chiều dài

    1⌈ - ít nhất một hoặc

    ⎕A⍳819⌶⍨∘1 - chỉ số của char cấp trên trong bảng chữ cái

        27| - modulo 27

↑ - làm phẳng một ma trận

⍉ - và hoán vị

Than , 12 byte

θ↙↓Ｅ⮌θ×ι⌕α↥ι

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

-3 cảm ơn Neil .

Python, 105 103 byte

Lưu 2 byte nhờ @TFeld

lambda s:'\n'.join(''.join((' '+l)[i<1or 91>ord(l.upper())>i+64]for l in s)for i in range(26)).rstrip()

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

Python 2 , 111 106 99 98 97 87 93 byte

s=input()
i=65
while s.strip():print s;s=''.join([' ',c][91>ord(c.upper())>i]for c in s);i+=1

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

C # (.NET Core) , 162 byte

s=>{string A="abcdefghijklmnopqrstuvwxyz",r=s;for(int i=-1;++i<s.Max(A.IndexOf);)r+='\n'+string.Concat(s.Select(c=>A.IndexOf(char.ToLower(c))>i?c:' '));return r;}

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

Bash, 78 , 76 71 byte

for c in {B..a};{ [[ -n ${1// } ]]&&echo "$1";set "${1//[!$c-Z${c,}-z]/ }";}

Tùy thuộc vào đối chiếu (LC_ALL mặc định) có thể lưu thêm một số byte

for c in {b..z} _;{ [[ -n ${1// } ]]&&echo "$1";set "${1//[!$c-Z]/ }";}

Dùng thử trực tuyến

Perl 5 , 43 byte

Mã 41 byte + 2 cho -nl.

$c=A;print,s/$c|[^a-z]/ /gi,$c++while/\S/

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

JavaScript (ES6), 87 78 76 byte

-9 byte nhờ @RickHitchcock .
-2 byte nhờ @Neil .

f=(s,i=10)=>s.trim()&&s+`
`+f(s.replace(/./g,c=>parseInt(c,36)>i?c:" "),i+1)

Lấy đầu vào dưới dạng một chuỗi và trả về với một dòng mới.

Các trường hợp thử nghiệm

f=(s,i=10)=>s.trim()&&s+`
`+f(s.replace(/./g,c=>parseInt(c,36)>i?c:" "),i+1)

;["hello", "Programming Puzzles & Code Golf!", "~|[abc<0>cba]|~", "abcdefg0123456789"]
.forEach(s=>console.log(f(s)));

.as-console-wrapper{max-height:100%!important}

R, 118 114 byte

function(a)while(grepl("[^ ]",a)){F=F+1;cat(a,"\n");for(j in c("[^a-zA-Z]",letters[F],LETTERS[F]))a=gsub(j," ",a)}

Cảm ơn @Giuseppe đã tắt 4 byte

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

Giải thích ngắn gọn:

function(a)
    while(grepl("[^ ]",a)){ #As long as the string is not just spaces.
        F=F+1 #Increment letter counter (F is FALSE, hence 0 by default)
        cat(a,"\n") #Print string
        for(j in c("[^a-zA-Z]",letters[F],LETTERS[F])) #Get rid of non-letters, and the current letter in lower and upper case
             a=gsub(j," ",a)
    }

R , 125 123 byte

Vượt trội bởi plannapus

for(i in 1:max(p<-pmax(1,match(tolower(S<-el(strsplit(scan(,""),''))),letters),na.rm=T)))cat(ifelse(p<i," ",S),'\n',sep='')

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

In ra thiết bị xuất chuẩn với một dòng mới duy nhất và đọc từ stdin() .

Hãy phá vỡ nó:

S <- el(strsplit(scan,""))            # split the string to characters

m <- match(tolower(S),letters)        # 1-based index in letters (lowercase a-z)
p <- pmax(1,m,na.rm=T)                # parallel max, replaces NA (non-alphabet) or 0 with 1
for(i in 1:max(p)){                   # iterate
 cat(                                 # print
  ifelse(p<1,' ',S),                  # the corresponding letter in S if p>=1, space otherwise
  '\n',sep='')                        # newline, and no spaces between chars
}

Câu trả lời thay thế, 106 byte

function(S)for(i in 1:max(p<-pmax(1,match(tolower(S),letters),na.rm=T)))cat(ifelse(p<i,' ',S),'\n',sep='')

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

Chức năng; in ra thiết bị xuất chuẩn nhưng về cơ bản, phản hồi của tôi ở trên đã được chuyển sang chấp nhận danh sách các ký tự thay vì tách chuỗi, vì vậy tôi cảm thấy như đó là "gian lận". Thêm vào đó, cách tiếp cận của plannapus với regex khá gọn gàng!

Octave / MATLAB, 74 66 byte

@(s)char(arrayfun(@(c){repmat(c,1,prod(find(upper(c)==65:90)))},s))'

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

Japt , 15 14 11 10 byte

Cơ hội đầu tiên để chơi với các phương pháp đệm chuỗi mới của Japt vì vậy vẫn có thể có chỗ để cải thiện.

y_ùZInZu c

Thử nó

Giải trình

Đầu vào ngầm định của chuỗi U.

y_

Vượt qua từng cột Uthông qua một hàm, trong đó Zphần tử hiện tại (hoặc chữ cái, trong trường hợp này).

InZu c

Chuyển đổi Zthành chữ hoa ( u), lấy charcode ( c) và trừ ( u) 64 ( I).

ùZ

Pad bắt đầu Zvới chính nó cho đến khi nó đạt đến chiều dài đó.

Thay thế

y_ùZ9aZn36

Thử nó

Haskell , 137 136 127 119 byte

import Data.Char
p c=last$0:[k|k<-[0..25],k+65==ord(toUpper c)]
f s=[[last$c:[' '|i>p c]|c<-s]|i<-[0..maximum$map p s]]

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

Khá dài nhưng tôi không thể nghĩ ra cách nào để rút ngắn hơn nữa. Tôi cảm thấy như phải có một số cách ngắn hơn cú pháp if-then nhưng tôi không thấy nó.

EDIT: Cảm ơn @streetster đã giúp tôi cạo sạch một byte! Lúc đầu tôi không sử dụng toUppervì chi phí nhập khẩu Data.Charnhưng tôi quên rằng nó cũng cung cấp ordngắn hơn nhiều so vớifromEnum

EDIT 2: Cảm ơn @Laikoni đã loại bỏ 6 byte khác và xác định một lỗi mà tôi đã sửa. Tôi đã sử dụng 26 thay vì 25 vì tôi quên rằng các mảng Haskell đã được bao gồm. Sau đó, tôi nhận thấy tôi có thể sử dụng lastthay vì headsẽ cho phép tôi sử dụng 0:chứ không phải ++[0].

EDIT 3: Cảm ơn một lần nữa Laikoni cho 8 byte đó. Tôi thực sự đã quên mất không gian đó. Vì một số lý do, Sublime Text lật ra mà không có nó và tôi quên xóa nó. Tôi không biết rằng danh sách các dòng được cho phép, tôi nên đọc các quy tắc cẩn thận hơn.

VBA Excel, 110 byte

Chức năng cửa sổ tức thời VBE ẩn danh lấy đầu vào là loại dự kiến Variant\Stringtừ phạm vi [A1]và sử dụng nó để làm mưa bảng chữ cái trong cửa sổ ngay lập tức VBE.

?[A1]:For i=1To 26:For j=1To[Len(A1)]:c=Mid([A1],j,1):d=Asc(UCase(c)):?IIf((d>64+i)*(d<91),c," ");:Next:?:Next

Mẫu I / O

[A1]="qwertyuiop[]ASDFGHJKL:'zxcvbnm,./"
?[A1]:For i=1To 26:For j=1To[Len(A1)]:c=Mid([A1],j,1):d=Asc(UCase(c)):?IIf((d>64+i)*(d<91),c," ");:Next:?:Next
qwertyuiop[]ASDFGHJKL:'zxcvbnm,./
qwertyuiop   SDFGHJKL  zxcvbnm   
qwertyuiop   SDFGHJKL  zxcv nm   
qwertyuiop   SDFGHJKL  zx v nm   
qwertyuiop   S FGHJKL  zx v nm   
qw rtyuiop   S FGHJKL  zx v nm   
qw rtyuiop   S  GHJKL  zx v nm   
qw rtyuiop   S   HJKL  zx v nm   
qw rtyuiop   S    JKL  zx v nm   
qw rtyu op   S    JKL  zx v nm   
qw rtyu op   S     KL  zx v nm   
qw rtyu op   S      L  zx v nm   
qw rtyu op   S         zx v nm   
qw rtyu op   S         zx v n    
qw rtyu op   S         zx v      
qw rtyu  p   S         zx v      
qw rtyu      S         zx v      
 w rtyu      S         zx v      
 w  tyu      S         zx v      
 w  tyu                zx v      
 w   yu                zx v      
 w   y                 zx v      
 w   y                 zx        
     y                 zx        
     y                 z         
                       z 

PHP, 69 78 77 85 + 1 byte

for($c=A;!$c[1]&&~trim($s=&$argn);$s=eregi_replace("[^".++$c."-Z]"," ",$s))echo"$s
";

yêu cầu PHP <7. Chạy như ống với -nRhoặc thử trực tuyến .

Bash + sed, 37

sed -rne"/^ *$/q;p;s/\W|"{a..z}/\ /gi

Dùng thử trực tuyến .

C (gcc) , 189 byte

#define F for(q=c,p=s;*p;++p,++q)
char*p,*q,s[99],c[99];main(h){gets(s);F{*q=*p>64&&*p<91?*p-65:*p>96&&*p<123?*p-97:0;h=h>*q?h:*q;}for(puts(s);h--;){F{putchar(*q?--*q,*p:32);}putchar(10);}}

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

Ruby, 70 67 74 byte

f=->s{puts s;(?b..?z).each{|c|s.gsub! /[^#{c}-z]/i,' ';puts s if s=~/\S/}}

Cảm ơn @TuukkaX vì đã chỉ ra một số parens có thể bị hủy (-3 byte)

Thật không may, sau đó tôi đã phải thêm 7 byte vì phiên bản gốc không thể xử lý "z".

Gọi nó là:

f.call('The quick brown fox jumps over the lazy dog!')
The quick brown fox jumps over the lazy dog!
The quick brown fox jumps over the l zy dog
The quick  rown fox jumps over the l zy dog
The qui k  rown fox jumps over the l zy dog
The qui k  rown fox jumps over the l zy  og
Th  qui k  rown fox jumps ov r th  l zy  og
Th  qui k  rown  ox jumps ov r th  l zy  og
Th  qui k  rown  ox jumps ov r th  l zy  o
T   qui k  rown  ox jumps ov r t   l zy  o
T   qu  k  rown  ox jumps ov r t   l zy  o
T   qu  k  rown  ox  umps ov r t   l zy  o
T   qu     rown  ox  umps ov r t   l zy  o
T   qu     rown  ox  umps ov r t     zy  o
T   qu     rown  ox  u ps ov r t     zy  o
T   qu     row   ox  u ps ov r t     zy  o
T   qu     r w    x  u ps  v r t     zy
T   qu     r w    x  u  s  v r t     zy
T    u     r w    x  u  s  v r t     zy
T    u       w    x  u  s  v   t     zy
T    u       w    x  u     v   t     zy
     u       w    x  u     v         zy
             w    x        v         zy
             w    x                  zy
                  x                  zy
                                     zy
                                     z

Oracle SQL, 186 byte

Giả sử chuỗi sẽ nằm trong một bảng ttrong cột v:

WITH a(s,l)AS(SELECT v,64 FROM t UNION ALL SELECT REGEXP_REPLACE(s,'[^'||CHR(l+1)||'-Z]',' ',1,0,'i'),l+1 FROM a WHERE l<90)SELECT LISTAGG(RTRIM(s),CHR(10))WITHIN GROUP(ORDER BY l)FROM a

Câu đố SQL

Thiết lập lược đồ Oracle 11g R2 :

CREATE TABLE t ( v ) AS
SELECT '~|[abc<0>cba]|~' FROM DUAL
/

Truy vấn 1 :

WITH a(s,l)AS(
  SELECT v,64 FROM t
UNION ALL
  SELECT REGEXP_REPLACE(s,'[^'||CHR(l+1)||'-Z]',' ',1,0,'i'),l+1
  FROM a
  WHERE l<90
)
SELECT LISTAGG(RTRIM(s),CHR(10))WITHIN GROUP(ORDER BY l)
FROM a

Kết quả :

|      LISTAGG(RTRIM(S),CHR(10))WITHINGROUP(ORDERBYL) |
|-----------------------------------------------------|
| ~|[abc<0>cba]|~                                     |
|    abc   cba                                        |
|     bc   cb                                         |
|      c   c                                          |

Thạch , 15 byte

ØaḊiЀŒl‘⁸ẋ"z⁶Y

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

Haskell , 98 byte

p c=sum[length[a..c]|a:e<-["B[","b{"],[c]<e]
f s=[[last$c:[' '|i>p c]|c<-s]|i<-[0..maximum$p<$>s]]

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

Ví dụ sử dụng: f "[Abc]"mang lại một danh sách các dòng : ["[Abc]"," bc "," c "]. Sử dụng putStr.unlines.f $ "[Abc]"cho đầu ra được in đẹp:

[Abc]
  bc
   c

Một phần lấy cảm hứng từ Now trực tiếp dựa trên câu trả lời Haskell của user1472751 .

Cách tiếp cận trước đó ( 100 99 byte)

f s=[h|i<-[0..26],h<-[[(c:concat[c<$[a..c]|[a,e]<-["B[","b{"],c<e]++cycle" ")!!i|c<-s]],any(>' ')h]

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

PowerShell , 122 127 byte

param($a)$a;(1..25|%{$i=$_;(-join([char[]]$a|%{(' ',$_)[$_-match'[a-z]'-and[math]::Max(0,($_-bor32)-96-$i)]})).TrimEnd()})-ne''

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

Ngắn gọn nhờ vào cách PowerShell có thể tự động chuyển giữa [char]và [int], nhưng lâu vì loại bỏ khoảng trắng bên ngoài và tính toán xem có nên xuất một khoảng trắng hoặc ký tự không.

Sửa lỗi nhờ beatcracker.

Java 8, 151 147 144 143 139 byte

s->{String x="\n"+s;for(int i=64,t;++i<91;)for(char c:x.toCharArray())s+=(t=c&~32)>64&t<91&t>i|c<11?c:" ";return s.replaceAll("\\s+$","");}

Giải trình:

Hãy thử nó ở đây.

s->{                   // Method with String as both parameter and return-type
  String x="\n"+s;     //  Temp-String (equal to leading new-line + input)
  for(int i=64,        //  Index-integer `i` (starting at 64)
          t;           //  Temp-integer
      ++i<91;)         //  Loop (1) from 'A' (65) to 'Z' (90) (inclusive)
    for(char c:x.toCharArray())
                       //   Inner loop (2) over the character of the array
      s+=(t=c&~32)>64  //    If the current character as uppercase is larger than 'A'
         &t<91         //    and smaller or equal to 'Z'
         &t>i          //    and larger than the current index
         |c<11?        //    or the current character is a new-line
          c            //     Append the current character to `s`
         :             //    Else:
          " ";         //     Append a space to `s` instead
                       //   End of inner loop (2) (implicit / single-line body)
                       //  End of loop (1) (implicit / single-line body)
  return s             //  Return the result,
    .replaceAll("\\s+$",""); 
                       //   after we've removed all trailing spaces and new-lines
}                      // End of method

q , 42 37 byte

{(+)max[m]$(m:1+mod[.Q.a?(_)x]26)#'x}

-5 cảm ơn streetster!

giải pháp cũ + giải thích:

{(+)max[m]$'(m:1+mod[.Q.a?lower x;26])#'x}


{                                        }  / lambda func
                     .Q.a?lower x           / get lowercase of input (ignores non-alpha values) and find (?) their index in "a...z" (.Q.a). non-alpha values return `26`
                 mod[.Q.a?lower x;26]       / get mod 26 of each index, this returns 0 where index is 26
            (m:1+mod[.Q.a?lower x;26])      / add 1 and assign to m
            (m:1+mod[.Q.a?lower x;26])#'x   / m and x conform, so we can take (#) m copies of each (') x at corresponding indices
    max[m]$'(m:1+mod[.Q.a?lower x;26])#'x   / get max of m, and pad each ($') of right-side list to that length
 (+)                                        / transpose the char matrix

SOGL V0.12 , 12 11 byte

ā,{Z⁴UW1Χ∙┼

Hãy thử nó ở đây!

Giải trình:

ā            push an empty array
 ,{          for each character in the input, pushing it
   Z           push the uppercase alphabet
    ⁴          push a duplicate of the character
     U         uppercase it
      W        find its index in that alphabet
       1Χ      get the maximum of that and 1
         ∙     repeat the character that many times
          ┼    append horizontally to that array