Inspirado en un meme que vi hoy más temprano.

Descripción del desafío

Considere una cuadrícula de alfabeto infinito:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
...

Tome una palabra ( CODEGOLFen este ejemplo) y conviértala en una subsecuencia de la cuadrícula, reemplazando las letras no utilizadas por un espacio y eliminando las letras al final de la cuadrícula infinita por completo:

  C           O           
   DE G       O           
           L              
     F

Ejemplos

STACKEXCHANGE

                  ST      
A C       K               
    E                  X  
  C    H                  
A            N            
      G                   
    E

ZYXWVUTSRQPONMLKJIHGFEDCBA

                         Z
                        Y 
                       X  
                      W   
                     V    
                    U     
                   T      
                  S       
                 R        
                Q         
               P          
              O           
             N            
            M             
           L              
          K               
         J                
        I                 
       H                  
      G                   
     F                    
    E                     
   D                      
  C                       
 B                        
A

F

     F

ANTIDISESTABLISHMENTARIANISM

A            N     T      
        I                 
   D    I         S       
    E             ST      
AB         L              
        I         S       
       H    M             
    E        N     T      
A                R        
        I                 
A            N            
        I         S       
            M

Notas

• Se permiten espacios en blanco al final.
• No necesita rellenar la última línea con espacios. Por ejemplo, si la entrada es ABC, puede salir ABCsin 23 espacios finales.
• Puede suponer que la entrada coincidirá con la [A-Z]+expresión regular.
• Alternativamente, puede usar el alfabeto en minúsculas, en cuyo caso la salida coincidirá [a-z]+.
• Se debe utilizar una nueva línea ( \n, \r\no equivalente) a las líneas separadas, que es una lista de cadenas no es un formato de salida adecuado.
• Este es un desafío de código de golf , ¡así que haga su código lo más corto posible!

Casco , 15 bytes

TṪS`?' €…"AZ"ġ>

Pruébalo en línea!

Explicación

TṪS`?' €…"AZ"ġ>  Implicit input, e.g. "HELLO"
             ġ>  Split into strictly increasing substrings: x = ["H","EL","LO"]
        …"AZ"    The uppercase alphabet (technically, the string "AZ" rangified).
 Ṫ               Outer product of the alphabet and x
  S`?' €         using this function:
                   Arguments: character, say c = 'L', and string, say s = "EL".
       €           1-based index of c in s, or 0 if not found: 2
  S`?'             If this is truthy, then c, else a space: 'L'
                 This gives, for each letter c of the alphabet,
                 a string of the same length as x,
                 containing c for those substrings that contain c,
                 and a space for others.
T                Transpose, implicitly print separated by newlines.

Java 10, 161 159 152 bytes

s->{var x="";int p=0;for(var c:s)x+=p<(p=c)?c:";"+c;for(var y:x.split(";"))System.out.println("ABCDEFGHIJKLMNOPQRSTUVWXYZ".replaceAll("[^"+y+"]"," "));}

-2 bytes gracias a @Nevay .
-7 bytes de impresión directamente en lugar de devolver una Cadena y convertir a Java 10.

Explicación: "

Pruébalo aquí

s->{                      // Method with String parameter and no return-type
  var x="";               //  Temp-String
  int p=0;                //  Previous character (as integer), starting at 0
  for(var c:s)            //  Loop (1) over the characters of the input
    x+=p<(p=c)?           //   If the current character is later in the alphabet
                          //   (replace previous `p` with current `c` afterwards)
        c                 //    Append the current character to Temp-String `x`
       :                  //   Else:
        ";"+c;            //    Append a delimiter ";" + this character to Temp-String `x`
  for(var y:x.split(";")) //  Loop (2) over the String-parts
    System.out.println(   //   Print, with trailing new-line:
     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                          //    Take the alphabet,
        .replaceAll("[^"+y+"]"," "));}
                          //    and replace all letters not in the String-part with a space

La primera parte del método divide la palabra de entrada en partes con un delimitador.
Por ejemplo: CODEGOLF→ CO;DEGO;L;Fo BALLOON→ B;AL;LO;O;N.

La segunda parte recorre estas partes y usa la expresión regular [^...]para reemplazar todo lo que no coincide con un espacio.
Por ejemplo, .replaceAll("[^CO]"," ")deja el C, y O, y reemplaza todo lo demás con un espacio.

C (gcc) , 69 bytes

i;f(char*s){for(i=64;*s;putchar(*s^i?32:*s++))i+=i^90?1:puts("")-26;}

Pruébalo en línea!

Perl 5 , 44 bytes

Código de 40 bytes + 4 para -lF.

print map/$F[0]/?shift@F:$",A..Z while@F

Pruébalo en línea!

Python 2 , 92 bytes

f=lambda x,y=65:x and(y<=ord(x[0])and" "*(ord(x[0])-y)+x[0]+f(x[1:],-~ord(x[0]))or"\n"+f(x))

Pruébalo en línea!

JavaScript (ES6), 79

Editar Como se acepta una nueva línea principal, puedo guardar 2 bytes

s=>eval("for(o='',v=i=0;c=s.charCodeAt(i);v%=27)o+=v++?c-63-v?' ':s[i++]:`\n`")

Por 1 byte más, puedo aceptar entradas en minúsculas o mayúsculas:

s=>eval("for(o='',v=i=0;c=s[i];v%=27)o+=v++?parseInt(c,36)-8-v?' ':s[i++]:`\n`")

Menos golf

s=>{
  var i,o,c,v
  for(o = '', v = 1, i = 0; c = s.charCodeAt(i); v %= 27)
    o += v++ ? c-63-v ? ' ' : s[i++] : '\n'
  return o
}  

Prueba

f=s=>eval("for(o='',v=i=0;c=s.charCodeAt(i);v%=27)o+=v++?c-63-v?' ':s[i++]:`\n`")

function update() {
  var i=I.value
  i=i.replace(/[^A-Z]/gi,'').toUpperCase()
  O.textContent=f(i)
}

update()

<input id=I value='BALLOON' oninput='update()' >
<pre id=O></pre>

MATL , 24 23 bytes

''jt8+t1)wdh26X\Ys(26e!

Utiliza letras minúsculas.

¡Pruébalo en MATL Online!

Explicación

''     % Push empty string
jt     % Push input string. Duplicate
8+     % Add 8 to each char (ASCII code). This transforms 'a' 105,
       % 'b' into 106, which modulo 26 correspond to 1, 2 etc
t1)    % Duplicate. Get first entry
wd     % Swap. COnsecutive differences.
h      % Concatenate horizontally
26X\   % 1-based modulo 26. This gives a result from 1 to 26
Ys     % Cumulative sum
(      % Write values (converted into chars) at specified positions
       % of the initially empty string
26e    % Reshape into a 26-row char matrix, padding with char 0
!      % Transpose. Implicitly display. Char 0 is shown as space

Japt , 18 16 bytes

-2 bytes gracias a @Shaggy

;ò¨ £B®kX ?S:Z
·

Entrada en mayúscula solamente.

Pruébalo en línea!

Explicación

;

Cambie a variables alternativas, donde Bestá el alfabeto en mayúsculas.

ò¨

Divida la cadena de entrada entre caracteres donde el primero es mayor o igual que ( ¨) el segundo.

£

Asigne cada partición por la función, donde Xestá la partición actual.

B®

Asigna cada carácter del alfabeto en mayúscula a lo siguiente, Zsiendo la letra actual.

kX

Elimina todas las letras de la partición actual de la letra actual. Si la letra actual está contenida en la partición actual, esto da como resultado una cadena vacía.

?S:Z

Si eso es verdad (no una cadena vacía), devuelve un espacio ( S), de lo contrario devuelve la letra actual.

·

Une el resultado de la línea anterior con nuevas líneas e imprime el resultado.

Pyth, 18 bytes

#pbVGp?JqhzNNd=>zJ

Pruébalo aquí

Nueva línea inicial en salida, alfabeto en minúsculas.

Jalea , 19 bytes

<2\¬0;œṗfȯ⁶$¥€@€ØAY

Pruébalo en línea!

C (gcc), 91 63 bytes

-28 gracias a ASCII-only

_;f(char*s){for(_=64;*s;)putchar(++_>90?_=64,10:*s^_?32:*s++);}

Pruébalo en línea!

Anterior:

i,j;f(char*s){while(s[i]){for(j=65;j<91;j++)s[i]==j?putchar(s[i++]):printf(" ");puts("");}}

Sí, hay una solución más corta, pero me di cuenta después de escribir esta ... ¡ Pruébelo en línea!

Mathematica, 101 bytes

StringRiffle[
  Alphabet[]/.#->" "&/@
   (Except[#|##,_String]&@@@
     Split[Characters@#,#==1&@*Order]),"
",""]&

Splitla entrada en secuencias de letras estrictamente crecientes, comparando letras adyacentes con Order. Si Order[x,y] == 1, entoncesx precede yal alfabeto y, por lo tanto, puede aparecer en la misma línea.

Para cada secuencia de letras, cree un patrón para que coincida con las cadenas Exceptde esas letras; #|##es una abreviatura de Alternatives. Reemplace las letras Alphabetque coinciden con el patrón con espacios.

Ilustración de los pasos intermedios:

"codegolf";
Split[Characters@#,#==1&@*Order]  &@%
Except[#|##,_String]&@@@         #&@%
Alphabet[]/.#->" "&/@               %

{{"c", "o"}, {"d", "e", "g", "o"}, {"l"}, {"f"}}

{Except["c" | "c" | "o", _String], 
 Except["d" | "d" | "e" | "g" | "o", _String], 
 Except["l" | "l", _String],
 Except["f" | "f", _String]}

{{" "," ","c"," "," "," "," "," "," "," "," "," "," "," ","o"," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," ","d","e"," ","g"," "," "," "," "," "," "," ","o"," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," "," "," "," "," "," "," "," "," ","l"," "," "," "," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," "," "," ","f"," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "}}

Golfscript, 22 21 bytes

Pruébalo en línea!

-1 byte gracias a la cuidadosa redefinición final del nincorporado.

{.n>{}{'
'\}if:n}%:n;

Explicación (con una versión ligeramente diferente):

{.n>{}{"\n"\}if:n}%:n; # Full program
{                }%    # Go through every character in the string
 .n>         if        # If ASCII code is greater than previous...
                       # (n means newline by default, so 1st char guaranteed to fit)
    {}                 # Do nothing
      {"\n"\}          # Else, put newline before character
               :n      # Redefine n as the last used character
                   :n; # The stack contents are printed at end of execution
                       # Literally followed by the variable n, usually newline
                       # So because n is by now an ASCII code...
                       # ...redefine n as the new string, and empty the stack

Retina , 80 bytes

^
;¶
{`;.*
¶;ABCDEFGHIJKLMNOPQRSTUVWXYZ
¶¶
¶
)+`;(.*)(.)(.*¶)\2
$.1$* $2;$3
;.*

Pruébalo en línea!

Siempre hay exactamente una nueva línea principal. El código un poco torpemente antepone la palabra con el alfabeto junto con un marcador (punto y coma). Luego mueve el marcador hasta la primera letra de la palabra, mientras cambia todas las demás letras que pasa a espacios. También elimina la primera letra de la palabra. Repite esto hasta que la primera letra de la palabra ya no esté detrás del marcador. Luego borra ese marcador y el resto del alfabeto, y lo reemplaza con una nueva línea y el alfabeto con un marcador nuevamente. Sigue repitiendo esto hasta que la palabra de entrada esté vacía, luego limpia el último alfabeto y marcador, dejando la salida deseada.

05AB1E , 18 bytes

ćIgµ¶?AvDyÊið?ë¼?ć

Pruébalo en línea!

Tengo problemas con 05AB1E ć(extracto 1) dejando una cadena / lista vacía en la pila después de extraer el último elemento. Esta solución sería 1-2 bytes más corta si no fuera por eso.

ćIgµ¶?AvDyÊið?ë¼?ć  Implicit input 
ć                   Extract the 1st char from the string
 Igµ                While counter != length of the string
    ¶?              Print a newline
      Av            For each letter of the lowercased alphabet
        DyÊ         Is the examined character different from the current letter?
           ið?      If true, then print a space

              ë¼?ć  Else increment the counter, print the letter and push
                    the next character of the string on the stack

Retina , 130 126 bytes

$
¶A
{-2=`
$'
}T`RL`_o`.$
+`(?<=(.)*)((.).*¶(?<-1>.)*(?(1)(?!)).+\3.*$)
 $2
(?<=(.)*)((.).*¶(?<-1>.)*(?<-1>\3.*$))
¶$2
}`¶.*$

Pruébalo en línea! Editar: Guardado 4 bytes usando el generador de alfabeto de @ MartinEnder. Explicación:

$
¶A
{-2=`
$'
}T`RL`_o`.$

Añade el alfabeto.

+`(?<=(.)*)((.).*¶(?<-1>.)*(?(1)(?!)).+\3.*$)
 $2

Alinee tantas letras como sea posible con su posición en el alfabeto.

(?<=(.)*)((.).*¶(?<-1>.)*(?<-1>\3.*$))
¶$2

Comience una nueva línea antes de la primera letra que no se pudo alinear.

}`¶.*$

Elimine el alfabeto, pero luego haga todo de nuevo hasta que no haya letras desalineadas.

q / kdb + , 48 45 bytes

Solución:

-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:;

Pruébalo en línea!

Nota: El enlace es a una K (oK) puerto de esta solución ya que no hay TIO para q / kdb +.

Ejemplos:

q)-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:"STACKEXCHANGE";
                  ST
A C       K
    E                  X
  C    H
A            N
      G
    E

q)-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:"BALLOON";
 B
A          L
           L  O
              O
             N

Explicación:

Q se interpreta de derecha a izquierda. La solución se divide en dos partes. Primero divida la cadena donde el siguiente carácter es menor o igual que el actual:

"STACKEXCHANGE" -> "ST","ACK","EX","CH","AN","G","E"

Luego tome una cadena de 26 espacios en blanco y aplique la entrada en los índices donde la entrada aparece en el alfabeto, e imprima en stdout.

"__________________________" -> __________________ST______

Descompostura:

-1{@[26#" ";.Q.A?x;:;x]}each(0,where (<=':)x) cut x:; / ungolfed solution
-1                                                  ; / print to stdout, swallow return value
                                                  x:  / store input as variable x
                                              cut     / cut slices x at these indices
                            (               )         / do this together
                                     (<=':)x          / is current char less-or-equal (<=) than each previous (':)?
                               where                  / indices where this is true
                             0,                       / prepended with 0
                        each                          / take each item and apply function to it
  {                    }                              / lambda function with x as implicit input
   @[      ;      ; ; ]                               / apply[variable;indices;function;arguments]
     26#" "                                           / 26 take " " is "      "...
            .Q.A?x                                    / lookup x in the uppercase alphabet, returns indice(s)
                   :                                  / assignment
                     x                                / the input to apply to these indices

Notas:

• -3 bytes reemplazando prev con la versión K4

Powershell, 70 63 bytes

-7 bytes gracias @Veskah

$args|%{if($_-le$p){$x;rv x}
$x=("$x"|% *ht($_-65))+($p=$_)}
$x

Pruébalo en línea!

Explicación:

Para cada personaje en el argumento salpicado:

• Cadena de salida $xy $xvalor claro ( rves alias para Remove-Variable ), si un código del carácter actual es menor o equivalente (-le ) a un código del carácter anterior.
• Agregue espacios y el carácter actual a $x, almacénelo en $x. También refresca un valor de carácter anterior.

Salida al final $x.

Jalea , 24 21 bytes

3 bytes gracias a Erik the Outgolfer.

O64;I%26’⁶ẋЀ;"⁸Ẏs26Y

Pruébalo en línea!

SOGL V0.12 , 22 bytes

±E⁄Z*{@;eJι=?Xē}}¹∑z⁄n

Pruébalo aquí!

JavaScript (ES6), 87 bytes

f=([...s])=>s[0]?(g=i=>i>35?`
`+f(s):(i-parseInt(s[0],36)?" ":s.shift())+g(i+1))(10):""

Acepta entradas en mayúsculas o minúsculas. La salida coincide con el caso de la entrada.

Pruebas

f=([...s])=>s[0]?(g=i=>i>35?`
`+f(s):(i-parseInt(s[0],36)?" ":s.shift())+g(i+1))(10):""

;O.innerText=["CODEGOLF","STACKEXCHANGE","F","ZYXWVUTSRQPONMLKJIHGFEDCBA","ANTIDISESTABLISHMENTARIANISM"]
.map(f).join("=".repeat(26)+"\n")

<pre id=O>

Haskell, 81 74 73 bytes

q@(w:y)!(x:z)|w==x=x:y!z|1<2=min ' 'x:q!z
x!_=x
a=['A'..'Z']++'\n':a
(!a)

¡Guardado 1 byte gracias a Laikoni !

Pruébalo en línea.

Optimizaciones de Haskell Hugs

1. El intérprete de Hugs me permite guardar un byte más haciendo en (!cycle$['A'..'Z']++"\n")lugar de: (!cycle(['A'..'Z']++"\n"))pero a GHC no le gusta el primero . (Esto ahora es obsoleto; Laikoni ya reescribió esa línea de una manera que ahorró 1 byte).

2. Aparentemente, Hugs tampoco requiere paréntesis alrededor del patrón de lista, por lo que podría guardar dos bytes más yendo de: q@(w:y)!(x:z)a q@(w:y)!x:z.

Python 3 , 87 85 bytes

def f(s,l=65):c,*t=s;o=ord(c)-l;return o<0and'\n'+f(s)or' '*o+c+(t and f(t,o-~l)or'')

Pruébalo en línea!

J , 39 bytes

(_65+3 u:[)}&(26{.'')/.~0+/\@,2>:/\3&u:

Pruébalo en línea!

Carbón de leña , 15 bytes

Ｆθ«Ｊ⌕αι⁺ⅉ‹⌕αιⅈι

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 θ              Input string
Ｆ «             Loop over characters
     α     α    Uppercase letters predefined variable
      ι     ι   Current character
    ⌕     ⌕     Find index
             ⅈ  Current X co-ordinate
         ‹      Compare
        ⅉ       Current Y co-ordinate
       ⁺        Sum
   Ｊ            Jump to aboslute position
              ι Print current character

APL (Dyalog Classic) , 20 bytes

⊃¨⎕a∘.∩⍨⊢⊂⍨1,2≥/⎕a⍳⊢

Pruébalo en línea!

K (ngn / k) , 29 28 bytes

{{x@x?`c$65+!26}'(&~>':x)_x}

Pruébalo en línea!

{ } funcionar con argumento x

>':x para cada personaje, ¿es mayor que el personaje anterior?

~ negar

& ¿Dónde (en qué índices) tenemos verdad

( )_xcortar xesos índices, devolver una lista de cadenas

{ }' para cada una de esas cuerdas

`c$65+!26

el alfabeto inglés

x?encuentre el índice de la primera aparición de cada letra x, use 0N(un valor "nulo" especial) si no se encuentra

x@indice xcon eso; indexación con 0Nretornos " ", por lo que obtenemos una cadena de longitud 26 en la que las letras xestán en sus posiciones alfabéticas y todo lo demás son espacios

R , 129117 bytes

function(s){z={}
y=diff(x<-utf8ToInt(s)-64)
z[diffinv(y+26*(y<0))+x[1]]=LETTERS[x]
z[is.na(z)]=" "
write(z,1,26,,"")}

Pruébalo en línea!

Explicación (sin golf):

function(s){
 z <- c()                  # initialize an empty vector
 x <- utf8ToInt(s)-64      # map to char code, map to range 1:26
 y <- diff(x)              # successive differences of x
 idx <- cumsum(c(          # indices into z: cumulative sum of:
    x[1],                  # first element of x
    ifelse(y<=0,y+26,y)))  # vectorized if: maps non-positive values to themselves + 26, positives to themselves
 z[idx] <- LETTERS[x]      # put letters at indices
 z[is.na(z)] <- " "        # replace NA with space
 write(z,"",26,,"")        # write z as a matrix to STDOUT ("") with 26 columns and empty separator.

R , 95 bytes

Simplemente recorra el alfabeto en mayúsculas repetidamente mientras avanza un contador en 1 si encuentra la letra en la posición del contador de la palabra e imprime la letra, un espacio en caso contrario.

function(s)while(F>""){for(l in LETTERS)cat("if"((F=substr(s,T,T))==l,{T=T+1;l}," "));cat("
")}

Pruébalo en línea!

GolfScript , 37 bytes

64:a;{.a>{}{'
'\64:a;}if.a-(' '*\:a}%

Pruébalo en línea!

Hice un Golfscript con un nombre diferente, pero tenía una salida incorrecta.