En raison des limitations techniques de Stack Exchange, le titre est mal interprété. Le titre correct pour ce défi est

Faire un

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

Le défi actuel est de faire des glaçons du mot d’entrée. Avec une chaîne d' ASCII entièrement imprimable et au moins deux caractères autres que des espaces, procédez comme suit:

1. Affiche l'état actuel de la chaîne.

2. Remplacez le caractère lexicalement le plus petit (autre que les espaces) par un espace. En cas d'égalité, remplacez le caractère le plus à gauche.

3. Répétez l'opération sur des lignes consécutives jusqu'à ce que la chaîne ne contienne plus qu'un seul caractère.

Cela crée l'effet que la chaîne d'entrée a l'air de fondre ...

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      

Règles

• Après quelques itérations, votre sortie aura presque certainement des espaces de fin sur chaque ligne. Si vous choisissez de les tronquer, cela est autorisé.

• Vous pouvez avoir une dernière ligne vide, mais pas plus.

• N'oubliez pas que l'entrée peut contenir plusieurs espaces, mais ceux-ci sont tous ignorés. Par exemple, l’entrée a adevrait donner

  a      a
         a
  

• Vous pouvez prendre les entrées sous forme de liste de chaînes si vous le souhaitez. Pour la sortie, vous pouvez renvoyer ou imprimer une liste de chaînes, une seule chaîne avec des nouvelles lignes ou un tableau matriciel / 2D. En règle générale, je préfère les formats d'E / S permissifs. Par conséquent, d'autres formats sont probablement autorisés dans la mesure où ils sont cohérents et correspondent clairement à la sortie correcte. En cas de doute, n'hésitez pas à demander. Comme d'habitude, les programmes ou fonctions complets sont autorisés.

• Rappelez-vous qu’il s’agit d’un concours pour la réponse la plus courte dans n’importe quelle langue! Si vous choisissez de répondre en Java, essayez de fournir la réponse Java la plus courte possible (en octets).

Cas de test

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 octets

^{-1 octet grâce aux ovs}

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

Essayez-le en ligne!

Retina , 28 octets

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

Essayez-le en ligne! Explication:

/\S/+

Répétez l'opération tant que la valeur d'entrée n'est pas vide.

¶<

Imprimer la valeur actuelle.

~(

Exécutez le reste du script sur la valeur. Ensuite, exécutez le résultat de ce script en tant que script sur la valeur.

O`.

Triez les caractères dans l'ordre.

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

Sélectionnez le premier caractère non vide et générez un programme Retina qui remplace la première $\occurrence literal ( ) de ce caractère ( $&) par un espace (espace de fin dans le code d'origine).

APL (Dyalog Unicode) , 18 à 11 octets

∪∘↓∘⍉⍋∘⍋⍴⌸⊢

Essayez-le en ligne!

utilise ⎕io←1; retourne un tableau de chaînes (vecteur de vecteurs de caractères)

05AB1E , 9 octets

ðм{v=yð.;

Essayez-le en ligne!

Explication

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

V-SQdQ=XQxQNd

Essayez ici

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 octets

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

Essayez-le en ligne!

(note: il y a des onglets dans le programme)

Sed n'ayant pas de concept d'ordre lexicographique, j'ai dû coder en dur l'ensemble des caractères imprimables ASCII et cela prend plus de la moitié du décompte.

L'utilisation de sed 4.2.2 réduira le nombre de compteurs de 2, car cela permet d'utiliser des étiquettes sans nom. Essayez-le en ligne!

-r active les expressions régulières étendues (golfier)

-n désactive l'impression implicite de l'espace de modèle à la fin du programme

L'espace motif commence par l'entrée

:alabel a, ceci est la boucle principale du programme

p affiche l'espace du motif (nom de fantaisie pour le tampon)

maintenant nous ajoutons le jeu de caractères imprimables ASCII (en excluant l'espace)

s/$/ ABCDEFGHIJKLMNOPQRSTUVWXYZ/ ajoute un onglet, faisant office de délimiteur d'1 octet, suivi de l'alphabet majuscule

s<tab>substitute (sed peut prendre n’importe quel caractère comme délimiteur, dans ce cas, la tabulation sert à empêcher un octet d’échapper de la /)

• \w+$ l'alphabet majuscule que nous venons d'ajouter

• <tab> avec

• !"#$%\&'()*+,-./0123456789:;<=>?@&[\\]^_\`\L&{|}~<tab>le reste des caractères, notez qu'il \L&s'agit de la version minuscule de l'alphabet majuscule

:blabel b, supprime les caractères du début qui ne sont pas présents en entrée

/(.).* \1/! si le premier caractère du jeu ASCII n'est pas dans l'entrée

• s/ ./ / l'enlever

tbrépéter bjusqu'à ce que la substitution échoue

s/(.)(.*) \1.*/ \2/ remplace le premier caractère du jeu ASCII présent dans l'entrée par un espace et supprime le jeu ASCII

ta récidive

Ruby , 60 58 55 47 octets

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

Essayez-le en ligne!

R , 140 à 100 octets

-40 octets Merci à Giuseppe!

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

Essayez-le en ligne!

Une solution utilisant outerla magie de Giuseppe pour fonctionner correctement est plus longue à 104 octets. Inspiré par cette réponse .

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

Essayez-le en ligne!

Python 3 , 71 octets

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

Essayez-le en ligne!

-4 octets grâce aux ovs

Python 2 , 70 69 66 64 octets

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

Essayez-le en ligne!

Thx pour 2 octets à partir de ovs via using S and f()au lieu deif S:f()

Gelée , 8 octets

ẋ"ỤỤ$z⁶Q

Essayez-le en ligne!

Idée

L'idée de base est de créer directement les colonnes de la sortie souhaitée, au lieu de manipuler la chaîne et de renvoyer tous les résultats intermédiaires.

Nous commençons par numéroter les caractères de la chaîne d'entrée dans l'ordre dans lequel ils seront supprimés. Pour le moment, nous allons prétendre que les espaces seront également supprimés.

tee ay oh
845139276

Maintenant, nous construisons les colonnes en répétant chaque caractère par son index dans cette énumération.

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   

Tout ce qui reste à faire est de supprimer les doublons, pour tenir compte des espaces.

Code

ẋ"ỤỤ$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 octets

Oubli de trois octets avec l'aide de @TonHospel

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

Essayez-le en ligne!

JavaScript, 67 66 65 octets

Parce que je n'ai pas joué au golf saoul depuis un moment!

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

Essayez-le en ligne

Merci à DanielIndie pour avoir signalé 4 octets redondants que la bière est incluse!

K (ngn / k) , 26 à 24 octets

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

Essayez-le en ligne!

C # (compilateur interactif Visual C #) , 129 octets

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

Essayez-le en ligne!

Perl 5 avec -nlF/\s|/, 39 octets

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

Cela pourrait pousser les limites des drapeaux de Perl à ne pas être comptés, si c'est le cas, je reviens à la réponse précédente.

Essayez-le en ligne!

Haskell , 67 octets

12 octets sauvés grâce à Laikoni

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

Essayez-le en ligne!

Celui-ci se termine par une erreur

Haskell , 83 79 octets

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

Essayez-le en ligne!

Celui-ci se termine par une erreur

Haskell , 86 octets

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

Essayez-le en ligne!

Haskell , 100 91 88 octets

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

Essayez-le en ligne!

JavaScript (Node.js) , 80 à 65 octets

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

Essayez-le en ligne!

Je ne savais pas que la replacechaîne était une chaîne, pas une expression rationnelle

K4 , 28 20 18 octets

Solution:

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

Exemple:

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

Explication:

C'est la même chose que Ngn . Recherchez les index qui donneraient une liste ascendante, écrasez-les un par un " ", puis supprimez-les pour supprimer les lignes en double:

?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 octets

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

Merci à Jonathan Frech pour -1 octet

MATLAB, 74 octets

Ceci utilise la forme à 2 sorties de la fonction max () pour récupérer le plus petit caractère et son index, après avoir transformé la chaîne en valeurs zéro dans les espaces et en 256 la valeur des caractères imprimables.

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

Common Lisp , 240 228 224 octets

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

Essayez-le en ligne!

C'est ma première publication.
Je suis en train d’apprendre à respirer, alors je suis sûr que quelqu'un peut penser à quelque chose de plus court.

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

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

Essayez-le en ligne!

Dfn.

Comment?

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

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

Essayez-le en ligne!

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 octets

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

Essayez-le en ligne!

Prend l'entrée sous forme de chaîne dans $a. Nous passons ensuite de 2à $a.length(c.- à -d. Le nombre approprié de temps verticaux nécessaires pour supprimer tous les caractères sauf un). À chaque itération, nous sortons la chaîne en $xcours dans laquelle nous enregistrons de manière pratique en même temps. Ensuite , nous avons construit un nouvel [regex]objet, $pattern constitué par les caractères restants en $ace que sont -not eQual à l' espace, sorted, alors la 0ième de celle - ci.

Nous définissons ensuite $aégal à une nouvelle chaîne de l'objet regex avec la .Replaceméthode à remplacer dans la chaîne $x, $pattern, par un espace " ", mais uniquement la première 1correspondance. Oui, cette syntaxe est bizarre.

Les chaînes sont laissées sur le pipeline et implicitement Write-Outputnous donne une nouvelle ligne entre elles gratuitement, plus une nouvelle ligne.

Java (JDK 10) , 140 octets

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

Essayez-le en ligne!

Techniquement, il y a une ligne blanche, mais ce n'est pas vide .

Stax , 9 octets

ü¡%/"=πbΓ

Exécuter et déboguer

C'est le même algorithme que la solution de Luis 05AB1E

MATL , 17 16 octets

tSXz"tOy@=f1)(]x

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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 octets

Une fonction de fenêtre immédiate VBE anonyme qui prend les entrées de la plage [A1]et les envoie à la fenêtre immédiate 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

Ungolfed and Commented

''  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 octets

14 octets sauvés grâce à Shaggy!

rS ¬£=hSUbZn gYÃiN

Essayez-le en ligne!