Introducción

Observemos la cuerda abc. Las subcadenas que se pueden hacer de esto son:

a, ab, abc, b, bc, c

Ahora necesitamos alinearlos debajo de la cadena inicial, así:

abc
a
 b
  c
ab
 bc
abc

El orden de la cadena no importa, por lo que esto también es perfectamente válido:

abc
a
ab
abc
 b
 bc
  c

Entonces, la subcadena se coloca debajo de la ubicación de la subcadena en la cadena inicial. Entonces para abcdefy la subcadena cde, se vería así:

abcdef
  cde

La tarea

La tarea es alinear todas las subcadenas con una longitud mayor que 0 , como se muestra arriba. Puede suponer que la cadena en sí solo contendrá caracteres alfabéticos y tendrá al menos 1 carácter. Para el relleno, puede usar un espacio o algún otro carácter ASCII imprimible no alfabético ( 32 - 127). Tal vez no sea necesario mencionar, pero la cadena en sí solo contendrá caracteres únicos, por lo que no me gusta aba, ya que aocurre dos veces.

Casos de prueba

Entrada: abcde

Salida posible:

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

Entrada: abcdefghij

Salida posible:

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

Este es el código de golf , por lo que gana el envío con la menor cantidad de bytes.

Pyth, 14 13 10 bytes

Gracias a @FryAmTheEggman por guardar 3 bytes.

jmXQ-Qd;.:

Pruébalo en línea!

Perl, 32 28 24 bytes

Incluye +1 para -n

Código:

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

Ejecutar con la cadena en STDIN:

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

Los idiomas del golf están tan cerca y tan lejos ...

Explicación

/.+/coincide con una subcadena. Desafortunadamente, se detiene una vez que coincide con uno. Por lo tanto, utilizo la construcción de expresiones regulares en tiempo de ejecución (??{})para extender la expresión regular para que falle y el retroceso intentará la siguiente subcadena, al final probándolas todas antes de darse por vencido.

En el interior (??{}), imprimo la subcadena actual con el prefijo de tantos espacios como el desplazamiento de la subcadena usando$"x"@-"

Por lo tanto, el resultado documenta claramente cómo funciona el backgecking de expresiones regulares:

abcd
abc
ab
a
 bcd
 bc
 b
  cd
  c
   d

MATL , 20 18 bytes

Inspirado en el patrón de subcadenas generado por la respuesta de @ aditsu

tt!+gR*c`t3Lt3$)tn

Pruébalo en línea!

El patrón de subcadenas es generado por una matriz triangular superior del mismo tamaño que la entrada, y todas las submatrices obtenidas eliminando sucesivamente la última fila y columna.

Explicación

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

Enfoque antiguo (poder cartesiano)

Mantengo este enfoque en caso de que sirva de inspiración para otras respuestas

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

En el compilador en línea esto se queda sin memoria para el caso de prueba más largo.

Pruébalo en línea!

Explicación

Esto genera todos los patrones de valores 0, 1y 2en orden creciente, y luego se transforma 2en 0. Esto proporciona todos los patrones posibles de 0y 1donde los 1valores son contiguos. Estos se utilizan para marcar qué caracteres se toman de la cadena original.

Como ejemplo, para cadenas 'abc'los patrones se generan de la siguiente manera. Primero [0 1 2]se obtiene el poder cartesiano de elevado al 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

Ordenar cada fila da

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

Transformarse 2en 0(es decir mod(...,2)) y eliminar filas duplicadas da el patrón final

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

en el que cada fila es una máscara correspondiente a una subcadena (contigua). La primera fila debe eliminarse porque corresponde a la subcadena vacía.

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

Gracias a Kenny Lau por guardar 3 bytes y allanar el camino para muchos más.

El recuento de bytes asume la codificación ISO 8859-1.

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

Pruébalo en línea!

Orden de las subcadenas generadas:

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

Explicación

M&!r`.+

Esto nos da todos los prefijos de la entrada. Esto se hace combinando ( M) cualquier subcadena ( .+) comenzando desde el final ( r), considerando coincidencias superpuestas ( &) y devolviendo todas esas coincidencias unidas con saltos de línea ( !).

Ahora todo lo que tenemos que hacer es tallar los prefijos sucesivos de esos prefijos (reemplazándolos con espacios). Hacemos esto paso a paso con un bucle:

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

Esto %significa que todo esto se hace en cada línea individualmente (considerándolo una cadena separada por el momento, y uniendo todo nuevamente con saltos de línea al final). El +le dice a Retina que ejecute esta sustitución en un bucle hasta que la salida deje de cambiar (lo que en este caso significa que la expresión regular ya no coincide). Luego, la expresión regular intenta hacer coincidir la última línea de la entrada con al menos dos caracteres que no son espacios, y agrega una nueva fila donde el primero de ellos se reemplaza con un espacio.

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;

Sin golf

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

Pruébalo en línea

Explicación:

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)

Produce un me setgusta {' b', 'a', 'ab'}. La idea es recurrir a dos bifurcaciones que cortan el primer o el último carácter. Ofrece salidas redundantes, pero setelimina automáticamente los duplicados. Para la alineación, cada vez que se corta el primer carácter, se agrega un espacio al prefijo p, que se concatena en el frente.

PowerShell v2 +, 69 bytes

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

Toma entrada $a, recorre la longitud (configuración $ben el proceso para su uso posterior). En cada bucle externo, volvemos a hacerlo $b, configurando $ipara su uso posterior. En cada bucle interno, generamos un $inúmero de espacios concatenados con un segmento de la cadena de entrada. Como solo estamos recorriendo la cadena, esto realmente manejará cualquier cadena arbitraria (letras duplicadas, espacios, lo que sea).

Ejemplo

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

Golfed

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

Sin golf

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

Lanzamientos

• v1.2 - -1 byte- Se ha modificado el String o="",e="";de String o="",e=o;ahorrar 1 byte. La idea era de Gallant ( me olvidé de aplicar esta parte en la última actualización, me disculpo ).
• v1.1 - -4 bytes- Quitó los corchetes de los forbucles y movió el incremento de espacioe var a la zona de iterador del bucle externo . La idea era de Gallant .for
• v1.0 - 136 bytes- Solución inicial.

Python 2.7, 70 82 bytes

No pude encontrar la manera de obtenerlo en 1 línea. Llamar cone("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 78 bytes

Recorra el número de espacios para prefijar y luego el 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: espacios eliminados antes de los bucles for.

MATL 15 14 bytes

Guardado de un byte, debido a @ LuisMendo de punta aquí !

tfWt2/!-RXzB*c

Tantas maneras ... tuve que encontrar una nueva. ¡Felices bits! :)

Pruébalo en línea!

Explotó

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

Enfoque directo. La salida tiene una nueva línea final.

JavaScript (ES6), 72

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

Pyth, 12 11 bytes

jm+*;xQdd.:

Lamentablemente, la pregunta nos permite asumir caracteres únicos, por lo que solo busco la primera posición de la subcadena y rellena con espacios.

Mathematica 89 bytes

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

Explicación

i se refiere a la cadena de entrada

Subsequences[y=Characters@i]devuelve todas las subsecuencias (listas representadas de caracteres) de la entrada. (Subsequences fue introducido en el v. 10.4)

Para cada subsecuencia, Complement...devuelve los caracteres de la cadena de entrada que no están presentes. Cada uno de esos caracteres se reemplaza por un espacio vacío vía StringReplace[i,#->" "].

Columnmuestra los resultados en una sola columna. Cada cadena de salida tiene el mismo número de caracteres, lo que resulta en letras alineadas.

r@"abcdefgh"

J, 32 29 28 bytes

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

Esto se evalúa como un verbo monádico. Pruébalo aquí. Uso:

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

Explicación

Como algunas otras respuestas, calculo el índice de ocurrencia del primer carácter de cada subcadena. Las subcadenas se almacenan en una matriz con espacios finales, por lo que las giro a la derecha por su índice para obtener la cantidad correcta de relleno. Ese espacio en blanco entre "1y a:es realmente molesto ...

(-@{.@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]

Devuelve una matriz de cadenas. Como ES6 son 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

La FORestrategia básica de doble bucle, modificada un poco para la indexación basada en 1 de QBasic. El truco principal es LOCATE,j, que mueve el cursor a la columna jde la línea actual antes de imprimir. Dado que la columna 1 es la primera columna, esto es equivalente a imprimir j-1espacios iniciales.

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

La razón del +antes putes para que regrese en 1lugar de True, lo que garantiza que no estará en la entrada, por lo que siempre tiene que retroceder.

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

   d
  cd
  c
 bcd
 bc
 b
abcd
abc
ab
a

(Si lo desea en el orden opuesto, use en (.*?)(.+?)lugar de (.*)(.+))

Esto fue inspirado por la respuesta de Perl 5 .

J, 35 23 22 bytes

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

Me tomó un tiempo pero finalmente lo optimicé.

Uso

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

Explicación

[:;#\.<@{."_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;}

Formateado:

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<

Pruébalo aquí!

Asume que la variedad de cuerdas acolchadas es aceptable

Almohadillas primero y luego chuletas.

Haskell, 65 bytes

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

Sin embargo, requiere initsy tailsde Data.List. Para sacarlo, agrégalo mapM_ putStrLn.al frente.

Relativamente sencillo; el reversees asegurarse de que la cadena original es en primer lugar.

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

Función anónima. Utiliza la sustitución de expresiones regulares para alinear las subcadenas. .Es el personaje de relleno.

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

bash + GNU coreutils, 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}
}; }

Quizás haya una solución más corta, pero esta es la mejor que se me ocurrió. La singularidad de los personajes no importa aquí.

PHP, 151 caracteres

Sin golf

<?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";
    }
}
?>

Golfed

<?$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";}}

Ejemplo

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

C ++, 145 bytes

el primer parámetro de inicio se usa como entrada, la consola como salida

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