알파벳 비

작업:

기본 전제는 입력 문자열을 인쇄 한 다음 (대소 문자 구분) 알파벳의 (0- 인덱싱 된) 위치에 따라 각 문자를 세로로 반복하는 것입니다 A-Z. A있으므로 반복하지 않는다 위치 0에 e, SO 4 회 반복 4 번 위치에있다가 P너무 15 회 반복 위치 15이다 !아닌 A-Z등 때문에 반복 0 회

명확성을 B-Zb-z위해 숫자 또는 특수 문자와 같이 범위를 벗어나는 것은 반복되지 않으므로 첫 번째 행에만 나타납니다.

이것은 code-golf 이므로 각 언어에서 가장 짧은 솔루션이 승자입니다.

입력:

• 입력은 32 에서 126까지 의 표준 인쇄 가능 ASCII 문자 세트로 입력됩니다 ~.
• 입력 문자열의 길이는 1 자 이상입니다.
• 선행 또는 후행 공백이 없습니다.
• 당신은 문자열 (로 입력을 취할 수 "hello"() 또는 문자의 목록 ["h", "e", "l", "l", "o"])

예 :

aaaa제공의 입력 :

aaaa

abcda제공의 입력 :

abcda
 bcd
  cd
   d

의 입력은 다음 Programming Puzzles & Code Golf!을 제공합니다.

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

의 입력은 다음 ~|[abc<0>cba]|~을 제공합니다.

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

노트:

• 표준 허점 적용
• 출력 은 문자열 목록이 될 수 있지만 다음과 같습니다.
• 불필요한 후행 줄 바꿈은 허용되지 않습니다 ( \n마지막 줄은 한 줄만 허용됩니다)
• 비가 오는 것처럼 보이는 한 출력 은 문자 목록의 목록이 될 수 있습니다.
• 선행 줄 바꿈 없음
• "AZ"알파벳으로 된 몇 개의 글자가 더 있는 북유럽 사용자에게 자유롭게 지원할 수 있지만 이는 도전의 일부가 아닙니다.

6502 머신 코드 (C64), 113 바이트

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

온라인 데모

사용법 : sys49152,"[string]" 예 sys49152,"Programming Puzzles & Code Golf!".

중요 : 프로그램이 온라인 데모와 같이 디스크에서로드 된 경우 new먼저 명령을 실행하십시오! 머신 프로그램을로드하면 일부 C64 BASIC 포인터가 손상되기 때문에이 작업이 필요합니다.

참고 : C64는 기본적으로 소문자가없는 모드입니다. 대소 문자를 혼합하여 문자열을 입력하려면 먼저 SHIFT+ 를 눌러 소문자 모드로 전환하십시오 CBM.

설명

주석 처리 된 해체 목록은 다음과 같습니다.

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

,εDlAsk×}ζ»,

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

설명

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

Pyth, 12 10 9 바이트

.tm+*xGr0

테스트 스위트.

설명:

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

j.t*VmxGr0d

(마지막 줄 바꿈)

테스트 스위트.

설명:

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

파이썬 3 , 83 바이트

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

온라인으로 사용해보십시오! 문자 목록을 가져옵니다. 문자 목록을 반환합니다.

파이썬 2 , 90 바이트

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

온라인으로 사용해보십시오! 문자열을받습니다. 문자열을 반환합니다.

매스 매 티카, 115 89 바이트

그것은을 취 문자의 목록 을 출력 문자의 목록의 목록을input [{"a", "b", "c", "d", "a"}]

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

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

Misha Lavrov에서 -26 바이트

user202729에서 -5 바이트

그러나 테스트 사례에서와 같이 출력을 보려면이 (128 바이트) 코드를
사용해보십시오. 온라인으로 사용해보십시오!

Dyalog APL , 27 22 바이트

@ Adám 덕분에 5 바이트 절약

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

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

어떻게?

⍴¨⍨ -각 문자의 길이를

    1⌈ -적어도 하나 또는

    ⎕A⍳819⌶⍨∘1 -알파벳 대문자로 된 문자의 색인

        27| -모듈로 27

↑ -행렬로 평탄화

⍉ -전치

숯 , 12 바이트

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

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

Neil 덕분에 -3 .

파이썬, (105) 103 바이트

@TFeld 덕분에 2 바이트 절약

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

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

파이썬 (2) , 111 (106) 99 98 97 87 93 바이트

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

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

C # (. NET 코어) 162 바이트

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

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

배쉬, 78 , 76 71 바이트

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

데이터 정렬 (기본 LC_ALL)에 따라 더 많은 바이트를 절약 할 수 있습니다.

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

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

펄 5 , 43 바이트

41 바이트 코드 + 2 -nl.

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

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

자바 스크립트 (ES6), 87 78 76 바이트

@RickHitchcock 덕분에 -9 바이트 . @Neil
덕분에 -2 바이트 .

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

입력을 문자열로 받아서 후행 줄 바꿈으로 리턴합니다.

테스트 사례

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

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

4 바이트를 줄인 @Giuseppe에게 감사드립니다.

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

간단한 설명 :

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

plannapus에 의해 outgolfed

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

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

하나의 후행 줄 바꿈으로 stdout으로 인쇄하고에서 읽습니다 stdin().

그것을 분해하자 :

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
}

대체 답변, 106 바이트

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

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

기능; stdout으로 인쇄하지만 기본적으로 위의 응답은 문자열을 나누지 않고 문자 목록을 허용하도록 포팅되었으므로 "속임수"인 것 같습니다. 또한 정규 표현식을 사용한 plannapus의 접근 방식은 매우 깔끔합니다!

옥타브 / MATLAB, 74 66 바이트

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

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

Japt , 15 14 11 10 바이트

Japt의 새로운 문자열 패딩 방법을 사용하는 첫 번째 기회로 여전히 개선의 여지가 있습니다.

y_ùZInZu c

시도 해봐

설명

문자열의 암시 적 입력 U.

y_

현재 요소 (이 경우 문자) 인 U함수 를 통해 각 열을 전달하십시오 Z.

InZu c

Z대문자 ( u)로 변환 하고 해당 문자 코드 ( c)를 빼고 ( u) 64 ( I)를 빼십시오 .

ùZ

Z길이에 도달 할 때까지 시작 부분 을 채 웁니다.

대안

y_ùZ9aZn36

시도 해봐

하스켈 , 137 136 127 119 바이트

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

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

꽤 길지만 더 짧아 질 방법을 생각할 수 없습니다. if-then 구문보다 짧은 방법이 있어야한다고 생각하지만 보이지 않습니다.

편집 : 1 바이트를 제거하는 데 도움을 주신 @streetster에게 감사드립니다! toUpper수입 비용 때문에 처음 에는 사용하지 않았지만 Data.Char제공 ord하는 것보다 훨씬 짧은 것을 잊어 버렸습니다.fromEnum

편집 2 : 다른 6 바이트를 제거하고 내가 수정 한 버그를 식별 한 @Laikoni에게 감사드립니다. Haskell 배열이 포함 된 것을 잊었 기 때문에 25 대신 26을 사용했습니다. 그리고 내가 사용할 수있는주의 last대신에 head어느 날 사용할 수 있습니다 것 0:보다는 ++[0].

편집 3 : 8 바이트에 대해 다시 Laikoni에게 감사드립니다. 나는 실제로 그 공간을 잊었다. 어떤 이유로 Sublime Text가 없으면 튀어 나와서 그것을 잊어 버렸습니다. 나는 줄 목록이 허용된다는 것을 몰랐다. 나는 규칙을 더주의 깊게 읽어야했다.

Excel VBA, 110 바이트

Anonymous VBE Immediate Window 기능 Variant\String범위에서 예상되는 유형으로 입력을 가져 와서 VBE 즉시 창 [A1]에서 알파벳을 내리는 데 사용하는 함수입니다 .

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

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

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

PHP <7이 필요합니다. 파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

배쉬 + sed, 37

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

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

C (gcc) , 189 바이트

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

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

루비, 70 67 74 바이트

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

일부 Parens 가 제거 될 수 있음을 지적 한 @TuukkaX 덕분에 (-3 바이트)

불행히도 원래 버전이 "z"를 처리하지 못했기 때문에 7 바이트를 추가해야했습니다.

그것을 호출 :

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

문자열이 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

SQL 바이올린

Oracle 11g R2 스키마 설정 :

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

쿼리 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

결과 :

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

젤리 , 15 바이트

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

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

하스켈 , 98 바이트

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

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

사용법 예 : f "[Abc]"행 목록을 생성합니다 ["[Abc]"," bc "," c "].. 사용 putStr.unlines.f $ "[Abc]"꽤 인쇄 출력 :

[알파벳]
  기원전
   씨

user1472751의 Haskell answer 에 직접 기반 하여 Now에서 부분적으로 영감을 얻었습니다 .

이전 접근 방식 ( 100 99 바이트)

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

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

PowerShell을 , 122 127 바이트

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

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

PowerShell을 동적 사이에 주조 방법에 짧은 감사 [char]하고 [int]있지만, 긴 때문에 여분의 공백 여부 출력에 공백이나 문자의 계산을 제거.

비트 크래커 덕분에 버그 수정.

자바 (8) 151 147 144 143 139 바이트

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+$","");}

설명:

여기에서 시도하십시오.

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

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

streetster 덕분에 -5!

오래된 솔루션 + 설명 :

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

ā,{Z⁴UW1Χ∙┼

여기 사용해보십시오!

설명:

ā            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