Введение

Давайте посмотрим на строку abc. Подстроки, которые могут быть сделаны из этого:

a, ab, abc, b, bc, c

Теперь нам нужно выровнять их по исходной строке, например так:

abc
a
 b
  c
ab
 bc
abc

Порядок строки не имеет значения, поэтому это также совершенно верно:

abc
a
ab
abc
 b
 bc
  c

Таким образом, подстрока расположена под местоположением подстроки в исходной строке. Так что для abcdefподстроки 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

Это код-гольф , поэтому выигрывает представление с наименьшим количеством байтов!

Pyth, 14 13 10 байт

Спасибо @FryAmTheEggman за сохранение 3 байтов.

jmXQ-Qd;.:

Попробуйте онлайн!

Perl, 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в 0(т.е. mod(...,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 байта и проложил путь для многих других.

Число байтов предполагает кодировку 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`.+

Это дает нам все префиксы ввода. Это делается путем match ( M) любой substring ( .+), начиная с end ( r), учитывая перекрывающиеся match ( &) и возвращая все эти совпадения, объединенные с linefeeds ( !).

Теперь все, что нам нужно сделать, это выделить последовательные префиксы этих префиксов (заменив их пробелами). Мы делаем это шаг за шагом с помощью цикла:

%+`( *)\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;

Un-golfed

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

Python, 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..$_]}}

Принимает ввод $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 байт

Golfed

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

Полный код

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

релизы

• v1.2 - -1 byte- Изменен String o="",e="";для , String o="",e=o;чтобы сохранить 1 байт. Идея была от Галанта ( я забыл применить эту часть в последнем обновлении, извиняюсь. ).
• v1.1 - -4 bytes- Удалил скобки из forциклов и переместил приращение пространстваe var в зону итератора внешнего цикла. Идея была от галанта .for
• v1.0 - 136 bytes- Исходное решение.

Python 2.7, 70 82 байта

Я не мог понять, как получить это на 1 линии. Позвонить с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)

Python 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 в наконечнике здесь !

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

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

Прямой подход. Выход имеет завершающий перевод строки.

JavaScript (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]возвращает все подпоследовательности (представленные списки символов) ввода. ( Subsequencesбыло введено в ст. 10.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.

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

QBasic, 75 байтов

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

Базовая FORстратегия с двойным циклом, немного измененная для индексации на основе 1 в QBasic. Основной трюк заключается в том LOCATE,j, чтобы jперед печатью переместить курсор на столбец текущей строки. Поскольку столбец 1 является первым столбцом, это эквивалентно печати j-1начальных пробелов.

Perl 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том, что он возвращает 1вместо True, что гарантированно не будет во входных данных, поэтому он всегда должен возвращаться назад.

$ 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

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

Попробуй это здесь!

Предполагается, что массив мягких строк является приемлемым

Сначала прокладки, а затем отбивные.

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

Может быть, есть более короткое решение, но это лучшее, что пришло мне в голову. Уникальность персонажей здесь не имеет значения.

PHP, 151 символ

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

Golfed

<?$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)}

Python 2 (Ungolfed) 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