Crea una parola ghiacciolo


45

A causa delle limitazioni tecniche di Stack Exchange, il titolo viene visualizzato in modo errato. Il titolo corretto per questa sfida è

Fare un

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

La sfida di oggi è rendere i ghiaccioli dalla parola in ingresso. Data una stringa di ASCII interamente stampabile e almeno 2 caratteri non spaziali, procedere come segue:

  1. Stampa lo stato corrente della stringa.

  2. Sostituisci il carattere lessicale più piccolo (diverso dagli spazi) con uno spazio. Se c'è un pareggio, sostituisci il carattere più a sinistra.

  3. Ripeti su righe consecutive fino a quando la stringa contiene solo 1 carattere non spaziale.

Questo crea l'effetto che la stringa di input sembra fondersi ...

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      

Regole

  • Dopo un paio di iterazioni, l'output avrà quasi sicuramente spazi finali su ogni riga. Se si sceglie di troncare questi, ciò è consentito.

  • Potresti avere una riga vuota finale, ma non di più.

  • Ricorda che l'input può contenere diversi spazi, ma questi vengono effettivamente saltati. Ad esempio, l'input a adovrebbe dare

    a      a
           a
    
  • Se lo desideri, puoi inserire input come elenco di stringhe. Per l'output, è possibile restituire o stampare un elenco di stringhe, una singola stringa con newline o matrice di caratteri / matrice 2D. In generale, preferisco i formati IO permissivi, quindi molto probabilmente altri formati sono consentiti purché siano coerenti e corrispondano chiaramente all'output corretto. In caso di dubbi, non esitare a chiedere. Come al solito, sono ammessi programmi o funzioni completi.

  • Ricorda, questo è un concorso per rendere la risposta più breve in qualsiasi lingua! Se si sceglie di rispondere in Java, provare a creare la risposta Java più breve (in byte) possibile.

Casi 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        


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

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

1
"lessicalmente più piccolo" significa per punto di codice?
Giuseppe,

1
@Giuseppe Sì, il personaggio con il punto di codice ASCII più piccolo (ovviamente
diverso dallo

2
Mi ricorda un'altra sfida in cui dovevamo, credo, ripetere verticalmente un personaggio in base al suo indice nell'alfabeto.
Shaggy,

6
@Shaggy Probabilmente stai pensando di creare un po 'di Alphabet Rain .
Rainbolt

2
Quel riferimento a MediaWiki però ...
Erik the Outgolfer

Risposte:



8

Retina , 28 byte

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

Provalo online! Spiegazione:

/\S/+

Ripeti mentre il valore di input non è vuoto.

¶<

Stampa il valore corrente.

~(

Eseguire il resto dello script sul valore. Quindi, esegui il risultato di quello script come script sul valore.

O`.

Ordina i personaggi in ordine.

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

Seleziona il primo carattere non vuoto e genera un programma Retina che sostituisce la prima $\occorrenza letterale ( ) di quel carattere ( $&) con uno spazio (spazio finale nel codice originale).


6

APL (Dyalog Unicode) , 18 11 byte

∪∘↓∘⍉⍋∘⍋⍴⌸⊢

Provalo online!

usi ⎕io←1; restituisce una matrice di stringhe (vettore dei vettori di caratteri)


È necessario?
Kritixi Lithos,

@Cowsquack sì, altrimenti le prime righe dell'output potrebbero essere identiche
ngn

@Cowsquack grazie, non me ne sono accorto
ngn

fortunatamente, risolvere questo ha portato a una soluzione più breve :)
ngn

Bello, uso davvero intelligente di ⍋∘⍋:)
Kritixi Lithos

6

05AB1E , 9 byte

ðм{v=yð.;

Provalo online!

Spiegazione

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

1
{ðKv=yð.;era mio, bello.
Magic Octopus Urn

@MagicOctopusUrn Heh, abbastanza simile
Luis Mendo

1
@MagicOctopusUrn In realtà, rimarrebbero comunque gli stessi 9 byte nell'ultima versione 05AB1E .. :sostituisce tutti i caratteri invece dei .;quali sostituisce il primo (ovvero vedi cosa fa il tuo 7 byte con il !caso di test). Inoltre, la sfida afferma esplicitamente di escludere gli spazi, quindi il tuo 7-byte non funzionerebbe per l'input con più spazi. PS: bella risposta, Luis! +1 da me. :)
Kevin Cruijssen il

1
@KevinCruijssen lasciami a me per dimenticare il motivo per cui ho dovuto usare .;in primo luogo. Ricordo letteralmente di aver lottato con questo il 1 ° maggio all'inizio di quest'anno, ora che me lo dici.
Magic Octopus Urn,

1
@LuisMendo Beh, nessuno dei comandi che hai usato in questa risposta è cambiato nella riscrittura dell'Elisir di 05AB1E. :)
Kevin Cruijssen,

5

Pyth, 17 14 13 byte

V-SQdQ=XQxQNd

Provalo qui

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.

5

sed -rn , 142 143 byte

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

Provalo online!

(nota: ci sono schede nel programma)

Dato che sed non ha alcun concetto di ordine lessicografico, ho dovuto codificare il set di caratteri ASCII stampabili e occupa più della metà del byte.

L'uso di sed 4.2.2 ridurrà il conteggio del numero di 2, poiché consente etichette senza nome, provalo online!


-r abilita espressioni regolari estese (golfista)

-n disabilita la stampa implicita dello spazio del motivo alla fine del programma

Lo spazio del motivo inizia con l'input

:aetichetta a, questo è il ciclo principale del programma

p stampa lo spazio del modello (nome di fantasia per il buffer)

ora aggiungiamo il set di caratteri ASCII stampabili (escluso lo spazio)

s/$/ ABCDEFGHIJKLMNOPQRSTUVWXYZ/ aggiungere una scheda, che funge da delimitatore a 1 byte, seguito dall'alfabeto maiuscolo

s<tab>sostituto (sed può prendere qualsiasi carattere come delimitatore, in questo caso la scheda viene utilizzata per salvare un byte dall'evasione del /)

  • \w+$ l'alfabeto maiuscolo che abbiamo appena aggiunto

  • <tab> con

  • !"#$%\&'()*+,-./0123456789:;<=>?@&[\\]^_\`\L&{|}~<tab>il resto dei caratteri, nota che \L&è la versione minuscola dell'alfabeto maiuscolo

:betichetta b, rimuovere i caratteri dal set iniziale che non sono presenti nell'input

/(.).* \1/! se il primo carattere del set ASCII non è presente nell'input

  • s/ ./ / rimuoverlo

tbripetere bfino a quando la sostituzione fallisce

s/(.)(.*) \1.*/ \2/ sostituire il primo carattere nel set ASCII presente nell'input con uno spazio e rimuovere il set ASCII

ta ricorso


La corrispondenza non avida sarebbe stata davvero utile qui, ma sono stato in grado di inventare qualcosa che è sedbastato a risparmiare almeno 4 byte: provalo online!
Neil,

(Il ciarlatano delle mucche ha sottolineato che sono stato solo parzialmente in grado di ingannare sed, mentre rimuovo personaggi identici nell'ordine sbagliato.)
Neil


4

R , 140 100 byte

-40 byte Grazie a Giuseppe!

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

Provalo online!

Una soluzione che utilizza outere la magia di Giuseppe per funzionare correttamente è più lunga a 104 byte. Ispirato da questa risposta .

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

Provalo online!


109 byte prendendo input come vettore di caratteri
Giuseppe

1
100 byte prendendo input come stringa!
Giuseppe,

Comunque, una risposta molto bella; il mio era aumentato in mongolfiera a oltre 200 byte da quando non mi ricordavo rank!
Giuseppe,

@Giuseppe Parlamene - Ho prima provato "ordine" per un risultato che si stava sciogliendo ma non nell'ordine corretto!
JayCe

@Giuseppe e il mio tentativo di utilizzare l'esterno ispirato al tuo post sono riusciti a rimuovere tutti gli spazi. TIO Mi piacerebbe vedere un approccio esterno funzionante pubblicato come una risposta separata. Ci sto ancora lavorando, ma potrebbe non essere così elegante.
JayCe,

3

Python 3 , 71 byte

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

Provalo online!

-4 byte grazie agli ovs


Salva 2 byte usando *bool({*a}-{" "})invece diif{*a}-{" "}else[a]
RootDue

@RootTwo non si tradurrebbe in un RecursionError?
Ovs,

@RootDue if/elsescorciatoie ma *boolnon, quindi sì, ricorsionerror come ovs detto
HyperNeutrino

Certo che hai ragione. A causa di un bug, la mia funzione si è ripetuta chiamando la tua funzione in modo che sembrasse funzionare.
Radice Due

3

Python 2 , 70 69 66 64 byte

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

Provalo online!

Grazie per 2 byte da ovs usando S and f()invece diif S:f()


Ti manca la ...If there is a tie, replace the leftmost character...regola, puoi risolverlo conreplace(min(...),' ',1)
Rod

@Rod: Ah! Capito ...
Chas Brown,

3

Gelatina , 8 byte

ẋ"ỤỤ$z⁶Q

Provalo online!

Idea

L'idea di base è costruire direttamente le colonne dell'output desiderato, invece di manipolare la stringa e restituire tutti i risultati intermedi.

Iniziamo numerando i caratteri della stringa di input nell'ordine in cui verranno rimossi. Per il momento, faremo finta che anche gli spazi vengano rimossi.

tee ay oh
845139276

Ora, costruiamo le colonne ripetendo ogni carattere per il suo indice in questa enumerazione.

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   

Non resta che rimuovere i duplicati, tenere conto degli spazi.

Codice

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

3

Perl 5 -n , 37 34 byte

Eliminati tre byte con l'aiuto di @TonHospel

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

Provalo online!


Ah, approccio molto carino, molto più bello! Penso che tu abbia bisogno del pensiero \Qper l'ultimo caso di test .... Mi è mancato anche quello le prime volte!
Dom Hastings,

Hai ragione. Aggiunto.
Xcali,

Shorter: say&&s/\Q$a/ / while($a)=sort/\S/g. Inoltre gestisce correttamente0
Ton Hospel

3

JavaScript, 67 66 65 byte

Perché non gioco da ubriaco da un po '!

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

Provalo online

Grazie a DanielIndie per aver segnalato 4 byte ridondanti inclusi nella birra!


perché specifichi y nella mappa? : P può essere fatto 67
DanielIndie

@DanielIndie, perché la birra! : D Grazie per averlo sottolineato.
Shaggy,

sì, ho pensato che sarebbe stato il caso: P
DanielIndie

3

K (ngn / k) , 26 24 byte

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

Provalo online!


Bellissimo! Il mio tentativo di K è arrivato a 41: `{. [X; (- 1 + # x) & x? _Ci & / _ ic x _dv" ";:;" "]}` Sto sprecando byte convertendoli in in e viceversa e facendo certo che non va oltre i limiti.
uryga,

@uryga Grazie. Se avessi implementato correttamente le proiezioni, {@[x;y;:;" "]}avrebbe potuto essere @[;;:;" "]. Quale versione di k usi? Non ho dimestichezza con questi: _ci _ic _dv.
ngn

Penso che sia 2.8-ish? Sto usando l'interprete di Kona che fornisce gli operatori come builtin: char-of-int, int-of-char, delete-value.
uryga,

2

C # (compilatore interattivo Visual C #) , 129 byte

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

Provalo online!


c!=32può essere c>32; c==32può essere c<33; e (char)999può essere '¡'(o qualsiasi altro carattere al di sopra dell'intervallo unicode ASCII stampabile).
Kevin Cruijssen,

Oh, e si può risparmiare più byte cambiare il due whileper fore mettendo il var s=ReadLine()e s=s.Remove(i,1).Insert(i," ")al suo interno (in modo che i due punti e virgola non sono più necessari).
Kevin Cruijssen,


2

Haskell , 67 byte

12 byte salvati grazie a Laikoni

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

Provalo online!

Questo termina con un errore

Haskell , 83 79 byte

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

Provalo online!

Questo termina con un errore

Haskell , 86 byte

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

Provalo online!

Haskell , 100 91 88 byte

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

Provalo online!


67 byte: f s|(a,_:b)<-span(/=minimum(id=<<words s))s=putStrLn s>>f(a++' ':b) provalo online!
Laikoni,

@Laikoni Grazie! Ero sull'orlo di qualcosa del genere e mi sono addormentato. Tuttavia non penso che mi sarei id=<<inventato abbastanza intelligente
Wheat Wizard


2

K4 , 28 20 18 byte

Soluzione:

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

Esempio:

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

Spiegazione:

È la stessa cosa che sta facendo Ngn . Trova gli indici che risulterebbero in un elenco crescente, sovrascrivili uno a uno con " ", quindi prendi il distinto per rimuovere le righe duplicate:

?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

2

gcc a 32 bit, 66 65 byte

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

Grazie per Jonathan Frech per -1 byte


*p==i?...:0;potrebbe essere *p-i?0:...;.
Jonathan Frech,

@JonathanFrech No, è più lungo di 1 byte (anche se *p-1||(...)è della stessa lunghezza)
l4m2

Spiacenti, non ho riconosciuto l'importanza di mantenere insieme l'espressione virgola. Tuttavia, questo potrebbe essere 65 byte . Inoltre non so come f(a)compilare, come adovrebbe essere di tipo char*, ma presumo che abbia qualcosa a che fare con il tuo utilizzo di gcc a 32 bit.
Jonathan Frech,

@JonathanFrech Penso che char*p,i;f(long long a){for(i=31;++i;)for(p=a;*p;)*p==i?puts(a),*p=32:++p;}su tio (64 bit) possa spiegare come f(a)funziona
l4m2

Mi dispiace, anche se ho chiesto all'OP delle specifiche della sfida e hanno detto che la stringa di input potrebbe iniziare con uno spazio. Pertanto la mia soluzione proposta non è valida (poiché un input di questo tipo genera un ciclo infinito) e molto probabilmente dovresti tornare alla soluzione originale.
Jonathan Frech,

2

MATLAB, 74 byte

Questo utilizza la forma a 2 output della funzione max () per recuperare il carattere più piccolo e il suo indice, dopo aver trasformato la stringa in valori zero negli spazi e in 256 il valore del carattere per i caratteri stampabili.

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

1
Benvenuti in PPCG! Bel lavoro!
AJFaraday,

2

Lisp comune , 240 228 224 byte

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

Provalo online!

Questa è la mia prima pubblicazione.
Sto imparando lisp, quindi sono sicuro che qualcuno possa pensare a qualcosa di più corto di questo.


1
Benvenuti nel sito! Bello vedere qualche pisolino comune!
Mago del grano

1

APL (Dyalog Unicode) , SBCS da 39 byte

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

Provalo online!

DFN.

Come?

{⎕←⍵⋄×≢⍵∩g' '~⍨⎕UCS256:∇' '@(⊃g⍋⍵)⊢⍵}  Main function, argument 
 ⎕←⍵⋄                                     Print 
         g' '~⍨⎕UCS256                  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.

1

V , 27 byte

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

Provalo online!

hexdump:

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

1

PowerShell , 103 99 byte

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

Provalo online!

Accetta input come stringa in $a. Passiamo quindi da 2a $a.length(ovvero il numero appropriato di volte verticali necessario per rimuovere tutti i caratteri tranne uno). Ogni iterazione, produciamo la stringa corrente e convenientemente salviamo $xallo stesso tempo. Abbiamo poi costruisce un nuovo [regex]oggetto, $pattern costituito dai rimanenti caratteri $ache sono -not equal allo spazio, sorted allora 0l'esima stessa.

Quindi impostiamo $auguale a una nuova stringa dell'oggetto regex con il .Replacemetodo da sostituire nella stringa $x, l' $pattern, con uno spazio " ", ma solo la 1corrispondenza st. Sì, questa sintassi è strana.

Le stringhe vengono lasciate sulla pipeline e implicitamente Write-Outputci fornisce una nuova riga tra loro gratuitamente, oltre a una nuova riga finale.


1

Java (JDK 10) , 140 byte

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

Provalo online!

Tecnicamente c'è una linea vuota, ma non è vuota .



1

MATL , 17 16 byte

tSXz"tOy@=f1)(]x

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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

1

Excel VBA, 167 byte

Una funzione di finestra immediata VBE anonima che accetta input dalla gamma [A1]e output nella finestra immediata 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 e commentato

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

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.