Giới thiệu

Hãy quan sát chuỗi abc. Các chuỗi con có thể được thực hiện từ đây là:

a, ab, abc, b, bc, c

Bây giờ chúng ta cần căn chỉnh chúng theo chuỗi ban đầu, như thế này:

abc
a
 b
  c
ab
 bc
abc

Thứ tự của chuỗi không quan trọng, vì vậy điều này cũng hoàn toàn hợp lệ:

abc
a
ab
abc
 b
 bc
  c

Vì vậy, chuỗi con được định vị dưới vị trí của chuỗi con trong chuỗi ban đầu. Vì vậy, cho abcdefvà chuỗi con cde, nó sẽ trông như thế này:

abcdef
  cde

Nhiệm vụ

Nhiệm vụ là căn chỉnh tất cả các chuỗi con có độ dài lớn hơn 0 , như được hiển thị ở trên. Bạn có thể giả sử rằng chính chuỗi đó sẽ chỉ chứa các ký tự chữ cái và có ít nhất 1 ký tự. Đối với phần đệm, bạn có thể sử dụng khoảng trắng hoặc một số ký tự ASCII có thể in không chữ cái khác ( 32 - 127). Có thể không cần thiết phải đề cập, nhưng bản thân chuỗi sẽ chỉ chứa các ký tự duy nhất, vì vậy không thích aba, vì việc anày xảy ra hai lần.

Các trường hợp thử nghiệm

Đầu vào: abcde

Sản lượng có thể:

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

Đầu vào: abcdefghij

Sản lượng có thể:

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

Đây là môn đánh gôn , vì vậy bài nộp có số byte ít nhất sẽ thắng!

Bình thường, 14 13 10 byte

Cảm ơn @FryAmTheEggman vì đã lưu 3 byte.

jmXQ-Qd;.:

Hãy thử trực tuyến!

Perl, 32 28 24 byte

Bao gồm +1 cho -n

Mã số:

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

Chạy với chuỗi trên STDIN:

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

Các ngôn ngữ chơi gôn rất gần và rất xa ...

Giải trình

/.+/phù hợp với một chuỗi con. Thật không may, nó dừng lại một khi nó phù hợp với một. Vì vậy, tôi sử dụng cấu trúc regex thời gian chạy (??{})để mở rộng regex để nó thất bại và quay lui sẽ thử chuỗi con sau, cuối cùng thử tất cả chúng trước khi bỏ cuộc trong sự ghê tởm.

Bên trong (??{})tôi in chuỗi con hiện tại có tiền tố bằng nhiều khoảng trắng bằng phần bù của chuỗi con bằng cách sử dụng$"x"@-"

Vì vậy, đầu ra tài liệu gọn gàng làm thế nào regex backtracking hoạt động:

abcd
abc
ab
a
 bcd
 bc
 b
  cd
  c
   d

MATL , 20 18 byte

Lấy cảm hứng từ mô hình của các chuỗi con được tạo bởi câu trả lời của @ aditsu

tt!+gR*c`t3Lt3$)tn

Hãy thử trực tuyến!

Mẫu của các chuỗi con được tạo bởi một ma trận tam giác trên có cùng kích thước với đầu vào và tất cả các mô hình con thu được bằng cách loại bỏ liên tiếp hàng và cột cuối cùng.

Giải trình

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

Cách tiếp cận cũ (sức mạnh của Cartesian)

Tôi đang giữ cách tiếp cận này trong trường hợp nó là nguồn cảm hứng cho các câu trả lời khác

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

Trong trình biên dịch trực tuyến, điều này hết bộ nhớ cho trường hợp thử nghiệm dài nhất.

Hãy thử trực tuyến!

Giải trình

Điều này tạo ra tất cả các mẫu của các giá trị 0, 1và 2theo thứ tự tăng dần, và sau đó chuyển đổi 2thành 0. Điều này cung cấp cho tất cả các mẫu có thể 0và 1nơi các 1giá trị tiếp giáp nhau. Chúng được sử dụng để đánh dấu các ký tự được lấy từ chuỗi gốc.

Ví dụ, đối với chuỗi 'abc'các mẫu được tạo như sau. Đầu tiên, sức mạnh của Cartesian [0 1 2]tăng lên đến số lượng ký tự đầu vào được lấy:

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

Sắp xếp từng hàng cho

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

Chuyển đổi 2thành 0(nghĩa là mod(...,2)) và loại bỏ các hàng trùng lặp sẽ tạo ra mẫu cuối cùng

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

trong đó mỗi hàng là một mặt nạ tương ứng với một chuỗi con (liền kề). Hàng đầu tiên cần được loại bỏ vì nó tương ứng với chuỗi con trống.

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

Võng mạc , 48 32 31 byte

Cảm ơn Kenny Lau đã lưu 3 byte và mở đường cho nhiều hơn nữa.

Số lượng byte giả định mã hóa ISO 8859-1.

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

Hãy thử trực tuyến!

Thứ tự của các chuỗi con được tạo ra:

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

Giải trình

M&!r`.+

Điều này cho chúng ta tất cả các tiền tố của đầu vào. Điều này được thực hiện bằng cách khớp ( M) bất kỳ chuỗi con ( .+) nào bắt đầu từ cuối ( r), xem xét các kết quả trùng khớp ( &) và trả về tất cả các kết quả khớp được nối với linefeed ( !).

Bây giờ tất cả những gì chúng ta cần làm là khắc các tiền tố liên tiếp của các tiền tố đó (bằng cách thay thế chúng bằng dấu cách). Chúng tôi làm điều này từng bước với một vòng lặp:

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

Điều này %có nghĩa là toàn bộ điều này được thực hiện cho từng dòng riêng lẻ (coi đây là một chuỗi riêng biệt và kết hợp tất cả lại với nhau bằng các nguồn cấp dữ liệu ở cuối). Việc báo +cho Retina chạy thay thế này trong một vòng lặp cho đến khi đầu ra dừng thay đổi (trong trường hợp này có nghĩa là biểu thức chính quy không còn phù hợp nữa). Regex sau đó cố gắng khớp dòng cuối cùng của đầu vào với ít nhất hai ký tự không phải khoảng trắng và nối thêm một hàng mới trong đó hàng đầu tiên được thay thế bằng khoảng trắng.

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;

Không chơi gôn

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

Dùng thử trực tuyến

Giải trình:

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 byte

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

Đầu ra setnhư một {' b', 'a', 'ab'}. Ý tưởng là tái diễn hai nhánh mà cắt bỏ ký tự đầu tiên hoặc cuối cùng. Việc cung cấp đầu ra dự phòng, nhưng settự động loại bỏ trùng lặp. Để căn chỉnh, mỗi khi ký tự đầu tiên bị cắt, một khoảng trắng được thêm vào tiền tố p, được nối vào phía trước.

PowerShell v2 +, 69 byte

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

Đưa đầu vào $a, vòng lặp theo chiều dài (thiết lập $btrong quy trình để sử dụng sau). Mỗi vòng lặp bên ngoài, chúng tôi lặp $blại một lần nữa, thiết lập $iđể sử dụng sau. Mỗi vòng lặp bên trong, chúng ta xuất $isố lượng khoảng trắng được nối với một lát của chuỗi đầu vào. Vì chúng ta chỉ lặp qua chuỗi, nên điều này thực sự sẽ xử lý bất kỳ chuỗi tùy ý nào (trùng lặp chữ cái, dấu cách, bất cứ điều gì).

Thí dụ

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 byte

Chơi gôn

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

Ung dung

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

Mã đầy đủ

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

Phát hành

• v1.2 - -1 byte- Thay đổi String o="",e="";thành String o="",e=o;để lưu 1 byte. Ý tưởng là từ Gallant ( tôi đã quên áp dụng phần này trong bản cập nhật cuối cùng, tôi xin lỗi. ).
• v1.1 - -4 bytes- Thả dấu ngoặc từ các forvòng lặp và di chuyển gia tăng không giane var sang vùng lặp của forvòng lặp bên ngoài . Ý tưởng là từ Gallant .
• v1.0 - 136 bytes- Giải pháp ban đầu.

Python 2.7, 70 82 byte

Tôi không thể tìm ra làm thế nào để có được nó trên 1 dòng. Gọi vớie("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 byte

Lặp lại số lượng khoảng trắng để tiền tố với và sau đó là số lượng ký tự kết thúc bằng.

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

Chỉnh sửa: Đã xóa khoảng trắng trước các vòng lặp.

MATL, 15 14 byte

Đã lưu một byte do mẹo của @ LuisMendo tại đây !

tfWt2/!-RXzB*c

Rất nhiều cách ... phải tìm một cái mới. Chúc mừng bit! :)

Hãy thử trực tuyến!

Phát nổ

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

Phương pháp tiếp cận thẳng. Đầu ra có một dòng mới.

JavaScript (ES6), 72

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

Bình thường, 12 11 byte

jm+*;xQdd.:

Đáng buồn thay, câu hỏi cho phép chúng ta giả sử các ký tự duy nhất, vì vậy tôi chỉ tìm kiếm vị trí đầu tiên của chuỗi con và đệm với khoảng trắng.

Toán học 89 byte

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

Giải trình

i đề cập đến chuỗi đầu vào

Subsequences[y=Characters@i]trả về tất cả các chuỗi (danh sách ký tự đại diện) của đầu vào. (Subsequences đã được giới thiệu trong câu 10,4)

Đối với mỗi lần sau, Complement...trả về các ký tự đó từ chuỗi đầu vào không có. Mỗi nhân vật được thay thế bằng một khoảng trống thông qua StringReplace[i,#->" "].

Columnhiển thị kết quả trong một cột duy nhất. Mỗi chuỗi đầu ra có cùng số lượng ký tự, dẫn đến các chữ cái được căn chỉnh.

r@"abcdefgh"

J, 32 29 28 byte

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

Điều này đánh giá một động từ đơn âm. Hãy thử nó ở đây. Sử dụng:

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

Giải trình

Như một số câu trả lời khác, tôi tính chỉ số xuất hiện của ký tự đầu tiên của mỗi chuỗi con. Các chuỗi con được lưu trữ trong một ma trận với các khoảng trắng ở cuối, vì vậy tôi xoay chúng sang phải theo chỉ mục của chúng để có được số lượng đệm phù hợp. Đó là một khoảng trắng giữa "1và a:thực sự khó chịu ...

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

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

Trả về một chuỗi các chuỗi. Như ES6, nó là 78 ​​byte:

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

QBasic, 75 byte

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

FORChiến lược tăng gấp đôi cơ bản , đã sửa đổi một chút cho lập chỉ mục dựa trên 1 của QBasic. Thủ thuật chính là LOCATE,j, di chuyển con trỏ qua cột jcủa dòng hiện tại trước khi in. Vì cột 1 là cột đầu tiên, điều này tương đương với việc in j-1các không gian hàng đầu.

Perl 6 , 34 byte

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

Lý do cho +trước đó putlà để nó trả về 1thay vì True, điều này được đảm bảo không nằm trong đầu vào để nó luôn phải quay lại.

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

   d
  cd
  c
 bcd
 bc
 b
abcd
abc
ab
a

(Nếu bạn muốn nó theo thứ tự ngược lại sử dụng (.*?)(.+?)thay vì (.*)(.+))

Điều này được lấy cảm hứng từ câu trả lời Perl 5 .

J, 35 23 22 byte

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

Phải mất một lúc nhưng cuối cùng tôi cũng tối ưu hóa nó.

Sử dụng

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

Giải trình

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

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

Định dạng:

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 byte

QlFUQRd:DlRF2h<

Hãy thử nó ở đây!

Giả sử mảng chuỗi đệm được chấp nhận

Miếng đệm đầu tiên và sau đó chops.

Haskell, 65 byte

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

Nó đòi hỏi initsvà tailstừ Data.List, mặc dù. Để xuất nó, thêm mapM_ putStrLn.vào phía trước.

Tương đối đơn giản; đó reverselà để đảm bảo chuỗi gốc là đầu tiên.

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 byte

Chức năng ẩn danh. Sử dụng thay thế regex để căn chỉnh các chuỗi con. .là nhân vật phụ.

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

bash + lõi core GNU, 109 byte

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

Có thể có một giải pháp ngắn hơn, nhưng đây là cách tốt nhất xuất hiện trong tâm trí tôi. Tính độc đáo của kẻ lừa đảo không quan trọng ở đây.

PHP, 151 ký tự

Ung dung

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

Chơi gôn

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

Thí dụ

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

C ++, 145 byte

tham số bắt đầu đầu tiên được sử dụng làm đầu vào, bàn điều khiển làm đầu ra

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

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]  

Kết quả:

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