Faça um pouco de chuva do alfabeto

54

Chuva de alfabeto

A tarefa:

A premissa básica é imprimir a sequência de entrada e depois repetir cada caractere verticalmente, com base em sua posição (indexada 0) no alfabeto (que não diferencia maiúsculas de minúsculas) A-Z. Aestá no local 0, então não se repete, eestá na posição 4, se repete 4 vezes, Pestá na posição 15, se repete 15 vezes, !não está no A-Zmodo se repete 0 vezes, etc.

Para maior clareza, qualquer coisa que esteja fora do intervalo B-Zb-z, por exemplo, dígitos ou caracteres especiais, não será repetida e, portanto, aparecerá apenas na primeira linha.

Esse é o , então a solução mais curta em cada idioma é a vencedora.

Entrada:

  • A entrada estará no conjunto de caracteres ASCII imprimível padrão, de 32 a 126 ~.
  • A sequência de entrada terá 1 caractere ou mais.
  • Não haverá espaços em branco à esquerda ou à direita.
  • Você pode usar a entrada como uma string ( "hello") ou uma lista de caracteres ( ["h", "e", "l", "l", "o"])

Exemplos:

Entrada de aaaadá:

aaaa

Entrada de abcdadá:

abcda
 bcd
  cd
   d

Entrada de 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

Entrada de ~|[abc<0>cba]|~, dá:

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

Notas:

  • lacunas padrão se aplicam
  • output pode ser uma lista de strings, mas:
  • novas linhas finais não são permitidas (uma única \nlinha final é aceitável)
  • saída pode ser uma lista de listas de caracteres, desde que pareça chover caracteres
  • nenhuma nova linha principal
  • para nossos usuários nórdicos que têm algumas letras extras no alfabeto "AZ", sinta-se à vontade para apoiá-los, mas isso não faz parte do desafio
rua
fonte
2
Uma única liderança é \n aceitável?
Lynn
@ Lynn, sem novas linhas principais, a primeira linha deve ser a lista de caracteres / caracteres de entrada - atualizarei a postagem!
streetster
18
FWIW, eu acho que eles parecem mais como pingentes de gelo do que chuva
caird coinheringaahing
sons @cairdcoinheringaahing quase festivo
Pureferret
:( Apenas nórdico?
somente ASCII

Respostas:

22

Código da máquina 6502 (C64), 113 bytes

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

captura de tela

Demonstração online

Uso: sys49152,"[string]" por exemplo sys49152,"Programming Puzzles & Code Golf!".

Importante: Se o programa foi carregado do disco (como na demonstração online), emita um newcomando primeiro! Isso é necessário porque o carregamento de um programa de máquina elimina alguns ponteiros C64 BASIC.

Nota: Por padrão, o C64 está em um modo sem letras minúsculas - para poder digitar uma sequência de maiúsculas e minúsculas, mude primeiro para o modo minúsculo pressionando SHIFT+ CBM.


Explicação

Aqui está uma lista de desmontagem comentada:

         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
Felix Palmen
fonte
3
código de máquina c64. Estou impressionado.
Dschoni
@Dschoni graças, mas ainda é código simples (e é divertido, para mim!) - você deve ter um olhar para a cena do demo para obras C64 realmente impressionante;)
Felix Palmen
Se continuarmos a obtê-los, convém configurar links para um emulador JavaScript C64 para que as pessoas possam vê-los sendo executados.
trlkly
11
@trlkly tenho essa ligação uma em minha submissão, clique em "Demonstração online";)
Felix Palmen
14

05AB1E , 13 12 bytes

,εDlAsk×}ζ»,

Experimente online!

Explicação

,             # 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
Emigna
fonte
32
Precisa obter o índice de caracteres no alfabeto minúsculo? apenas Askpara ele
Uriel
8

Pitão, 12 10 9 bytes

.tm+*xGr0

Suíte de teste.

Explicação:

.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 bytes:

j.t*VmxGr0d

(com nova linha à direita)

Suíte de teste.

Explicação:

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
Steven H.
fonte
saída pode ser uma lista de listas de personagens, desde que parece que está chovendo personagens - Assim você não precisaj
Mr. Xcoder
Ah, você está certo! Eu estava mantendo isso porque a versão de 12 bytes imprimia uma linha literalmente e não conseguia misturar os formatos assim, e esqueci que poderia removê-lo agora que tudo está na transposição. Obrigado!
Steven H.
8

Python 3 , 83 bytes

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

Experimente online! Leva uma lista de caracteres. Retorna uma lista de listas de caracteres.

Python 2 , 90 bytes

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

Experimente online! Toma uma corda. Retorna uma string.

Lynn
fonte
7

Mathematica, 115 89 bytes

Toma como inputuma lista de caracteres [{"a", "b", "c", "d", "a"}] e gera uma lista de listas de caracteres

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

Experimente online!

-26 bytes de Misha Lavrov

-5 bytes do usuário202729

mas se você quiser ver a saída como está no caso de teste, tente o código (128 bytes)
Experimente online!

J42161217
fonte
Para futuros leitores: A parte "esta resposta funciona apenas no Mathematica ..." é um pouco enganadora, o problema é que o Mathematica suporta apenas caracteres Unicode no modo notebook (REPL). No modo de script , ele entende apenas ASCII e caracteres especiais que foram convertidos em ASCII (por exemplo, (3 bytes) -> \[Infinity](11 bytes)).
user202729
@ user202729 ok, vou editar e direcionar as pessoas a lerem seu
comment.thanks #
Sugestão de golfe para o Mathematica (modo de script): \[Infinity](11 bytes) pode ser substituído por Infinity(8 bytes) ou \:221e(6 bytes). O último é a representação padrão de caracteres especiais sem nomes. (embora não seja a parte principal)
user202729 10/10
Nós podemos evitar Infinitycompletamente. A parte problemática é If[(d=Min@Position[Alphabet[],If[UpperCaseQ@#,ToLowerCase@#,#]])==∞,1,d]e podemos mudar isso para Max@Position[Alphabet[]/."a"->#,#|ToLowerCase@#]. (Procurando na lista {#,b,c,d,...,y,z}, que está garantido para encontrar #pelo menos uma vez.)
Misha Lavrov
@MishaLavrov very nice. consertou!
J42161217
6

Dyalog APL , 27 22 bytes

5 bytes salvos graças a @ Adám

⍉∘↑⊢⍴¨⍨127|⎕A819⌶⍨∘1

Experimente online!

Quão?

⍴¨⍨ - modele cada caractere para o comprimento de

    1⌈ - pelo menos um ou

    ⎕A⍳819⌶⍨∘1 - índice do caractere maiúsculo em alfabeto

        27| - módulo 27

- achatar para uma matriz

- e transpor

Uriel
fonte
@ Adám obrigado! atualizado
Uriel
5

Python, 105 103 bytes

2 bytes salvos graças 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()

Experimente online!

Uriel
fonte
103 bytes
TFeld 10/10
@TFeld boa captura, obrigado!
Uriel
5

Python 2 , 111 106 99 98 97 87 93 bytes

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

Experimente online!

TFeld
fonte
whilepode ser substituído por execpara salvar alguns bytes, ipode começar com 65 para salvar mais um para atingir 87 bytes #
1010 Rod Rod
O OP diz que novas linhas finais não são permitidas , mas seu código imprime várias delas quando a entrada não contém zou Z.
Lynn
@Lynn fixo, eu esqueci de verificar novamente a execmudança ...
TFeld
5

C # (.NET Core) , 162 bytes

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

Experimente online!

Nejosan
fonte
2
Bem-vindo ao PPCG e boa primeira resposta. Você pode encurtar seu código usando alguns truques. Aqui está uma versão mais elaborada do seu código: Experimente online! .
10247 Ian
Obrigado pelos comentários, presumi que meu código tivesse que ser executável por si só, então criei esse pressuposto! Obrigado pelo comentário e orientação.
Nejosan
2
Se você quiser encontrar mais alguns truques sobre como jogar golfe em C #, dê uma olhada nesta publicação ou nas respostas existentes em C #. Feliz golfe!
Ian H.
Boa resposta. Continue indo :)
aloisdg diz Reinstate Monica
11
Olá, seja bem-vindo ao PPCG! Ótima primeira resposta, especialmente agora que ele é jogado. +1 de mim. Atualmente, são 180 bytes, não 162. using System.Linq;Infelizmente, a importação necessária é obrigatória para adicionar à contagem de bytes (ou você deve alterar Maxpara System.Linq.Maxe Selectpara System.Linq.Max, o que seria maior do que apenas using System.Linq;uma vez.) Novamente, seja bem-vindo e aproveite a sua estadia. Ah, e vejo @IanH. já mencionado Dicas para jogar golfe em C #. Dicas para jogar golfe em <todos os idiomas> também podem ser interessantes para ler.
21717 Kevin Murrijssen 13:17
5

Bash, 78 , 76 71 bytes

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

Dependendo do agrupamento (padrão LC_ALL), você pode economizar mais alguns bytes

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

Experimente Online

Nahuel Fouilleul
fonte
4

Perl 5 , 43 bytes

Código de 41 bytes + 2 para -nl.

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

Experimente online!

Dom Hastings
fonte
11
loop para [_0-9] caracteres, talvez s/["-$c]/ /gie -lnão é necessário
Nahuel FOUILLEUL
@NahuelFouilleul Ahh, sim, eu fui um pouco rápido demais nos casos de teste. Eles devem ser adicionados ao OP! :) Obrigado! +4 :(
Dom Hastings
minha sugestão não funciona para todos os caracteres entre 32 e 126 (não maior do que alfa Z)
Nahuel FOUILLEUL
@NahuelFouilleul não consegue encontrar um caminho mais curto que atenda todos os requisitos ... Vou continuar a jogar ...
Dom Hastings
4

JavaScript (ES6), 87 78 76 bytes

-9 bytes graças a @RickHitchcock .
-2 bytes graças a @Neil .

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

Recebe a entrada como uma sequência e retorna com uma nova linha à direita.

Casos de teste

Justin Mariner
fonte
76 bytes (uma nova linha à direita): f=(s,i=10)=>s.trim()&&s+'newline'+f(s.replace(/./g,c=>parseInt(c,36)-i?c:" "),i+1)
Rick Hitchcock
@ RickHitchcock Parece um loop infinito para uma string de entrada contendo números: Experimente online! . A ideia de mudar passo a passo para sé realmente muito boa.
Justin Mariner
Ahh, bom argumento. Isso pode ser corrigido ao custo de 2 bytes:parseInt(c,36)-i>0
Rick Hitchcock
11
@ RickHitchcock Você não pode usar parseInt(c,36)>ipara salvar 2 bytes?
Neil
@ Neil, duh. Justin: O que Neil disse. :)
Rick Hitchcock
4

R, 118 114 bytes

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

Obrigado a @ Giuseppe por esses 4 bytes de desconto

Experimente online!

Breve explicação:

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)
    }
plannapus
fonte
ohhh, espere, problema em potencial: se ahouver todos os espaços, isso não imprimirá nada ... mas você pode alterar a whilecondição para a grepl()|!Fqual ainda é um byte menor que a resposta original.
Giuseppe
4

R , 125 123 bytes

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

Experimente online!

Imprime no stdout com uma única linha nova à direita e lê a partir de stdin().

Vamos dividir:

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
}

Resposta alternativa, 106 bytes

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

Experimente online!

Função; imprime em stdout, mas é basicamente minha resposta acima portada para aceitar uma lista de caracteres em vez de dividir a string, então eu sinto que está "trapaceando". Além disso, a abordagem do plannapus com o regex é bastante interessante!

Giuseppe
fonte
4

Oitava / MATLAB, 74 66 bytes

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

Experimente online!

Luis Mendo
fonte
3

Japonês , 15 14 11 10 bytes

Primeira chance de brincar com os novos métodos de preenchimento de cordas de Japt, para que ainda haja espaço para melhorias.

y_ùZInZu c

Tente


Explicação

Entrada implícita da sequência U.

y_

Passe cada coluna Uatravés de uma função, onde Zestá o elemento atual (ou letra, neste caso).

InZu c

Converta Zem maiúsculas ( u), obtenha seu código ( c) e subtraia ( u) 64 ( I).

ùZ

Almofada o início de Zsi mesmo até atingir esse comprimento.


Alternativa

y_ùZ9aZn36

Tente

Shaggy
fonte
Mas você não pode mudar ùZpara psalvar um b ... deixa
pra lá
@ETHproductions: Eu fiz algumas tentativas p( pode haver 1 no histórico de edições), mas ùvenci no final.
Shaggy
3

Haskell , 137 136 127 119 bytes

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

Experimente online!

Muito longo, mas não consigo pensar em nenhuma maneira de reduzi-lo ainda mais. Sinto que deve haver um pouco mais do que a sintaxe if-then, mas não a vejo.

EDIT: Obrigado @streetster por me ajudar a raspar um byte! Não usei toUpperno início por causa do custo de importação, Data.Charmas esqueci que ele também fornece ordum valor muito menor do quefromEnum

EDIT 2: Obrigado ao @Laikoni por remover outros 6 bytes e identificar um bug que eu corrigi agora. Eu usei 26 em vez de 25 porque esqueci que as matrizes Haskell são inclusivas. Então notei que eu poderia usar em lastvez do headque me permitiria usar em 0:vez de ++[0].

EDIT 3: Mais uma vez obrigado Laikoni por esses 8 bytes. Na verdade, eu tinha me esquecido daquele espaço. Por alguma razão, o Sublime Text sai sem ele e eu esqueci de removê-lo. Eu não sabia que listas de linhas eram permitidas, eu deveria ter lido as regras com mais cuidado.

user1472751
fonte
11
Você pode minúscula a entrada para evitar ter que verificar AZ e az e depois modificar?
Streetster 10/10
@streetster De maneira haskell, as funções toLower e toUpper exigem a importação do Data.Char, que custa mais caracteres do que economiza. TIO
user1472751 10/10
11
Você pode querer dar uma olhada nas dicas de golfe em Haskell . Por exemplo, if i>p c then ' ' else cpode ser reduzido para last$c:[' '|i>p c].
Laikoni
Mais duas coisas: há um espaço desnecessário [k | e o retorno de uma lista de linhas é permitido, portanto você não precisa do unlines. Finalmente, você pode estar interessado em nossa sala de bate-papo em Haskell .
Laikoni
3

Excel VBA, 110 bytes

Janela Imediata do VBE Anônimo Função que recebe a entrada do tipo esperado Variant\Stringdo intervalo [A1]e a utiliza para fazer chover o alfabeto na janela imediata do 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

E / S de amostra

[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 
Taylor Scott
fonte
Brutal!!! Ele emendas você também pode fazer?A1:...
LS_ᴅᴇᴠ
@ LS_ᴅᴇᴠ, infelizmente, como []indica que a cadeia contida deve ser avaliada para um objeto em / em / como uma pasta de trabalho, a [A1]chamada não pode ser reduzida para A1- pois isso não será necessário e imprimirá a entrada inicial do intervalo [A1]; em vez isso só vai deixar uma linha em branco e todas as linhas seguintes serão impressos
Taylor Scott
Ups, você está certo ... Não percebeu isso!
LS_ᴅᴇᴠ
3

PHP, 69 78 77 85 + 1 bytes

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

requer PHP <7. Execute como pipe -nRou experimente online .

Titus
fonte
@ Shaggy obrigado por apontar. Está completo agora.
Titus
+1 para $c=A;!$c[1];$c++. Agradável! Infelizmente extraneous trailing newlines are not allowed (single \n on final line is acceptable). Portanto, falha em todas as strings que não contêm z.
11407 Christoph
11
@Christoph corrigido
Titus
3

Bash + sed, 37

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

Experimente online .

Trauma Digital
fonte
parece que ele está repetindo caracteres do alfabeto 1 demasiado muitas vezes
streetster
@ streetster Acho que está consertado agora.
Digital Trauma
2

C (gcc) , 189 bytes

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

Experimente online!

Felix Palmen
fonte
Tente em puts("");vez deputchar(10)
Conor O'Brien
178 bytes
ceilingcat 21/08/18
2

Ruby, 70 67 74 bytes

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

Graças a @TuukkaX por apontar que algumas parênteses podem ser eliminadas (-3 bytes)

Infelizmente, tive que adicionar 7 bytes porque a versão original falhou ao manipular "z".

Chamando:

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
Neil Slater
fonte
Os parênteses na definição lambda podem ser removidos. +1.
Yytsi 10/10
2

Oracle SQL, 186 bytes

Assume que a string estará em uma tabela tna coluna 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

Configuração do esquema do Oracle 11g R2 :

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

Consulta 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

Resultados :

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

Haskell , 98 bytes

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

Experimente online!

Exemplo de utilização: f "[Abc]"produz uma lista de linhas: ["[Abc]"," bc "," c "]. Use putStr.unlines.f $ "[Abc]"para impressões bonitas:

[Abc]
  bc
   c

Em parte inspirado pelo Now, baseado diretamente na resposta de Haskell do usuário1472751 .


Abordagem anterior ( 100 99 bytes)

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

Experimente online!

Laikoni
fonte
2

PowerShell , 122 127 bytes

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

Experimente online!

Breve agradecimento à forma como o PowerShell pode transmitir dinamicamente entre [char]e [int], mas muito tempo por causa da remoção de espaço em branco estranho e do cálculo da saída de um espaço ou do caractere.

Correção de bug graças ao beatcracker.

AdmBorkBork
fonte
Infelizmente, isso falha no ~|[abc<0>cba]|~caso de teste. Tente isto:param($a)$a;(1..25|%{$i=$_;(-join([char[]]$a|%{(' ',$_)[$_-match'[a-z]'-and[math]::Max(0,($_-bor32)-96-$i)]})).TrimEnd()})-ne''
beatcracker 16/10
@beatcracker Boa captura. Essa é uma maneira inteligente de lidar com a comparação. Obrigado!
AdmBorkBork
2

Java 8, 151 147 144 143 139 bytes

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

Explicação:

Experimente aqui.

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
Kevin Cruijssen
fonte
2

q , 42 37 bytes

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

-5 graças ao streetster!


solução antiga + explicação:

{(+)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
rabisco
fonte
11
{(+)max[m]$(m:1+mod[.Q.a?(_)x]26)#'x}por 37 anos, não consigo lembrar como resolvi ao criar a pergunta, provavelmente muito parecida!
streetster 04/09
@ streetster, obrigado! Atualizada. não sabia sobre k _, digitei lowero interpretador q e consegui k){$[~t&77h>t:abs@@x;.z.s'x;19<t;.z.s@. x;~t in 10 11h;'`type;_x]}. por isso, dando a minha resposta em q haha
rabisco
1

SOGL V0.12 , 12 11 bytes

ā,{Z⁴UW1Χ∙┼

Experimente aqui!

Explicação:

ā            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
dzaima
fonte