Dada una cadena ASCII, genera los sufijos explotados de la misma. Por ejemplo, si la cadena era abcde, hay 5 sufijos, ordenados de mayor a menor:

abcde
bcde
cde
de
e

Luego se explota cada sufijo , lo que significa que cada personaje se copia tantas veces como su ubicación indexada en ese sufijo. Por ejemplo, explotando los sufijos de abcde,

abcde
12345
abbcccddddeeeee

bcde
1234
bccdddeeee

cde
123
cddeee

de
12
dee

e
1
e

En total, los sufijos explotados de abcdeson

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

Reglas

• Este es el código de golf, por lo que gana el código más corto.
• La entrada consistirá en los caracteres ASCII imprimibles. (Esto excluye las nuevas líneas pero incluye espacios).
• La salida tendrá cada cadena en una línea separada.
• Se permiten espacios finales en cada línea y puede haber una nueva línea adicional al final.

Casos de prueba

''

'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

Jalea , 5 bytes

ṫJxJY

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

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

¡Gracias a las millas por ahorrar 14 bytes!

(#~#\)\.

Ahora esta es una muy buena solución. Bastante sucinto, también.

Este es el gancho #~#\aplicado a los sufijos ( \.) de la entrada. El gancho, cuando se llama en la entrada y, se descompone así:

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

Aquí hay algunos resultados intermedios:

   ]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

Casos de prueba

   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 bytes

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:]))

Pitón 3, 91 68 65 bytes

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

Termina con un error después de imprimir la salida deseada. Pruébalo en Ideone .

Cómo funciona

Antes de f pueda llamarse recursivamente, los índices de s[1:...]tienen que ser calculados.

Primero enumerate(s[0]+s)produce todos los pares (i, c) de caracteres c de s - con su primer carácter duplicado - y los índices correspondientes i . El antecedente s[0]tiene dos propósitos aquí.

• El primer carácter de s debe repetirse una vez, pero el primer índice es 0 .

• Una vez que se hayan procesado todos los caracteres, s[0]generará un IndexError , haciendo que f termine con un error en lugar de imprimir nuevas líneas hasta que se alcance el límite de recursión.

''.join(i*c for i,c in ...)construye una cadena plana de cada c repetida i veces, que printhace eco en STDOUT.

Finalmente, dado que printdevuelve None y s[1:None]es simplemente s[1:], la llamada recursiva f(s[1:...])repite el proceso anterior para s sin su primer carácter.

Perl 6 , 38 bytes

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

37 bytes + 1 para -ncambio de línea de comando

Ejemplo:

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

Expandido:

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

@]Elyk:Erz:jac@w\

Pruébalo en línea!

Explicación

@]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 bytes

.sRvyvyN>×}J,

Pruébalo en línea!

Explicación

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

Sl+{_eee~n1>}h

Pruébalo en línea!

Explicación

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 bytes

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

Función anónima recursiva, que también imprime una nueva línea principal. Si la nueva línea inicial no está permitida, 3 bytes adicionales la convierten en una nueva línea final:

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

Programa completo con método no protegido y casos de prueba:

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 bytes

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

está interconectado por cualquiera de

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 bytes

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

Necesidades -ny -E(o -M5.010) para ejecutar:

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

Tenga en cuenta que funciona solo en una instancia cada vez que lo ejecuta (porque usa la variable $.que se incrementa cada vez que se lee una línea, por lo que se mantiene 1solo la primera vez que se lee una línea). (¡Pero no hay problema aquí, solo ^Dy vuelva a ejecutarlo!)

Retina , 31 bytes

El recuento de bytes supone la codificación ISO 8859-1.

M&!`.+

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

Pruébalo en línea!

Java, 150 127 bytes

Editar:

• -23 bytes desactivados. Gracias 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);}

Sin golf:

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

Raqueta 184 bytes

(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))))]))

Sin golf:

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

Salida:

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

xyyzzz
yzz
z

JavaScript (ES6), 65 bytes

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>

Intentos previos:

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 bytes (99 con etiquetas cortas)

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

Estoy bastante seguro de que esta no es la respuesta más corta posible.

MATL , 12 bytes

&+gYRYs"G@Y"

¡Me encanta cuando las comillas se juntan!

Pruébalo en línea!

Explicación

Esto funciona construyendo una matriz cuyas columnas se utilizan, una por una, para decodificar la entrada de longitud de ejecución. Como ejemplo, para la entrada 'abcde'la matriz es

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

Código:

&+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 bytes

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

Esto fue sorprendentemente más difícil de lo que esperaba. Rehice toda mi función tal vez 4 veces.

Java 7.140 bytes

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

Sin golf

 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 siguiente línea me da mucho dolor. No sé cómo puedo jugar golf (porque hay dos bucles para romper la condición para poner "\n"en la declaración impresa).
System.out.println();

Pyke, 12 bytes

VilS],A*s
}t

Pruébalo aquí!

Ruby, 51 bytes

Utiliza la -nbandera para +1 byte.

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

R, 108 bytes

Lea la entrada de stdin e imprime en 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="")

Sentí que el uso de do.callera apropiado aquí. Básicamente toma dos entradas: 1. un nombre de función en forma de cadena (rep aquí) y una lista de argumentos y 2. aplica iterativamente las llamadas a la función usando los argumentos de la lista.

P.ej:

• rep("c",3) produce el vector "c" "c" "c"
• do.call("rep",list(c("a","b","c"),1:3)) produce el vector "a" "b" "b" "c" "c" "c"
• que es equivalente a llamar consecutivamente rep("a",1), rep("b",2)yrep("c",3)

Vim, 43 bytes

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

La primera macro separa los sufijos, la segunda macro los "explota". Probablemente vencible. Los espacios son molestos.

C, 186 bytes

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

Esto probablemente se puede acortar un poco, pero solo quería probarlo. Es mi segundo intento en el golf, así que dame algunos consejos (* lol) que puedas. Toma una cadena como parámetro y explota desde allí. u se usa como un búfer que almacena la cadena explotada.

Sin golf:

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

Espera entrada en stdin, terminada con un carácter de tabulación.

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
}

Explicación

¡Esto es realmente una muy buena tarea para Acc !! , ya que solo requiere leer una cadena e iterar sobre ella con algunos bucles anidados. Leemos la cadena en el acumulador, tratándola como una secuencia de dígitos de base 128, con el primer carácter en el extremo inferior. Después del Count cciclo de apertura , el valor del acumulador se puede conceptualizar de esta manera (utilizando xyzcomo entrada de ejemplo):

128^   3  2  1  0
     tab  z  y  x

(El valor real del acumulador para este ejemplo es 9*128^3 + 122*128^2 + 121*128 + 120=20888824 .)

Luego podemos iterar sobre la cadena iterando sobre poderes crecientes de 128. Y podemos iterar sobre los sufijos dividiendo el acumulador por 128 después de cada iteración, cortando un carácter.

Con sangría y comentarios:

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