introduction

Observons la chaîne abc. Les sous-chaînes qui peuvent être faites à partir de cela sont:

a, ab, abc, b, bc, c

Nous devons maintenant les aligner sous la chaîne initiale, comme ceci:

abc
a
 b
  c
ab
 bc
abc

L'ordre de la chaîne n'a pas d'importance, c'est donc également parfaitement valable:

abc
a
ab
abc
 b
 bc
  c

Ainsi, la sous-chaîne est positionnée sous l'emplacement de la sous-chaîne dans la chaîne initiale. Donc, pour abcdefla sous-chaîne cde, cela ressemblerait à ceci:

abcdef
  cde

La tâche

La tâche consiste à aligner toutes les sous-chaînes avec une longueur supérieure à 0 , comme illustré ci-dessus. Vous pouvez supposer que la chaîne elle-même ne contiendra que des caractères alphabétiques et aura au moins 1 caractère. Pour le remplissage, vous pouvez utiliser un espace ou un autre caractère ASCII imprimable non alphabétique ( 32 - 127). Peut-être pas nécessaire de le mentionner, mais la chaîne elle-même ne contiendra que des caractères uniques, donc pas comme aba, car le ase produit deux fois.

Cas de test

Contribution: abcde

Sortie possible:

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

Contribution: abcdefghij

Sortie possible:

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

C'est du code-golf , donc la soumission avec le moins d'octets gagne!

Pyth, 14 13 10 octets

Merci à @FryAmTheEggman pour avoir économisé 3 octets.

jmXQ-Qd;.:

Essayez-le en ligne!

Perl, 32 28 24 octets

Inclut +1 pour -n

Code:

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

Exécutez avec la chaîne sur STDIN:

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

Les langues de golf sont si proches et pourtant si loin ...

Explication

/.+/correspond à une sous-chaîne. Malheureusement, il s'arrête une fois qu'il a correspondu à un. J'utilise donc la construction regex d'exécution (??{})pour étendre l'expression régulière afin qu'elle échoue et le retour en arrière essaiera la sous-chaîne suivante, à la fin, en les essayant tous avant d'abandonner de dégoût.

À l'intérieur du (??{})I, j'imprime la sous-chaîne courante préfixée par autant d'espaces que le décalage de la sous-chaîne en utilisant$"x"@-"

Ainsi, la sortie documente parfaitement le fonctionnement du retour en arrière regex:

abcd
abc
ab
a
 bcd
 bc
 b
  cd
  c
   d

MATL , 20 18 octets

Inspiré par le modèle de sous-chaînes généré par la réponse de @ aditsu

tt!+gR*c`t3Lt3$)tn

Essayez-le en ligne!

Le motif de sous-chaînes est généré par une matrice triangulaire supérieure de la même taille que l'entrée, et toutes les sous-matrices sont obtenues en supprimant successivement la dernière ligne et la dernière colonne.

Explication

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

Ancienne approche (pouvoir cartésien)

Je garde cette approche au cas où elle servirait d'inspiration pour d'autres réponses

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

Dans le compilateur en ligne, cela manque de mémoire pour le cas de test le plus long.

Essayez-le en ligne!

Explication

Cela génère tous les modèles de valeurs 0, 1et 2dans l'ordre croissant, puis se transforme 2en 0. Cela donne tous les modèles possibles de 0et 1où les 1valeurs sont contiguës. Ceux-ci sont utilisés pour marquer quels caractères sont extraits de la chaîne d'origine.

Par exemple, pour la chaîne, 'abc'les modèles sont générés comme suit. [0 1 2]On obtient d' abord la puissance cartésienne de élevée au nombre de caractères saisis:

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

Le tri de chaque ligne donne

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

La transformation 2en 0(c'est-à-dire mod(...,2)) et la suppression des lignes en double donne le motif final

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

dans lequel chaque ligne est un masque correspondant à une sous-chaîne (contiguë). La première ligne doit être supprimée car elle correspond à la sous-chaîne vide.

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

Rétine , 48 32 31 octets

Merci à Kenny Lau pour avoir économisé 3 octets et ouvert la voie à bien d'autres.

Le nombre d'octets suppose un codage ISO 8859-1.

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

Essayez-le en ligne!

Ordre des sous-chaînes générées:

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

Explication

M&!r`.+

Cela nous donne tous les préfixes de l'entrée. Cela se fait en faisant correspondre ( M) toute sous-chaîne ( .+) à partir de la fin ( r), en considérant les correspondances qui se chevauchent ( &) et en retournant toutes ces correspondances jointes avec des sauts de ligne ( !).

Il ne nous reste plus qu'à tailler les préfixes successifs de ces préfixes (en les remplaçant par des espaces). Nous faisons cela étape par étape avec une boucle:

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

Les %moyens que cette chose ensemble est fait à chaque ligne individuellement ( en considérant une chaîne séparée pour être de temps, et se joindre à tout retour ensemble avec linefeeds à la fin). Le +dit à Retina d'exécuter cette substitution en boucle jusqu'à ce que la sortie cesse de changer (ce qui signifie dans ce cas que l'expression régulière ne correspond plus). L'expression régulière essaie ensuite de faire correspondre la dernière ligne de l'entrée avec au moins deux caractères non-espace et ajoute une nouvelle ligne où le premier de ceux-ci est remplacé par un espace.

Oracle SQL 11.2, 146 octets

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;

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

Essayez-le en ligne

Explication:

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 octets

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

Sort un setsemblable {' b', 'a', 'ab'}. L'idée est de rappeler deux branches qui coupent le premier ou le dernier caractère. Le donne des sorties redondantes, mais le setsupprime automatiquement les doublons. Pour l'alignement, chaque fois que le premier caractère est coupé, un espace est ajouté au préfixe p, qui est concaténé sur le devant.

PowerShell v2 +, 69 octets

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

Prend l'entrée $a, boucle sur la longueur (réglage $bdans le processus pour une utilisation ultérieure). Chaque boucle externe, nous bouclons à $bnouveau, en $ivue d'une utilisation ultérieure. Chaque boucle interne, nous sortons le $inombre d'espaces concaténés avec une tranche de la chaîne d'entrée. Étant donné que nous parcourons simplement la chaîne, cela gérera en fait n'importe quelle chaîne arbitraire (lettres en double, espaces, etc.).

Exemple

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 octets

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

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

Code complet

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

Communiqués

• v1.2 - -1 byte- Changé la String o="",e="";pour String o="",e=o;sauver 1 octet. L'idée est venue de Gallant ( j'ai oublié d'appliquer cette partie dans la dernière mise à jour, je m'excuse. ).
• v1.1 - -4 bytes- Suppression des crochets des forboucles et déplacement de l' incrément d'espacee var vers la zone itérateur de la boucle externe . L'idée venait defor Gallant .
• v1.0 - 136 bytes- Solution initiale.

Python 2.7, 70 82 octets

Je ne pouvais pas comprendre comment l'obtenir sur 1 ligne. Appeler avece("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 octets

Parcourez le nombre d'espaces à préfixer, puis le nombre de caractères à terminer.

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

Edit: Suppression des espaces avant les boucles for.

MATL, 15 14 octets

Un octet enregistré grâce à la astuce de @ LuisMendo ici !

tfWt2/!-RXzB*c

Tant de façons ... ont dû en trouver une nouvelle. Des morceaux heureux! :)

Essayez-le en ligne!

A explosé

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 octets

document.write("<pre>"+(

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

)("abcde"))

Approche directe. La sortie a une nouvelle ligne de fin.

JavaScript (ES6), 72

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

Pyth, 12 11 octets

jm+*;xQdd.:

Malheureusement, la question nous permet de supposer des caractères uniques, donc je viens de rechercher la première position de la sous-chaîne et de remplir avec des espaces.

Mathematica 89 octets

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

Explication

i fait référence à la chaîne d'entrée

Subsequences[y=Characters@i]renvoie toutes les sous-séquences (listes de caractères représentées) de l'entrée. (a Subsequencesété introduit au v. 10.4)

Pour chaque sous-séquence, Complement...renvoie les caractères de la chaîne d'entrée qui ne sont pas présents. Chacun de ces personnages est remplacé par un espace vide via StringReplace[i,#->" "].

Columnaffiche les résultats dans une seule colonne. Chaque chaîne de sortie a le même nombre de caractères, ce qui donne des lettres alignées.

r@"abcdefgh"

J, 32 29 28 octets

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

Cela équivaut à un verbe monadique. Essayez ici. Usage:

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

Explication

Comme quelques autres réponses, je calcule l'indice d'occurrence du premier caractère de chaque sous-chaîne. Les sous-chaînes sont stockées dans une matrice avec des espaces de fin, donc je les fais pivoter vers la droite par leur index pour obtenir la bonne quantité de remplissage. Ce seul espace entre "1et a:est vraiment ennuyeux ...

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

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

Retourne un tableau de chaînes. Comme ES6, c'est 78 octets:

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

QBasic, 75 octets

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

La FORstratégie de base à double boucle, un peu modifiée pour l'indexation basée sur 1 de QBasic. L'astuce principale est de LOCATE,jdéplacer le curseur sur la colonne jde la ligne actuelle avant l'impression. Étant donné que la colonne 1 est la première colonne, cela équivaut à imprimer j-1des espaces de début .

Perl 6 , 34 octets

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 raison de l' +avant putest qu'il retourne 1au lieu de True, ce qui est garanti de ne pas être dans l'entrée, il doit donc toujours revenir en arrière.

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

   d
  cd
  c
 bcd
 bc
 b
abcd
abc
ab
a

(Si vous le souhaitez dans l'ordre inverse, utilisez (.*?)(.+?)plutôt que (.*)(.+))

Cela a été inspiré par la réponse Perl 5 .

J, 35 23 22 octets

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

Cela m'a pris du temps mais je l'ai finalement optimisé.

Usage

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

Explication

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

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

Formaté:

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 octets

QlFUQRd:DlRF2h<

Essayez-le ici!

Suppose que le tableau de chaînes rembourrées est acceptable

Tamponnez d'abord, puis hachez.

Haskell, 65 octets

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

Cela nécessite initset tailsdepuis Data.List, cependant. Pour le sortir, ajoutez-le mapM_ putStrLn.à l'avant.

Relativement simple; l' reverseest pour vous assurer que la chaîne d' origine est d' abord.

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)

Rubis, 75 67 octets

Fonction anonyme. Utilise la substitution regex pour aligner les sous-chaînes. .est le caractère de remplissage.

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

bash + GNU coreutils, 109 octets

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

Il y a peut-être une solution plus courte, mais c'est la meilleure qui m'est venue à l'esprit. L'unicité des caractères n'a pas d'importance ici.

PHP, 151 caractères

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

Golfé

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

Exemple

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

C ++, 145 octets

le premier paramètre de démarrage est utilisé comme entrée, la console comme sortie

#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 (non golfé) 99 octets

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]  

Résultat:

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