Вступ

Давайте спостерігатимемо рядок 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

Мови гри в гольф настільки близькі, але все ж таки далеко ...

Пояснення

/.+/відповідає підрядку. На жаль, він зупиняється, як тільки він відповідає. Тому я використовую конструкцію регексу (??{})для виконання, щоб розширити регулярний вираз, щоб він вийшов з ладу, а зворотний трекінг спробує наступну підрядку, врешті-решт, спробувавши їх, перш ніж огида відмовитися.

Всередині (??{})I друкується поточна підрядка з префіксом на стільки пробілів, скільки зсув підстроки за допомогою$"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`.+

Це отримує нам усі префікси вхідних даних. Це робиться шляхом зіставлення ( 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..$_]}}

Бере введення $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;
        }
    }
}

Релізи

• v1.2 - -1 byte- Змінено String o="",e="";на, String o="",e=o;щоб зберегти 1 байт. Ідея була від Gallant ( я забув застосувати цю частину в останньому оновлення, вибачаюся. )
• v1.1 - -4 bytes- скинув дужки з forпетель і перемістив прирістe вар- простору до ітераторної зони зовнішньої 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.:

На жаль, питання дозволяє нам припускати унікальних символів, тому я просто шукаю перше положення підрядка та прокладку з пробілами.

Математика 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 символів

Безумовно

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

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