Introdução

Vamos observar a corda abc. As substrings que podem ser feitas com isso são:

a, ab, abc, b, bc, c

Agora precisamos alinhá-los sob a string inicial, assim:

abc
a
 b
  c
ab
 bc
abc

A ordem da string não importa, então isso também é perfeitamente válido:

abc
a
ab
abc
 b
 bc
  c

Portanto, a substring é posicionada sob o local da substring na string inicial. Portanto, para abcdefe a substring cde, ficaria assim:

abcdef
  cde

A tarefa

A tarefa é alinhar todas as substrings com um comprimento maior que 0 , como mostrado acima. Você pode supor que a própria string conterá apenas caracteres alfabéticos e tenha pelo menos 1 caractere. Para o preenchimento, você pode usar um espaço ou outro caractere ASCII imprimível não alfabético ( 32 - 127). Talvez não seja necessário mencionar, mas a própria string conterá apenas caracteres únicos, portanto não é o caso aba, pois aocorre duas vezes.

Casos de teste

Entrada: abcde

Saída possível:

a
ab
abc
abcd
abcde
 b
 bc
 bcd
 bcde
  c
  cd
  cde
   d
   de
    e

Entrada: abcdefghij

Saída possível:

a
ab
abc
abcd
abcde
abcdef
abcdefg
abcdefgh
abcdefghi
abcdefghij
 b
 bc
 bcd
 bcde
 bcdef
 bcdefg
 bcdefgh
 bcdefghi
 bcdefghij
  c
  cd
  cde
  cdef
  cdefg
  cdefgh
  cdefghi
  cdefghij
   d
   de
   def
   defg
   defgh
   defghi
   defghij
    e
    ef
    efg
    efgh
    efghi
    efghij
     f
     fg
     fgh
     fghi
     fghij
      g
      gh
      ghi
      ghij
       h
       hi
       hij
        i
        ij
         j

Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha!

Pitão, 14 13 10 bytes

Obrigado a @FryAmTheEggman por salvar 3 bytes.

jmXQ-Qd;.:

Experimente online!

Perl, 32 28 24 bytes

Inclui +1 para -n

Código:

/.+(??{say$"x"@-".$&})/

Execute com a string em STDIN:

perl -nE '/.+(??{say$"x"@-".$&})/' <<< abcd

As línguas do golfe são tão próximas e tão distantes ...

Explicação

/.+/corresponde a uma substring. Infelizmente, ele pára quando corresponde a um. Então, eu uso a construção regex de tempo de execução (??{})para estender a regex, para que ela falhe e o backtracking tente a seguinte substring, no final, tentando todas elas antes de desistir com nojo.

Dentro do (??{})eu imprimo a substring atual prefixada por tantos espaços quanto o deslocamento da substring usando$"x"@-"

Portanto, a saída documenta perfeitamente como o regex backtracking funciona:

abcd
abc
ab
a
 bcd
 bc
 b
  cd
  c
   d

MATL , 20 18 bytes

Inspirado no padrão de substrings gerados pela resposta do @ aditsu

tt!+gR*c`t3Lt3$)tn

Experimente online!

O padrão de substrings é gerado por uma matriz triangular superior do mesmo tamanho da entrada e todas as submatrizes obtidas removendo sucessivamente a última linha e coluna.

Explicação

t         % implicit input. Duplicate
t!+g      % square matrix with size as input
R         % keep upper triangular part
*c        % multiply element-wise with broadcast. Convert to char
`         % do...while
  t       %   duplicate
  3Lt3$)  %   remove last row and column
  tn      %   number of remaining elements. Used as loop condition
          % implicitly end loop and display

Abordagem antiga (poder cartesiano)

Estou mantendo essa abordagem caso ela sirva de inspiração para outras respostas

tn0:2Z^!S!2\Xu4LY)*c

No compilador online, isso fica sem memória para o caso de teste mais longo.

Experimente online!

Explicação

Isso gera todos os padrões de valores 0, 1e 2em ordem crescente, e depois se transforma 2em 0. Isso fornece todos os padrões possíveis de 0e 1onde os 1valores são contíguos. Eles são usados ​​para marcar quais caracteres são retirados da string original.

Como um exemplo, para string, 'abc'os padrões são gerados da seguinte maneira. Primeiro, [0 1 2]é obtido o poder cartesiano de elevado ao número de caracteres de entrada:

0 0 0
0 0 1
0 0 2
0 1 0
0 1 1
···
2 2 1
2 2 2

A classificação de cada linha fornece

0 0 0
0 0 1
0 0 2
0 0 1
0 1 1
···
1 2 2
2 2 2

Transformar 2em 0(ie mod(...,2)) e remover linhas duplicadas fornece o padrão final

0 0 0
0 0 1
0 1 1
0 1 0
1 1 1
1 1 0
1 0 0

em que cada linha é uma máscara correspondente a uma substring (contígua). A primeira linha precisa ser removida porque corresponde à substring vazia.

t      % Implicitly get input. Duplicate
n      % Number of elements
0:2    % Vector [0 1 2]
Z^     % Cartesian power. Each result is a row
!S!    % Sort each row
2\     % Modulo 2: transform 2 into 0
Xu     % Unique rows
4LY)   % Remove first (corresponds to the empty substring)
*      % Element-wise multiplication by original string
c      % Convert to char. Implicitly display

Retina , 48 32 31 bytes

Agradecemos a Kenny Lau por salvar 3 bytes e abrir caminho para muitos mais.

A contagem de bytes assume a codificação ISO 8859-1.

M&!r`.+
%+`( *)\S(.+)$
$&¶$1 $2

Experimente online!

Ordem das substrings geradas:

abcde
 bcde
  cde
   de
    e
abcd
 bcd
  cd
   d
abc
 bc
  c
ab
 b
a

Explicação

M&!r`.+

Isso nos dá todos os prefixos da entrada. Isso é feito combinando ( M) qualquer substring ( .+) a partir do final ( r), considerando correspondências sobrepostas ( &) e retornando todas essas correspondências associadas a feeds de linha ( !).

Agora tudo o que precisamos fazer é esculpir os prefixos sucessivos desses prefixos (substituindo-os por espaços). Fazemos isso passo a passo com um loop:

%+`( *)\S(.+)$
$&¶$1 $2

Os %meios que esta coisa inteira é feito para cada linha individualmente (considerando uma string separada para ser tempo, e juntando tudo de volta, juntamente com linefeeds no final). O +instrui o Retina a executar essa substituição em um loop até que a saída pare de mudar (o que nesse caso significa que o regex não corresponde mais). O regex, em seguida, tenta corresponder a última linha da entrada com pelo menos dois caracteres não espaciais e anexa uma nova linha onde o primeiro deles é substituído por um espaço.

Oracle SQL 11.2, 146 bytes

WITH v AS(SELECT LEVEL i FROM DUAL CONNECT BY LEVEL<=LENGTH(:1))SELECT LPAD(SUBSTR(:1,s.i,l.i),s.i+l.i-1)FROM v s,v l WHERE s.i+l.i<=LENGTH(:1)+1;

Sem golfe

WITH v AS(SELECT LEVEL i FROM DUAL CONNECT BY LEVEL<=LENGTH(:1))
SELECT LPAD(SUBSTR(:1,s.i,l.i),s.i+l.i-1)
FROM   v s, v l
WHERE  s.i+l.i<=LENGTH(:1)+1

CJam, 20

q{__,{\_N+oSt}/;W<}h

Experimente online

Explicação:

q           read the input (initial string)
{…}h        do … while
  _         copy the current string
  _,        copy and get the length
  {…}/      for each value (say i) from 0 to length-1
    \       bring the string to the top
    _N+o    make a copy, append a newline and print
    St      set the i'th element to S=" "
  ;         pop the last result (array full of spaces)
  W<        remove the last character of the current string
             if the string is empty, the do-while loop terminates

Python, 57 bytes

f=lambda s,p='':set(s)and{p+s}|f(s[1:],' '+p)|f(s[:-1],p)

Produz um setgosto {' b', 'a', 'ab'}. A idéia é recuar duas ramificações que cortam o primeiro ou o último caractere. O resultado é redundante, mas o setremove automaticamente duplicatas. Para alinhamento, toda vez que o primeiro caractere é cortado, um espaço é adicionado ao prefixo p, que é concatenado na frente.

PowerShell v2 +, 69 bytes

param($a)0..($b=$a.length-1)|%{($i=$_)..$b|%{" "*$i+-join$a[$i..$_]}}

Recebe entrada $a, faz um loop ao longo do comprimento (configuração $bno processo para uso posterior). A cada loop externo, repetimos o loop $bnovamente, configurando $ipara uso posterior. Cada loop interno, produzimos um $inúmero de espaços concatenados com uma fatia da string de entrada. Como estamos apenas percorrendo a string, isso realmente manipulará qualquer string arbitrária (letras duplicadas, espaços, o que for).

Exemplo

PS C:\Tools\Scripts\golfing> .\exploded-substrings.ps1 "Golfing"
G
Go
Gol
Golf
Golfi
Golfin
Golfing
 o
 ol
 olf
 olfi
 olfin
 olfing
  l
  lf
  lfi
  lfin
  lfing
   f
   fi
   fin
   fing
    i
    in
    ing
     n
     ng
      g

C #, 136 132 131 bytes

Golfe

String m(String s){String o="",e=o;for(int i=0,a,l=s.Length;i<l;i++,e+=" ")for(a=1;a+i<=l;a++)o+=e+s.Substring(i,a)+"\n";return o;}

Ungolfed

String m( String s ) {
    String o = "", e = o;

    for (int i = 0, a, l = s.Length; i < l; i++, e += " ")
        for (a = 1; a + i <= l; a++)
            o += e + s.Substring( i, a ) + "\n";

    return o;
}

Código completo

    using System;
using System.Collections.Generic;

namespace Namespace {
    class Program {
        static void Main( string[] args ) {
            List<String> ls = new List<String>() {
                    "abcde",
                    "abcdefghijklmnop",
                    "0123456789",
                };

            foreach (String s in ls) {
                Console.WriteLine( s );
                Console.WriteLine( m( s ) );
                Console.WriteLine( "" );
            }

            Console.ReadLine();
        }

        static String m( String s ) {
            String o = "", e = o;

            for (int i = 0, a, l = s.Length; i < l; i++, e += " ")
                for (a = 1; a + i <= l; a++)
                    o += e + s.Substring( i, a ) + "\n";

            return o;
        }
    }
}

Lançamentos

• v1.2 - -1 byte- Mudou o String o="",e="";para String o="",e=o;salvar 1 byte. A ideia era de Gallant ( esqueci de aplicar esta parte na última atualização, peço desculpas. ).
• v1.1 - -4 bytes- Soltou os colchetes dos forloops e moveu o incremento de espaçoe var para a zona do iterador do loop externo . A ideia era de Gallant .for
• v1.0 - 136 bytes- Solução inicial.

Python 2.7, 70 82 bytes

Eu não conseguia descobrir como obtê-lo em 1 linha. Ligue come("abcde",0)

def e(s,p):
 f=len(s)
 for x in range(f):print(' '*p+s[:x+1])
 if f>1:e(s[1:],p+1)

Python 3, 80 bytes

Faça um loop pelo número de espaços para prefixar e, em seguida, pelo número de caracteres para terminar.

lambda x:[print(' '*i+x[i:j+1])for i in range(len(x))for j in range(i,len(x))]

Editar: espaços removidos antes dos loops for.

MATL, 15 14 bytes

Guardou um byte devido à dica de @ LuisMendo aqui !

tfWt2/!-RXzB*c

Tantas maneiras ... tinha que encontrar uma nova. Pedaços felizes! :)

Experimente online!

Explodido

t       % duplicate input
f       % get indices of nonzero elements in vector (i.e. 1:n)
W       % 2 raised to array, element-wise: 2^(1:n)
t       % duplicate array
2/      % divide by 2: 2^(0:n-1)
!       % transpose array 
-       % element-wise subtraction (w/singleton expansion)
R       % upper triangular part
Xz      % nonzero elements
B       % convert from decimal to binary. Produces a logical array
*       % array product (element-wise, singleton expansion)
c       % convert to character array; 0's automatically converted to spaces

JavaScript (ES6), 89 bytes

document.write("<pre>"+(

s=>(a=[...s]).map((_,i)=>a.map((_,j)=>++j>i?r+=" ".repeat(i)+s.slice(i,j)+`
`:0),r="")&&r

)("abcde"))

Abordagem direta. A saída tem uma nova linha à direita.

JavaScript (ES6), 72

s=>{for(i=j=0;s[j]||s[j=++i];)console.log(' '.repeat(i)+s.slice(i,++j))}      

Pitão, 12 11 bytes

jm+*;xQdd.:

Infelizmente, a pergunta nos permite assumir caracteres únicos, então apenas procuro a primeira posição da substring e preencho com espaços.

Mathematica 89 bytes

r@i_:=StringReplace[i,#->" "]&/@(Complement[y,#]&/@Subsequences[y=Characters@i])//Column

Explicação

i refere-se à sequência de entrada

Subsequences[y=Characters@i]retorna todas as subsequências (listas representadas de caracteres) da entrada. (Subsequences foi introduzido no v. 10.4)

Para cada subsequência, Complement...retorna os caracteres da sequência de entrada que não estão presentes. Cada um desses caracteres é substituído por um espaço vazio via StringReplace[i,#->" "].

Columnexibe os resultados em uma única coluna. Cada sequência de saída possui o mesmo número de caracteres, resultando em letras alinhadas.

r@"abcdefgh"

J, 32 29 28 bytes

(-@{.@i.|.])"1 a:>@-.~&,<\\.

Isso avalia um verbo monádico. Experimente aqui. Uso:

   f =: (-@{.@i.|.])"1 a:>@-.~&,<\\.
   f 'abe'
a  
ab 
abe
 b 
 be
  e

Explicação

Como algumas outras respostas, calculo o índice de ocorrência do primeiro caractere de cada substring. As substrings são armazenadas em uma matriz com espaços à direita, então eu as giro para a direita pelo seu índice para obter a quantidade certa de preenchimento. Esse pedaço de espaço em branco entre "1e a:é realmente irritante ...

(-@{.@i.|.])"1 a:>@-.~&,<\\.  Input is y
                        <\\.  Compute suffixes of prefixes of y, and put them in boxes.
                              This gives a 2D array of substrings in boxes.
                      &,      Flatten the array of boxes,
               a:  -.~        remove all empty strings, and
                 >@           open each box. This places the strings in a 2D matrix of
                              characters, with trailing spaces to make it rectangular.
(          )"1                Do this for each line x in the matrix:
      i.                        The index of every character of x in y.
 -@{.@                          Take the first one and negate it.
        |.]                     Rotate x to the left by that amount.
                                Since we negated the index, this rotates to the right.

JavaScript (Firefox 30-57), 65 63 bytes

s=>[for(c of(i=0,s))for(d of(t=r=i?t+' ':'',s.slice(i++)))r+=d]

Retorna uma matriz de seqüências de caracteres. Como ES6, são 78 bytes:

s=>[...s].map((_,i,a)=>a.slice(i).map(c=>r.push(u+=c),t=u=i?t+' ':''),r=[])&&r

QBasic, 75 bytes

INPUT s$
FOR i=1TO LEN(s$)
FOR j=1TO i
LOCATE,j
?MID$(s$,j,i+1-j)
NEXT
NEXT

A FORestratégia básica de duplo loop, modificou um pouco a indexação baseada em 1 do QBasic. O principal truque é LOCATE,j, que move o cursor para a coluna jda linha atual antes da impressão. Como a coluna 1 é a primeira coluna, isso equivale a imprimir j-1espaços à esquerda.

Perl 6 , 34 bytes

perl6 -ne 'm/^(.*)(.+)<{+put " "x$0.to,$1}>/'

m/       # match the input line
  ^      # from the start
  ( .* ) # 0 or more characters ( $0 )
  ( .+ ) # 1 or more characters ( $1 )

  <{ # match against the result of:

    +put # print with a trailing newline:
      " " x $0.to, # add the leading spaces
      $1           # the substring
  }>
/

A razão para o +anterior puté que ele retorna em 1vez de True, o que é garantido para não estar na entrada, portanto, ele sempre deve retornar.

$ perl6 -ne 'm/^(.*)(.+)<{+put " "x$0.to,$1}>/' <<< abcd

   d
  cd
  c
 bcd
 bc
 b
abcd
abc
ab
a

(Se você quiser na ordem oposta, use em (.*?)(.+?)vez de (.*)(.+))

Isso foi inspirado na resposta do Perl 5 .

J, 35 23 22 bytes

[:;#\.<@{."_1|.\."1^:2

Demorei um pouco, mas finalmente o otimizei.

Uso

   f =: [:;#\.<@{."_1|.\."1^:2
   f 'abcde'
abcde
abcd 
abc  
ab   
a    
 bcde
 bcd 
 bc  
 b   
  cde
  cd 
  c  
   de
   d 
    e

Explicação

[:;#\.<@{."_1|.\."1^:2  Input: s
             |.\."1     For each suffix of s, reverse it
                   ^:2  Repeat that twice to create all exploded substrings
   #\.                  Get the length of each suffix. This is
                        used to make the range [len(s), len(s)-1, ..., 1]
        {."_1           For each value in the range, take that many strings from
                        the list of exploded substrings. This avoids blank substrings
      <@                Box each set of strings
[:;                     Unbox and join the strings together and return

Java, 138 bytes

String e(String s){int l=s.length(),a=0,i,j;for(;++a<l;)for(i=0;i<=l-a;){s+="\n";for(j=0;j++<i;)s+=" ";s+=s.substring(i,i+++a);}return s;}

Formatado:

String e(String s) {
    int l = s.length(), a = 0, i, j;
    for (; ++a < l;)
        for (i = 0; i <= l - a;) {
            s += "\n";
            for (j = 0; j++ < i;)
                s += " ";
            s += s.substring(i, i++ + a);
        }
    return s;
}

Pyke, 15 bytes

QlFUQRd:DlRF2h<

Experimente aqui!

Assume que a matriz de cordas acolchoadas é aceitável

Almofadas primeiro e depois costeletas.

Haskell, 65 bytes

(>>=zipWith((++).(`replicate`' '))[0..].init.tails).reverse.inits

Isso requer inits e tailsdo Data.List, no entanto. Para produzi-lo, adicione mapM_ putStrLn.à frente.

Relativamente simples; o reverseé para garantir que a sequência original seja a primeira.

GHCi> mapM_ putStrLn.(>>=zipWith((++).(`replicate`' '))[0..].init.tails).reverse.inits$"abcde"
abcde
 bcde
  cde
   de
    e
abcd
 bcd
  cd
   d
abc
 bc
  c
ab
 b
a
it :: ()
(0.02 secs, 0 bytes)

Ruby, 75 67 bytes

Função anônima. Usa substituição de regex para alinhar as substrings. .é o caractere de preenchimento.

->s{(l=s.size).times{|i|(l-i).times{|j|puts s.tr(?^+s[j,i+1],?.)}}}

bash + núcleo GNU, 109 bytes

l=${#1}
for i in `seq 0 $l`;{
for j in `seq $((l-i))`;{
for k in `seq $i`;{ printf ' ';}
echo ${1:i:j}
}; }

Talvez exista uma solução mais curta, mas é a melhor que me ocorreu. A exclusividade dos caracteres não importa aqui.

PHP, 151 caracteres

Ungolfed

<?php
$input = $argv[1];
foreach(str_split($input) as $p=>$letter)
{
    $spaces = str_repeat(" ", $p);
    echo $spaces.$letter."\n";
    $p++;
    for($i=$p;$i<strlen($input);$i++)
    {
        echo $spaces.$letter.substr($input, $p, $i)."\n";
    }
}
?>

Golfe

<?$c=$argv[1];foreach(str_split($c)as$d=>$b){$a=str_repeat(" ",$d);echo$a.$b."\n";$d++;for($e=$d;$e<strlen($c);$e++){echo$a.$b.substr($c,$d,$e)."\n";}}

Exemplo

php explodesub.php 'abc'
a
ab
abc
 b
 bc
  c

C ++, 145 bytes

o primeiro parâmetro inicial é usado como entrada, console como saída

#include<iostream>
#define f(y,b,d) for(int y=b;r[0][y];y++){d;}
int main(int,char*r[]){f(x,0,f(y,x+1,std::cout.write(r[0],y)<<'\n')r[0][x]=32)}

Python 2 (não jogado) 99 bytes

t=raw_input()
l=len(t)
for j in range(l):
 for i in range(l):
  if i>=j:print j*' '+t[j:i+1]  

Resultado:

>>python codegolf.py
abc
a
ab
abc
 b
 bc
  c

>>python codegolf.py
abcdef
a
ab
abc
abcd
abcde
abcdef
 b
 bc
 bcd
 bcde
 bcdef
  c
  cd
  cde
  cdef
   d
   de
   def
    e
    ef
     f

>>python codegolf.py
lmnopqrst
l
lm
lmn
lmno
lmnop
lmnopq
lmnopqr
lmnopqrs
lmnopqrst
 m
 mn
 mno
 mnop
 mnopq
 mnopqr
 mnopqrs
 mnopqrst
  n
  no
  nop
  nopq
  nopqr
  nopqrs
  nopqrst
   o
   op
   opq
   opqr
   opqrs
   opqrst
    p
    pq
    pqr
    pqrs
    pqrst
     q
     qr
     qrs
     qrst
      r
      rs
      rst
       s
       st
        t