Debido a limitaciones técnicas de Stack Exchange, el título se representa incorrectamente. El título correcto para este desafío es

Hacer una

Word Icicle!
Word Icicle 
Word  cicle 
 ord  cicle 
 ord   icle 
 ord   i le 
 or    i le 
 or    i l  
 or      l  
 or         
  r         

El desafío de hoy es hacer carámbanos con la palabra de entrada. Dada una cadena de ASCII completamente imprimible , y al menos 2 caracteres que no sean espacios, realice los siguientes pasos:

1. Imprime el estado actual de la cadena.

2. Reemplace el carácter léxicamente más pequeño (que no sea espacios) con un espacio. Si hay un empate, reemplace el carácter más a la izquierda.

3. Repita en líneas consecutivas hasta que la cadena contenga solo 1 carácter no espacial.

Esto crea el efecto de que la cadena de entrada parece que se está derritiendo ...

I'm Melting!!!
I'm Melting !!
I'm Melting  !
I'm Melting   
I m Melting     
  m Melting   
  m  elting   
  m   lting   
  m   ltin    
  m   lt n    
  m    t n    
       t n    
       t      

Reglas

• Después de un par de iteraciones, su salida seguramente tendrá espacios finales en cada línea. Si elige truncarlos, eso está permitido.

• Puede tener una línea vacía al final, pero no más.

• Recuerde que la entrada puede contener varios espacios, pero estos se omiten de manera efectiva. Por ejemplo, la entrada a adebería dar

  a      a
         a
  

• Puede tomar la entrada como una lista de cadenas si lo desea. Para la salida, puede devolver o imprimir una lista de cadenas, una sola cadena con nuevas líneas o matriz de caracteres / matriz 2D. En general, prefiero los formatos IO permisivos, por lo que es probable que otros formatos estén permitidos siempre que sean consistentes y se correspondan claramente con la salida correcta. En caso de duda, no dude en preguntar. Como de costumbre, se permiten programas o funciones completos.

• ¡Recuerde, este es un concurso para hacer la respuesta más corta en cualquier idioma! Si elige responder en Java, intente hacer la respuesta Java más corta (en bytes) que pueda.

Casos de prueba

Hello World! -->

Hello World!
Hello World 
 ello World 
 ello  orld 
 ello  orl  
  llo  orl  
   lo  orl  
    o  orl  
    o  or   
       or   
        r   


AbCdEfGhIjKlMnOpQrStUvWxYz -->

AbCdEfGhIjKlMnOpQrStUvWxYz
 bCdEfGhIjKlMnOpQrStUvWxYz
 b dEfGhIjKlMnOpQrStUvWxYz
 b d fGhIjKlMnOpQrStUvWxYz
 b d f hIjKlMnOpQrStUvWxYz
 b d f h jKlMnOpQrStUvWxYz
 b d f h j lMnOpQrStUvWxYz
 b d f h j l nOpQrStUvWxYz
 b d f h j l n pQrStUvWxYz
 b d f h j l n p rStUvWxYz
 b d f h j l n p r tUvWxYz
 b d f h j l n p r t vWxYz
 b d f h j l n p r t v xYz
 b d f h j l n p r t v x z
   d f h j l n p r t v x z
     f h j l n p r t v x z
       h j l n p r t v x z
         j l n p r t v x z
           l n p r t v x z
             n p r t v x z
               p r t v x z
                 r t v x z
                   t v x z
                     v x z
                       x z
                         z


PPCG is da BEST --> 

PPCG is da BEST
PPCG is da  EST
PP G is da  EST
PP G is da   ST
PP   is da   ST
 P   is da   ST
     is da   ST
     is da    T
     is da     
     is d      
     is        
      s        


({({})({}[()])}{}) -->

({({})({}[()])}{})
 {({})({}[()])}{})
 { {})({}[()])}{})
 { {}) {}[()])}{})
 { {}) {}[ )])}{})
 { {}  {}[ )])}{})
 { {}  {}[  ])}{})
 { {}  {}[  ] }{})
 { {}  {}[  ] }{} 
 { {}  {}   ] }{} 
 { {}  {}     }{} 
   {}  {}     }{} 
    }  {}     }{} 
    }   }     }{} 
    }   }     } } 
        }     } } 
              } } 
                } 

Python 2 , 71 70 bytes

^{-1 byte gracias a ovs}

x=input()
while x.strip():print x;r=x.replace;x=r(min(r(*' ~')),' ',1)

Pruébalo en línea!

Retina , 28 bytes

/\S/+¶<~(O`.
0L$`\S
0`$\$&¶ 

Pruébalo en línea! Explicación:

/\S/+

Repita mientras el valor de entrada no esté en blanco.

¶<

Imprime el valor actual.

~(

Ejecute el resto del script en el valor. Luego, ejecute el resultado de ese script como un script en el valor.

O`.

Ordena los personajes en orden.

0L$`\S
0`$\$&¶ 

Seleccione el primer carácter no en blanco y genere un programa Retina que reemplace la primera $\aparición literal ( ) de ese carácter ( $&) con un espacio (espacio final en el código original).

APL (Dyalog Unicode) , 18 11 bytes

∪∘↓∘⍉⍋∘⍋⍴⌸⊢

Pruébalo en línea!

usos ⎕io←1; devuelve una matriz de cadenas (vector de vectores de caracteres)

05AB1E , 9 bytes

ðм{v=yð.;

Pruébalo en línea!

Explicación

ð      # Push space
м      # Implicit input. Remove spaces
{      # Sort. Gives string of sorted, non-space chars
v      # For each char in that string
  =    #   Print latest string, without popping. The first time it prints the input
  y    #   Push current char
  ð    #   Push space
  .;   #   Replace first occurrence of current char by space
       # Implicitly end for-each loop

Pyth, 17 14 13 bytes

V-SQdQ=XQxQNd

Pruébalo aquí

V-SQdQ=XQxQNd
V-SQd              For each non-space character in the sorted input (Q)...
     Q             ... print the current value of Q...
      = Q          ... and set Q to itself...
         xQN       ... with the first instance of the character...
       X    d      ... replaced by a space.

sed -rn , 142143 bytes

:a
p
s/$/	ABCDEFGHIJKLMNOPQRSTUVWXYZ/
s	\w+$	!"#$%\&'()*+,-./0123456789:;<=>?@&[\\]^_`\L&{|}~	
:b
/(.).*	\1/!s/	./	/
tb
s/(.)(.*)	\1.*/ \2/
ta

Pruébalo en línea!

(nota: hay pestañas en el programa)

Como sed no tiene el concepto de orden lexicográfico, tuve que codificar el conjunto de caracteres ASCII imprimibles y ocupa más de la mitad del bytecount.

Usar sed 4.2.2 reducirá el bytecount en 2, ya que eso permite etiquetas sin nombre, ¡ Pruébelo en línea!

-r habilita expresiones regulares extendidas (golfier)

-n deshabilita la impresión implícita del espacio del patrón al final del programa

El espacio del patrón comienza con la entrada

:aetiqueta a, este es el ciclo principal del programa

p imprime el espacio del patrón (nombre elegante para el búfer)

ahora agregamos el conjunto de caracteres ASCII imprimibles (excluyendo el espacio)

s/$/ ABCDEFGHIJKLMNOPQRSTUVWXYZ/ agregar una pestaña, que actúa como delimitador de 1 byte, seguido del alfabeto en mayúsculas

s<tab>sustituto (sed puede tomar cualquier carácter como delimitador, en este caso, la pestaña se usa para evitar que un byte escape del /)

• \w+$ el alfabeto en mayúscula que acabamos de agregar

• <tab> con

• !"#$%\&'()*+,-./0123456789:;<=>?@&[\\]^_\`\L&{|}~<tab>el resto de los caracteres, tenga en cuenta que \L&es la versión en minúsculas del alfabeto en mayúsculas

:betiqueta b, eliminar caracteres del conjunto inicial que no están presentes en la entrada

/(.).* \1/! si el primer carácter del conjunto ASCII no está en la entrada

• s/ ./ / eliminarlo

tbrepetir bhasta que la sustitución falle

s/(.)(.*) \1.*/ \2/ reemplace el primer carácter en el conjunto ASCII presente en la entrada con un espacio y elimine el conjunto ASCII

ta recurse

Ruby , 60 58 55 47 bytes

->a{[-a]+a.scan(/\S/).sort.map{|x|a[x]=' ';-a}}

Pruébalo en línea!

R , 140100 bytes

-40 bytes ¡Gracias a Giuseppe!

function(x)for(i in any((z=utf8ToInt(x))<33):max(y<-rank(z,,"f"))){z[y==i]=32
cat(intToUtf8(z),"
")}

Pruébalo en línea!

Una solución que utiliza outery la magia de Giuseppe para funcionar correctamente es más larga en 104 bytes. Inspirado por esta respuesta .

function(x,z=utf8ToInt(x)-32)apply(t(outer(rank(z,,"f"),(2-(min(z)>0)):nchar(x),">=")*z+32),1,intToUtf8)

Pruébalo en línea!

Python 3 , 71 bytes

f=lambda a:[*a.strip()]and[a]+f(a.replace(min(a.replace(*" ~"))," ",1))

Pruébalo en línea!

-4 bytes gracias a ovs

Python 2 , 70 69 66 64 bytes

def f(s):print s;S=set(s)-{' '};S and f(s.replace(min(S),' ',1))

Pruébalo en línea!

Thx para 2 bytes desde ovs mediante el uso en S and f()lugar deif S:f()

Jalea , 8 bytes

ẋ"ỤỤ$z⁶Q

Pruébalo en línea!

Idea

La idea básica es construir las columnas de la salida deseada directamente, en lugar de manipular la cadena y devolver todos los resultados intermedios.

Comenzamos numerando los caracteres de la cadena de entrada en el orden en que se eliminarán. Por el momento, fingiremos que también se eliminarán los espacios.

tee ay oh
845139276

Ahora, construimos las columnas repitiendo cada carácter por su índice en esta enumeración.

tee ay oh
tee ay oh
tee ay oh
tee  y oh
t e  y oh
t    y oh
t    y o 
t    y   
     y   

Todo lo que queda es eliminar duplicados, para tener en cuenta los espacios.

Código

ẋ"ỤỤ$z⁶Q  Main link. Argument: s (string)

    $     Combine the two links to the left into a chain.
  Ụ       Grade up; sort the indices of s by their corresponding values.
          Let's call the result J.
          Grade up again, sorting the indices of J by the corr. values in J.
          This enumerates the positions of s as described before.
ẋ"        Repeat each character of s that many times.
     z⁶   Zip the resulting 2D array, filling missing characters with spaces.
       Q  Unique; deduplicate the array of rows.

Perl 5 -n , 37 34 bytes

Se eliminaron tres bytes con la ayuda de @TonHospel

say&&s/\Q$a/ / while($a)=sort/\S/g

Pruébalo en línea!

JavaScript, 67 66 65 bytes

¡Porque no he jugado golf borracho en mucho tiempo!

s=>[...t=s].sort().map(x=>x>` `?t+=`
${s=s.replace(x,` `)}`:0)&&t

Pruébalo en línea

¡Gracias a DanielIndie por señalar 4 bytes redundantes que incluye la cerveza!

K (ngn / k) , 26 24 bytes

{?(,x),x{x[y]:" ";x}\<x}

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 129 bytes

var s=ReadLine();while(s.Any(c=>c!=32)){WriteLine(s);var i=s.IndexOf(s.Min(c=>c==32?(char)999:c));s=s.Remove(i,1).Insert(i," ");}

Pruébalo en línea!

Perl 5 con -nlF/\s|/, 39 bytes

@F=sort@F;say,s~\Q$F[$F++]~ ~ while/\S/

Esto podría estar empujando los límites de las banderas de Perl que no se cuentan, si es así, volveré a la respuesta anterior.

Pruébalo en línea!

Haskell , 67 bytes

12 bytes guardados gracias a Laikoni

f s|(a,_:b)<-span(/=minimum(id=<<words s))s=putStrLn s>>f(a++' ':b)

Pruébalo en línea!

Este termina en un error

Haskell , 83 79 bytes

g(a,_:b)=a++' ':b
mapM_ putStrLn.(iterate$g.(span=<<(/=).minimum.concat.words))

Pruébalo en línea!

Este termina en un error

Haskell , 86 bytes

u=concat.words
g(a,_:b)=a++' ':b
(take.length.u)<*>(iterate$g.(span=<<(/=).minimum.u))

Pruébalo en línea!

Haskell , 100 91 88 bytes

u=concat.words
f x|(a,_:b)<-span(/=minimum(u x))x=a++' ':b
(take.length.u)<*>(iterate f)

Pruébalo en línea!

JavaScript (Node.js) , 80 65 bytes

x=>[...x].sort().map(c=>x=x.replace(c,' ',c>' '&&console.log(x)))

Pruébalo en línea!

No sabía replacetomar string como string, no regexp

K4 , 28 20 18 bytes

Solución:

?x{x[y]:" ";x}\<x:

Ejemplo:

q)k)?x{x[y]:" ";x}\<x:"PPCG is da BEST"
"PPCG is da BEST"
"PPCG is da  EST"
"PP G is da  EST"
"PP G is da   ST"
"PP   is da   ST"
" P   is da   ST"
"     is da   ST"
"     is da    T"
"     is da     "
"     is d      "
"     is        "
"      s        "
"               "

Explicación:

Es lo mismo que ngn está haciendo. Busque índices que den como resultado una lista ascendente, sobrescríbalos uno por uno " ", luego tome el distintivo para eliminar las líneas duplicadas:

?x{x[y]:" ";x}\<x: / the solution
                x: / save input as x
               <   / return indices that would result in ascending sort
 x{        ; }\    / two-line lambda with scan
        " "        / whitespace
       :           / assignment
   x[y]            / x at index y
            x      / return x
?                  / distinct

gcc 32 bits, 66 65 bytes

char*p,i;f(a){for(i=32;i++;)for(p=a;*p;)*p==i?puts(a),*p=32:++p;}
main(){char s[]="3.1415926";f(s);}

Gracias por Jonathan Frech por -1 byte

MATLAB, 74 bytes

Esto utiliza la forma de 2 salidas de la función max () para recuperar el carácter más pequeño y su índice, transformando la cadena a valores cero en los espacios y 256-el valor del carácter para los caracteres imprimibles.

s=input('s');x=1;while(x);disp(s);[x,y]=max((256-s).*(s~=' '));s(y)=' ';end

Lisp común , 240 228 224 bytes

(setf s(read))(defun f(x)(setf y(char-code(elt s x)))(if(= y 32)1e9 y))(loop for _ across s do(print s)do(setf s(replace s" ":start1(position(code-char(reduce #'min (loop for i from 0 below(length s)collect i):key #'f))s))))

Pruébalo en línea!

Es mi primera vez publicando.
Estoy en el proceso de aprender lisp, así que estoy seguro de que alguien puede pensar en algo más corto que esto.

APL (Dyalog Unicode) , ^{SBCS de} 39 bytes

{⎕←⍵⋄×≢⍵∩g←' '~⍨⎕UCS⍳256:∇' '@(⊃g⍋⍵)⊢⍵}

Pruébalo en línea!

Dfn.

¿Cómo?

{⎕←⍵⋄×≢⍵∩g←' '~⍨⎕UCS⍳256:∇' '@(⊃g⍋⍵)⊢⍵} ⍝ Main function, argument ⍵
 ⎕←⍵⋄                                    ⍝ Print ⍵
         g←' '~⍨⎕UCS⍳256                 ⍝ Assign to g every Unicode character except space
     ×≢⍵∩                :               ⍝ If ⍵∩g is not empty
                          ∇              ⍝ Recursively call the function with argument:
                           ' '@       ⍵  ⍝ Space at
                               (⊃g⍋⍵)    ⍝ The first (⊃) element in ⍵ graded up (⍋) with g
                                         ⍝ The dyadic grade up function will index ⍵ according
                                         ⍝ to its left argument, in this case g.

V , 27 bytes

>>ò2Ùúú^lDhrfDj|@"r kdòdj<H

Pruébalo en línea!

Hexdump:

00000000: 3e3e f232 d9fa fa5e 6c44 6872 6644 6a7c  >>.2...^lDhrfDj|
00000010: 4022 7220 6b64 f264 6a3c 48              @"r kd.dj<H

PowerShell , 103 99 bytes

param($a)2..$a.length|%{($x=$a);[regex]$p=""+([char[]]$a-ne' '|sort)[0];$a=($p.replace($x," ", 1))}

Pruébalo en línea!

Toma la entrada como una cadena en $a. Luego hacemos un bucle de 2a $a.length(es decir, el número apropiado de tiempos verticales necesarios para eliminar todos los caracteres menos uno). En cada iteración, sacamos la cadena actual y la guardamos convenientemente $xal mismo tiempo. A continuación, se construye un nuevo [regex]objeto, $pattern que consiste en los caracteres restantes en $aque son -not equal al espacio, sorted, entonces el 0º uno de los mismos.

Luego establecemos $aigual a una nueva cadena del objeto regex con el .Replacemétodo para reemplazar en la cadena $x, el $pattern, con un espacio " ", pero solo la 1coincidencia st. Sí, esta sintaxis es rara.

Las cadenas se dejan en la tubería e implícito Write-Outputnos da una nueva línea entre ellas de forma gratuita, más una nueva línea final.

Java (JDK 10) , 140 bytes

s->{for(int m=1,i;m>0;s=s.substring(0,i=s.indexOf(m=s.chars().filter(c->c>32).min().orElse(0)))+" "+s.substring(i+1))System.out.println(s);}

Pruébalo en línea!

Técnicamente hay una línea en blanco, pero no está vacía .

Stax , 9 bytes

ü¡%/"=πbΓ

Ejecutar y depurarlo

Este es el mismo algoritmo que la solución 05AB1E de Luis

MATL , 17 16 bytes

tSXz"tOy@=f1)(]x

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

t       % Implicit input. Duplicate
S       % Sort
Xz      % Remove spaces
"       % For each char in that string
  t     %   Duplicate last result. This is the most recent string obtained
        %   from replacing chars by spaces in the input
  O     %   Push 0
  y     %   Duplicate from below
  @     %   Push current char
  =     %   Equals? (element-wise) Gives 1 for occurrences of current char
        %   in the most recent string, 0 otherwise
  f     %   Indices of nonzeros
  1)    %   Get the first entry
  (     %   Write 0 at that position. Char 0 will be displayed as space
]       % End
x       % Delete last result, which consists only of space / char zero

Excel VBA, 167 bytes

Una función de ventana inmediata anónima de VBE que toma la entrada del rango [A1]y las salidas a la ventana inmediata de VBE.

s="Code(Mid(A$1,Row(),1))":[B1].Resize([Len(A1)])="=If("&s &"=32,1E3,"&s &")":For i=1To[Len(A1)-CountIf(B:B,1E3)]:?[A1]:[A1]=[Substitute(A1,Char(Min(B:B))," ",1)]:Next

No golfista y comentado

''  run as `call icicle("Test")` or `icicle"I am the WALRUS`
Sub icicle(Optional str As String)
    If Not IsMissing(str) Then [A1] = str   ''  pipe input
    [B:B].Clear                             ''  reset between runs
    [B1].Resize([Len(A1)]) = "=If(Code(Mid(A$1,Row(),1))=32,1E3,Code(Mid(A$1,Row(),1)))"  ''  get char number for every char in input
    For i = 1 To [Len(A1)-CountIf(B:B,1E3)] ''  iterate across from 1 to length of input - number of spaces
        Debug.Print [A1]                    ''  output a single line
        [A1]=[Substitute(A1,Char(Min(B:B))," ",1)]  ''  replace minimum char with space
    Next
End Sub

Japt , 32 18 bytes

¡Ahorró 14 bytes gracias a Shaggy!

rS ¬£=hSUbZn gYÃiN

Pruébalo en línea!