Data una stringa ASCII, genera i suffissi esplosi di essa. Ad esempio, se la stringa fosse abcde, ci sono 5 suffissi, ordinati dal più lungo al più corto:

abcde
bcde
cde
de
e

Ogni suffisso viene quindi esploso , il che significa che ogni personaggio viene copiato tante volte quanto la sua posizione a un indice in quel suffisso. Ad esempio, esplodendo i suffissi di abcde,

abcde
12345
abbcccddddeeeee

bcde
1234
bccdddeeee

cde
123
cddeee

de
12
dee

e
1
e

Complessivamente, i suffissi esplosi di abcdesono

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

Regole

• Questo è code-golf, quindi vince il codice più corto.
• L'input sarà composto dai caratteri ASCII stampabili. (Ciò esclude le nuove righe ma include gli spazi.)
• L'output avrà ciascuna stringa su una riga separata.
• Gli spazi finali sono consentiti su ogni riga e potrebbe esserci una nuova riga alla fine.

Casi test

''

'a'
a

'bc'
bcc
c

'xyz'
xyyzzz
yzz
z

'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f

's p a c e'
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e

Gelatina , 5 byte

ṫJxJY

Provalo online! o verifica tutti i casi di test .

Come funziona

ṫJxJY  Main link. Argument: s (string)

 J     Indices; yield I := [1, ..., len(s)].
ṫ      Tail; get the suffixes of s starting at indices [1, ..., len(s)].
   J   Indices; yield I again.
  x    Repeat. The atom 'x' vectorizes at depth 1 (1D arrays of numbers/characters)
       in its arguments. This way, each suffix t gets repeated I times, meaning
       that the first character of t is repeated once, the second twice, etc.
       If left and right argument have different lengths, the longer one is
       truncated, so I can safely be applied to all suffixes.
    Y  Join, separating by linefeeds.

J, 22 12 8 byte

Grazie a miglia per aver salvato 14 byte!

(#~#\)\.

Questa è davvero una bella soluzione. Abbastanza anche succinta.

Questo è l'hook #~#\applicato ai suffissi ( \.) dell'input. Il hook, quando viene chiamato in input y, viene scomposto in questo modo:

(#~#\) y
y #~ #\ y

Ecco alcuni risultati intermedi:

   ]s =: 's p a c e'
s p a c e
   #\ s
1 2 3 4 5 6 7 8 9
   (quote) s
's p a c e'
   (quote;#)\ s
+-----------+-+
|'s'        |1|
+-----------+-+
|'s '       |2|
+-----------+-+
|'s p'      |3|
+-----------+-+
|'s p '     |4|
+-----------+-+
|'s p a'    |5|
+-----------+-+
|'s p a '   |6|
+-----------+-+
|'s p a c'  |7|
+-----------+-+
|'s p a c ' |8|
+-----------+-+
|'s p a c e'|9|
+-----------+-+
   1 2 3 # '123'
122333
   3 3 3 # '123'
111222333
   ]\. s
s p a c e
 p a c e
p a c e
 a c e
a c e
 c e
c e
 e
e
   quote\. s
's p a c e'
' p a c e'
'p a c e'
' a c e'
'a c e'
' c e'
'c e'
' e'
'e'
   (#~#\) s
s  ppp    aaaaa      ccccccc        eeeeeeeee
   (#~#\)\. s
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e

Casi test

   f =: (#~#\)\.
   f
(#~ #\)\.
   f ''
   f 'a'
a
   f 'bc'
bcc
c
   f 'xyz'
xyyzzz
yzz
z
   f 'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f
   f 's p a c e'
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e

   ]tc =: <;._1 '|' , '|a|bc|xyz|code-golf|s p a c e'
++-+--+---+---------+---------+
||a|bc|xyz|code-golf|s p a c e|
++-+--+---+---------+---------+
   ,. f &. > tc
+---------------------------------------------+
+---------------------------------------------+
|a                                            |
+---------------------------------------------+
|bcc                                          |
|c                                            |
+---------------------------------------------+
|xyyzzz                                       |
|yzz                                          |
|z                                            |
+---------------------------------------------+
|coodddeeee-----ggggggooooooollllllllfffffffff|
|oddeee----gggggoooooolllllllffffffff         |
|dee---ggggooooollllllfffffff                 |
|e--gggoooolllllffffff                        |
|-ggooollllfffff                              |
|goolllffff                                   |
|ollfff                                       |
|lff                                          |
|f                                            |
+---------------------------------------------+
|s  ppp    aaaaa      ccccccc        eeeeeeeee|
| pp   aaaa     cccccc       eeeeeeee         |
|p  aaa    ccccc      eeeeeee                 |
| aa   cccc     eeeeee                        |
|a  ccc    eeeee                              |
| cc   eeee                                   |
|c  eee                                       |
| ee                                          |
|e                                            |
+---------------------------------------------+

Python, 61 byte

f=lambda s,i=0:s[i:]and-~i*s[i]+f(s,i+1)or s and'\n'+f(s[1:])

Alternativa 63:

f=lambda s,b=1:s and f(s[:-1],0)+s[-1]*len(s)+b*('\n'+f(s[1:]))

Python 3, 91 68 65 byte

def f(s):f(s[1:print(''.join(i*c for i,c in enumerate(s[0]+s)))])

Termina con un errore dopo aver stampato l'output desiderato. Provalo su Ideone .

Come funziona

Prima che f possa chiamarsi ricorsivamente, gli indici di s[1:...]devono essere calcolati.

First enumerate(s[0]+s)produce tutte le coppie (i, c) di caratteri c di s - con il suo primo carattere duplicato - e gli indici corrispondenti i . La preparazione ha s[0]due scopi qui.

• Il primo carattere di s deve essere ripetuto una volta, ma il primo indice è 0 .

• Una volta che tutti i caratteri sono stati elaborati, s[0]genererà un IndexError , causando la fine di f con un errore anziché la stampa di nuove righe fino al raggiungimento del limite di ricorsione.

''.join(i*c for i,c in ...)costruisce una stringa piatta di ogni c ripetuta i volte, che fa printeco a STDOUT.

Infine, poiché printrestituisce None ed s[1:None]è semplicemente s[1:], la chiamata ricorsiva f(s[1:...])ripete il processo sopra descritto per s senza il suo primo carattere.

Perl 6 , 38 byte

m:ex/.+$/.map:{put [~] .comb Zx 1..*}

37 byte + 1 per l' -nopzione della riga di comando

Esempio:

$ perl6 -ne 'm:ex/.+$/.map:{put [~] .comb Zx 1..*}' <<< 'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f

Allargato:

# -n command line switch takes each input line and places it in ｢$_｣

# You can think of it as surrounding the whole program with a for loop
# like this:
for lines() {

  # match
  m
  :exhaustive # every possible way
  / .+ $/     # at least one character, followed by the end of the string

  .map:

  {
    put           # print with newline
      [~]         # reduce using string concatenation ( don't add spaces between elements )
        .comb     # split into individual chars
        Z[x]      # zip using string repetition operator
        1 .. *    # 1,2,3,4 ... Inf
  }

}

Brachylog , 17 byte

@]Elyk:Erz:jac@w\

Provalo online!

Spiegazione

@]E                 E is a suffix of the Input
   lyk              The list [0, ..., length(E) - 1]
      :Erz          The list [[0th char of E, 0], ..., [Last char of E, length(E) - 1]]
          :ja       For all elements of that list, concatenate the Ith char I times to itself
             c      Concatenate the list into a string
              @w    Write followed by a line break
                \   False: backtrack to another suffix of the Input

05AB1E , 13 byte

.sRvyvyN>×}J,

Provalo online!

Spiegazione

.s              # push list of suffixes of input
  R             # reverse the list
   vy           # for each string
     vy   }     # for each char in string
       N>×      # repeat it index+1 times
           J,   # join and print with newline

CJam , 14 byte

Sl+{_eee~n1>}h

Provalo online!

Spiegazione

Sl+   e# Read input and prepend a space.
{     e# While the string is non-empty...
  _   e#   Make a copy.
  ee  e#   Enumerate. Gives, e.g. [[0 ' ] [1 'a] [2 'b] [3 'c]].
  e~  e#   Run-length decode. Gives "abbccc".
  n   e#   Print with trailing linefeed.
  1>  e#   Discard first character.
}h

C #, 101 byte

f=s=>{var r="\n";for(int i=0;i<s.Length;)r+=new string(s[i],++i);return""==s?r:r+f(s.Substring(1));};

Funzione anonima ricorsiva, che stampa anche una nuova riga principale. Se la nuova riga iniziale non è consentita, 3 byte extra la trasformano in una nuova riga finale:

f=s=>{var r="";for(int i=0;i<s.Length;)r+=new string(s[i],++i);return""==s?r:r+"\n"+f(s.Substring(1));};

Programma completo con metodo non golfizzato e casi di test:

using System;

namespace ExplodedSuffixes
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string, string> f = null;
            f = s =>
            {
                var r = "\n";
                for (int i = 0; i < s.Length; )
                    r += new string(s[i], ++i);
                return "" == s ? r : r + f(s.Substring(1));
            };

            // test cases:
            string x = "abcde";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "a";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "bc";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "xyz";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "code-golf";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "s p a c e";
            Console.WriteLine("\'" + x + "\'" + f(x));
        }
    }
}

Haskell, 48 byte

e=map(concat.zipWith replicate[1..]).scanr(:)[] 

è interfacciato da uno qualsiasi di

ghc exploded_suffixes.hs -e 'e"abcde"'
ghc exploded_suffixes.hs -e 'mapM_ putStrLn.e=<<getLine' <<<code-golf
ghc exploded_suffixes.hs -e 'Control.Monad.forever$putStr.unlines.e=<<getLine'

Perl, 36 + 1 ( -n) = 37 byte

/.+$(?{$.=say$&=~s%.%$&x$.++%rge})^/

Necessità -ne -E(o -M5.010) per eseguire:

perl -nE '/.+$(?{$.=say$&=~s%.%$&x$.++%rge})^/' <<< "code-golf"

Nota che funziona solo su un'istanza ogni volta che lo esegui (perché utilizza la variabile $.che viene incrementata ogni volta che viene letta una riga, quindi mantiene 1solo la prima volta che viene letta una riga). (Ma nessun problema qui, basta ^De rieseguirlo!)

Retina , 31 byte

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

M&!`.+

$.%`$*»
%+r`»($|.)
$1$1

Provalo online!

Java, 150 127 byte

Modificare:

• -23 byte di sconto. Grazie a @Kevin Cruijssen

Snipet:

f->{String s[]=f.split(""),o="";int i=-1,j,l=s.length;for(;++i<l;)for(j=-2;++j<i;o+=s[i]);return l<1?"":o+"\n"+f.substring(1);}

Ungolfed:

public static String explodeSuff(String suff){
  char [] s = suff.toCharArray();
  String out = "";
  if(s.length==0)return "";
  for(int i=-1;++i<s.length;){
    for(int j=-2;++j<i;){
      out+=s[i];
    }
  }
  return out+"\n"+suff.subString(1);
}

Racchetta 184 byte

(let p((l(string->list s))(ol'()))(cond[(null? l)(display(list->string(flatten ol)))]
[else(p(cdr l)(append ol(list #\newline)(for/list((i l)(n(length l)))(for/list((j(+ 1 n)))i))))]))

Ungolfed:

(define(f s)
 (let loop((l(string->list s))
             (outl '()))
    (cond
      [(null? l)
       (display
        (list->string
         (flatten outl)))]
      [else
       (loop
        (rest l)
        (append outl
                (list #\newline)
                (for/list ((i l)
                           (n (length l)))
                  (for/list ((j (add1 n)))
                    i
                    ))))]  )))


(f "abcde")
(f "xyz")

Produzione:

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

xyyzzz
yzz
z

JavaScript (ES6), 65 byte

f=s=>s?[s.replace(/./g,(c,i)=>c.repeat(i+1)),...f(s.slice(1))]:[]

<input oninput=o.textContent=f(this.value).join`\n`><pre id=o>

Tentativi precedenti:

67: s=>[...s].map((_,i)=>s.slice(i).replace(/./g,(c,i)=>c.repeat(i+1)))
84: s=>s.replace(/./g,`$&$'
    `).match(/.+/g).map(s=>s.replace(/./g,(c,i)=>c.repeat(i+1)))
89: f=(s,t=s.replace(/./g,(c,i)=>c.repeat(i+1)))=>t?[]:[t,...f(s,t.replace(/(.)(?=\1)/g,''))]

PHP, 103 byte (99 con tag brevi)

<?php for($s=$argv[1];""!=$s[$i++];$o.="
")for($j=0;""!=$l=$s[$j+$i-1];)$o.=str_pad('',++$j,$l);echo$o;

Sono abbastanza sicuro che questa non sia la risposta più breve possibile.

MATL , 12 byte

&+gYRYs"G@Y"

Adoro quando le virgolette si uniscono!

Provalo online!

Spiegazione

Funziona costruendo una matrice le cui colonne sono usate, una per una, per decodificare l'input in lunghezza. Ad esempio, per l'input 'abcde'la matrice è

1 0 0 0 0
2 1 0 0 0
3 2 1 0 0
4 3 2 1 0
5 4 3 2 1

Codice:

&+g    % Implicit input. NxN matrix of ones, where N is input size
YR     % Set entries above diagonal to zero
Ys     % Cumulative sum of each column. This gives the desired matrix 
"      % For each column
  G    %   Push input (for example 'abcde')
  @    %   Push current column (for example [0;0;1;2;3])
  Y"   %   Run-length decode (example output 'cddeee')
       % Implicit end
       % Implicit display

Python 3, 95 byte

def f(s):return'\n'.join(''.join(s[j:][i]*(i+1)for i in range(len(s)-j))for j in range(len(s)))

Questo è stato sorprendentemente più difficile di quanto mi aspettassi. Ho rifatto tutta la mia funzione forse 4 volte.

Java 7.140 byte

void c(char[]a,int l,int j){if(l<1)return;c(a,--l,++j);for(int i=0,k;i<j;i++)for(k=0;k++<=i;)System.out.print(a[i+l]);System.out.println();}

Ungolfed

 void c(char[]a,int l,int j)
{
if (l < 1) 
return ;
c(a , --l , ++j) ;
for(int i = 0 , k; i < j ; i++)
for(k = 0 ; k++ <= i ;)
System.out.print(a[i+l]);
System.out.println();
}

La riga seguente mi dà molto dolore. Non so come posso giocarci (perché ci sono due anelli per spezzare la condizione da mettere "\n"in stampa).
System.out.println();

Pyke, 12 byte

VilS],A*s
}t

Provalo qui!

Rubino, 51 byte

Utilizza il -nflag per +1 byte.

(k=0;puts$_.gsub(/./){$&*k+=1};$_[0]="")while$_>$/

R, 108 byte

Legge input da stdin e stampa su stdout

s=scan(,"");n=nchar(s);for(i in 1:n)cat(do.call("rep",list(strsplit(s,"")[[1]][i:n],1:(n-i+1))),"\n",sep="")

Ho sentito che l'uso di do.callera appropriato qui. Prende sostanzialmente due input: 1. un nome di funzione sotto forma di una stringa ( repqui) e un elenco di argomenti e 2. applica in modo iterativo chiama la funzione usando gli argomenti nell'elenco.

Per esempio:

• rep("c",3) produce il vettore "c" "c" "c"
• do.call("rep",list(c("a","b","c"),1:3)) produce il vettore "a" "b" "b" "c" "c" "c"
• che equivale a chiamare consecutivamente rep("a",1), rep("b",2)erep("c",3)

Vim, 43 byte

qqYlpx@qq@qqr0<C-H><C-V>{$:s/\v%V(.)\1*/&\1/g<CR>@rq@r

La prima macro separa i suffissi, la seconda macro li "esplode". Probabilmente battibile. Gli spazi sono fastidiosi.

C, 186 byte

#include <string.h>
#define S strlen
p(char* s){char *t=s;char u[999]="";for(int i=0;i<S(s);i++){for(int j=i+1;j>0;j--){sprintf(u+S(u),"%c",*t);}t++;}printf("%s\n",u);if(S(s)>1)p(s+1);}

Questo probabilmente può essere abbreviato un po ', ma volevo solo provarlo. È il mio secondo tentativo di golf, quindi dammi tutti i suggerimenti (* lol) che puoi. Prende una stringa come parametro e fa esplodere da lì. u viene utilizzato come buffer che memorizza la stringa esplosa.

Ungolfed:

#include <string.h>
#define S strlen 
p(char* s){
    char *t=s;
    char u[999]="";
    for(int i=0;i<S(s);i++){
        for(int j=i+1;j>0;j--){
            sprintf(u+S(u),"%c",*t);
        }
        t++;
    }
    printf("%s\n",u);
    if(S(s)>1)p(s+1);
}

Acc !! , 150 byte

Prevede input su stdin, terminato con un carattere tab.

N
Count c while _/128^c-9 {
_+N*128^(c+1)
}
Count i while _-9 {
Count j while _/128^j-9 {
Count k while j+1-k {
Write _/128^j%128
}
}
Write 10
_/128
}

Spiegazione

Questo è in realtà un compito abbastanza buono per Acc !! , poiché richiede solo la lettura di una stringa e l'iterazione su di essa con alcuni loop nidificati. Leggiamo la stringa nell'accumulatore, trattandola come una sequenza di 128 cifre di base, con il primo carattere all'estremità di ordine inferiore. Dopo il Count cciclo di apertura , il valore dell'accumulatore può essere concettualizzato in questo modo (usando xyzcome input di esempio):

128^   3  2  1  0
     tab  z  y  x

(Il valore effettivo dell'accumulatore per questo esempio è 9*128^3 + 122*128^2 + 121*128 + 120= 20888824.)

Possiamo quindi iterare sulla stringa ripetendo i poteri crescenti di 128. E possiamo iterare sui suffissi dividendo l'accumulatore per 128 dopo ogni iterazione, tagliando un carattere.

Con rientro e commenti:

# Initialize the accumulator with the first input character
N
# Loop until most recent input was a tab (ASCII 9)
Count c while _/128^c - 9 {
    # Input another character and add it at the left end (next higher power of 128)
    _ + N * 128^(c+1)
}

# Loop over each suffix, until only the tab is left
Count i while _ - 9 {
    # Loop over powers of 128 until the tab
    Count j while _/128^j - 9 {
        # Loop (j+1) times
        Count k while j + 1 - k {
            # Output the j'th character
            Write _ / 128^j % 128
        }
    }
    # Output a newline
    Write 10
    # Remove a character
    _/128
}