introduzione

Osserviamo la stringa abc. Le sottostringhe che possono essere fatte da questo sono:

a, ab, abc, b, bc, c

Ora dobbiamo allinearli sotto la stringa iniziale, in questo modo:

abc
a
 b
  c
ab
 bc
abc

L'ordine della stringa non ha importanza, quindi anche questo è perfettamente valido:

abc
a
ab
abc
 b
 bc
  c

Pertanto, la sottostringa viene posizionata sotto la posizione della sottostringa nella stringa iniziale. Quindi per abcdefe la sottostringa cde, sarebbe simile a questa:

abcdef
  cde

L'obiettivo

Il compito è allineare tutte le sottostringhe con una lunghezza maggiore di 0 , come mostrato sopra. Puoi presumere che la stringa stessa conterrà solo caratteri alfabetici e abbia almeno 1 carattere. Per il riempimento, è possibile utilizzare uno spazio o qualche altro carattere ASCII stampabile non alfabetico ( 32 - 127). Forse non è necessario menzionarlo, ma la stringa stessa conterrà solo caratteri univoci, quindi non piace aba, poiché si averifica due volte.

Casi test

Ingresso: abcde

Uscita possibile:

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

Ingresso: abcdefghij

Uscita possibile:

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

Questo è code-golf , quindi vince l'invio con il minor numero di byte!

Pyth, 14 13 10 byte

Grazie a @FryAmTheEggman per aver salvato 3 byte.

jmXQ-Qd;.:

Provalo online!

Perl, 32 28 24 byte

Include +1 per -n

Codice:

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

Esegui con la stringa su STDIN:

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

Le lingue del golf sono così vicine eppure così lontane ...

Spiegazione

/.+/corrisponde a una sottostringa. Sfortunatamente si ferma una volta abbinato a uno. Quindi uso il costrutto regex di runtime(??{}) per estendere il regex in modo che fallisca e il backtracking proverà la sottostringa seguente, alla fine provandoli tutti prima di arrendersi con disgusto.

All'interno di (??{})I, stampa la sottostringa corrente con il prefisso di tanti spazi quanti sono gli offset della sottostringa$"x"@-"

Quindi l'output documenta perfettamente il funzionamento del backtracking di regex:

abcd
abc
ab
a
 bcd
 bc
 b
  cd
  c
   d

MATL , 20 18 byte

Ispirato al modello di sottostringhe generato dalla risposta di @aditsu

tt!+gR*c`t3Lt3$)tn

Provalo online!

Il modello di sottostringhe è generato da una matrice triangolare superiore delle stesse dimensioni dell'input e da tutte le sottomaterie ottenute rimuovendo successivamente l'ultima riga e colonna.

Spiegazione

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

Vecchio approccio (potere cartesiano)

Sto mantenendo questo approccio nel caso serva da ispirazione per altre risposte

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

Nel compilatore online questo esaurisce la memoria per il test case più lungo.

Provalo online!

Spiegazione

Questo genera tutti i modelli di valori 0, 1e 2in ordine crescente, e poi si trasforma 2in 0. Ciò fornisce tutti i possibili modelli di 0e in 1cui i 1valori sono contigui. Questi sono usati per contrassegnare quali caratteri sono presi dalla stringa originale.

Ad esempio, per la stringa 'abc'i motivi sono generati come segue. Innanzitutto [0 1 2]si ottiene il potere cartesiano di elevare al numero di caratteri di input:

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

L'ordinamento di ogni riga dà

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

La trasformazione 2in 0(cioè mod(...,2)) e la rimozione di righe duplicate fornisce il modello finale

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

in cui ogni riga è una maschera corrispondente a una sottostringa (contigua). La prima riga deve essere rimossa perché corrisponde alla sottostringa vuota.

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 byte

Grazie a Kenny Lau per aver salvato 3 byte e spianato la strada a molti altri.

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

Provalo online!

Ordine delle sottostringhe generate:

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

Spiegazione

M&!r`.+

Questo ci dà tutti i prefissi dell'input. Questo viene fatto abbinando ( M) qualsiasi sottostringa ( .+) a partire dalla fine ( r), considerando le corrispondenze sovrapposte ( &) e restituendo tutte quelle corrispondenze unite con linefeed ( !).

Ora tutto ciò che dobbiamo fare è ritagliare i prefissi successivi di quei prefissi (sostituendoli con spazi). Facciamo questo passo per passo con un ciclo:

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

I %mezzi quali l'intera cosa viene fatto per ogni linea singolarmente (considerando che una stringa separata per questo momento, e unendo tutto insieme con linefeeds alla fine). Il +dice a Retina di eseguire questa sostituzione in un ciclo fino a quando l'uscita smette di cambiare (il che in questo caso significa che il regex non corrisponde più). La regex quindi cerca di far corrispondere l'ultima riga dell'input con almeno due caratteri non spaziali e aggiunge una nuova riga in cui la prima di queste viene sostituita da uno spazio.

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;

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

Provalo online

Spiegazione:

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)

Emette un setlike {' b', 'a', 'ab'}. L'idea è quella di rievocare due ramificati che tagliano il primo o l'ultimo personaggio. Dà output ridondanti, ma setrimuove automaticamente i duplicati. Per l'allineamento, ogni volta che viene tagliato il primo carattere, viene aggiunto uno spazio al prefisso p, che viene concatenato sul fronte.

PowerShell v2 +, 69 byte

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

Accetta input $a, esegue un loop sulla lunghezza (impostazione $bnel processo per l'uso successivo). Ad ogni loop esterno, eseguiamo il loop up di $bnuovo, impostando $iper l'uso in seguito. Ogni loop interno, abbiamo emesso$i numero di spazi concatenati con una porzione della stringa di input. Dal momento che stiamo solo eseguendo il loop della stringa, in realtà gestirà qualsiasi stringa arbitraria (lettere duplicate, spazi, qualunque cosa).

Esempio

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

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

Codice completo

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

Uscite

• v1.2 - -1 byte- Modificato il String o="",e="";to String o="",e=o;per salvare 1 byte. L'idea era di Gallant ( ho dimenticato di applicare questa parte nell'ultimo aggiornamento, mi scuso. ).
• v1.1 - -4 bytes- Rilasciato le parentesi dai forloop e spostato l' incrementoe var space nella zona iteratore del forloop esterno . L'idea era di Gallant .
• v1.0 - 136 bytes- Soluzione iniziale.

Python 2.7, 70 82 byte

Non riuscivo a capire come ottenerlo su 1 riga. Chiama cone("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

Scorri il numero di spazi con il prefisso e quindi il numero di caratteri con cui terminare.

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

Modificare: spazi rimossi prima dei cicli for.

MATL, 15 14 byte

Salvato un byte a causa di @ LuisMendo punta qui !

tfWt2/!-RXzB*c

Tanti modi ... ho dovuto trovarne uno nuovo. Pezzi felici! :)

Provalo online!

esploso

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

Approccio diretto. L'output ha una nuova riga finale.

JavaScript (ES6), 72

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

Pyth, 12 11 byte

jm+*;xQdd.:

Purtroppo la domanda ci consente di assumere caratteri unici, quindi cerco solo la prima posizione della sottostringa e il pad con gli spazi.

Mathematica 89 byte

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

Spiegazione

i si riferisce alla stringa di input

Subsequences[y=Characters@i]restituisce tutte le sottosequenze (rappresentate liste di caratteri) dell'input. (Subsequences stato introdotto in v. 10.4)

Per ogni sottosequenza, Complement...restituisce quei caratteri della stringa di input che non lo sono presenti. Ognuno di questi personaggi è sostituito da uno spazio vuoto tramiteStringReplace[i,#->" "] .

Columnvisualizza i risultati in una singola colonna. Ogni stringa di output ha lo stesso numero di caratteri, risultando in lettere allineate.

r@"abcdefgh"

J, 32 29 28 byte

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

Questo valuta un verbo monadico. Provalo qui. Uso:

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

Spiegazione

Come alcune altre risposte, computo l'indice di occorrenza del primo carattere di ogni sottostringa. Le sottostringhe sono memorizzate in una matrice con spazi finali, quindi le giro a destra in base al loro indice per ottenere la giusta quantità di imbottitura. Quell'unico spazio vuoto tra "1ed a:è davvero fastidioso ...

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

Restituisce una matrice di stringhe. Come ES6 è di 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

La FORstrategia di base a doppio loop, modificata un po 'per l'indicizzazione basata su 1 di QBasic. Il trucco principale è LOCATE,jche sposta il cursore sulla colonna jdella riga corrente prima di stampare. Poiché la colonna 1 è la prima colonna, ciò equivale alla stampa di j-1spazi iniziali.

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

Il motivo del +prima putè che ritorna 1invece diTrue , il che è garantito per non essere nell'input, quindi deve sempre tornare indietro.

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

   d
  cd
  c
 bcd
 bc
 b
abcd
abc
ab
a

(Se lo vuoi nell'ordine opposto usa (.*?)(.+?)invece di(.*)(.+) )

Questo è stato ispirato dalla risposta Perl 5 .

J, 35 23 22 byte

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

Mi ci è voluto un po 'ma alla fine l'ho ottimizzato.

uso

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

Spiegazione

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

formattato:

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<

Provalo qui!

Suppone che una serie di stringhe imbottite sia accettabile

Prima i pad e poi le costolette.

Haskell, 65 byte

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

Richiede initse tailsda DataList, tuttavia. Per produrlo, aggiungimapM_ putStrLn. in primo piano.

Relativamente semplice; il reverseè quello di assicurarsi la stringa originale è il primo.

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)

Rubino, 75 67 byte

Funzione anonima. Usa la sostituzione regex per allineare le sottostringhe. .è il carattere di riempimento.

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

bash + GNU coreutils, 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}
}; }

Forse esiste una soluzione più breve, ma questa è la migliore che mi è venuta in mente. L'unicità dei personaggi non ha importanza qui.

PHP, 151 caratteri

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

Esempio

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

C ++, 145 byte

il primo parametro di avvio viene utilizzato come input, console come output

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

Risultato:

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