소개

문자열을 살펴 봅시다 abc. 이것으로 만들 수있는 부분 문자열은 다음과 같습니다.

a, ab, abc, b, bc, c

이제 다음과 같이 초기 문자열 아래에 정렬해야합니다.

abc
a
 b
  c
ab
 bc
abc

문자열의 순서는 중요하지 않으므로 완벽하게 유효합니다.

abc
a
ab
abc
 b
 bc
  c

따라서 하위 문자열은 초기 문자열에서 하위 문자열의 위치 아래에 배치됩니다. 따라서 for abcdef및 substring cde은 다음과 같습니다.

abcdef
  cde

작업

이 작업은 위에 표시된 것처럼 모든 하위 문자열 을 0보다 큰 길이 로 정렬 하는 것 입니다. 문자열 자체에는 알파벳 문자 만 포함 되며 1 자 이상이 있다고 가정 할 수 있습니다 . 패딩의 경우 공백이나 다른 비 알파벳 인쇄 가능 ASCII 문자 ( 32 - 127)를 사용할 수 있습니다. 어쩌면 필요는 언급하지만, 문자열 자체는 그렇게하지 같은 고유 문자를 포함 할 것 aba(가) 이후, a두 번 발생합니다.

테스트 사례

입력: abcde

가능한 출력 :

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

입력: abcdefghij

가능한 출력 :

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

이것은 code-golf 이므로 바이트 수가 가장 적은 제출이 승리합니다!

Pyth, 14 13 10 바이트

3 바이트를 저장 한 @FryAmTheEggman 에게 감사 합니다.

jmXQ-Qd;.:

온라인으로 사용해보십시오!

펄, 32 28 24 바이트

에 +1 포함 -n

암호:

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

STDIN에서 문자열로 실행하십시오.

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

골프 언어는 아주 가깝지만 아직 멀었습니다 ...

설명

/.+/부분 문자열과 일치합니다. 불행히도 일단 일치하면 중지됩니다. 그래서 나는 정규식 (??{})을 확장 하기 위해 런타임 정규식 구성 을 사용하여 실패하고 역 추적은 다음 하위 문자열을 시도하여 결국 혐오감을 포기하기 전에 모든 하위 문자열을 시도합니다.

내부에서 (??{})나는 현재 문자열을 사용하여 부분 문자열의 오프셋만큼 많은 공백을 접두어로 사용합니다.$"x"@-"

따라서 출력은 정규식 역 추적이 어떻게 작동하는지 깔끔하게 문서화합니다.

abcd
abc
ab
a
 bcd
 bc
 b
  cd
  c
   d

MATL , 20 18 바이트

@aditsu의 답변에 의해 생성 된 하위 문자열 패턴에서 영감을 얻었습니다.

tt!+gR*c`t3Lt3$)tn

온라인으로 사용해보십시오!

하위 문자열의 패턴은 입력과 동일한 크기의 상위 삼각 행렬과 마지막 행과 열을 연속적으로 제거하여 얻은 모든 하위 행렬에 의해 생성됩니다.

설명

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

옛 접근 방식 (직교도)

다른 답변에 영감을주는 경우를 대비 하여이 접근법을 유지하고 있습니다.

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

온라인 컴파일러에서 가장 긴 테스트 케이스의 메모리가 부족합니다.

온라인으로 사용해보십시오!

설명

이 값의 모든 형태를 생성 0, 1및 2증가하는 순서로, 그리고 변환 2에 0. 이는 가능한 모든 패턴 0과 값이 인접한 1위치를 제공합니다 1. 원래 문자열에서 가져온 문자를 표시하는 데 사용됩니다.

예를 들어, 문자열의 'abc'경우 패턴은 다음과 같이 생성됩니다. 먼저 [0 1 2]입력 문자 수만큼 증가한 데카르트 힘을 얻습니다.

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

각 행을 정렬하면

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

(예 :) 2로 변환 하고 중복 행을 제거하면 최종 패턴이 제공됩니다.0mod(...,2)

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

여기서 각 행은 (연속적인) 하위 문자열에 해당하는 마스크입니다. 첫 번째 행은 빈 하위 문자열에 해당하므로 제거해야합니다.

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

망막 , 48 32 31 바이트

3 바이트를 절약하고 더 많은 길을 열어 준 Kenny Lau에게 감사드립니다.

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

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

온라인으로 사용해보십시오!

생성 된 하위 문자열의 순서 :

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

설명

M&!r`.+

이것은 우리에게 입력의 모든 접두사를 얻습니다. 이는 일치하는 겹침 ( )을 고려 하고 줄 바꿈 ( ) 과 결합 된 모든 일치 항목을 반환 하여 끝 M( .+)부터 시작 하는 하위 문자열 ( )을 r일치 ( &)하여 수행 !합니다.

이제 우리가해야 할 일은 접두사 의 연속 접두사 를 공백으로 바꾸는 것입니다. 우리는 루프를 통해이 단계를 단계별로 수행합니다.

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

%이 모든 것은 개별적으로 각 라인에 수행되는 것을 의미한다 (그것을 당분간 별도의 문자열을 고려하고, 마지막에 줄 바꿈 모든 다시 함께 합류). 이 명령 +은 출력이 변경을 멈출 때까지 (이 경우 정규식이 더 이상 일치하지 않음을 의미 할 때까지) 루프에서이 대체를 실행하도록 Retina에 지시합니다. 그런 다음 정규 표현식은 입력의 마지막 줄을 두 개 이상의 공백이 아닌 문자와 일치시키고 첫 번째 행이 공백으로 바뀌는 새 행을 추가합니다.

Oracle SQL 11.2, 146 바이트

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;

언 골프

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

온라인으로 사용해보십시오

설명:

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

파이썬, 57 바이트

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

set같은 출력합니다 {' b', 'a', 'ab'}. 아이디어는 첫 번째 또는 마지막 문자를 차단하는 두 개의 분기를 반복하는 것입니다. 중복 출력을 제공하지만 set자동으로 중복을 제거합니다. 정렬을 위해 첫 번째 문자가 잘릴 때마다 접두어에 공백이 추가되어 p앞면에 연결됩니다.

PowerShell v2 +, 69 바이트

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

input을 가져 와서 $a길이를 반복합니다 ( $b나중에 사용하기 위해 프로세스에서 설정 ). 각 외부 루프 는 나중에 $b다시 $i사용하도록 설정 하여 다시 반복합니다 . 각 내부 루프 $i에서 입력 문자열 조각과 연결된 공간 수를 출력 합니다. 우리는 문자열을 반복하기 때문에 임의의 문자열 (중복 문자, 공백 등)을 실제로 처리합니다.

예

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 바이트

골프

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

언 골프

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

전체 코드

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

자료

• 1.2 - -1 byte-을 변경 String o="",e="";하기 위해 String o="",e=o;1 바이트를 저장합니다. 아이디어는 Gallant 에서 나왔습니다 ( 마지막 업데이트에서이 부분을 적용하는 것을 잊었습니다. 사과드립니다 ).
• 버전 1.1 - -4 bytes- 떨어 뜨린하여에서 괄호 for루프와 이동 evar에 공간이 증가 외부의 반복자 영역에 for루프를. 아이디어는 Gallant 에서 나왔습니다 .
• V1.0 - 136 bytes- 초기 솔루션입니다.

파이썬 2.7, 70 82 바이트

한 줄로 얻는 방법을 알 수 없었습니다. 와 전화e("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)

파이썬 3, 80 78 바이트

접두사를 지정할 공백 수를 반복 한 다음 끝나는 문자 수를 반복하십시오.

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

편집 : for 루프 앞의 공백을 제거했습니다.

MATL, 15 14 바이트

@LuisMendo의 팁 으로 인해 1 바이트를 절약 했습니다 !

tfWt2/!-RXzB*c

여러 가지 방법으로 ... 새로운 것을 찾아야했습니다. 행복한 비트! :)

온라인으로 사용해보십시오!

폭발

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

자바 스크립트 (ES6), 89 바이트

document.write("<pre>"+(

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

)("abcde"))

직접적인 접근. 출력에 줄 바꿈이 있습니다.

자바 스크립트 (ES6), 72

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

Pyth, 12 11 바이트

jm+*;xQdd.:

슬프게도 문제는 고유 한 문자를 가정 할 수 있으므로 하위 문자열의 첫 번째 위치를 찾고 공백으로 채 웁니다.

Mathematica 89 바이트

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

설명

i 입력 문자열을 나타냅니다

Subsequences[y=Characters@i]입력의 모든 하위 시퀀스 (표시된 문자 목록)를 반환합니다. ( Subsequences10.4 절에서 소개되었습니다)

각 서브 시퀀스에 대해 존재 하지 않는Complement... 입력 문자열에서 해당 문자를 리턴합니다 . 각 문자는를 통해 빈 공간으로 대체됩니다 .StringReplace[i,#->" "]

Column단일 열에 결과를 표시합니다. 각 출력 문자열의 문자 수가 동일하므로 문자가 정렬됩니다.

r@"abcdefgh"

J, 32 29 28 바이트

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

이것은 모나 딕 동사로 평가됩니다. 여기에서 시도하십시오. 용법:

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

설명

다른 답변으로 각 하위 문자열의 첫 번째 문자의 발생 색인을 계산합니다. 하위 문자열은 후행 공백이있는 행렬에 저장되므로 적절한 양의 패딩을 얻기 위해 인덱스를 기준으로 오른쪽으로 회전시킵니다. 사이 공백의 한 조각 "1과는 a:정말 짜증나는 ...

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

자바 스크립트 (Firefox 30-57), 65 63 바이트

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

문자열 배열을 반환합니다. ES6로서 78 바이트입니다.

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

Q 기본, 75 바이트

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

기본적인 이중 FOR루프 전략은 QBasic의 1 기반 인덱싱에 대한 비트를 수정했습니다. 주요 트릭은 인쇄하기 전에 LOCATE,j커서를 j현재 줄의 열로 이동합니다 . 열 1이 첫 번째 열이므로 j-1선행 공백 을 인쇄 하는 것과 같습니다 .

펄 6 , 34 바이트

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

이전의 이유 는 대신에 리턴 +하기 put때문에 입력에 포함되지 않으므로 항상 역 추적해야합니다.1True

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

   d
  cd
  c
 bcd
 bc
 b
abcd
abc
ab
a

(당신이 그것을 반대 순서로 원한다면 (.*?)(.+?)대신에 사용하십시오 (.*)(.+))

이것은 Perl 5 답변 에서 영감을 얻은 것 입니다.

J, 35 23 22 바이트

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

시간이 걸렸지 만 마침내 최적화했습니다.

용법

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

설명

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

자바, 138 바이트

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

형식화 :

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

파이크, 15 바이트

QlFUQRd:DlRF2h<

여기 사용해보십시오!

채워진 문자열 배열이 허용되는 것으로 가정

먼저 패딩 한 다음 잘게 썬다.

하스켈, 65 바이트

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

그것은 필요로 inits하고 tails있지만, Data.List에서. 출력하려면 mapM_ putStrLn.앞에 추가 하십시오.

비교적 간단합니다. 는 reverse원래 문자열이 첫 번째인지 확인하는 것입니다.

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)

루비, 75 67 바이트

익명의 기능. 정규식 대체를 사용하여 하위 문자열을 정렬합니다. .필러 문자입니다.

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

bash + GNU coreutils, 109 바이트

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

아마도 더 짧은 해결책이있을 수 있지만 이것이 내 마음에 온 최고의 것입니다. chracter의 고유성은 여기에서 중요하지 않습니다.

PHP, 151 자

언 골프

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

골프

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

예

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

C ++, 145 바이트

첫 번째 시작 매개 변수는 입력으로 사용되며 콘솔은 출력으로 사용됩니다

#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)}

파이썬 2 (비 골프) 99 바이트

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]  

결과:

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