Wprowadzenie

Obserwujmy ciąg abc. Podciągi, które można z tego wykonać, to:

a, ab, abc, b, bc, c

Teraz musimy wyrównać je pod początkowym ciągiem, tak jak to:

abc
a
 b
  c
ab
 bc
abc

Kolejność łańcucha nie ma znaczenia, więc jest to również całkowicie poprawne:

abc
a
ab
abc
 b
 bc
  c

Zatem podłańcuch jest umieszczony pod lokalizacją podłańcucha w początkowym ciągu. A więc dla abcdefi podciągów cdewyglądałoby to tak:

abcdef
  cde

Zadanie

Zadaniem jest wyrównanie wszystkich podciągów o długości większej niż 0 , jak pokazano powyżej. Możesz założyć, że sam łańcuch będzie zawierał tylko znaki alfabetyczne i ma co najmniej 1 znak. Do wypełnienia można użyć spacji lub innego niealfabetycznego drukowalnego znaku ASCII ( 32 - 127). Może nie trzeba wspominać, ale sam łańcuch będzie zawierał tylko unikalne znaki, więc nie lubię aba, ponieważ awystępuje dwa razy.

Przypadki testowe

Wkład: abcde

Możliwe wyjście:

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

Wkład: abcdefghij

Możliwe wyjście:

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

To jest golf golfowy , więc wygrywanie z najmniejszą ilością bajtów wygrywa!

Pyth, 14 13 10 bajtów

Dzięki @FryAmTheEggman za zapisanie 3 bajtów.

jmXQ-Qd;.:

Wypróbuj online!

Perl, 32 28 24 bajtów

Obejmuje +1 dla -n

Kod:

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

Uruchom z ciągiem na STDIN:

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

Języki gry w golfa są tak blisko, a jednocześnie tak daleko ...

Wyjaśnienie

/.+/dopasowuje podciąg. Niestety przestaje działać, gdy pasuje do jednego. Dlatego używam konstrukcji wyrażenia regularnego w (??{})celu rozszerzenia wyrażenia regularnego, aby się nie powiodło, a backtracking wypróbuje następujące podciągi, w końcu wypróbuje je wszystkie, zanim zrezygnuje z obrzydzenia.

Wewnątrz (??{})drukuję bieżący podciąg poprzedzony tyloma spacjami, ile używa przesunięcie podła$"x"@-"

Dane wyjściowe dokładnie dokumentują działanie funkcji powrotu wyrażenia regularnego:

abcd
abc
ab
a
 bcd
 bc
 b
  cd
  c
   d

MATL , 20 18 bajtów

Zainspirowany wzorcem podciągów generowanym przez odpowiedź @ aditsu

tt!+gR*c`t3Lt3$)tn

Wypróbuj online!

Wzór podciągów jest generowany przez górną trójkątną matrycę tego samego rozmiaru co dane wejściowe, a wszystkie podmacierze uzyskane przez sukcesywne usuwanie ostatniego rzędu i kolumny.

Wyjaśnienie

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

Stare podejście (moc kartezjańska)

Utrzymuję to podejście na wypadek, gdyby stanowiło inspirację dla innych odpowiedzi

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

W kompilatorze online zabraknie pamięci dla najdłuższego przypadku testowego.

Wypróbuj online!

Wyjaśnienie

To generuje wszystkie wzory wartości 0, 1i 2w kolejności rosnącej, a następnie przekształca 2się 0. Daje to wszystkie możliwe wzorce 0i 1gdzie 1wartości są ciągłe. Służą do oznaczania, które znaki pochodzą z oryginalnego łańcucha.

Na przykład dla łańcucha 'abc'wzorce są generowane w następujący sposób. Najpierw [0 1 2]uzyskuje się siłę kartezjańską podniesionej do liczby znaków wejściowych:

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

Sortowanie każdego wiersza daje

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

Przekształcenie 2w 0(tj. mod(...,2)) I usunięcie zduplikowanych wierszy daje ostateczny wzór

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

w którym każdy wiersz jest maską odpowiadającą (ciągłemu) podciągowi. Pierwszy wiersz musi zostać usunięty, ponieważ odpowiada pustemu podciągowi.

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 bajtów

Dzięki Kenny Lau za uratowanie 3 bajtów i torowanie drogi dla wielu innych.

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

Wypróbuj online!

Kolejność generowanych podciągów:

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

Wyjaśnienie

M&!r`.+

Daje nam to wszystkie prefiksy wejścia. Odbywa się to poprzez dopasowanie ( M) dowolnego podłańcucha (.+ ) zaczynającego się od końca ( r), z uwzględnieniem nakładających się dopasowań ( &) i zwracania wszystkich dopasowań połączonych z linefeeds ( !).

Teraz wszystko, co musimy zrobić, to wykreślić kolejne prefiksy tych prefiksów (zastępując je spacjami). Robimy to krok po kroku za pomocą pętli:

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

Te %środki, cała ta sprawa jest wykonywana indywidualnie dla każdej linii (biorąc pod uwagę to osobny ciąg na chwilę obecną i łączenia go z powrotem wszystko razem z karetki na końcu). +Mówi siatkówka do uruchomienia tej zmiany w pętli aż wyjście przestaje zmianę (co w tym przypadku oznacza, że już nie regex mecze). Wyrażenie regularne następnie próbuje dopasować ostatni wiersz danych wejściowych co najmniej dwoma znakami spacji i dołącza nowy wiersz, w którym pierwszy z nich jest zastąpiony spacją.

Oracle SQL 11.2, 146 bajtów

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;

Bez golfa

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

Wypróbuj online

Wyjaśnienie:

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 bajtów

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

Wykazuje setpodobny {' b', 'a', 'ab'}. Chodzi o to, aby powtórzyć dwa rozgałęzienia, które odcinają pierwszą lub ostatnią postać. Daje nadmiarowe dane wyjściowe, ale setautomatycznie usuwa duplikaty. W celu wyrównania za każdym razem, gdy pierwszy znak jest odcinany, do prefiksu dodawana jest spacja p, która jest łączona z przodu.

PowerShell v2 +, 69 bajtów

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

Pobiera dane wejściowe $a, pętle na całej długości (ustawienie $bw procesie do użytku później). Każdą pętlę zewnętrzną zapętlamy $bponownie, ustawiając $ido późniejszego użycia. Każdą wewnętrzną pętlę wysyłamy$i liczbę spacji połączonych z wycinkiem ciągu wejściowego. Ponieważ po prostu zapętlamy ciąg, w rzeczywistości obsłuży on dowolny dowolny ciąg (zduplikowane litery, spacje, cokolwiek).

Przykład

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 bajtów

Grał w golfa

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

Bez golfa

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

Pełny kod

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

Wydawnictwa

• v1.2 - -1 byte- Zmieniono String o="",e="";aby String o="",e=o;zapisać 1 bajt. Pomysł pochodzi od Gallanta ( przepraszam, zapomniałem zastosować tę część w ostatniej aktualizacji ).
• v1.1 - -4 bytes- Upuścił nawiasy z forpętli i przesunął przyrost przestrzenie var do strefy iteratora zewnętrznejfor pętli. Pomysł pochodzi od Gallanta .
• v1.0 - 136 bytes- Wstępne rozwiązanie.

Python 2.7, 70 82 bajtów

Nie mogłem wymyślić, jak to zrobić w 1 linii. Zadzwoń ze("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 bajtów

Zapętlaj liczbę spacji do poprzedzenia, a następnie liczbę znaków na końcu.

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

Edycja: Usunięto spacje przed pętlami for.

MATL, 15 14 bajtów

Zapisane jeden bajt powodu @ LuisMendo w końcówce tutaj !

tfWt2/!-RXzB*c

Tyle sposobów ... musiałem znaleźć nowy. Szczęśliwe kawałki! :)

Wypróbuj online!

Eksplodował

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 bajtów

document.write("<pre>"+(

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

)("abcde"))

Proste podejście. Wyjście ma końcowy znak nowej linii.

JavaScript (ES6), 72

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

Pyth 12 11 bajtów

jm+*;xQdd.:

Niestety pytanie pozwala nam przyjąć unikalne znaki, więc po prostu sprawdzam pierwszą pozycję podłańcucha i pad ze spacjami.

Matematyka 89 bajtów

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

Wyjaśnienie

i odnosi się do ciągu wejściowego

Subsequences[y=Characters@i]zwraca wszystkie podciągi (reprezentowane listy znaków) danych wejściowych. (Subsequences został wprowadzony w wer. 10.4)

Dla każdego podsekwencji Complement...zwraca te znaki z ciągu wejściowego, które nie są obecne. Każdą z tych postaci zastępuje puste miejsce przez StringReplace[i,#->" "].

Columnwyświetla wyniki w jednej kolumnie. Każdy ciąg wyjściowy ma taką samą liczbę znaków, co powoduje wyrównanie liter.

r@"abcdefgh"

J, 32 29 28 bajtów

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

To odnosi się do czasownika monadycznego. Wypróbuj tutaj. Stosowanie:

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

Wyjaśnienie

Jako kilka innych odpowiedzi obliczam wskaźnik występowania pierwszego znaku każdego podłańcucha. Podciągi są przechowywane w macierzy ze spacjami końcowymi, więc obracam je w prawo o ich indeks, aby uzyskać odpowiednią ilość wypełnienia. Ten jeden biały znak pomiędzy "1i a:jest naprawdę denerwujący ...

(-@{.@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 bajtów

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

Zwraca tablicę ciągów. Jako ES6 ma 78 bajtów:

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

QBasic, 75 bajtów

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

Podstawowa FORstrategia podwójnego zapętlenia, nieco zmodyfikowana dla indeksowania opartego na 1 QBasic. Główną sztuczką jestLOCATE,j przeniesienie kursora do kolumny jbieżącego wiersza przed wydrukowaniem. Ponieważ kolumna 1 jest pierwszą kolumną, jest to równoważne z drukowaniem j-1spacji wiodących.

Perl 6 , 34 bajtów

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

Powodem dla +wcześniej putjest tak, że zwraca 1zamiast True, co jest zagwarantowane, aby nie być na wejściu więc zawsze musi wracać.

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

   d
  cd
  c
 bcd
 bc
 b
abcd
abc
ab
a

(Jeśli chcesz to w odwrotnej kolejności, użyj (.*?)(.+?)zamiast (.*)(.+))

Zostało to zainspirowane odpowiedzią Perla 5 .

J, 35 23 22 bajtów

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

Zajęło mi to trochę czasu, ale w końcu go zoptymalizowałem.

Stosowanie

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

Wyjaśnienie

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

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

Sformatowany:

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 bajtów

QlFUQRd:DlRF2h<

Wypróbuj tutaj!

Przyjmuje, że tablica wyściełanych łańcuchów jest dopuszczalna

Najpierw podkładki, a następnie kotlety.

Haskell, 65 bajtów

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

Wymaga to jednak initsi tailsod Data.List. Aby go wydrukować, dodajmapM_ putStrLn. do przodu.

Stosunkowo proste; reversejest upewnienie się oryginalny łańcuch jest pierwszy.

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 bajtów

Funkcja anonimowa. Używa podstawienia wyrażenia regularnego, aby wyrównać podciągi. .jest znakiem wypełniającym.

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

bash + GNU coreutils, 109 bajtów

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

Być może istnieje krótsze rozwiązanie, ale to najlepsze, co przyszło mi do głowy. Wyjątkowość znaków nie ma tutaj znaczenia.

PHP, 151 znaków

Bez golfa

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

Grał w golfa

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

Przykład

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

C ++, 145 bajtów

pierwszy parametr początkowy służy jako wejście, konsola jako wyjście

#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 bajtów

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]  

Wynik:

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