Alfabeto Pioggia

L'obiettivo:

La premessa di base è stampare la stringa di input e quindi ripetere ogni carattere in verticale, in base alla sua posizione (indicizzata 0) nell'alfabeto (senza distinzione tra maiuscole e minuscole) A-Z. Aè nella posizione 0, quindi non viene ripetuto, eè nella posizione 4, quindi viene ripetuto 4 volte, Pè nella posizione 15, quindi viene ripetuto 15 volte, !non si trova , A-Zquindi viene ripetuto 0 volte, ecc.

Per chiarezza, tutto ciò che non rientra nell'intervallo B-Zb-z, ad esempio cifre o caratteri speciali, non verrà ripetuto e quindi apparirà solo sulla prima riga.

Questo è code-golf , quindi la soluzione più breve in ogni lingua è il vincitore.

Ingresso:

• L'input sarà nel set di caratteri ASCII stampabili standard, da 32 a 126 ~.
• La stringa di input avrà una lunghezza di 1 carattere o più.
• Non ci saranno spazi bianchi iniziali o finali.
• Puoi prendere take input come stringa ( "hello") o elenco di caratteri ( ["h", "e", "l", "l", "o"])

Esempi:

Input di aaaadà:

aaaa

Input di abcdadà:

abcda
 bcd
  cd
   d

L'input di Programming Puzzles & Code Golf!, dà:

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

L'input di ~|[abc<0>cba]|~, dà:

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

Appunti:

• si applicano scappatoie standard
• l'output può essere un elenco di stringhe, ma:
• non sono consentite nuove righe finali secondarie ( \nè accettabile la sola riga finale)
• l'output può essere un elenco di elenchi di caratteri, purché sembri piovere caratteri
• nessuna newline leader
• ai nostri utenti nordici che hanno qualche lettera in più nel loro alfabeto "AZ", non esitate a supportarli, ma non fa parte della sfida

6502 codice macchina (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

Demo online

Utilizzo: sys49152,"[string]" ad es sys49152,"Programming Puzzles & Code Golf!".

Importante: se il programma è stato caricato dal disco (come nella demo online), emettere newprima un comando! Ciò è necessario perché il caricamento di un programma macchina elimina alcuni puntatori BASIC C64.

Nota: il C64 è di default in una modalità senza lettere minuscole - per poter inserire una stringa in maiuscolo, passa prima alla modalità minuscola premendo SHIFT+ CBM.

Spiegazione

Ecco un elenco di smontaggio commentato:

         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×}ζ»,

Provalo online!

Spiegazione

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

.tm+*xGr0

Suite di test.

Spiegazione:

.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

(con la nuova riga finale)

Suite di test.

Spiegazione:

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)

Provalo online! Prende un elenco di caratteri. Restituisce un elenco di elenchi di caratteri.

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)

Provalo online! Prende una stringa. Restituisce una stringa.

Mathematica, 115 89 byte

Prende come inputun elenco di caratteri [{"a", "b", "c", "d", "a"}] e genera un elenco di elenchi di caratteri

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

Provalo online!

-26 byte da Misha Lavrov

-5 byte dall'utente202729

ma se vuoi vedere l'output così com'è nel test case, prova questo codice (128 byte)
Provalo online!

Dyalog APL , 27 22 byte

5 byte salvati grazie a @ Adám

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

Provalo online!

Come?

⍴¨⍨ - forma ogni carattere per lunghezza di

    1⌈ - almeno uno o

    ⎕A⍳819⌶⍨∘1 - indice del carattere maiuscolo in alfabeto

        27| - modulo 27

↑ - appiattire su una matrice

⍉ - e trasporre

Carbone , 12 byte

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

Provalo online!

-3 grazie a Neil .

Python, 105 103 byte

2 byte salvati grazie a @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()

Provalo online!

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

Provalo online!

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

Provalo online!

bash, 78 , 76 71 byte

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

A seconda delle regole di confronto (LC_ALL predefinito) è possibile salvare qualche altro byte

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

Provalo online

Perl 5 , 43 byte

41 byte codice + 2 per -nl.

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

Provalo online!

JavaScript (ES6), 87 78 76 byte

-9 byte grazie a @RickHitchcock .
-2 byte grazie a @Neil .

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

Prende l'input come stringa e ritorna con una nuova riga finale.

Casi test

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

Grazie a @Giuseppe per quei 4 byte di sconto

Provalo online!

Breve spiegazione:

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

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

Provalo online!

Stampa su stdout con una nuova riga finale e legge da stdin() .

Analizziamolo:

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
}

Risposta alternativa, 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='')

Provalo online!

Funzione; stampa su stdout ma fondamentalmente la mia risposta sopra riportata è accettata per accettare un elenco di caratteri piuttosto che dividere la stringa, quindi mi sento come se fosse "barare". Inoltre, l'approccio di plannapus con regex è abbastanza accurato!

Octave / MATLAB, 74 66 byte

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

Provalo online!

Japt , 15 14 11 10 byte

Prima possibilità di giocare con i nuovi metodi di imbottitura di corde di Japt, quindi potrebbero esserci ancora margini di miglioramento.

y_ùZInZu c

Provalo

Spiegazione

Immissione implicita della stringa U.

y_

Passa ogni colonna Uattraverso una funzione, dove si Ztrova l'elemento corrente (o la lettera, in questo caso).

InZu c

Converti Zin maiuscolo ( u), ottieni il suo charcode ( c) e sottrai ( u) 64 ( I).

ùZ

Riempi l'inizio di Zcon se stesso fino a raggiungere quella lunghezza.

Alternativa

y_ùZ9aZn36

Provalo

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

Provalo online!

Abbastanza a lungo ma non riesco a pensare ad alcun modo per accorciarlo ulteriormente. Sento che ci deve essere un modo più breve della sintassi if-then, ma non la vedo.

EDIT: Grazie @streetster per avermi aiutato a radere un byte! All'inizio non ho usato toUppera causa del costo di importazione, Data.Charma ho dimenticato che fornisce anche ordche è molto più breve difromEnum

EDIT 2: Grazie a @Laikoni per aver rasato altri 6 byte e aver identificato un bug che ora ho risolto. Ho usato 26 invece di 25 perché ho dimenticato che gli array Haskell sono inclusivi. Poi ho notato che avrei potuto usare lastinvece di quello headche mi avrebbe permesso di usare 0:piuttosto che ++[0].

EDIT 3: Grazie ancora Laikoni per quegli 8 byte. Mi ero davvero dimenticato di quello spazio. Per qualche motivo, Sublime Text esce senza di essa e ho dimenticato di rimuoverlo. Non sapevo che gli elenchi di righe fossero consentiti, avrei dovuto leggere le regole più attentamente.

Excel VBA, 110 byte

Anonimo VBE Funzione finestra immediata che accetta l'input come tipo previsto Variant\Stringdall'intervallo [A1]e lo utilizza per far piovere l'alfabeto nella finestra immediata di 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

I / O di esempio

[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
";

richiede PHP <7. Esegui come pipe -nRo provalo online .

Bash + sed, 37

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

Provalo online .

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

Provalo online!

Rubino, 70 67 74 byte

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

Grazie a @TuukkaX per aver segnalato alcune parentesi potrebbero essere eliminate (-3 byte)

Purtroppo ho dovuto aggiungere 7 byte perché la versione originale non è riuscita a gestire "z".

Chiamandolo:

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

Presuppone che la stringa sarà in una tabella tnella colonna 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 Fiddle

Oracle 11g R2 Schema Setup :

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

Query 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

Risultati :

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

Gelatina , 15 byte

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

Provalo online!

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

Provalo online!

Esempio di utilizzo: f "[Abc]"si ottiene un elenco di linee: ["[Abc]"," bc "," c "]. UsoputStr.unlines.f $ "[Abc]" per stampe piuttosto stampate:

[Abc]
  avanti Cristo
   c

In parte ispirato da Now direttamente sulla base della risposta Haskell dell'utente1472751 .

Approccio precedente ( 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]

Provalo online!

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

Provalo online!

Breve grazie a come PowerShell può eseguire il cast dinamico tra [char]e[int] , ma lungo a causa della rimozione di spazi bianchi estranei e del calcolo dell'output di uno spazio o del personaggio.

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

Spiegazione:

Provalo qui.

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 grazie a streetster!

vecchia soluzione + spiegazione:

{(+)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Χ∙┼

Provalo qui!

Spiegazione:

ā            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