Devido a limitações técnicas do Stack Exchange, o título é renderizado incorretamente. O título correto para este desafio é

Faça um

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

O desafio de hoje é fazer pingentes de gelo da palavra de entrada. Dada uma sequência de caracteres ASCII totalmente imprimíveis e pelo menos 2 caracteres não espaciais, execute as seguintes etapas:

1. Imprima o estado atual da sequência.

2. Substitua o caractere lexicamente menor (exceto espaços) por um espaço. Se houver um empate, substitua o caractere mais à esquerda.

3. Repita em linhas consecutivas até que a sequência contenha apenas 1 caractere não espacial.

Isso cria o efeito de que a string de entrada parece estar derretendo ...

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      

Regras

• Após algumas iterações, sua saída quase certamente terá espaços à direita em cada linha. Se você optar por truncar esses, isso é permitido.

• Você pode ter uma linha vazia à direita, mas não mais.

• Lembre-se de que a entrada pode conter vários espaços, mas todos são efetivamente ignorados. Por exemplo, a entrada a adeve fornecer

  a      a
         a
  

• Você pode considerar a entrada como uma lista de strings, se desejar. Para saída, você pode retornar ou imprimir uma lista de cadeias, uma única cadeia com novas linhas ou matriz de caracteres / matriz 2D. Geralmente, eu prefiro formatos de E / S permissivos; portanto, é provável que outros formatos sejam permitidos desde que sejam consistentes e correspondam claramente à saída correta. Em caso de dúvida, não hesite em perguntar. Como de costume, programas ou funções completos são permitidos.

• Lembre-se, este é um concurso para obter a resposta mais curta em qualquer idioma! Se você optar por responder em Java, tente fazer a resposta Java mais curta possível (em bytes).

Casos de teste

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 graças a ovs}

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

Experimente online!

Retina , 28 bytes

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

Experimente online! Explicação:

/\S/+

Repita enquanto o valor de entrada não estiver em branco.

¶<

Imprima o valor atual.

~(

Execute o restante do script no valor. Em seguida, execute o resultado desse script como um script no valor.

O`.

Classifique os caracteres em ordem.

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

Selecione o primeiro caractere não vazio e produza um programa Retina que substitua a primeira $\ocorrência literal ( ) desse caractere ( $&) por um espaço (espaço à direita no código original).

APL (Dyalog Unicode) , 18 11 bytes

∪∘↓∘⍉⍋∘⍋⍴⌸⊢

Experimente online!

usos ⎕io←1; retorna uma matriz de strings (vetor de vetores de caracteres)

05AB1E , 9 bytes

ðм{v=yð.;

Experimente online!

Explicação

ð      # 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

Pitão, 17 14 13 bytes

V-SQdQ=XQxQNd

Experimente aqui

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 , 142 143 bytes

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

Experimente online!

(nota: existem abas no programa)

Como sed não tem um conceito de ordem lexicográfica, tive que codificar o conjunto de caracteres ASCII imprimíveis e ocupar mais da metade do número de bytes.

O uso do sed 4.2.2 reduzirá o número de unidades em 2, pois isso permite rótulos sem nome. Experimente online!

-r permite expressões regulares estendidas (golfista)

-n desativa a impressão implícita do espaço do padrão no final do programa

O espaço do padrão começa com a entrada

:aetiqueta a, este é o loop principal do programa

p imprimir o espaço padrão (nome sofisticado para o buffer)

agora anexamos o conjunto de caracteres ASCII imprimíveis (excluindo o espaço)

s/$/ ABCDEFGHIJKLMNOPQRSTUVWXYZ/ anexa uma guia, atuando como delimitador de 1 byte, seguido pelo alfabeto maiúsculo

s<tab>substituto (sed pode assumir qualquer caractere como delimitador; nesse caso, a guia é usada para evitar que um byte escape do /)

• \w+$ o alfabeto maiúsculo que acabamos de acrescentar

• <tab> com

• !"#$%\&'()*+,-./0123456789:;<=>?@&[\\]^_\`\L&{|}~<tab>o restante dos caracteres, observe que \L&é a versão em minúscula do alfabeto em maiúsculas

:betiqueta b, remova caracteres do conjunto inicial que não estão presentes na entrada

/(.).* \1/! se o primeiro caractere do conjunto ASCII não estiver na entrada

• s/ ./ / remova

tbrepita baté a substituição falhar

s/(.)(.*) \1.*/ \2/ substitua o primeiro caractere no conjunto ASCII presente na entrada por um espaço e remova o conjunto ASCII

ta recurso

Ruby , 60 58 55 47 bytes

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

Experimente online!

R , 140 100 bytes

-40 bytes Graças a Giuseppe!

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

Experimente online!

Uma solução que usa outera magia de Giuseppe para funcionar corretamente é maior em 104 bytes. Inspirado por esta resposta .

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

Experimente online!

Python 3 , 71 bytes

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

Experimente online!

-4 bytes graças 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))

Experimente online!

Thx por 2 bytes de ovs via usando em S and f()vez deif S:f()

Gelatina , 8 bytes

ẋ"ỤỤ$z⁶Q

Experimente online!

Idéia

A idéia básica é construir diretamente as colunas da saída desejada, em vez de manipular a string e retornar todos os resultados intermediários.

Começamos numerando os caracteres da sequência de entrada na ordem em que serão removidos. Por enquanto, fingiremos que os espaços também serão removidos.

tee ay oh
845139276

Agora, criamos as colunas repetindo cada caractere por seu índice nesta enumeração.

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   

Tudo o que resta é remover duplicatas, para dar conta dos espaços.

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

Eliminou três bytes com a ajuda do @TonHospel

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

Experimente online!

JavaScript, 67 66 65 bytes

Porque não jogo bêbado há algum tempo!

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

Experimente online

Agradecemos a DanielIndie por apontar 4 bytes redundantes que a cerveja incluía!

K (ngn / k) , 26 24 bytes

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

Experimente online!

C # (compilador interativo do 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," ");}

Experimente online!

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

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

Isso pode estar ultrapassando os limites das bandeiras do Perl, caso contrário, voltarei à resposta anterior.

Experimente online!

Haskell , 67 bytes

12 bytes salvos graças a Laikoni

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

Experimente online!

Este termina com um erro

Haskell , 83 79 bytes

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

Experimente online!

Este termina com um erro

Haskell , 86 bytes

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

Experimente online!

Haskell , 100 91 88 bytes

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

Experimente online!

JavaScript (Node.js) , 80 65 bytes

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

Experimente online!

Não sabia replacepegar string como string, não regexp

K4 , 28 20 18 bytes

Solução:

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

Exemplo:

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

Explicação:

É a mesma coisa que a ngn está fazendo. Encontre índices que resultem em uma lista crescente, substitua-os um por um e " ", em seguida, use o distinto para remover qualquer linha duplicada:

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

Obrigado por Jonathan Frech por -1 byte

MATLAB, 74 bytes

Isso usa a forma de 2 saídas da função max () para recuperar o menor caractere e seu índice, depois de transformar a sequência em zero nos espaços e 256 em caracteres para os caracteres imprimíveis.

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

Lisp comum , 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))))

Experimente online!

Esta é a minha primeira vez postando.
Estou no processo de aprender cocô, então tenho certeza que alguém pode pensar em algo mais curto que isso.

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

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

Experimente online!

Dfn.

Quão?

{⎕←⍵⋄×≢⍵∩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

Experimente online!

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

Experimente online!

Leva a entrada como uma string para $a. Em seguida, passamos de 2para $a.length(ou seja, o número apropriado de vezes na vertical necessário para remover todos os caracteres, exceto um). A cada iteração, produzimos a string atual e salvamos convenientemente $xao mesmo tempo. Nós então construir um novo [regex]objecto, $pattern consistindo dos restantes caracteres em $aque são -not equa a espaço, sorted, em seguida, o 0th um destes.

Em seguida, definimos $aigual a uma nova string do objeto regex com o .Replacemétodo para substituir na string $x, a $pattern, por um espaço " ", mas apenas a 1st corresponde. Sim, essa sintaxe é estranha.

As strings são deixadas no pipeline e implícitas Write-Outputnos dão uma nova linha entre elas de graça, mais uma nova linha à direita.

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

Experimente online!

Tecnicamente, há uma linha em branco, mas não está vazia .

Stax , 9 bytes

ü¡%/"=πbΓ

Execute e depure

Este é o mesmo algoritmo que a solução 05AB1E de Luis

MATL , 17 16 bytes

tSXz"tOy@=f1)(]x

Experimente online! Ou verifique todos os casos de teste .

Explicação

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

Uma função de janela imediata anônima do VBE que leva a entrada do intervalo [A1]e sai para a janela imediata do 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

Sem Golfe e 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

Economizou 14 bytes graças a Shaggy!

rS ¬£=hSUbZn gYÃiN

Experimente online!