Einführung

Lassen Sie uns die Zeichenfolge beobachten abc. Die Teilzeichenfolgen, die daraus erstellt werden können, sind:

a, ab, abc, b, bc, c

Wir müssen sie nun wie folgt unter der Anfangszeichenfolge ausrichten:

abc
a
 b
  c
ab
 bc
abc

Die Reihenfolge der Zeichenfolge spielt keine Rolle, daher gilt dies auch:

abc
a
ab
abc
 b
 bc
  c

Die Teilzeichenfolge befindet sich also unter der Position der Teilzeichenfolge in der Anfangszeichenfolge. Also für abcdefund die Teilzeichenfolge cdewürde es so aussehen:

abcdef
  cde

Die Aufgabe

Die Aufgabe besteht darin, alle Teilzeichenfolgen mit einer Länge größer als 0 auszurichten , wie oben gezeigt. Sie können davon ausgehen, dass die Zeichenfolge selbst nur alphabetische Zeichen enthält und mindestens 1 Zeichen enthält. Zum Auffüllen können Sie ein Leerzeichen oder ein anderes nicht alphabetisch druckbares ASCII-Zeichen ( 32 - 127) verwenden. Vielleicht nicht unbedingt zu erwähnen, aber die Zeichenfolge selbst enthält nur eindeutige Zeichen, also nicht wie aba, da die azweimal vorkommt.

Testfälle

Eingang: abcde

Mögliche Ausgabe:

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

Eingang: abcdefghij

Mögliche Ausgabe:

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

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

Pyth, 14 13 10 Bytes

Vielen Dank an @FryAmTheEggman für das Speichern von 3 Bytes.

jmXQ-Qd;.:

Probieren Sie es online!

Perl, 32 28 24 Bytes

Beinhaltet +1 für -n

Code:

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

Führen Sie mit der Zeichenfolge auf STDIN aus:

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

Die Golfsprachen sind so nah und doch so fern ...

Erläuterung

/.+/stimmt mit einem Teilstring überein. Leider hört es auf, sobald es zu einem passt. Also benutze ich das Runtime-Regex-Konstrukt (??{}), um das Regex so zu erweitern, dass es fehlschlägt. Beim Backtracking wird die folgende Teilzeichenfolge verwendet, und am Ende werden alle ausprobiert, bevor es angewidert aufgibt.

Innerhalb des (??{})drucke ich den aktuellen Teilstring, dem so viele Leerzeichen vorangestellt sind, wie der Versatz des Teilstrings verwendet$"x"@-"

Die Ausgabe dokumentiert also genau, wie das Regex-Backtracking funktioniert:

abcd
abc
ab
a
 bcd
 bc
 b
  cd
  c
   d

MATL , 20 bis 18 Bytes

Inspiriert von dem Muster der Teilzeichenfolgen, die durch @ aditsus Antwort generiert wurden

tt!+gR*c`t3Lt3$)tn

Probieren Sie es online!

Das Muster der Teilzeichenfolgen wird durch eine obere Dreiecksmatrix mit der gleichen Größe wie die Eingabe und alle Teilmatrizen erzeugt, die durch sukzessives Entfernen der letzten Zeile und Spalte erhalten werden.

Erläuterung

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

Alter Ansatz (kartesische Kraft)

Ich behalte diesen Ansatz bei, falls er als Inspiration für andere Antworten dient

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

Im Online-Compiler hat dies nicht genügend Speicher für den längsten Testfall.

Probieren Sie es online!

Erläuterung

Dies erzeugt alle Muster von Werten 0, 1und 2in aufsteigender Reihenfolge, und dann transformiert 2in 0. Dies gibt alle möglichen Muster von 0und 1wo die 1Werte zusammenhängend sind. Diese werden verwendet, um zu markieren, welche Zeichen aus der ursprünglichen Zeichenfolge stammen.

Als Beispiel für eine Zeichenfolge werden 'abc'die Muster wie folgt generiert. Zuerst wird die kartesische Potenz der [0 1 2]Erhöhung auf die Anzahl der eingegebenen Zeichen erhalten:

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

Das Sortieren jeder Zeile ergibt

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

Die Umwandlung 2in 0(dh mod(...,2)) und das Entfernen doppelter Zeilen ergibt das endgültige Muster

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

in der jede Zeile eine Maske ist, die einem (zusammenhängenden) Teilstring entspricht. Die erste Zeile muss entfernt werden, da sie der leeren Teilzeichenfolge entspricht.

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

Vielen Dank an Kenny Lau, der 3 Bytes gespart und den Weg für viele mehr geebnet hat.

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Probieren Sie es online!

Reihenfolge der generierten Teilstrings:

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

Erläuterung

M&!r`.+

Dadurch erhalten wir alle Präfixe der Eingabe. Dies erfolgt durch Matching ( M) eines beliebigen Teilstrings ( .+) beginnend mit end ( r), wobei überlappende Übereinstimmungen ( &) berücksichtigt werden und alle Übereinstimmungen zurückgegeben werden, die mit linefeeds ( !) verknüpft sind .

Jetzt müssen wir nur noch die aufeinander folgenden Präfixe dieser Präfixe herausarbeiten (indem wir sie durch Leerzeichen ersetzen). Wir machen dies Schritt für Schritt mit einer Schleife:

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

Die %bedeutet , dass diese ganze Sache auf jede Zeile einzeln durchgeführt wird (wenn man bedenkt es eine separate Zeichenfolge für Vorerst, und alles wieder zusammen mit Zeilenvorschübe am Ende Beitritt). Das +weist Retina an, diese Ersetzung in einer Schleife auszuführen, bis sich die Ausgabe nicht mehr ändert (was in diesem Fall bedeutet, dass die Regex nicht mehr übereinstimmt). Der Regex versucht dann, die letzte Zeile der Eingabe mit mindestens zwei Nicht-Leerzeichen abzugleichen, und fügt eine neue Zeile hinzu, wobei die erste durch ein Leerzeichen ersetzt wird.

Oracle SQL 11.2, 146 Byte

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;

Nicht golfen

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

Probieren Sie es online aus

Erläuterung:

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)

Gibt ein setähnliches aus {' b', 'a', 'ab'}. Die Idee ist, zwei Verzweigungen, die das erste oder letzte Zeichen abschneiden, zu rekursiv zu behandeln. Das gibt redundante Ausgaben, aber das setentfernt automatisch Duplikate. Bei der Ausrichtung wird jedes Mal, wenn das erste Zeichen abgeschnitten wird, dem Präfix ein Leerzeichen hinzugefügt p, das auf der Vorderseite verkettet wird.

PowerShell v2 +, 69 Byte

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

Nimmt Eingaben auf $a, durchläuft die Länge (Einstellung $bfür spätere Verwendung). Jede äußere Schleife wird $berneut durchlaufen und $ifür die spätere Verwendung eingestellt. In jeder inneren Schleife geben wir die $iAnzahl der Leerzeichen aus, die mit einem Teil der Eingabezeichenfolge verknüpft sind. Da wir nur die Zeichenfolge durchlaufen, werden alle beliebigen Zeichenfolgen (doppelte Buchstaben, Leerzeichen usw.) verarbeitet.

Beispiel

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

Golf gespielt

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

Vollständiger Code

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

Releases

• v1.2 - -1 byte- Geändert String o="",e="";in String o="",e=o;, um 1 Byte zu speichern. Die Idee kam von Gallant ( ich habe vergessen, diesen Teil im letzten Update anzuwenden, ich entschuldige mich. ).
• v1.1 - -4 bytes- Löste die Klammern von den forSchleifen und verschob das eVar- Space-Inkrement in die Iteratorzone der äußeren forSchleife. Die Idee kam von Gallant .
• v1.0 - 136 bytes- Anfangslösung.

Python 2.7, 70 82 Bytes

Ich konnte nicht herausfinden, wie ich es in eine Zeile bekomme. Mit anrufene("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

Durchlaufen Sie die Anzahl der Leerzeichen, denen das Präfix vorangestellt werden soll, und die Anzahl der Zeichen, mit denen das Zeichen enden soll.

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

Bearbeiten: Leerzeichen vor den for-Schleifen entfernt.

MATL, 15 14 Bytes

1 Byte aufgrund des @ LuisMendo- Tipps hier gespeichert !

tfWt2/!-RXzB*c

So viele Wege ... mussten einen neuen finden. Glückliche Stücke! :)

Probieren Sie es online!

Explodiert

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 Byte

document.write("<pre>"+(

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

)("abcde"))

Unkomplizierter Ansatz. Die Ausgabe enthält eine nachgestellte Newline.

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

Leider erlaubt uns die Frage, eindeutige Zeichen anzunehmen, so dass ich nur die erste Position des Teilstrings suche und mit Leerzeichen auffülle.

Mathematica 89 Bytes

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

Erläuterung

i bezieht sich auf die Eingabezeichenfolge

Subsequences[y=Characters@i]gibt alle Teilfolgen (dargestellte Zeichenlisten) der Eingabe zurück. ( Subsequenceswurde in v. 10.4 eingeführt)

Gibt für jede Complement...Untersequenz die Zeichen aus der Eingabezeichenfolge zurück, die nicht vorhanden sind. Jedes dieser Zeichen wird durch ein Leerzeichen ersetztStringReplace[i,#->" "] .

ColumnZeigt die Ergebnisse in einer einzelnen Spalte an. Jede Ausgabezeichenfolge hat die gleiche Anzahl von Zeichen, was zu ausgerichteten Buchstaben führt.

r@"abcdefgh"

J 32 29 28 Bytes

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

Dies ergibt ein monadisches Verb. Probieren Sie es hier aus. Verwendung:

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

Erläuterung

Als einige andere Antworten berechne ich den Index des Vorkommens des ersten Zeichens jeder Teilzeichenfolge. Die Teilzeichenfolgen werden in einer Matrix mit nachgestellten Leerzeichen gespeichert, daher drehe ich sie um ihren Index nach rechts, um den richtigen Abstand zu erhalten. Das ein Stück Whitespace zwischen "1und a:ist wirklich nervig ...

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

Gibt ein Array von Zeichenfolgen zurück. Als ES6 sind es 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

Die grundlegende FORDouble-Loop-Strategie wurde für die 1-basierte Indexierung von QBasic etwas modifiziert. Der Haupttrick ist LOCATE,j, den Cursor jvor dem Drucken in die Spalte der aktuellen Zeile zu bewegen. Da Spalte 1 die erste Spalte ist, entspricht dies dem Drucken von j-1führenden Leerzeichen.

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

Der Grund für das +Vorher putist, dass es 1stattdessen zurückkehrt True, was garantiert nicht in der Eingabe ist, so dass es immer zurückverfolgen muss.

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

   d
  cd
  c
 bcd
 bc
 b
abcd
abc
ab
a

(Wenn Sie es in umgekehrter Reihenfolge wünschen, verwenden Sie (.*?)(.+?) statt(.*)(.+) )

Dies wurde von der Perl 5-Antwort inspiriert .

J, 35 23 22 Bytes

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

Es hat eine Weile gedauert, aber ich habe es endlich optimiert.

Verwendung

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

Erläuterung

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

Formatiert:

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<

Probieren Sie es hier aus!

Vorausgesetzt, ein Array mit gepolsterten Zeichenfolgen ist zulässig

Erst Pads und dann Chops.

Haskell, 65 Bytes

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

Es erfordert initsund tailsvon Data.List. Um es auszugeben, fügen Sie mapM_ putStrLn.es der Vorderseite hinzu.

Relativ einfach; Damit reversestellen Sie sicher, dass die ursprüngliche Zeichenfolge an erster Stelle steht.

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

Anonyme Funktion. Verwendet die Regex-Ersetzung, um die Teilzeichenfolgen auszurichten. .ist das Füllzeichen.

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

Vielleicht gibt es eine kürzere Lösung, aber dies ist die beste, die mir eingefallen ist. Die Einzigartigkeit der Chracters spielt hier keine Rolle.

PHP, 151 Zeichen

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 gespielt

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

Beispiel

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

C ++, 145 Bytes

Der erste Startparameter wird als Eingabe, die Konsole als Ausgabe verwendet

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

Ergebnis:

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