Hacer un poco de lluvia del alfabeto

54

Lluvia del alfabeto

La tarea:

La premisa básica es imprimir la cadena de entrada y luego repetir cada carácter verticalmente, en función de su posición (indexada a 0) en el alfabeto (sin distinción entre mayúsculas y minúsculas) A-Z. Aestá en la ubicación 0, por lo que no se repite, eestá en la posición 4, se repite 4 veces, Pestá en la posición 15, se repite 15 veces, !no está en, A-Zse repite 0 veces, etc.

Para mayor claridad, cualquier cosa que quede fuera del rango B-Zb-z, por ejemplo, dígitos o caracteres especiales, no se repetirá y, por lo tanto, solo aparecerá en la primera línea.

Este es el , por lo que la solución más corta en cada idioma es el ganador.

Entrada:

  • La entrada estará en el juego de caracteres ASCII imprimible estándar, desde 32 hasta 126 ~.
  • La cadena de entrada tendrá 1 carácter o más.
  • No habrá espacios en blanco iniciales o finales.
  • Puede tomar la entrada de entrada como una cadena ( "hello") o una lista de caracteres ( ["h", "e", "l", "l", "o"])

Ejemplos:

Entrada de aaaada:

aaaa

Entrada de abcdada:

abcda
 bcd
  cd
   d

La entrada de Programming Puzzles & Code Golf!da:

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

La entrada de ~|[abc<0>cba]|~da:

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

Notas:

  • se aplican lagunas estándar
  • La salida puede ser una lista de cadenas, pero:
  • no se permiten saltos de línea extraños (se acepta un solo \nen la línea final)
  • la salida puede ser una lista de listas de caracteres, siempre y cuando parezca que está lloviendo caracteres
  • sin línea nueva
  • para nuestros usuarios nórdicos que tienen algunas letras adicionales en su alfabeto "AZ", siéntanse libres de apoyarlos, pero no es parte del desafío
callejero
fuente
2
¿Es aceptable un solo líder \n ?
Lynn
@ Lynn, no hay nuevas líneas principales, la primera línea debe ser la cadena de entrada / lista de caracteres. ¡Actualizaré la publicación!
streetter
18
FWIW, creo que se parecen más a carámbanos que a lluvia
caird coinheringaahing
@cairdcoinheringaahing suena casi festivo
Pureferret
:( Just Nordic?
ASCII-only

Respuestas:

22

Código de 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 pantalla

Demostración en línea

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

Importante: si el programa se cargó desde el disco (como en la demostración en línea), ¡emita newprimero un comando! Esto es necesario porque cargar un programa de máquina destruye algunos punteros BÁSICOS C64.

Nota: El C64 está por defecto en un modo sin letras minúsculas; para poder ingresar una cadena de mayúsculas y minúsculas, primero cambie al modo minúsculas presionando SHIFT+ CBM.


Explicación

Aquí hay un listado de desmontaje comentado:

         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
fuente
3
Código de máquina c64. Estoy impresionado.
Dschoni
@Dschoni, gracias, pero sigue siendo un código simple (¡y es divertido, para mí!) - deberías echar un vistazo a la escena de demostración para ver trabajos realmente impresionantes de C64;)
Felix Palmen
Si vamos a seguir obteniendo estos, es posible que queramos configurar enlaces a un emulador JavaScript C64 para que la gente pueda verlos ejecutarse.
Trlyly
1
@trlkly tengo dicho enlace en mi envío, haga clic en "Demo en línea";)
Felix Palmen
14

05AB1E , 13 12 bytes

,εDlAsk×}ζ»,

Pruébalo en línea!

Explicación

,             # 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
fuente
32
¿Necesita obtener el índice de char en minúsculas? solo Askpor eso
Uriel
8

Pyth, 12 10 9 bytes

.tm+*xGr0

Banco de pruebas.

Explicación:

.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

(con nueva línea al final)

Banco de pruebas.

Explicación:

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.
fuente
la salida puede ser una lista de listas de caracteres, siempre y cuando parezca que está lloviendo caracteres - Por lo tanto, no es necesarioj
Sr. Xcoder
Ah, tienes razon! Lo guardaba porque la versión de 12 bytes imprimía una línea literalmente y no podía mezclar los formatos así, y olvidé que podía eliminar eso ahora que todo está en la transposición. ¡Gracias!
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)

Pruébalo en línea! Toma una lista de personajes. Devuelve una 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)

Pruébalo en línea! Toma una cuerda. Devuelve una cadena.

Lynn
fuente
7

Mathematica, 115 89 bytes

Toma como inputuna lista de caracteres [{"a", "b", "c", "d", "a"}] y genera una lista de listas de caracteres

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

Pruébalo en línea!

-26 bytes de Misha Lavrov

-5 bytes del usuario202729

pero si desea ver el resultado tal como está en el caso de prueba, intente este código (128 bytes) ¡
Pruébelo en línea!

J42161217
fuente
Para futuros lectores: la parte "esta respuesta solo funciona en Mathematica ..." es un poco engañosa, el problema es que Mathematica solo admite caracteres Unicode en modo notebook (REPL). En el modo de secuencia de comandos , solo comprende ASCII y caracteres especiales que se han convertido a ASCII (por ejemplo, (3 bytes) -> \[Infinity](11 bytes)).
user202729
@ user202729 ok, editaré y me dirigiré a las personas para que lean tu comentario
Gracias
Sugerencia de golf para Mathematica (modo script): \[Infinity](11 bytes) se puede reemplazar por Infinity(8 bytes) o \:221e(6 bytes). La última es la representación predeterminada de caracteres especiales sin nombres. (aunque no es la parte principal)
user202729
Podemos evitar por Infinitycompleto. La parte problemática es If[(d=Min@Position[Alphabet[],If[UpperCaseQ@#,ToLowerCase@#,#]])==∞,1,d]y podemos cambiar esto a Max@Position[Alphabet[]/."a"->#,#|ToLowerCase@#]. (Al {#,b,c,d,...,y,z}buscar en la lista , se nos garantiza encontrar #al menos una vez.)
Misha Lavrov
@MishaLavrov muy agradable. ¡arreglado!
J42161217
6

Dyalog APL , 27 22 bytes

5 bytes guardados gracias a @ Adám

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

Pruébalo en línea!

¿Cómo?

⍴¨⍨ - dar forma a cada carácter a la longitud de

    1⌈ - al menos uno o

    ⎕A⍳819⌶⍨∘1 - índice del carácter en mayúsculas en alfabeto

        27| - módulo 27

- aplanar a una matriz

- y transponer

Uriel
fuente
@ Adám gracias! actualizado
Uriel
5

Python, 105 103 bytes

2 bytes guardados gracias 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()

Pruébalo en línea!

Uriel
fuente
103 bytes
TFeld
@TFeld buena captura, gracias!
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

Pruébalo en línea!

TFeld
fuente
whilepuede reemplazarse execpara ahorrar algunos bytes, ipuede comenzar con 65 para guardar más para alcanzar 87 bytes
Rod
El OP dice que no se permiten nuevas líneas finales extrañas , pero su código imprime varias de ellas cuando la entrada no contiene zo Z.
Lynn
@Lynn solucionado, olvidé verificar el execcambio ...
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;}

Pruébalo en línea!

Nejosan
fuente
2
Bienvenido a PPCG y buena primera respuesta. Puedes acortar tu código usando algunos trucos. Aquí hay una versión más golfizada de su código: ¡ Pruébelo en línea! .
Ian H.
Gracias por los comentarios, asumí que mi código tenía que ser ejecutable solo, ¡así que lo construí sobre esa suposición! Gracias por el comentario y la tutoría.
Nejosan
2
Si desea encontrar más trucos sobre cómo jugar golf en C #, eche un vistazo a esta publicación o eche un vistazo a las respuestas existentes de C #. ¡Feliz golf!
Ian H.
Buena respuesta. Sigue adelante :)
aloisdg dice Reinstate Monica
1
Hola, bienvenido a PPCG! Gran primera respuesta, especialmente ahora que se juega golf. +1 de mi parte Por cierto, que es actualmente de 180 bytes, no 162. La importación requerida using System.Linq;es obligatoria por desgracia añadir al byte-count (o debe cambiar Maxa System.Linq.Maxy Selecta System.Linq.Max, lo que sería más alta que simplemente using System.Linq;una vez.) Una vez más la bienvenida, y disfrutar de su estancia. Ah, y veo a @IanH. Consejos ya mencionados para jugar al golf en C #. Los consejos para jugar golf en <todos los idiomas> también pueden ser interesantes de leer.
Kevin Cruijssen
5

Bash, 78 , 76 71 bytes

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

Dependiendo de la clasificación (valor predeterminado LC_ALL) puede guardar algunos bytes más

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

Pruébalo en línea

Nahuel Fouilleul
fuente
4

Perl 5 , 43 bytes

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

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

Pruébalo en línea!

Dom Hastings
fuente
1
bucle para [_0-9] caracteres, tal vez s/["-$c]/ /giy -lno sea necesario
Nahuel Fouilleul
@NahuelFouilleul Ahh, sí, fui demasiado rápido en los casos de prueba. ¡Deben agregarse al OP! :) ¡Gracias! +4 :(
Dom Hastings
mi sugerencia no funciona para ningún personaje entre 32 y 126 (no alfa mayor que Z)
Nahuel Fouilleul
@NahuelFouilleul No puedo encontrar un camino más corto que cumpla con todos los requisitos ... Seguiré jugando ...
Dom Hastings
4

JavaScript (ES6), 87 78 76 bytes

-9 bytes gracias a @RickHitchcock .
-2 bytes gracias a @Neil .

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

Toma la entrada como una cadena y regresa con una nueva línea final.

Casos de prueba

Justin Mariner
fuente
76 bytes (una nueva línea final): f=(s,i=10)=>s.trim()&&s+'newline'+f(s.replace(/./g,c=>parseInt(c,36)-i?c:" "),i+1)
Rick Hitchcock
@RickHitchcock Eso parece un bucle infinito para una cadena de entrada que contiene números: ¡ Pruébelo en línea! . Sin sembargo, la idea de los cambios paso a paso es realmente agradable.
Justin Mariner
Ahh, buen punto. Eso se puede arreglar al costo de 2 bytes:parseInt(c,36)-i>0
Rick Hitchcock
1
@RickHitchcock ¿No puede usar parseInt(c,36)>ien su lugar para guardar 2 bytes?
Neil
@Neil, duh. Justin: Lo que dijo Neil. :)
Rick Hitchcock
4

R, 118114 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)}

Gracias a @Giuseppe por esos 4 bytes de descuento

Pruébalo en línea!

Breve explicació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)
    }
plannapus
fuente
ohhh, espera, posible problema: si ason todos los espacios, esto no imprimirá nada ... pero puedes cambiar la whilecondición a la grepl()|!Fque todavía es un byte más corto que tu respuesta 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='')

Pruébalo en línea!

Imprime en stdout con una nueva línea final y lee desde stdin().

Vamos a desglosarlo:

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
}

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

Pruébalo en línea!

Función; se imprime en stdout pero es básicamente mi respuesta anterior portada para aceptar una lista de caracteres en lugar de dividir la cadena, por lo que siento que es "trampa". Además, ¡el enfoque de plannapus con regex es bastante bueno!

Giuseppe
fuente
3

Japt , 15 14 11 10 bytes

Primera oportunidad de jugar con los nuevos métodos de relleno de cuerdas de Japt, por lo que aún puede haber margen de mejora.

y_ùZInZu c

Intentalo


Explicación

Entrada implícita de cadena U.

y_

Pase cada columna de a Utravés de una función, donde Zestá el elemento actual (o letra, en este caso).

InZu c

Convierta Za mayúsculas ( u), obtenga su charcode ( c) y reste ( u) 64 ( I).

ùZ

Acolche el comienzo de Zsí mismo hasta que alcance esa longitud.


Alternativa

y_ùZ9aZn36

Intentalo

Lanudo
fuente
Pero no podría cambiar ùZpara psalvar una b ... no importa, eso es muy inteligente ...
ETHproductions
@ETHproductions: Hice algunos intentos con p( puede haber 1 en el historial de edición) pero ùal final gané.
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]]

Pruébalo en línea!

Bastante largo, pero no se me ocurre ninguna forma de acortarlo más. Siento que debe haber algo más corto que la sintaxis if-then, pero no lo veo.

EDITAR: ¡Gracias @streetster por ayudarme a depilarme un byte! Al principio no lo usé toUpperdebido al costo de importación, Data.Charpero olvidé que también proporciona un valor ordmucho más corto quefromEnum

EDIT 2: Gracias a @Laikoni por eliminar otros 6 bytes e identificar un error que ahora he solucionado. Usé 26 en lugar de 25 porque olvidé que las matrices de Haskell son inclusivas. Entonces noté que podía usar en lastlugar de headlo que me permitiría usar en 0:lugar de ++[0].

EDITAR 3: Gracias de nuevo a Laikoni por esos 8 bytes. En realidad me había olvidado de ese espacio. Por alguna razón, Sublime Text se voltea sin él y olvidé eliminarlo. No sabía que se permitían listas de líneas, debería haber leído las reglas con más cuidado.

usuario1472751
fuente
1
¿Puede minúscula la entrada para evitar tener que verificar AZ, así como az y luego modificar?
streetter
@streetster En haskell, las funciones toLower y toUpper requieren importar Data.Char, que cuesta más caracteres de los que ahorra. TIO
user1472751
1
Es posible que desee echar un vistazo a los consejos para jugar al golf en Haskell . Por ejemplo, if i>p c then ' ' else cse puede acortar a last$c:[' '|i>p c].
Laikoni
Dos cosas más: hay un espacio innecesario [k | y está permitido devolver una lista de líneas, por lo que no es necesario unlines. Finalmente, puede interesarle nuestra sala de chat Haskell .
Laikoni
3

Excel VBA, 110 bytes

Función de ventana inmediata anónima de VBE que toma la entrada como tipo esperado Variant\Stringdel rango [A1]y la usa para hacer que llueva el alfabeto en la ventana inmediata de 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

Muestra de E / S

[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
fuente
¡¡¡Brutal!!! Parece que también puedes hacer?A1:...
LS_ᴅᴇᴠ
@ LS_ᴅᴇᴠ, desafortunadamente, como []indica que la cadena contenida se debe evaluar a un objeto en / on / as a workbook, la [A1]llamada no puede reducirse a A1, ya que esto no tomará e imprimirá la entrada inicial del rango [A1]; más bien, esto dejará una línea vacía y se imprimirán todas las líneas posteriores
Taylor Scott
Ups, tienes razón ... ¡No me di cuenta de esto!
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
";

requiere PHP <7. Ejecutar como tubería -nRo probarlo en línea .

Titus
fuente
@ Shaggy gracias por señalar. Está completo ahora.
Tito
+1 para $c=A;!$c[1];$c++. ¡Buena esa! Tristemente extraneous trailing newlines are not allowed (single \n on final line is acceptable). Por lo tanto, falla para todas las cadenas que no contienen z.
Christoph
1
@Christoph arreglado
Titus
3

Bash + sed, 37

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

Pruébalo en línea .

Trauma digital
fuente
parece que está repitiendo caracteres en el alfabeto 1-demasiadas veces
streetter
@streetster Creo que ya está arreglado.
Trauma digital
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);}}

Pruébalo en línea!

Felix Palmen
fuente
Prueba en puts("");lugar deputchar(10)
Conor O'Brien el
178 bytes
ceilingcat
2

Ruby, 70 67 74 bytes

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

Gracias a @TuukkaX por señalar que algunos parens podrían descartarse (-3 bytes)

Desafortunadamente, tuve que agregar 7 bytes porque la versión original no pudo manejar "z".

Llamándolo:

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
fuente
Los paréntesis en la definición lambda se pueden eliminar. +1.
Yytsi
2

Oracle SQL, 186 bytes

Asume que la cadena estará en una tabla ten la columna 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

Violín de SQL

Configuración del esquema de 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
fuente
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]]

Pruébalo en línea!

Ejemplo de uso: f "[Abc]"se obtiene una lista de líneas: ["[Abc]"," bc "," c "]. Uso putStr.unlines.f $ "[Abc]"para salida impresa bonita:

[A B C]
  antes de Cristo
   C

En parte inspirado por Now directamente basado en la respuesta Haskell del usuario 1472751 .


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

Pruébalo en línea!

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

Pruébalo en línea!

Un pequeño agradecimiento a cómo PowerShell puede emitir dinámicamente entre [char]y [int], pero largo debido a la eliminación de espacios en blanco extraños y al cálculo de si se debe generar un espacio o el carácter.

Bugfix gracias a beatcracker.

AdmBorkBork
fuente
Desafortunadamente, esto falla en el ~|[abc<0>cba]|~caso de prueba. Prueba esto:param($a)$a;(1..25|%{$i=$_;(-join([char[]]$a|%{(' ',$_)[$_-match'[a-z]'-and[math]::Max(0,($_-bor32)-96-$i)]})).TrimEnd()})-ne''
beatcracker
@beatcracker Buena captura. Esa es una forma inteligente de manejar la comparación. ¡Gracias!
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+$","");}

Explicación:

Pruébalo aquí

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
fuente
2

q , 42 37 bytes

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

-5 gracias a la calle!


antigua solución + explicación:

{(+)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
garabatear
fuente
1
{(+)max[m]$(m:1+mod[.Q.a?(_)x]26)#'x}para 37, no puedo recordar cómo lo resolví al crear la pregunta, ¡aunque probablemente sea muy similar!
StreetSter
@streetster, gracias! actualizado. no sabía de k _, escribí lowerel intérprete q y obtuve k){$[~t&77h>t:abs@@x;.z.s'x;19<t;.z.s@. x;~t in 10 11h;'`type;_x]}. por lo tanto, dar mi respuesta en q jaja
garabato
1

SOGL V0.12 , 12 11 bytes

ā,{Z⁴UW1Χ∙┼

Pruébalo aquí!

Explicación:

ā            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
fuente